Data update
This commit is contained in:
Ingy döt Net
parent
72eb4943cb
commit
4d5544505c
|
|
@ -0,0 +1 @@
|
|||
../../Task/Loops-Infinite/8080-Assembly
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Run-length-encoding/8080-Assembly
|
||||
|
|
@ -4,13 +4,13 @@
|
|||
===Segmented Memory===
|
||||
The 8086 uses a segmented memory model, similar to the Super Nintendo Entertainment System. Unlike banked memory models used in the Commodore 64 and late NES games, segment addresses are held in <i>segment registers</i>. These segment registers are 16 bit and get left-shifted by 4 and added to the pointer register of interest to determine the memory address to look up. The 8086 has four in total, but only the <code>DS</code> and <code>ES</code> registers can be used by the programmer. (The other two work with the stack pointer and instruction pointer, and are loaded for you.) On the 8086, you can only load segment registers with the value in a data register, or with the <code>POP</code> command. So first you must load a segment into a data register, THEN into a segment register.
|
||||
|
||||
<lang asm>;This is NOT valid code!
|
||||
<syntaxhighlight lang="asm">;This is NOT valid code!
|
||||
mov ds, @data ;you're trying to move the data segment location directly into DS. You can't!
|
||||
|
||||
|
||||
;This is the proper way:
|
||||
mov ax, @data ;I chose AX but I could have used BX, CX, or DX.
|
||||
mov ds, ax ;load DS with the data segment.</lang>
|
||||
mov ds, ax ;load DS with the data segment.</syntaxhighlight>
|
||||
|
||||
It's important to remember the subtle distinction between a ''segment'' and a ''segment register.'' Your program might have labeled ''segments'' such as <code>.data</code> and <code>.code</code>, but in order to properly read from/write to these sections you'll need to load their memory locations into ''segment registers.''
|
||||
|
||||
|
|
@ -18,17 +18,17 @@ It's important to remember the subtle distinction between a ''segment'' and a ''
|
|||
There are four data registers: <code>AX</code>, <code>BX</code>, <code>CX</code>, and <code>DX</code>. While most commands can use any of them, some only work with particular data registers. System calls in particular are very specific about which registers can be used for what. On [[MS-DOS]], the <code>AX</code> register is used for selecting the desired interrupt to use with the <code>INT</code> command.
|
||||
|
||||
Each data register is 16-bit, but has two eight bit halves ending in H or L, e.g. <code>AH, AL</code>. Instructions can be executed using the whole register or just half of it.
|
||||
<lang asm>mov ax, 1000h ;move 1000h into AX, or equivalently, move 10h into AH and 00h into AL.</lang>
|
||||
<syntaxhighlight lang="asm">mov ax, 1000h ;move 1000h into AX, or equivalently, move 10h into AH and 00h into AL.</syntaxhighlight>
|
||||
Moving a value smaller than 16 bits into <code>?X</code> is the same as moving it into <code>?L</code>, and moving 0 into <code>?H</code>. (? represents the data register of your choice. They are all the same in this regard.)
|
||||
|
||||
<lang asm>mov ax,0030h
|
||||
<syntaxhighlight lang="asm">mov ax,0030h
|
||||
;is the same as:
|
||||
mov al, 30h
|
||||
mov ah, 0h</lang>
|
||||
mov ah, 0h</syntaxhighlight>
|
||||
|
||||
Commands that alter the contents of a single register will not affect the other half.
|
||||
<lang asm>mov ax,00FFh
|
||||
inc al</lang>
|
||||
<syntaxhighlight lang="asm">mov ax,00FFh
|
||||
inc al</syntaxhighlight>
|
||||
If we had executed <code>INC AX</code>, then <code>AX</code> would have been incremented to 0x100. Since we only incremented <code>AL</code>, only <code>AL</code> was incremented in this case, and <code>AH</code> '''still equals 0x00!'''
|
||||
|
||||
Generally speaking, the 8086's registers serve the following purposes:
|
||||
|
|
@ -42,24 +42,24 @@ When writing to or reading from consecutive sections of memory, it is helpful to
|
|||
|
||||
The syntax for offsetting an index register will vary depending on your assembler. Many assemblers will often accept multiple different ways of writing it, and it comes down to personal preference.
|
||||
|
||||
<lang asm>mov si, offset MyArray
|
||||
<syntaxhighlight lang="asm">mov si, offset MyArray
|
||||
mov bx,2
|
||||
|
||||
mov al,[bx+si] ;loads decimal 30 into AL
|
||||
|
||||
MyArray:
|
||||
byte 10,20,30,40,50</lang>
|
||||
byte 10,20,30,40,50</syntaxhighlight>
|
||||
|
||||
===The Stack===
|
||||
As with [[Z80 Assembly]], you can't push 8-bit registers onto the stack. For data registers, you have to push/pop both halves.
|
||||
<lang asm>;This is valid code.
|
||||
<syntaxhighlight lang="asm">;This is valid code.
|
||||
push ax
|
||||
push bx
|
||||
|
||||
pop bx
|
||||
pop ax</lang>
|
||||
|
||||
<lang asm>;This is NOT valid code.
|
||||
<syntaxhighlight lang="asm">;This is NOT valid code.
|
||||
push ah
|
||||
push al
|
||||
push bh
|
||||
|
|
@ -69,14 +69,14 @@ push bl
|
|||
pop bl
|
||||
pop bh
|
||||
pop al
|
||||
pop ah</lang>
|
||||
pop ah</syntaxhighlight>
|
||||
|
||||
As with all processors that use a stack, if you push one or more registers and want to restore the backed-up values correctly, you must pop them in the reverse order. You can pop them out of order on purpose to swap registers around. In fact, this is a quick way to move the segment from <code>DS</code> into <code>ES</code>, or vice-versa:
|
||||
<lang asm>push DS
|
||||
pop ES ;you can't do "mov es, ds" but you can do this!</lang>
|
||||
<syntaxhighlight lang="asm">push DS
|
||||
pop ES ;you can't do "mov es, ds" but you can do this!</syntaxhighlight>
|
||||
|
||||
The proper way to use the stack to preserve registers:
|
||||
<lang asm>
|
||||
<syntaxhighlight lang="asm">
|
||||
call foo
|
||||
|
||||
mov ax,4C00h
|
||||
|
|
@ -91,7 +91,7 @@ push cx
|
|||
pop cx
|
||||
pop bx
|
||||
pop ax
|
||||
ret</lang>
|
||||
ret</syntaxhighlight>
|
||||
|
||||
If one of the push/pop commands in the routine above were missing, the <code>RET</code> instruction would not properly return to where it came from. As long as you pop at the end the same number of registers you pushed at the start, the stack is "balanced" and your return instruction will return correctly. This is because <code>RET</code> is actually <code>POP IP</code> (<code>IP</code> being the instruction pointer, which you can think of as what "line" of code the CPU is on.) The CPU assumes the top of the stack is the correct place to return to, but has no way of actually verifying it. If the function you just wrote causes the CPU to crash or jump to a completely different part of the code, there's a good chance you might have forgotten to balance the stack properly.
|
||||
|
||||
|
|
@ -107,40 +107,40 @@ One other caveat to mention: On early IBM PCs and compatibles, the 8087 was not
|
|||
===Looping Constructs===
|
||||
The 8086 has a lot more of these than most CPUs. The most obvious one is <code>LOOP</code>, which will subtract 1 from <code>CX</code>, then jump back to a specified label if <code>CX</code> is nonzero after the subtraction. If <code>CX</code> becomes zero after subtracting 1, then no jump will occur and the instruction pointer simply moves to the next instruction.
|
||||
|
||||
<lang asm>mov cx,0100h ;set the loop counter's starting value. This must be outside the loop, otherwise you'll loop forever!
|
||||
<syntaxhighlight lang="asm">mov cx,0100h ;set the loop counter's starting value. This must be outside the loop, otherwise you'll loop forever!
|
||||
|
||||
foo:
|
||||
;; your code that you want to loop goes here
|
||||
loop foo </lang>
|
||||
loop foo </syntaxhighlight>
|
||||
|
||||
It's important not to alter <code>CX</code> inside the loop. It's easy to make a mistake like this if you're in a hurry:
|
||||
|
||||
<lang asm>foobar:
|
||||
<syntaxhighlight lang="asm">foobar:
|
||||
mov cx,1000h
|
||||
;your code goes here
|
||||
loop foobar</lang>
|
||||
loop foobar</syntaxhighlight>
|
||||
|
||||
It may not be obvious at first but the above loop will never end. <code>CX</code> decrements to 0x0FFF with the <code>LOOP</code> instruction but the <code>mov cx,1000h</code> was mistakenly placed ''inside'' the loop, resetting the loop counter back to 0x1000, which means no progress is really being made. The correct way to do this is to set the starting loop counter '''outside''' the loop, like so:
|
||||
|
||||
<lang asm>mov cx,1000h
|
||||
<syntaxhighlight lang="asm">mov cx,1000h
|
||||
foobar:
|
||||
;your code goes here
|
||||
loop foobar</lang>
|
||||
loop foobar</syntaxhighlight>
|
||||
|
||||
Sometimes you'll have to change <code>CX</code> during a loop, like if you want to do bit shifts with a shift amount other than 1, for example. There's a simple fix - use the stack to stash and retrieve the loop counter.
|
||||
<lang asm>mov cx,0100h
|
||||
<syntaxhighlight lang="asm">mov cx,0100h
|
||||
|
||||
foo:
|
||||
push cx
|
||||
mov cl,2
|
||||
ror ax,cl ;starting with the 80186 you don't need CL for bit shifting.
|
||||
pop cx
|
||||
loop foo</lang>
|
||||
loop foo</syntaxhighlight>
|
||||
|
||||
By using <code>PUSH CX</code> and <code>POP CX</code>, you can temporarily use <code>CX</code> for something else, as long as you restore it before the <code>LOOP</code> instruction.
|
||||
|
||||
You can use other registers as loop counters as well, but not with the <code>LOOP</code> instruction - it's hardcoded to only work with <code>CX</code>. But you can do this:
|
||||
<lang asm>mov dx,0100h
|
||||
<syntaxhighlight lang="asm">mov dx,0100h
|
||||
baz:
|
||||
;your code goes here
|
||||
dec dx
|
||||
|
|
@ -148,7 +148,7 @@ jnz baz
|
|||
; A minor note for advanced programmers:
|
||||
; If you're expecting the flags to be in a particular state based on the loop body, tough luck!
|
||||
; They'll only reflect the decrement of DX from 1 to 0 at this point in the code.
|
||||
; LOOP doesn't change the flags, which makes it more useful for loops meant to compare things.</lang>
|
||||
; LOOP doesn't change the flags, which makes it more useful for loops meant to compare things.</syntaxhighlight>
|
||||
|
||||
|
||||
Another frequently used looping construct is <code>REP</code>. <code>REP</code> can be combined with certain instructions to repeat that instruction until <code>CX</code> equals zero. However, unlike <code>LOOP</code>, which can be used to repeat a block of instructions, <code>REP</code> can only repeat one. It doesn't work on all instructions, only the "string" instructions which operate on a block of memory. Typically these include <code>MOVSB</code>, <code>LODSB</code>, <code>STOSB</code>, <code>CMPSB</code>, and <code>SCASB</code> (each has a variant that ends in W instead of B, for 16-bit data.) There are also <code>REPZ</code> and <code>REPNZ</code>, which stand for "Repeat if Zero" and "Repeat if Nonzero" respectively. These two only work properly with <code>CMPSB</code> and <code>SCASB</code>, as <code>MOVSB</code>, <code>LODSB</code>, <code>STOSB</code> do not affect the flags. (The CPU doesn't detect whether <code>CX</code> equals zero using the flags, as the flags never reflect this equality to zero like you would expect.)
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Additive-primes/ALGOL-60
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Largest-proper-divisor-of-n/ALGOL-60
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Loops-Increment-loop-index-within-loop-body/ALGOL-60
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Proper-divisors/ALGOL-60
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Sequence-of-primes-by-trial-division/ALGOL-60
|
||||
|
|
@ -68,209 +68,11 @@ A syntax chart is available [http://www.softwarepreservation.org/projects/ALGOL/
|
|||
*Dec. 1968: Report on the Algorithmic Language ALGOL 68 - Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
|
||||
*Sep 1973: Revised Report on the Algorithmic Language Algol 68 - Springer-Verlag 1976 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker.
|
||||
==Coding style of samples, alphabets and stropping==
|
||||
Click "Expand" for more details.
|
||||
<div class="mw-collapsible mw-collapsed" style="width:880px; overflow:auto; background-color:parent;">
|
||||
<div class="mw-collapsible-content" style="padding-left:2em;">
|
||||
|
||||
Many of the code samples provided here have a leading <code>main:(</code> and a matching <code>)</code> at the end. These are not actually required in the language, but are included so as to highlight the main routine.
|
||||
|
||||
On some compilers, it may be necessary to include appropriate "job cards"
|
||||
or preludes in order for the programs to compile successfully. Hopefully
|
||||
not too much else is required. Examples:
|
||||
{|border="1" style="border-collapse: collapse; border: 5px double grey;" align="center"
|
||||
|| Brief Algol68
|
||||
|| Algol68 as in rosettacode
|
||||
|| Actual ELLA Algol 68RS code
|
||||
|-
|
||||
||
|
||||
print(("Hello, world!",new line))
|
||||
||
|
||||
main:(
|
||||
print(("Hello, world!",new line))
|
||||
)
|
||||
||
|
||||
PROGRAM helloworld CONTEXT VOID
|
||||
USE standard
|
||||
BEGIN
|
||||
print(("Hello, world!", new line))
|
||||
END
|
||||
FINISH
|
||||
|}
|
||||
<br><br>'''Alphabets'''
|
||||
<br><br>
|
||||
Notionally, Algol 68 source is written in two alphabets. The reserved words, mode indicants (type names) and operators that are non-symbolic (.e.g. '''and''', '''or''', ...) are generally referred to as "bold words" and usually shown in a bold font in literature. Words that are identifiers (used for "variable" names, procedure names, structure member names, ...) are in a separate, non-bold font.<br>
|
||||
The [https://www.softwarepreservation.org/projects/ALGOL/manual/a68s.txt/view Manual for CMU ALGOL 68S (on softwarepreservation.org)] refers to the non-bold words as being in timid face.
|
||||
<br><br>'''Examples of different program representations'''
|
||||
<br><br>
|
||||
At the time when ALGOL 68 was defined some predominant computers had
|
||||
24 or 36 bit words, with 6 bit character sets. Hence it was desirable that
|
||||
ALGOL 68 should be able to run on machines with only uppercase.
|
||||
As multiple fonts were generally unavailable, a method of identifying the bold words was required.<br>
|
||||
The official spec provided for different representations of the same
|
||||
program.
|
||||
Quote stropping (enclosing the bold words in single quotes)
|
||||
and Point stropping (preceeding the bold words with a dot)
|
||||
were used.<br>
|
||||
A variant of Point stropping called RES stropping was also defined.
|
||||
In RES stropping some language-defined bold words are not preceded by a dot.<br>
|
||||
A pragmatic comment may have been required to indicate which
|
||||
stropping convention was to be used, as in some of the examples below.<br>
|
||||
Upper stropping (representing the bold words by upper case and
|
||||
non-bold words in lower case) was introduced by Algol 68R.<br>
|
||||
Upper stropping is used by Algol 68RS and is one of the options for Algol 68G.<br>
|
||||
Rutgers ALGOL 68 uses quote stropping.<br>
|
||||
Most of the samples on Rosetta Code use Upper stropping.<br><br>
|
||||
Examples (pragmatic comments to set the stropping regime not shown):
|
||||
{|border="1" style="border-collapse: collapse; border: 2px double grey;" align="left"
|
||||
|| Algol68 as typically published
|
||||
'''mode''' '''xint''' = '''int''';
|
||||
'''xint''' sum sq:=0;
|
||||
'''for''' i '''while'''
|
||||
sum sq≠70×70
|
||||
'''do'''
|
||||
sum sq+:=i↑2
|
||||
'''od'''
|
||||
|| QUOTE stropping (similar to wiki)
|
||||
'mode' 'xint' = 'int';
|
||||
'xint' sum sq:=0;
|
||||
'for' i 'while'
|
||||
sum sq≠70×70
|
||||
'do'
|
||||
sum sq+:=i↑2
|
||||
'od'
|
||||
|| POINT stropping
|
||||
.MODE .XINT = .INT;
|
||||
.XINT SUM SQ:=0;
|
||||
.FOR I .WHILE
|
||||
SUM SQ .NE 70*70
|
||||
.DO
|
||||
SUM SQ .PLUSAB I .UP 2
|
||||
.OD
|
||||
|| RES stropping
|
||||
mode .xint = int;
|
||||
.xint sum sq:=0;
|
||||
for i while
|
||||
sum sq≠70×70
|
||||
do
|
||||
sum sq+:=i↑2
|
||||
od
|
||||
|| Upper stropping
|
||||
MODE XINT = INT;
|
||||
XINT sum sq:=0;
|
||||
FOR i WHILE
|
||||
sum sq /= 70*70
|
||||
DO
|
||||
sum sq PLUSAB i UP 2
|
||||
OD
|
||||
|}
|
||||
|
||||
</div></div>
|
||||
See [[ALGOL 68 Representation]].
|
||||
|
||||
== Coercion (casting) ==
|
||||
ALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program.
|
||||
<br>
|
||||
Click "Expand" for more details.
|
||||
<div class="mw-collapsible mw-collapsed" style="width:880px; overflow:auto; background-color:parent;">
|
||||
<div class="mw-collapsible-content" style="padding-left:2em;">
|
||||
|
||||
These contexts are:
|
||||
{|class="wikitable"
|
||||
!rowspan=2| N<br>
|
||||
a<br>
|
||||
m<br>
|
||||
e
|
||||
!rowspan=2| Context location
|
||||
!colspan=5| Coercions available in this context
|
||||
!rowspan=2| Coercion examples
|
||||
|-
|
||||
|bgcolor=aaaaff|Soft
|
||||
|bgcolor=aaeeaa|Weak
|
||||
|bgcolor=ffee99|Meek
|
||||
|bgcolor=ffcc99|Firm
|
||||
|bgcolor=ffcccc|Strong
|
||||
|-
|
||||
!S<br>
|
||||
t<br>
|
||||
r<br>
|
||||
o<br>
|
||||
n<br>
|
||||
g
|
||||
||Right hand side of:
|
||||
* Identity-declarations, as "~" in: <syntaxhighlight algol68>REAL x = ~</syntaxhighlight>
|
||||
* Initialisations, as "~" in: <syntaxhighlight algol68>REAL x := ~</syntaxhighlight>
|
||||
Also:
|
||||
* Actual-parameters of calls, as "~" in:<syntaxhighlight algol68>PROC: sin(~)</syntaxhighlight>
|
||||
* Enclosed clauses of casts, as "~" in: <syntaxhighlight algol68>REAL(~)</syntaxhighlight>
|
||||
* Units of routine-texts
|
||||
* Statements yielding VOID
|
||||
* All parts (but one) of a balanced clause
|
||||
* One side of an identity relation, as "~" in: <syntaxhighlight algol68> ~ IS ~</syntaxhighlight>
|
||||
|bgcolor=aaaaff rowspan=4 width="50px"| deproc- eduring
|
||||
|bgcolor=aaeeaa rowspan=3 width="50px"| all '''soft''' then weak deref- erencing
|
||||
|bgcolor=ffee99 rowspan=2 width="50px"| all '''weak''' then deref- erencing
|
||||
|bgcolor=ffcc99 rowspan=1 width="50px"| all '''meek''' then uniting
|
||||
|bgcolor=ffcccc width="50px"| all '''firm''' then widening, rowing and voiding
|
||||
|colspan=1 bgcolor=ffcccc|
|
||||
Widening occurs if there is no loss of precision. For example: An INT will be coerced to a REAL, and a REAL will be coerced to a LONG REAL. But not vice-versa. Examples:
|
||||
<syntaxhighlight algol68>INT to LONG INT
|
||||
INT to REAL
|
||||
REAL to COMPL
|
||||
BITS to []BOOL
|
||||
BYTES to STRING</syntaxhighlight>
|
||||
A variable can also be coerced (rowed) to an array of length 1.
|
||||
|
||||
For example:
|
||||
<syntaxhighlight algol68>INT to [1]INT
|
||||
REAL to [1]REAL</syntaxhighlight> etc
|
||||
|-
|
||||
!F<br>
|
||||
i<br>
|
||||
r<br>
|
||||
m
|
||||
||
|
||||
*Operands of formulas as "~" in:<syntaxhighlight algol68>OP: ~ * ~</syntaxhighlight>
|
||||
*Parameters of transput calls
|
||||
|colspan=3 bgcolor=ffcc99| Example:
|
||||
<syntaxhighlight algol68>UNION(INT,REAL) var := 1</syntaxhighlight>
|
||||
|-
|
||||
!M<br>
|
||||
e<br>
|
||||
e<br>
|
||||
k
|
||||
||
|
||||
* Trimscripts (yielding INT)
|
||||
* Enquiries: e.g. as "~" in the following
|
||||
<syntaxhighlight algol68>IF ~ THEN ... FI</syntaxhighlight> and
|
||||
<syntaxhighlight algol68>FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc</syntaxhighlight>
|
||||
* Primaries of calls (e.g. sin in sin(x))
|
||||
|colspan=4 bgcolor=ffee99|Examples:
|
||||
<syntaxhighlight algol68>REF REF BOOL to BOOL
|
||||
REF REF REF INT to INT</syntaxhighlight>
|
||||
|-
|
||||
!W<br>
|
||||
e<br>
|
||||
a<br>
|
||||
k
|
||||
||
|
||||
* Primaries of slices, as in "~" in: <syntaxhighlight algol68>~[1:99]</syntaxhighlight>
|
||||
* Secondaries of selections, as "~" in: <syntaxhighlight algol68>value OF ~</syntaxhighlight>
|
||||
|colspan=5 bgcolor=aaeeaa|Examples:
|
||||
<syntaxhighlight algol68>REF BOOL to REF BOOL
|
||||
REF REF INT to REF INT
|
||||
REF REF REF REAL to REF REAL
|
||||
REF REF REF REF STRUCT to REF STRUCT</syntaxhighlight>
|
||||
|-
|
||||
!S<br>
|
||||
o<br>
|
||||
f<br>
|
||||
t
|
||||
|| The LHS of assignments, as "~" in: <syntaxhighlight algol68>~ := ...</syntaxhighlight>
|
||||
|colspan=6 bgcolor=aaaaff| Example:
|
||||
* deproceduring of: <syntaxhighlight algol68>PROC REAL random: e.g. random</syntaxhighlight>
|
||||
|}
|
||||
For more details about Primaries and Secondaries refer to [[Operator_precedence#ALGOL_68|Operator precedence]].
|
||||
|
||||
</div></div>
|
||||
ALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program.<br/>
|
||||
See [[:Category:ALGOL_68_Coercions|ALGOL 68 Coercions]] for more details.
|
||||
|
||||
==See also==
|
||||
*[[Web 68]]
|
||||
|
|
@ -284,13 +86,14 @@ For more details about Primaries and Secondaries refer to [[Operator_precedence#
|
|||
* [https://en.wikipedia.org/wiki/S3_(programming_language) S3 for ICL 2900]
|
||||
|
||||
== Library code used in Rosetta Code samples ==
|
||||
[https://rosettacode.org/wiki/ALGOL_68/prelude Various (including the standard prelude)]<br/>
|
||||
<br/>
|
||||
[https://rosettacode.org/wiki/Category:ALGOL_68-files File related]<br/>
|
||||
[https://rosettacode.org/wiki/Category:ALGOL_68-l-system L-System related]<br/>
|
||||
[https://rosettacode.org/wiki/Category:ALGOL_68-primes Prime related]<br/>
|
||||
[https://rosettacode.org/wiki/Category:ALGOL_68-rows Row (array) related]<br/>
|
||||
[https://rosettacode.org/wiki/Category:ALGOL_68-sort Sorting related]<br/>
|
||||
* [[ALGOL_68/prelude|Various (including the standard prelude)]]
|
||||
*
|
||||
* [[:Category:ALGOL_68-bits|bit-manipulation related]]
|
||||
* [[:Category:ALGOL_68-files|File related]]
|
||||
* [[:Category:ALGOL_68-l-system|L-System related]]
|
||||
* [[:Category:ALGOL_68-primes|Prime related]]
|
||||
* [[:Category:ALGOL_68-rows|Row (array) related]]
|
||||
* [[:Category:ALGOL_68-sort|Sorting related]]
|
||||
|
||||
== Tools ==
|
||||
[[Syntax_highlighting_using_Mediawiki_formatting#ALGOL 68|Format an upper-stropped Algol 68 source with Mediawiki markup]]<br/>
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Elliptic-curve-arithmetic/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Permutation-test/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Primes---allocate-descendants-to-their-ancestors/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Pythagoras-tree/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Solve-a-Numbrix-puzzle/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Solve-the-no-connection-puzzle/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Text-processing-2/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Wasteful-equidigital-and-frugal-numbers/ALGOL-68
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Additive-primes/ALGOL-M
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Levenshtein-distance/ANSI-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/M-bius-function/ANSI-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Magic-constant/ANSI-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Map-range/ANSI-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Loops-Infinite/APL
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Sort-a-list-of-object-identifiers/APL
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Strip-comments-from-a-string/APL
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Tic-tac-toe/APL
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/M-bius-function/ASIC
|
||||
|
|
@ -4,7 +4,7 @@
|
|||
}}
|
||||
Action! is a language written by Clinton Parker and published by Optimized Sytems Software (OSS) for the Atari 8-bit line of home computers.
|
||||
It is related to ALGOL and optimized for single-pass compilation to 6502 code.
|
||||
|
||||
A manual for the language is available at https://seriouscomputerist.atariverse.com/media/pdf/manual/OSS%20OS-A+%20-%20Manual%20(1983).pdf
|
||||
==See Also==
|
||||
* [[wp:Action!_(programming_language)|Action! on Wikipedia]]
|
||||
* [[ALGOL 68]]
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Cistercian-numerals/Ada
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Curzon-numbers/Ada
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Bin-given-limits/AppleScript
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Nth-root/AppleScript
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Write-float-arrays-to-a-text-file/AppleScript
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Cistercian-numerals/Applesoft-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Formatted-numeric-output/Applesoft-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Levenshtein-distance/Applesoft-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Multi-dimensional-array/Applesoft-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Towers-of-Hanoi/Applesoft-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arithmetic-derivative/Arturo
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Dice-game-probabilities/Arturo
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Element-wise-operations/Arturo
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Entropy-Narcissist/Arturo
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Munching-squares/Arturo
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Evaluate-binomial-coefficients/Asymptote
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Pi/Atari-BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
{{stub}}{{language|AutoHotKey V2}}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Category:AutoHotKey_V2
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Hello-world-Graphical/AutoHotKey-V2
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
{{stub}}AutoHotkey V2 is an [[open source]] programming language for Microsoft [[Windows]].
|
||||
|
||||
AutoHotkey v2 is a major update to the AutoHotkey language, which includes numerous new features and improvements.
|
||||
|
||||
== Citations ==
|
||||
|
||||
* [https://www.autohotkey.com/docs/v2/ Documentation]
|
||||
* [http://autohotkey.com/download Downloads]
|
||||
* [http://autohotkey.com/docs/scripts/ Script Showcase]
|
||||
* [http://autohotkey.com/boards/ New Community forum]
|
||||
* [http://www.autohotkey.com/forum/ Archived Community forum]
|
||||
* [http://ahkscript.org/foundation AutoHotkey Foundation LLC]
|
||||
* [[wp:AutoHotkey|AutoHotkey on Wikipedia]]
|
||||
* <span class="external text" rel="mw:ExtLink nofollow">#ahk</span> on [http://webchat.freenode.net/?channels=%23ahk Freenode Web interface]
|
||||
* [[:Category:AutoHotkey_Originated]]
|
||||
{{language|Ayrch}}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Category:Autohotkey_V2
|
||||
|
|
@ -1 +0,0 @@
|
|||
../../Task/Hello-world-Graphical/Autohotkey-V2
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Partition-an-integer-x-into-n-primes/BASIC
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Evaluate-binomial-coefficients/BASIC256
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Find-common-directory-path/BQN
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Globally-replace-text-in-several-files/BQN
|
||||
|
|
@ -1 +1,17 @@
|
|||
{{stub}}{{language|Ballerina}}
|
||||
{{language|Ballerina
|
||||
|exec=bytecode
|
||||
|strength=strong
|
||||
|safety=safe
|
||||
|express=explicit
|
||||
|checking=static
|
||||
|gc=yes
|
||||
|hopl=no
|
||||
|site=https://ballerina.io
|
||||
}}
|
||||
'''[https://en.wikipedia.org/wiki/Ballerina_(programming_language) Ballerina]''' is an open source general-purpose programming language designed and supported by [https://wso2.com/ WSO2] for cloud-era application programmers.
|
||||
|
||||
It is under development on [https://github.com/ballerina-platform/ballerina-lang GitHub] and is fully documented [https://ballerina.io here].
|
||||
|
||||
Ballerina was first publicly announced in 2017 and version 1.0 was released on September 10, 2019. However, a major overhaul took place in 2022 when [https://blog.ballerina.io/posts/2022-02-01-announcing-ballerina-2201.0.0-swan-lake/ Ballerina 2201.0.0 (Swan Lake)] was released.
|
||||
|
||||
The current version (2201.12.3) has distributions available for Windows, Linux and macOS and can be downloaded [https://ballerina.io/downloads/ here].
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/A+B/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/ABC-problem/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/AKS-test-for-primes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Abundant-deficient-and-perfect-number-classifications/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Abundant-odd-numbers/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Accumulator-factory/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Achilles-numbers/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Ackermann-function/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Add-a-variable-to-a-class-instance-at-runtime/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Additive-primes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Address-of-a-variable/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Almost-prime/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Amb/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Angle-difference-between-two-bearings/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Anti-primes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Apply-a-callback-to-an-array/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Approximate-equality/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arithmetic-Complex/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arithmetic-Integer/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arithmetic-Rational/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arithmetic-numbers/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Array-concatenation/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Array-length/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Arrays/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Ascending-primes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Associative-array-Creation/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Associative-array-Iteration/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Associative-array-Merging/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Arithmetic-mean/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Mean-angle/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Mean-time-of-day/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Median/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Mode/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Pythagorean-means/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Root-mean-square/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Averages-Simple-moving-average/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Balanced-brackets/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Boolean-values/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Caesar-cipher/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Calculating-the-value-of-e/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Case-sensitivity-of-identifiers/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Character-codes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Classes/Ballerina
|
||||
|
|
@ -0,0 +1 @@
|
|||
../../Task/Count-in-octal/Ballerina
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue