ALGOL 68/prelude: Difference between revisions
→string in string: more bugfix
m (Summarise the various preclude templates - trying to minimise duplication of code.) |
(→string in string: more bugfix) |
||
| (24 intermediate revisions by 4 users not shown) | |||
Line 1:
The following summarises the useful and various [[ALGOL 68]]
These are used in several ALGOL 68 code samples.
Note: These are not part of the classic [http://web.comlab.ox.ac.uk/people/Jeremy.Gibbons/wg21/ UNESCO IFIP Working Group 2.1]'s standard prelude, rather they were specifically created for [[Main_Page|Rosetta Code]]'s ALGOL 68 code examples.
=== prelude/general.a68 ===
Used in:
[[
{{Template:
===
Used in:
[[Primality_by_Trial_Division#ALGOL 68|Primality_by_Trial_Division]] and
[[Trial_factoring_of_a_Mersenne_number#ALGOL 68|Trial_factoring_of_a_Mersenne_number]].
{{Template:prelude/pow_mod.a68}}
=== prelude/pow_mod.a68 ===
Used in:
[[Miller-Rabin test#ALGOL 68|Miller-Rabin test]],
[[Multiplicative order#ALGOL 68|Multiplicative order]] and
[[Trial factoring of a Mersenne number#ALGOL 68|Trial factoring of a Mersenne number]].
{{Template:prelude/pow_mod.a68}}
=== prelude/sort.a68 ===
Used in:
[[Multiplicative order#ALGOL 68|Multiplicative order]],
[[Sort_an_array_of_composite_structures#ALGOL_68|Sort an array of composite structures]] and
[[Sort most popular programming languages#ALGOL 68|Sort most popular programming languages]].
{{Template:prelude/sort.a68}}
=== prelude/errata.a68 ===
A collections of OPerators, MODES and variables that are "kind of" implied by Algol68's definition
Used in: [[Plot coordinate pairs#ALGOL 68|Plot coordinate pairs]].
* c.f. [[ALGOL_68/prelude/errata.a68]]
=== prelude/graph_2d.a68 ===
A simple tookit for producing basic 2d graphs.
Used in: [[Plot coordinate pairs#ALGOL 68|Plot coordinate pairs]].
* c.f. [[ALGOL_68/prelude/graph_2d.a68]]
=== string in string ===
The Algol 68G compiler/interpreter provides a procedure string in string, similar to the standard char in string.
<br/>
Here is a version for other implementations of Algol 68:
<syntaxhighlight lang=algol68># A string in string procedure for use with compilers other than Algol 68G #
# returns TRUE if s is in t, FALSE otherwise. #
# if pos is not NIL: #
# if s is in t, pos is set to the starting position os s in t, #
# pos is left unchanged is s is not in t #
PROC string in string = ( STRING s, REF INT pos, STRING t )BOOL:
IF s = "" THEN
# s is empty #
IF REF INT(pos) ISNT REF INT(NIL) THEN pos := LWB t FI;
TRUE
ELSE
# s and t are non-empty #
BOOL found := FALSE;
CHAR first char = s[ LWB s ];
INT s length = ( UPB s - LWB s ) + 1;
INT first pos := LWB t;
INT end pos = ( UPB t - s length ) + 1;
WHILE NOT found AND first pos <= end pos DO
found := char in string( first char, first pos, t[ first pos : @ first pos ] );
IF NOT found THEN
# the first character is not present #
first pos := end pos + 1
ELIF first pos > end pos THEN
# the first character is present but the rest of the string #
# is too short to contain s #
found := FALSE
ELIF s = t[ first pos : first pos + ( s length - 1 ) ] THEN
# found the full string s at first pos #
IF REF INT(pos) ISNT REF INT(NIL) THEN pos := first pos FI
ELSE
# haven't got the full string s at first pos #
first pos +:= 1;
found := FALSE
FI
OD;
found
FI # string in string # ;</syntaxhighlight>
=== aArray.a68 ===
An associative array MODE for STRING keys and values. This is used by a number of Rosseta Code tasks.
<syntaxhighlight lang=algol68># associative array for STRING elements and keys #
# the modes allowed as associative array element values - change to suit #
MODE AAVALUE = STRING;
# the modes allowed as associative array element keys - change to suit #
MODE AAKEY = STRING;
# an initial value for an array element #
AAVALUE init element value = "";
PR read "aArrayBase.a68" PR
</syntaxhighlight>
=== aArrayBase.a68 ===
The MODEs for associative arrays. The AAKEY and AAVALUE MODEs must be defined as required.
<br>An item "init element value" must also be defined.
<br>If AAKEY is not STRING, a suitable HASH operator will also need to be defined.
<syntaxhighlight lang=algol68># associative array handling using hashing #
# AAKEY and AAVALUE modes and OP HASH(AAKEY)INT must be defined to use this #
# nil element value #
REF AAVALUE nil value = NIL;
# generates a hash value from a STRING - additional HASH operators should be #
# defined for other AAKEY modes #
OP HASH = ( STRING key )INT:
BEGIN
INT result := ABS ( UPB key - LWB key ) MOD hash modulus;
FOR char pos FROM LWB key TO UPB key
DO
result PLUSAB ( ABS key[ char pos ] - ABS " " );
result MODAB hash modulus
OD;
result
END; # HASH #
# an element of an associative array #
MODE AAELEMENT = STRUCT( AAKEY key, REF AAVALUE value );
# a list of associative array elements - the element values with a #
# particular hash value are stored in an AAELEMENTLIST #
MODE AAELEMENTLIST = STRUCT( AAELEMENT element, REF AAELEMENTLIST next );
# nil element list reference #
REF AAELEMENTLIST nil element list = NIL;
# nil element reference #
REF AAELEMENT nil element = NIL;
# the hash modulus for the associative arrays #
INT hash modulus = 256;
# a mode representing an associative array #
MODE AARRAY = STRUCT( [ 0 : hash modulus - 1 ]REF AAELEMENTLIST elements
, INT curr hash
, REF AAELEMENTLIST curr position
);
# initialises an associative array so all the hash chains are empty #
OP INIT = ( REF AARRAY array )REF AARRAY:
BEGIN
FOR hash value FROM 0 TO hash modulus - 1 DO ( elements OF array )[ hash value ] := nil element list OD;
array
END; # INIT #
# gets a reference to the value corresponding to a particular key in an #
# associative array - the element is created if it doesn't exist #
PRIO // = 1;
OP // = ( REF AARRAY array, AAKEY key )REF AAVALUE:
BEGIN
REF AAVALUE result;
INT hash value = HASH key;
# get the hash chain for the key #
REF AAELEMENTLIST element := ( elements OF array )[ hash value ];
# find the element in the list, if it is there #
BOOL found element := FALSE;
WHILE ( element ISNT nil element list )
AND NOT found element
DO
found element := ( key OF element OF element = key );
IF found element
THEN
result := value OF element OF element
ELSE
element := next OF element
FI
OD;
IF NOT found element
THEN
# the element is not in the list #
# - add it to the front of the hash chain #
( elements OF array )[ hash value ]
:= HEAP AAELEMENTLIST
:= ( HEAP AAELEMENT := ( key
, HEAP AAVALUE := init element value
)
, ( elements OF array )[ hash value ]
);
result := value OF element OF ( elements OF array )[ hash value ]
FI;
result
END; # // #
# returns TRUE if array contains key, FALSE otherwise #
PRIO CONTAINSKEY = 1;
OP CONTAINSKEY = ( REF AARRAY array, AAKEY key )BOOL:
BEGIN
# get the hash chain for the key #
REF AAELEMENTLIST element := ( elements OF array )[ HASH key ];
# find the element in the list, if it is there #
BOOL found element := FALSE;
WHILE ( element ISNT nil element list )
AND NOT found element
DO
found element := ( key OF element OF element = key );
IF NOT found element
THEN
element := next OF element
FI
OD;
found element
END; # CONTAINSKEY #
# gets the first element (key, value) from the array #
OP FIRST = ( REF AARRAY array )REF AAELEMENT:
BEGIN
curr hash OF array := LWB ( elements OF array ) - 1;
curr position OF array := nil element list;
NEXT array
END; # FIRST #
# gets the next element (key, value) from the array #
OP NEXT = ( REF AARRAY array )REF AAELEMENT:
BEGIN
WHILE ( curr position OF array IS nil element list )
AND curr hash OF array < UPB ( elements OF array )
DO
# reached the end of the current element list - try the next #
curr hash OF array +:= 1;
curr position OF array := ( elements OF array )[ curr hash OF array ]
OD;
IF curr hash OF array > UPB ( elements OF array )
THEN
# no more elements #
nil element
ELIF curr position OF array IS nil element list
THEN
# reached the end of the table #
nil element
ELSE
# have another element #
REF AAELEMENTLIST found element = curr position OF array;
curr position OF array := next OF curr position OF array;
element OF found element
FI
END; # NEXT #
</syntaxhighlight>
=== URI Parser ===
An Algol 68 URI parser is here: [[URL_parser/URI_parser_ALGOL68]].
=== The classic [http://web.comlab.ox.ac.uk/people/Jeremy.Gibbons/wg21/ UNESCO IFIP Working Group 2.1]'s standard prelude contents ===
Names from the "official" standard prelude: <, <=, +, +:=, +=:, +*, &, ∧, ⌈, ↓, ⌋, ≥, ≤, =, ∨, ⊥, ÷, ÷×, ÷×:=, ÷*, ÷*:=, ÷:=, ×, ×:=, ~, ↑, *, **, *:=, ¬, -, -:=, /, /:=, /=, %, %×, %×:=, %*, %*:=, %:=, >, >=, =, ABS, AND, ARG, BIN, BITS, BOOL, BYTES, CHANNEL, CHAR, COMPL, CONJ, DIVAB, DOWN, ELEM, ENTIER, EQ, FILE, FORMAT, GE, GT, I, IM, INT, LE, LENG, LEVEL, LT, LWB, MINUSAB, MOD, MODAB, NE, NOT, ODD, OR, OVER, OVERAB, PLUSAB, PLUSTO, RE, REAL, REPR, ROUND, SEMA, SHL, SHORTEN, SHR, SIGN, STRING, TIMESAB, UP, UPB, VOID, arccos, arcsin, arctan, associate, backspace, bin possible, bits lengths, bits pack, bits shorths, bits width, blank, bytes lengths, bytes pack, bytes shorths, bytes width, chan, char in string, char number, close, compressible, cos, create, errorchar, estab possible, establish, exp, exp width, fixed, flip, float, flop, get, get bin, get possible, getf, int shorths, int width, last random, line number, ln, lock, make conv, make term, max abs char, max int, max real, newline, newpage, next random, null character, on char error, on format end, on line end, on logical file end, on page end, on physical file end, on value error, open, page number, pi, print, printf, put, put bin, put possible, putf, random, read, read bin, readf, real lengths, real shorths, real width, reidf, reidf possible, reset, reset possible, scratch, set, set char number, set possible, sin, small real, space, sqrt, stand back, stand back channel, stand in, stand in channel, stand out, stand out channel, standconv, stop, tan, whole, write, write bin, writef, L BITS, L BYTES, L COMPL, L INT, L REAL, L arccos, L arcsin, L arctan, L bits pack, L bits width, L bytes pack, L bytes width, L cos, L exp, L exp width, L int width, L last random, L ln, L max int, L max real, L next random, L pi, L random, L real width, L sin, L small real, L sqrt, L tan.
The L indicates extra precision, eg REAL, or LONG REAL or LONG LONG REAL etc, even SHORT REAL etc
These names next were intended for internal compiler use only: אBEYOND, אBFILE, אBOOK, אCOLLECTION, אCOLLITEM, אCONV, אCPATTERN, אFLEXTEXT, אFPATTERN, אFRAME, אGPATTERN, אINSERTION, אINTYPE, אNUMBER, אOUTTYPE, אPATTERN, אPICTURE, אPIECE, אPOS, אROWS, אSFRAME, אSIMPLIN, אSIMPLOUT, אSINSERT, אSTRAIGHTIN, אSTRAIGHTOUT, אTEXT, אalignment, אassociate format, אbfileprotect, אbook bounds, אchainbfile, אchar dig, אcheck pos, אcurrent pos, אdig char, אdo fpattern, אedit string, אfalse, אfile available, אfrom bin, אget char, אget good file, אget good line, אget good page, אget insertion, אget next picture, אgremlins, אidf ok, אindit string, אline ended, אlockedbfile, אlogical file ended, אmatch, אnext pos, אpage ended, אphysical file ended, אput char, אput insertion, אset bin mood, אset char mood, אset mood, אset read mood, אset write mood, אstandardize, אstaticize frames, אstaticize insertion, אstring to L int, אstring to L real, אsubfixed, אsubwhole, אto bin, אundefined, אL standardize
<!--[[Category:ALGOL 68|*]]-->
| |||