From 240ab1b0fce07f26ccd3c1dfac8580b349f4f65f Mon Sep 17 00:00:00 2001 From: davidly Date: Sat, 6 Jul 2024 09:53:43 -0700 Subject: [PATCH] RHA (Minisystems) ALGOL v5.5 --- RHA (Minisystems) ALGOL v55/ALGOL.EXE | Bin 0 -> 17332 bytes RHA (Minisystems) ALGOL v55/ALGOL.IAG | 1710 +++++++++ RHA (Minisystems) ALGOL v55/ALGOL60.CNT | 107 + RHA (Minisystems) ALGOL v55/ALGOL60.HLP | Bin 0 -> 142409 bytes RHA (Minisystems) ALGOL v55/ALGOL60.TXT | 4465 +++++++++++++++++++++++ RHA (Minisystems) ALGOL v55/ALIB.ALG | 47 + RHA (Minisystems) ALGOL v55/ALIB.ASC | Bin 0 -> 896 bytes RHA (Minisystems) ALGOL v55/ALIB.SRC | 121 + RHA (Minisystems) ALGOL v55/ALIBL.ALG | 10 + RHA (Minisystems) ALGOL v55/ALINK.EXE | Bin 0 -> 15488 bytes RHA (Minisystems) ALGOL v55/ALINKL.EXE | Bin 0 -> 14080 bytes RHA (Minisystems) ALGOL v55/ALINKS.EXE | Bin 0 -> 15281 bytes RHA (Minisystems) ALGOL v55/ARUN.EXE | Bin 0 -> 15744 bytes RHA (Minisystems) ALGOL v55/ARUNL.EXE | Bin 0 -> 14336 bytes RHA (Minisystems) ALGOL v55/E.ALG | 39 + RHA (Minisystems) ALGOL v55/HELLO.ALG | 26 + RHA (Minisystems) ALGOL v55/ICOM.EXE | Bin 0 -> 12969 bytes RHA (Minisystems) ALGOL v55/ICOM.IAG | 892 +++++ RHA (Minisystems) ALGOL v55/KEY.ALG | 13 + RHA (Minisystems) ALGOL v55/LCASE.ALG | 65 + RHA (Minisystems) ALGOL v55/MMIND.ALG | 111 + RHA (Minisystems) ALGOL v55/MMIND.ASC | Bin 0 -> 1152 bytes RHA (Minisystems) ALGOL v55/QSORT.ALG | 32 + RHA (Minisystems) ALGOL v55/QSORT.DAT | 6 + RHA (Minisystems) ALGOL v55/SCALE.ALG | 415 +++ RHA (Minisystems) ALGOL v55/SCALE.ASC | Bin 0 -> 4608 bytes RHA (Minisystems) ALGOL v55/SIEVE.ALG | 38 + RHA (Minisystems) ALGOL v55/TESTDEV.ALG | 17 + RHA (Minisystems) ALGOL v55/TESTDEV.ASC | Bin 0 -> 256 bytes RHA (Minisystems) ALGOL v55/TTT.ALG | 242 ++ RHA (Minisystems) ALGOL v55/UCASE.ALG | 68 + RHA (Minisystems) ALGOL v55/VDU.ALG | 218 ++ RHA (Minisystems) ALGOL v55/m.bat | 7 + 33 files changed, 8649 insertions(+) create mode 100644 RHA (Minisystems) ALGOL v55/ALGOL.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ALGOL.IAG create mode 100644 RHA (Minisystems) ALGOL v55/ALGOL60.CNT create mode 100644 RHA (Minisystems) ALGOL v55/ALGOL60.HLP create mode 100644 RHA (Minisystems) ALGOL v55/ALGOL60.TXT create mode 100644 RHA (Minisystems) ALGOL v55/ALIB.ALG create mode 100644 RHA (Minisystems) ALGOL v55/ALIB.ASC create mode 100644 RHA (Minisystems) ALGOL v55/ALIB.SRC create mode 100644 RHA (Minisystems) ALGOL v55/ALIBL.ALG create mode 100644 RHA (Minisystems) ALGOL v55/ALINK.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ALINKL.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ALINKS.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ARUN.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ARUNL.EXE create mode 100644 RHA (Minisystems) ALGOL v55/E.ALG create mode 100644 RHA (Minisystems) ALGOL v55/HELLO.ALG create mode 100644 RHA (Minisystems) ALGOL v55/ICOM.EXE create mode 100644 RHA (Minisystems) ALGOL v55/ICOM.IAG create mode 100644 RHA (Minisystems) ALGOL v55/KEY.ALG create mode 100644 RHA (Minisystems) ALGOL v55/LCASE.ALG create mode 100644 RHA (Minisystems) ALGOL v55/MMIND.ALG create mode 100644 RHA (Minisystems) ALGOL v55/MMIND.ASC create mode 100644 RHA (Minisystems) ALGOL v55/QSORT.ALG create mode 100644 RHA (Minisystems) ALGOL v55/QSORT.DAT create mode 100644 RHA (Minisystems) ALGOL v55/SCALE.ALG create mode 100644 RHA (Minisystems) ALGOL v55/SCALE.ASC create mode 100644 RHA (Minisystems) ALGOL v55/SIEVE.ALG create mode 100644 RHA (Minisystems) ALGOL v55/TESTDEV.ALG create mode 100644 RHA (Minisystems) ALGOL v55/TESTDEV.ASC create mode 100644 RHA (Minisystems) ALGOL v55/TTT.ALG create mode 100644 RHA (Minisystems) ALGOL v55/UCASE.ALG create mode 100644 RHA (Minisystems) ALGOL v55/VDU.ALG create mode 100644 RHA (Minisystems) ALGOL v55/m.bat diff --git a/RHA (Minisystems) ALGOL v55/ALGOL.EXE b/RHA (Minisystems) ALGOL v55/ALGOL.EXE new file mode 100644 index 0000000000000000000000000000000000000000..ab830803d6a3ba5d8f54307c1cc4557301438ff2 GIT binary patch literal 17332 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 literal 0 HcmV?d00001 diff --git a/RHA (Minisystems) ALGOL v55/ALGOL.IAG b/RHA (Minisystems) ALGOL v55/ALGOL.IAG new file mode 100644 index 0000000..9af5240 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/ALGOL.IAG @@ -0,0 +1,1710 @@ + +'BEGIN' +'BYTE''ARRAY' DIG,LBUF[1:100],LNAM[1:100],IDN[0:100]; +'INTEGER''ARRAY' ILEV,NLEV,LLEV[1:5]; +'INTEGER' INDEV,DEV,CHAR,LINE,BS,DECL,TYPE,NLAB,FIRST, + LDPT,SIZE,NADR,DBASE,NODEC,ND1,ND2,ADDR, + DEPTH,LBP,MAXNID, + ADEPTH,PDEPTH,FIXSP,NPN,SCHAR,BSIZE,RSIZE, + DEVT,BYTES,ITEM,ILEP,NAPT,MAXLAB,TLIN, + ILFP,FRFP,MAX,MXV; +'BOOLEAN' SECOND,DOLL,LETTER,DIGIT,FOUND,FRED,FFET,AEREAD, + HOL1,FULL,STRING,BUGS,RERUN,LIST,IDTAB,PRECOM,BITSTR, + LTAB,DIAGNOSTICS; + +'COMMENT' 10/10/80 COMPACT OUTPUT; +'COMMENT' 4/11/82 TANDY MULTIPLES, FASTER INPUT; +'COMMENT' 12/6/83 RING CHARACTER BUFFER, LINE NUMBERS FROM + START OF FILE; +'COMMENT' 27/2/84 EXTERNAL REFERENCES, + AUG-84, ADDITION OF VDEP, OCT-84 MULTIPLE ASSIGNMENTS + AND PARAMETER RECOGNITION IMPROVED, ADDITION OF + CASE, REPEAT AND WHILE; +'COMMENT' 26/4/85 INDEFINITE LENGTH IDENTIFIERS; + +'INTEGER' 'PROCEDURE' FREESP; IOC(10); + +MAXNID:=FREESP%2; 'IF' MAXNID<0 'THEN' MAXNID:=32767+MAXNID; +MAXNID:=(MAXNID-700)%7; +MAXLAB:=MAXNID%4; MAXNID:=MAXNID-MAXLAB; + +'BEGIN''INTEGER''ARRAY' ILNP,VADR,VDEP[1:MAXNID], + FRNP,FRLN,FLINE[1:MAXLAB]; +'BYTE''ARRAY' IL[0:MAXNID*6],ILVT,ILBD[1:MAXNID], + FRN[0:MAXLAB*6],FLVT,FLBD[1:MAXLAB]; + +'COMMENT' IOC(17) FINDS OUTPUT CHANNEL, +IOC(21) SELECTS OUTPUT CHANNEL, +IOC(22) FLUSHES OUT HALF FILLED BYTES, +BS2() OUTPUTS 2 BIT CODE, +BS8() OUTPUTS 1 BYTE, +BS16() OUTPUTS 1 WORD, +BITQ() OUTPUTS CODES FOR BYTES OR WORDS; + +'PROCEDURE' BS2(N); 'VALUE' N; 'INTEGER' N; +IOC(18); + +'PROCEDURE' BS8(N); 'VALUE' N; 'INTEGER' N; +IOC(19); + +'PROCEDURE' BS16(N); 'VALUE' N; 'INTEGER' N; +IOC(20); + +'PROCEDURE' BITQ(N,M); 'VALUE' N,M; 'INTEGER' N,M; +'BEGIN' 'IF' N>255 'THEN' + 'BEGIN' BS2(3); BS2(M); IOC(20); 'END' +'ELSE' 'BEGIN' BS2(M); IOC(19); 'END'; +'END'; + +'PROCEDURE' SNAM; +'IF' ILEP=1 'THEN' WRITE(DEVT,"MAIN SOURCE") +'ELSE''BEGIN''INTEGER' I; +WRITE(DEVT,"LIBRARY "); I:=NAPT; +LNOU: 'IF' LNAM[I]#0 'THEN' + 'BEGIN' CHOUT(DEVT,LNAM[I]); I:=I+1; 'GOTO' LNOU; + 'END'; +'END' OUTPUT SOURCE NAME; + +'PROCEDURE' INCH; +LOOP: +'IF' HOL1 'THEN' HOL1:='FALSE''ELSE' +'BEGIN' CHIN(,CHAR); +'COMMENT' FOR TRS-80 DO 'IF' CHAR=64 'THEN' CHAR:=94 'ELSE'; +'IF' CHAR=26 'THEN' + 'BEGIN' CLOSE(INDEV); + 'IF' (LTAB 'OR' IDTAB) 'AND''NOT' LIST 'THEN' + 'BEGIN' SKIP(DEVT); WRITE(DEVT,"END OF "); + SNAM; + 'END'; + 'IF' ILEP=1 'THEN' + 'BEGIN' INPUT(INDEV); + 'IF' INDEV>0 'THEN' + 'BEGIN' CHIN(INDEV); 'GOTO' LOOP 'END'; + INDEV:=0; CHIN(0); + WARN(49); 'GOTO' EPROG; + 'END' NOT LIBRARY FILE 'ELSE' + 'BEGIN' ILEP:=ILEP-1; INDEV:=ILEV[ILEP]; + LNAM[NAPT]:=0; NAPT:=NLEV[ILEP]; + LINE:=LLEV[ILEP]; CHIN(INDEV); + 'GOTO' LOOP; + 'END' LIBRARY CALL + 'END' END OF FILE; + +LBP:=LBP+1; 'IF' LBP=101 'THEN' LBP:=1; +LBUF[LBP]:=CHAR; +'IF' CHAR=13 'THEN' + 'BEGIN' LINE:=LINE+1; TLIN:=TLIN+1; + 'END'; +'IF' LIST 'THEN' + 'BEGIN' 'IF' CHAR=13 'THEN' + 'BEGIN' SKIP(DEVT); + WRITE(DEVT,TLIN,":",LINE,">"); + 'END''ELSE' + 'IF' CHAR # 10 'THEN' CHOUT(DEVT,CHAR); + 'END'; +'END' NEW INPUT NEEDED; + +'PROCEDURE' MSYM(I,K,J);'VALUE'I,K,J;'INTEGER'I,K,J; +'IF' BS=I 'THEN' + 'BEGIN' INCH; + 'IF'CHAR=K 'THEN' BS:=J 'ELSE' HOL1:='TRUE'; + 'END'; + +'PROCEDURE' LBS; +'BEGIN' BS:=40*(CHAR-64); +INCH; BS:=BS+CHAR-64; +'IF'BS<64'THEN'BS:=BS+64; +'IF' BS=725 'THEN''BEGIN' INCH; + 'IF' CHAR=80 'THEN' BS:=726; + 'END' FIND IF REPEAT OR REAL; +'END' LONG BASIC SYMBOL; + +'PROCEDURE' ABS; +'BEGIN' +L5: +'IF' DOLL 'THEN''BEGIN' WARN(27); 'GOTO' EPROG; + 'END' READING BEYOND THE END; +LYY: INCH; +'IF'CHAR<33'THEN''GOTO'LYY; +'IF'CHAR>95'THEN'BS:=CHAR-96'ELSE' +'IF'CHAR>90'THEN'BS:=CHAR-64'ELSE' +'IF'CHAR=39'THEN' + 'BEGIN' INCH; LBS; +LZZ: INCH; + 'IF' CHAR#39 'THEN''GOTO' LZZ 'ELSE' 'GOTO' CHKLBS; + 'END' +'ELSE''IF' CHAR<65 'THEN' + 'BEGIN' BS:=CHAR; + 'IF' CHAR>57 'THEN' + 'BEGIN' MSYM(58,61,7000);MSYM(60,61,63);MSYM(62,61,38); + 'COMMENT' FOR TRS80 DO MSYM(60,60,27) MSYM(62,62,29); + 'END' POSSIBLE MULTIPLE + 'END' +'ELSE''IF'FULL'THEN' + 'BEGIN' LBS; +LAA: INCH; + 'IF'CHAR>64'AND'CHAR<91'THEN''GOTO'LAA; + HOL1:='TRUE'; +CHKLBS: +'IF' BS=123 'THEN' + 'BEGIN''IF' DIAGNOSTICS 'THEN''GOTO' L5 + 'ELSE' 'BEGIN' L6: ABS; 'IF' BS#203 'THEN' + 'GOTO' L6 'ELSE''GOTO' L5; + 'END' DIAGNOSTICS ARE COMMENTS; + 'END' CC FOUND; +'IF' BS=203 'THEN''GOTO' L5; + +'IF' BS=489 'THEN' + 'BEGIN' 'INTEGER' J; + ILEV[ILEP]:=INDEV; + LLEV[ILEP]:=LINE; LINE:=1; + NLEV[ILEP]:=NAPT; J:=NAPT; +L4: 'IF' LNAM[J]#0 'THEN''BEGIN' J:=J+1; 'GOTO' L4; + 'END' FIND END OF CURRENT NAME; + NAPT:=J; ILEP:=ILEP+1; +L1: INCH; + 'IF' CHAR#34 'THEN' 'GOTO' L1; IOC(1); +L2: INCH; + 'IF' CHAR=34 'THEN' 'GOTO' L3; + LNAM[J]:=CHAR; J:=J+1; LNAM[J]:=0; + CHOUT(7,CHAR); 'GOTO' L2; +L3: IOC(5); INPUT(INDEV); + 'IF' INDEV<1 'THEN' + 'BEGIN' WARN(51); 'GOTO' EPROG; 'END'; + CHIN(INDEV); + 'IF' (LTAB 'OR' IDTAB) 'AND''NOT' LIST 'THEN' + 'BEGIN' SKIP(DEVT); WRITE(DEVT,"START OF "); + SNAM; + 'END'; + 'GOTO' LYY; + 'END' LIBRARY CALL; + 'END' LONG BASIC SYMBOL +'ELSE'BS:=CHAR-64; + +DIGIT:=BS>47 'AND' BS<58; LETTER:=BS<27; DOLL:=BS=249; +'END' ABS; + +'BOOLEAN''PROCEDURE' TERM; +TERM:=BS=214 'OR' BS=854 'OR' BS=59 'OR' BS=212 'OR' DOLL; + +'BOOLEAN''PROCEDURE' ATYPE; +ATYPE:=TYPE>4 'AND' TYPE<8; + +'BOOLEAN''PROCEDURE' BTYPE; +BTYPE:=TYPE=3 'OR' TYPE=7 'OR' TYPE=13 'OR' TYPE=18 'OR' TYPE=23; + +'INTEGER''PROCEDURE' EXPAND(X); 'VALUE' X; 'INTEGER' X; +'BEGIN' +'IF' X<=31 'THEN' X:=X+64; +EXPAND:=X; +'END' EXPAND; + +'PROCEDURE' DEFINE(L1,L2); 'VALUE' L1,L2; 'INTEGER' L1,L2; +'IF' BITSTR 'THEN' +'BEGIN' IOC(21); BITQ(L1,2); BS2(1); BITQ(L2,1); 'END' +'ELSE''BEGIN' SKIP(DEV); WRITE(DEV,"L",L1,"=L",L2); ITEM:=0; + SKIP(DEV); 'END'; + + +'INTEGER''PROCEDURE' LOWER(X); 'VALUE' X; 'INTEGER' X; +LOWER:=X-X%BSIZE*BSIZE; + +'PROCEDURE' IDENT; +'BEGIN''INTEGER' I,J; +IDN[0]:='IF' BS<27 'THEN' BS+64 'ELSE' BS+21; +I:=1; +NCH: INCH; +'IF' CHAR>95 'THEN' + 'BEGIN' + IDN[I]:=CHAR-32; I:=I+1; 'GOTO' NCH; + 'END' +'ELSE''IF' CHAR>47 'AND' CHAR<58 'THEN' + 'BEGIN' + IDN[I]:=CHAR; I:=I+1; 'GOTO' NCH; + 'END' +'ELSE''IF' 'NOT' FULL 'AND' CHAR>64 'AND' CHAR<91 'THEN' + 'BEGIN' + IDN[I]:=CHAR; I:=I+1; 'GOTO' NCH; + 'END' +'ELSE''IF' CHAR<33 'THEN''GOTO' NCH; +IDN[I]:=0; HOL1:='TRUE'; ABS; FOUND:='FALSE'; +'FOR' DECL:=NODEC 'STEP' -1 'UNTIL' 1 'DO' + 'BEGIN' J:=ILNP[DECL]; + 'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN''IF' IL[J+I] # IDN[I] 'THEN''GOTO' ID5; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' FOUND:='TRUE'; ADDR:=VADR[DECL]; + TYPE:=ILVT[DECL]; + 'IF' ATYPE 'THEN' ADDR:=LOWER(ADDR); + 'GOTO' ESRC; + 'END' IDENTIFIER FOUND; + 'END' LOOK AT ONE CHARACTER; +ID5: 'END' LOOK AT ONE IDENTIFIER; +ESRC: +'END' READ IDENT AND SEARCH DECLARATION LIST; + + +'PROCEDURE' CODE(X); 'VALUE' X; 'INTEGER' X; +'BEGIN' + 'IF' BITSTR 'THEN''BEGIN' + IOC(21); BITQ(X,0); + 'END''ELSE''BEGIN' + WRITE(DEV,X,","); ITEM:=ITEM+1; + 'IF' ITEM>20 'THEN''BEGIN' + SKIP(DEV); ITEM:=0; 'END'; + 'END' NOT BITSTREAM; + SIZE:=SIZE+1; +'END' OUTPUT CODE; + +'PROCEDURE' SIXBIT(CONSTANT); +'VALUE' CONSTANT; 'INTEGER' CONSTANT; +'IF' CONSTANT=0 'THEN' CODE(29) +'ELSE''IF' CONSTANT>64 'THEN' +'BEGIN' CODE(42); CODE(CONSTANT) 'END' +'ELSE' CODE(127+CONSTANT); + +'PROCEDURE' LDEC(LNO); 'VALUE' LNO; 'INTEGER' LNO; +'IF' BITSTR 'THEN''BEGIN' +IOC(21); BITQ(LNO,2); BS2(0); +'END''ELSE''BEGIN' 'IF' ITEM>0 'THEN' SKIP(DEV); +ITEM:=0; WRITE(DEV,"L",LNO,":"); +'END'; + +'PROCEDURE' LABEL(LNO); 'VALUE' LNO; 'INTEGER' LNO; +'BEGIN' SIZE:=SIZE+2; + 'IF' BITSTR 'THEN''BEGIN' + IOC(21); BITQ(LNO,1); + 'END''ELSE''BEGIN' WRITE(DEV,"#L",LNO,","); ITEM:=ITEM+2; + 'IF' ITEM>20 'THEN''BEGIN' SKIP(DEV); ITEM:=0; + 'END'; + 'END'; +'END'; + +'INTEGER' 'PROCEDURE' JMPNEW; +'BEGIN' JMP(NLAB); +JMPNEW:=NEWLAB 'END'; + +'PROCEDURE' JMP(LNO); 'INTEGER' LNO; 'VALUE' LNO; +'BEGIN' CODE(9); LABEL(LNO) 'END'; + +'INTEGER ''PROCEDURE' NEWLAB; +'BEGIN' NEWLAB:=NLAB; NLAB:=NLAB+1 'END'; + +'PROCEDURE' VINFO(DECL); 'VALUE' DECL; 'INTEGER' DECL; +'BEGIN' +CODE(ILBD[DECL]); CODE(LOWER(VADR[DECL])); +'END'; + +'PROCEDURE' NEWADR; +'BEGIN' ADDR:=NADR; NADR:=NADR+1 'END'; + +'PROCEDURE' FSCHK; +'IF' ADDR>FIXSP 'THEN' + 'BEGIN' FIXSP:=ADDR; 'IF' ADDR>=BSIZE 'THEN' WARN(5) + 'END'; + +'PROCEDURE' SID; +'BEGIN''INTEGER' I, NB; +'BOOLEAN' EXTRA; +NB:=BYTES; 'IF' NB>63 'THEN' NB:=NB-64; +'IF' NB>31 'THEN''BEGIN' NB:=NB-32; EXTRA:='TRUE'; + 'END''ELSE' EXTRA:='FALSE'; +'IF' NODEC>=MAXNID 'OR' ILFP>=MAXNID*6 'THEN' + 'BEGIN' WARN(15); 'GOTO' SID1; + 'END''ELSE' NODEC:=NODEC+1; +'IF' NODEC>MXV 'THEN' MXV:=NODEC; +'IF' FOUND 'AND' DECL>DBASE 'THEN' WARN(1); +'IF' TYPE<10 'THEN' FSCHK; +ILNP[NODEC]:=ILFP; +'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' IL[ILFP+I]:=IDN[I]; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' ILFP:=ILFP+I+1; + 'GOTO' SID1; + 'END' END OF NAME; + 'END'; +SID1: +VADR[NODEC]:=ADDR; VDEP[NODEC]:=DEPTH; +ILVT[NODEC]:=TYPE; ILBD[NODEC]:=PDEPTH; + +'IF' IDTAB 'OR' LTAB 'AND' TYPE>=10 'THEN' + 'BEGIN' SKIP(DEVT); + 'IF' IDTAB 'AND' TYPE>=10 'THEN' WRITE(DEVT," "); + IDOUT; + WRITE(DEVT," ",ADDR," "); + 'IF' TYPE>=10 'AND' TYPE<14 'THEN' + WRITE(DEVT,"(",PDEPTH,")") + 'ELSE' WRITE(DEVT,PDEPTH); + WRITE(DEVT," ",LINE," ",SIZE-2," "); + 'IF'TYPE=0'THEN'WRITE(DEVT,"PARAMETER")'ELSE' + 'IF'TYPE=1'THEN'WRITE(DEVT,"REAL")'ELSE' + 'IF'TYPE=2'THEN'WRITE(DEVT,"INTEGER")'ELSE' + 'IF'TYPE=3'THEN'WRITE(DEVT,"BOOLEAN")'ELSE' + 'IF'TYPE=5'THEN'WRITE(DEVT,"REAL ARRAY")'ELSE' + 'IF'TYPE=6 'AND' NB=2'THEN' + WRITE(DEVT,"INT ARRAY")'ELSE' + 'IF'TYPE=6 'AND' NB=1 'THEN' + WRITE(DEVT,"BYTE ARRAY") 'ELSE' + 'IF'TYPE=7'THEN'WRITE(DEVT,"BOOL ARRAY")'ELSE' + 'IF'TYPE=8'THEN'WRITE(DEVT,"SWITCH")'ELSE' + 'IF'TYPE=10'THEN'WRITE(DEVT,"PROCEDURE")'ELSE' + 'IF'TYPE=11'THEN'WRITE(DEVT,"REAL PROC")'ELSE' + 'IF'TYPE=12'THEN'WRITE(DEVT,"INT PROC")'ELSE' + 'IF'TYPE=13'THEN'WRITE(DEVT,"BOOL PROC")'ELSE' + 'IF'TYPE=14'THEN'WRITE(DEVT,"LABEL")'ELSE' + WRITE(DEVT,TYPE); + 'IF' EXTRA 'THEN' WRITE(DEVT," EXTRA"); + 'IF' LIST 'THEN' SKIP(DEVT); + 'END'; +'END' STORE IDENT IN LIST; + +'PROCEDURE' DARR(BYTES); 'VALUE' BYTES; 'INTEGER' BYTES; +'BEGIN''INTEGER' FIRST,DFIRST,COUNT,STYP,SUBS; +STYP:=TYPE; +DAR1: FIRST:=NADR; DFIRST:=NODEC+1; SUBS:=1; COUNT:=1; +DAR2: IDENT; TYPE:=STYP; NEWADR; SID; + 'IF' BS=44 'THEN''BEGIN' COUNT:=COUNT+1; + ABS; 'GOTO' DAR2 'END'; + CHFAIL(27,18); 'COMMENT' CHECK [; +NSUB: GET INTEGER; CHFAIL(58,18); GET INTEGER; + 'IF' BS=29 'THEN' ABS 'ELSE' + 'BEGIN' CHFAIL(44,18); SUBS:=SUBS+1; 'GOTO' NSUB + 'END'; +CODE(1); CODE(ADEPTH); CODE(COUNT); CODE(FIRST); +CODE(BYTES); CODE(SUBS); +'FOR' DECL:=DFIRST 'STEP' 1 'UNTIL' NODEC 'DO' + VADR[DECL]:=VADR[DECL]+BSIZE*SUBS; +'IF' BS=44 'THEN''BEGIN' ABS; 'GOTO' DAR1 'END'; +SEMI(61); 'END' DECLARE ARRAY; + +'PROCEDURE' DTV; +'BEGIN''INTEGER' STYP; +STYP:=TYPE; +DTV1: IDENT; TYPE:=STYP; NEWADR; +SID; 'IF' BS=44 'THEN''BEGIN' ABS; 'GOTO' DTV1 'END' +'ELSE''IF' BS=59 'THEN' SEMI(0); +'END' DECLARE VARIABLE LIST; + + +'INTEGER''PROCEDURE' DTYPE; +'BEGIN''INTEGER' I; +BYTES:=0; +I:='IF' BS=725 'THEN' 1 +'ELSE''IF' BS=374 'THEN' 2 +'ELSE''IF' BS=95 'THEN' 3 +'ELSE''IF' BS=780 'THEN' 4 +'ELSE''IF' BS=122 'THEN' 5 +'ELSE' 'IF' BS=105 'THEN' 6 +'ELSE''IF' BS=783 'THEN' 8 +'ELSE''IF' BS=881 'THEN' 9 +'ELSE''IF' BS=658 'THEN' 10 +'ELSE''IF' BS=481 'THEN' 14 'ELSE' 0; + +'IF' I=6 'THEN' + 'BEGIN' ABS; CHFAIL(122,48); BYTES:=1; + 'END' BYTE ARRAY +'ELSE''IF' I>0 'THEN' + 'BEGIN' ABS; + 'IF' BS=122 'THEN' + 'BEGIN' I:=I+4; ABS; + 'END' REAL, INTEGER OR BOOLEAN ARRAY + 'ELSE''IF' BS=658 'THEN' + 'BEGIN' I:=I+10; ABS; + 'END' REAL, INTEGER OR BOOLEAN PROCEDURE; + 'END' SOME SORT OF DECLARATION EXCEPT BYTE ARRAY; + +'IF' BYTES=0 'THEN' + 'BEGIN' BYTES:= + 'IF' I=5 'THEN' 4 'ELSE' 'IF' I=6 'THEN' 2 'ELSE' + 'IF' I=7 'THEN' 65 'ELSE' 0; + 'END' SET BYTE COUNT IF NOT ALREADY DONE; +'IF' BYTES#0 'AND' BS=224 'THEN' + 'BEGIN' ABS; BYTES:=BYTES+32; + 'END' ADD EXTRA MEMORY BIT; +DTYPE:=I; +'END' READ TYPE OF DECLARATION; + +'BOOLEAN''PROCEDURE' CHKFR(INDEX); +'VALUE' INDEX; 'INTEGER' INDEX; +'BEGIN''INTEGER' I,J; +CHKFR:='FALSE'; J:=FRNP[INDEX]; +'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' +'BEGIN' 'IF' IDN[I] # FRN[J+I] 'THEN''GOTO' NO; + 'IF' IDN[I]=0 'THEN' + 'BEGIN''IF' DEPTH=FLBD[INDEX] 'THEN' CHKFR:='TRUE'; + 'GOTO' NO; + 'END' FOUND; +'END' CHARACTER LOOP; +NO: +'END' CHECK IF REFERENCE SATISFIED; + +'PROCEDURE' GET INTEGER; +'IF' AE 'THEN' CODE(43); + +'PROCEDURE' SFR; +'BEGIN' +'IF' 'NOT' FOUND 'OR' FOUND 'AND''NOT' + (DEPTH=VDEP[DECL] 'OR' DEPTH=-VDEP[DECL]) 'THEN' +'BEGIN''INTEGER' I; +'IF' LDPT#0 'THEN' + 'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'IF' CHKFR(I) 'THEN' + 'BEGIN' ADDR:=FRLN[I]; + 'IF' FLVT[I]#TYPE 'THEN' WARN(50); + 'GOTO' ESFR; + 'END' CHECK FOR PRE-EXISTING SAME FORWARD REFERENCE; + +'IF' LDPT>=MAXLAB-1 'OR' FRFP>=MAXLAB*6 'THEN' + 'BEGIN' WARN(30); 'GOTO' ESFR; + 'END''ELSE' LDPT:=LDPT+1; +'IF' LDPT>MAX 'THEN' MAX:=LDPT; +FRNP[LDPT]:=FRFP; +'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' FRN[FRFP+I]:=IDN[I]; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' FRFP:=FRFP+I+1; + 'GOTO' SFR1; + 'END' END OF NAME; + 'END'; +SFR1: +FLVT[LDPT]:=TYPE; FLBD[LDPT]:=DEPTH; FLINE[LDPT]:=TLIN; +ADDR:=NEWLAB; FRLN[LDPT]:=ADDR; +'END' UNDECLARED PROCEDURE OR LABEL; +ESFR: +'END' RETURN PROCEDURE LABEL IF DECLARED, ELSE SET FORWARD REF; + +'PROCEDURE' DLAB(EXTR); 'VALUE' EXTR; 'BOOLEAN' EXTR; +'BEGIN''INTEGER' I,SDEV; + 'IF' EXTR 'THEN' + 'BEGIN''IF' BITSTR 'THEN' + 'BEGIN' IOC(21); BITQ(NLAB,2); BS2(2); IOC(22); + 'END' + 'ELSE' 'BEGIN' SKIP(DEV); WRITE(DEV,"L",NLAB,"='"); + 'END'; + SDEV:=DEVT; DEVT:=DEV; + IDOUT; DEVT:=SDEV; WRITE(DEV,"'"); + 'IF''NOT' BITSTR 'THEN''BEGIN' + WRITE(DEV,","); ITEM:=0; + 'END'; + 'END' EXTERNAL REFERENCE +'ELSE' LDEC(NLAB); +ADDR:=NEWLAB; SID; +'IF' LDPT#0 'THEN' + 'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'IF' CHKFR(I) 'THEN' + 'BEGIN' DEFINE(FRLN[I],ADDR); + 'IF' FLVT[I]#TYPE 'THEN' WARN(50); + D2ELETE(I); I:=I-1 + 'END' DELETE SATISFIED FORWARD REFS; +'END' PUT LABEL OR PROCEDURE DECLARATION IN LIST; + +'PROCEDURE' D2ELETE(ITEM); 'INTEGER' ITEM; 'VALUE' ITEM; +'IF' ITEM=LDPT 'THEN' +'BEGIN' LDPT:=LDPT-1; FRFP:=FRNP[ITEM]; +'END' DELETE LAST ITEM +'ELSE' +'BEGIN''INTEGER' I,J,K,LEN; +FRNP[LDPT+1]:=FRFP; FRFP:=FRNP[ITEM]; +'FOR' I:=ITEM 'STEP' 1 'UNTIL' LDPT-1 'DO' + 'BEGIN' K:=FRNP[I+1]; LEN:=FRNP[I+2] - K; + FRNP[I]:=FRFP; + 'FOR' J:=0 'STEP' 1 'UNTIL' LEN-1 'DO' + FRN[FRFP+J]:=FRN[K+J]; + FRFP:=FRFP + LEN; + FLVT[I]:=FLVT[I+1]; FLBD[I]:=FLBD[I+1]; + FLINE[I]:=FLINE[I+1]; FRLN[I]:=FRLN[I+1]; + 'END' MOVE 1 ITEM DOWM; +LDPT:=LDPT-1; +'END' DELETE INTERNAL ITEM FROM LABEL/PROCEDURE LISTS; + +'PROCEDURE' CSTR; +'BEGIN' +L: STCH; + 'IF'CHAR=34'THEN'CODE(0)'ELSE' + 'BEGIN' 'IF' CHAR=-1 'THEN' 'BEGIN' CODE(13); CODE(10) 'END' 'ELSE' + 'IF' CHAR=-2 'THEN' CODE(34) 'ELSE'CODE(CHAR);'GOTO'L + 'END'; + ABS +'END'; + + +'PROCEDURE' STCH; +'BEGIN' +L: INCH; 'IF' CHAR<32 'THEN' 'GOTO' L; + 'IF' CHAR=42 'THEN' + 'BEGIN' INCH; + 'IF' CHAR=78 'THEN' CHAR:=-1 'ELSE' + 'IF' CHAR=34 'THEN' CHAR:=-2 'ELSE' + 'IF' CHAR=76 'THEN' CHAR:=10 'ELSE' + 'IF' CHAR=84 'THEN' CHAR:=9 'ELSE' + 'IF' CHAR=80 'THEN' CHAR:=12 'ELSE' + 'IF' CHAR=67 'THEN' CHAR:=13 'ELSE' + 'IF' CHAR=83 'THEN' CHAR:=32 'ELSE' + 'IF' CHAR<32 'THEN' 'GOTO' L + 'END' 'ELSE' + 'IF' CHAR=94 'THEN' + 'BEGIN' INCH; CHAR:=CHAR-(CHAR%32)*32; + 'IF' CHAR=0 'THEN' 'GOTO' L + 'END' +'END'; + + +'PROCEDURE' PCALL; +'BEGIN''INTEGER' STYP; +'IF' FOUND 'AND' DECLND2 'THEN' + 'BEGIN' GETINTEGER; 'GOTO' NREAD; + 'END' DELETE OR EXTRA FUNCTION; + +'IF' DECL<10 'THEN' + 'BEGIN' + 'IF' DECL=5 'OR' DECL=3 'THEN' GET INTEGER + 'ELSE' 'IF' 'NOT' (BS=41 'OR' BS=44) 'THEN' GET INTEGER + 'ELSE' CODE(84); + 'IF' SDEC>=7 'THEN' + 'BEGIN' CHFAIL(44,42); + 'IF' SDEC#7 'THEN' + 'BEGIN' GETINTEGER; + 'IF' SDEC=8 'THEN' + 'BEGIN' 'IF' BS=41 'THEN' CODE(29) 'ELSE' + 'BEGIN' CHFAIL(44,42); GETINTEGER; + 'END'; + 'END' WRITE; + CODE(VADR[SDEC]); + 'END' WRITE OR CHOUT + 'ELSE' + 'BEGIN' 'IF''NOT' AE 'THEN' CODE(44); + 'IF' BS=41'THEN' + 'BEGIN' CODE(29); CODE(29) 'END' + 'ELSE' + 'BEGIN' CHFAIL(44,42); GETINTEGER; + CHFAIL(44,42); GET INTEGER; + 'END' FORMATTED PRINT; + CODE(2); + 'END' REAL WRITE + 'END' NUMBER/CHAR OUTPUT +'ELSE''IF' SDEC=6 'THEN' + 'BEGIN' CHFAIL(44,42); + 'IF' BS=34 'THEN' + 'BEGIN' CODE(5); CSTR + 'END' NORMAL CALL + 'ELSE' 'BEGIN' IDENT; + 'IF''NOT' FOUND 'OR' TYPE#4 'THEN' WARN(42); + GETOUT; CODE(60) + 'END' PRINT FORMAL STRING + 'END' TEXT +'ELSE''IF' SDEC=4 'THEN' + 'BEGIN' 'IF' BS#44 'THEN''GOTO' NREAD 'ELSE' + 'BEGIN' ABS; DBE(14); CODE(72); + 'END' READ WITH LABEL PARAMETER + 'END' READ + 'ELSE' +NREAD: CODE(VADR[SDEC]); + 'END' INPUT/OUTPUT CALLS SDEC<10 +'ELSE''IF' SDEC<=ND2 'THEN' + 'BEGIN' 'IF''NOT' AE 'THEN' CODE(44); + CODE(27); CODE(SDEC-11); + 'END' STANDARD FUNCTION CALL; +STYP:=ILVT[SDEC]; +'END' CALL OF BUILT IN ROUTINES +'ELSE' +'BEGIN' 'INTEGER' COUNT,PRAD,PTYPE; +'BOOLEAN' FORMAL; +FORMAL:=FOUND 'AND' TYPE>14; +'IF' FORMAL 'THEN' + 'BEGIN' PRAD:=DECL; STYP:=TYPE-5 + 'END' 'ELSE' + 'BEGIN' SFR; STYP:=TYPE; PRAD:=ADDR + 'END' SET TYPE OF NORMAL PROCEDURE CALL; +'IF' BS#40 'THEN' + 'BEGIN' 'IF' FORMAL 'THEN' + 'BEGIN' GETOUT; CODE(58); + 'END' PARAMETERLESS FORMAL + 'ELSE' 'BEGIN' CODE(11); LABEL(ADDR) + 'END'; + 'GOTO' ECL2 + 'END' CALL OF PARAMETERLESS PROCEDURE; + COUNT:=0; ABS; +NPAR: PTYPE:=DTYPE; +'IF' PTYPE#0 'THEN' +'BEGIN' 'IF' PTYPE<10 'THEN' WARN(19); DBE(PTYPE); +'END' LABEL/PROCEDURE PARAMETER +'ELSE' +'BEGIN' 'IF' 'NOT' LETTER 'THEN' + 'BEGIN''IF' BS=34 'THEN' + 'BEGIN''INTEGER' L1; CODE(47); LABEL(NEWLAB); + L1:=JMPNEW; LDEC(L1-1); CSTR; LDEC(L1); TYPE:=4; + 'END' STRING PARAMETER + 'ELSE' 'BEGIN' TYPE:='IF' BS=575 'OR' BS=818 'OR' + BS=241 'THEN' 3 'ELSE' 1; 'GOTO' VEXP; + 'END' NON-STRING NON-LETTER PARAMETER + 'END' NON-LETTER PARAMETER +'ELSE' 'BEGIN' IDENT; + 'IF''NOT' FOUND 'THEN' WARN(34); + 'IF' BS=44 'OR' BS=41 'THEN' + 'BEGIN''IF' TYPE>20 'OR' TYPE=4 'OR' ATYPE 'OR' + TYPE=8 'THEN' GETOUT + 'ELSE''IF' TYPE<4 'THEN' + 'BEGIN' TYPE:=TYPE+20; SVAD(DECL); + 'END' 'ELSE' 'GOTO' VPAR; + 'END' PARAMETER BY NAME + 'ELSE' + VPAR: 'BEGIN' FRED:='TRUE'; + VEXP: EXPRESSION; 'IF' TYPE<3 'AND' + (BS=35 'OR' BS=38 'OR' BS=60 'OR' BS=61 + 'OR' BS=62 'OR' BS=63) 'THEN' + 'BEGIN' AEREAD:='TRUE'; SBE; TYPE:=3; + 'END' RELATIONAL EXPRESSION + 'END' NUMERICAL/BOOLEAN + 'END' VARIABLE/ARRAY PARAMETER +'END' PARAMS NOT STARTING WITH DECLARATION; +SIXBIT(TYPE); +COUNT:=COUNT+1; 'IF' BS=44 'THEN' + 'BEGIN' ABS; 'GOTO' NPAR + 'END'; +'IF' FORMAL 'THEN' + 'BEGIN' DECL:=PRAD; GETOUT; CODE(59); CODE(COUNT); + 'END' +'ELSE' 'BEGIN' CODE(36); CODE(COUNT); LABEL(PRAD) + 'END'; +'END' USER DECLARED PROCEDURE CALL; +CHFAIL(41,21); +ECL2: TYPE:=STYP; +'END' PROCEDURE CALL; + +'PROCEDURE' SVAD(DECL); 'VALUE' DECL; 'INTEGER' DECL; +'BEGIN''INTEGER' LEVEL; +LEVEL:=ILBD[DECL]; +'IF' LEVEL=0 'THEN' +'BEGIN' CODE(67); CODE(LOWER(VADR[DECL])) 'END' +'ELSE''IF' LEVEL=PDEPTH 'THEN' +'BEGIN' CODE(66); CODE(LOWER(VADR[DECL])) 'END' +'ELSE''BEGIN' CODE(39); VINFO(DECL) 'END'; +'END' SET ADDRESS OF VARIABLE ON STACK; + + +'PROCEDURE' CURLY; +'BEGIN' +LOOP: INCH; + 'IF' CHAR=125 'THEN' 'GOTO' FIN + 'ELSE' + 'IF' CHAR=123 'THEN' CURLY; + 'GOTO' LOOP; +FIN: +'END'; + +'PROCEDURE' COMMENT; +'BEGIN' +COM: 'IF' CHAR=123 'THEN' + 'BEGIN' CURLY; ABS; 'GOTO' COM; + 'END'; + 'IF' BS=135 'THEN' + 'BEGIN' +CL: INCH; 'IF' CHAR#59 'THEN''GOTO' CL 'ELSE' + 'BEGIN' ABS; 'GOTO' COM + 'END' + 'END'; + 'IF' BS=169 'THEN' + 'BEGIN''INTEGER' I; + I:=1; +CL1: ABS; DIG[I]:=BS; I:=I+1; + 'IF' BS#59 'THEN''GOTO' CL1; + ABS; RDIR; 'GOTO' COM; + 'END' DIRECTIVE; +'END' CHECK FOR COMMENT OR DIRECTIVE; + +'PROCEDURE' RDIR; +'BEGIN''BOOLEAN' YES; 'INTEGER' P,C; +P:=1; YES:='TRUE'; +DL: C:=DIG[P]; P:=P+1; + 'IF' C=45 'THEN' YES:='FALSE' + 'ELSE''IF' C=43 'THEN' YES:='TRUE' + 'ELSE''IF' C=16 'THEN' PRECOM:=YES + 'ELSE''IF' C=2 'THEN' BITSTR:=YES + 'ELSE''IF' C=12 'THEN' LIST:=YES + 'ELSE''IF' C=20 'THEN' IDTAB:=YES + 'ELSE''IF' C=4 'THEN' DIAGNOSTICS:=YES + 'ELSE''IF' C=19 'THEN' LTAB:=YES; + 'IF' C#59 'THEN''GOTO' DL; +'END' DIRECTIVE; + +'PROCEDURE' SEMI(FNO); 'VALUE' FNO; 'INTEGER' FNO; +'BEGIN' CHFAIL(59,FNO); COMMENT 'END'; + +'PROCEDURE' STATEMENT; +'BEGIN' +ST: 'IF' LIST 'THEN' WRITE(DEVT,"<",SIZE-2,">"); +'IF' LETTER 'THEN' +'BEGIN' IDENT; +'IF' BS=58 'THEN' + 'BEGIN' TYPE:=14; DLAB('FALSE'); CODE(61); + CODE(PDEPTH); CODE(ADEPTH); ABS; + 'GOTO' ST; + 'END' LABEL +'ELSE''IF' BS=27 'OR' BS=7000 'THEN' ASSIGNMENT(0,'FALSE',0,0) +'ELSE' 'BEGIN' + 'IF' 'NOT' FOUND 'THEN' TYPE:=10 + 'ELSE''IF' TYPE#10 'AND' TYPE#15 'THEN' WARN(35); + PCALL + 'END' +'END' UNCONDITIONAL NON-GOTO + +'ELSE''IF' BS=366 'THEN' +'BEGIN''INTEGER' L1,L2; +L1:=IFCLAUSE; 'IF' BS=366 'THEN' WARN(33); +STATEMENT; +'IF' BS#212 'THEN' LDEC(L1) +'ELSE''BEGIN' ABS; L2:=JMPNEW; LDEC(L1); + STATEMENT; LDEC(L2) 'END' +'END' CONDITIONAL + +'ELSE' 'IF' BS=295 'THEN' +'BEGIN' ABS; DBE(14); CODE(57); +'END' GOTO STATEMENT + +'ELSE''IF' BS=928 'THEN' +'BEGIN''INTEGER' L1,L2; +L1:=NEWLAB; L2:=NEWLAB; LDEC(L1); +ABS; DBE(3); CHFAIL(175,56); CODE(28); LABEL(L2); +STATEMENT; JMP(L1); LDEC(L2); +'END' WHILE STATEMENT + +'ELSE''IF' BS=726 'THEN' +'BEGIN''INTEGER' L1; L1:=NEWLAB; +LDEC(L1); ABS; +NREP: STATEMENT; + 'IF' BS=59 'THEN''BEGIN' ABS; COMMENT; 'GOTO' NREP; + 'END'; +CHFAIL(854,57); +DBE(3); CODE(28); LABEL(L1); +'END' REPEAT STATEMENT + +'ELSE''IF' BS=121 'THEN' +'BEGIN''INTEGER' L1,L2; 'BOOLEAN' FIRST; +L1:=NEWLAB; ABS; GET INTEGER; CHFAIL(606,58); +CODE(37); CODE(1); +'IF' DIGIT 'THEN' +'BEGIN' FIRST:='TRUE'; +NEXC: GET INTEGER; CHFAIL(58,58); + CODE(38); CODE(1); CODE(41); CODE(22); + 'IF' FIRST 'THEN' FIRST:='FALSE' 'ELSE' CODE(32); + 'IF' DIGIT 'THEN''GOTO' NEXC; + L2:=NEWLAB; CODE(28); LABEL(L2); + STATEMENT; JMP(L1); LDEC(L2); + 'IF' BS=59 'THEN' + 'BEGIN' ABS; FIRST:='TRUE'; + 'IF' DIGIT 'THEN''GOTO' NEXC 'ELSE' WARN(58); + 'END' ANOTHER CASE; +'END' DIGIT LABEL FOUND; +'IF' BS=212 'THEN' +'BEGIN' ABS; STATEMENT; +'END' ELSE PART +'ELSE''BEGIN' CHFAIL(214,58); +ECC: 'IF''NOT' TERM 'THEN' + 'BEGIN' ABS; 'GOTO' ECC; + 'END' END COMMENT; +'END' CASE TERMINATED BY END; +LDEC(L1); +'END' CASE STATEMENT + +'ELSE' 'IF' BS=255 'THEN' +'BEGIN''INTEGER' SDECL,STYP,LVAR,STLAB,L1,L2,L3; +ABS; IDENT; +'IF''NOT'(FOUND'AND'(TYPE<3'OR' TYPE>20'AND'TYPE<23)) + 'THEN' WARN(13); +STYP:=TYPE; SDECL:=DECL; CHFAIL(7000,24); +NEWADR; LVAR:=ADDR; FSCHK; +STLAB:=NEWLAB; L3:=NEWLAB; + +ELEMENT: L1:=L3; L2:=NEWLAB; L3:=NEWLAB; LDEC(L1); + 'IF' STYP>20 'THEN' + 'BEGIN' DECL:=SDECL;GETOUT; RHS(STYP-20); + CODE(55); + 'END' CONTROLLED VARIABLE NAME PARAMETER + 'ELSE' 'BEGIN' RHS(STYP); DECL:=SDECL; PUTOUT; + 'END' VARIABLE IS NOT NAME PARAMETER; + CODE(64); CODE(LVAR); +LABEL('IF' BS=928 'THEN' L1 'ELSE''IF' BS=780 + 'THEN' L2 'ELSE' L3); + 'COMMENT' SET ADDRESS FOR RETURN; + 'IF' BS=928 'THEN' + 'BEGIN' ABS; DBE(3); 'GOTO' FOR1 + 'END' WHILE ELEMENT + 'ELSE''IF' BS#780 'THEN''GOTO' FOR2; + 'BEGIN''INTEGER' L4; L4:=NEWLAB; + ABS; CODE(29); JMP(L4); + 'COMMENT' SET ZERO FOR NO INCREMENT; + LDEC(L2); CODE(84); LDEC(L4); + 'COMMENT' -1 TO INCREMENT; + RHS(TYPE); CHFAIL(854,31); + RHS(TYPE); 'IF' STYP>20 'THEN' + 'BEGIN' DECL:=SDECL; GETOUT 'END' + 'ELSE' SVAD(SDECL) ; + CODE(34); + CODE('IF' STYP=2 'OR' STYP=22 'THEN' 2 'ELSE' 0); + LABEL(L3); 'GOTO' FOR2; + 'COMMENT' PARAMETERS FOR STEP TESTER; + 'END' STEP ELEMENT; + +FOR1: CODE(28); LABEL(L3); +FOR2: 'IF' BS=44 'THEN' + 'BEGIN' ABS; JMP(STLAB); 'GOTO' ELEMENT + 'END'; + CHFAIL(175,22); LDEC(STLAB); + STATEMENT; + CODE(65); CODE(LVAR); LDEC(L3); + NADR:=NADR-1; +'END' FOR STATEMENT + +'ELSE' 'IF' BS=85 'THEN' +'BEGIN''INTEGER' SDBASE,SNADR,SILFP,JPPL; +'BOOLEAN' PLS,ABM,BLOCK; +ABS; COMMENT; +PLS:='FALSE'; ABM:='FALSE'; BLOCK:='FALSE'; + +NDEC: TYPE:=DTYPE; +'IF' TYPE#0 'THEN' + 'BEGIN''IF''NOT' BLOCK 'THEN' + 'BEGIN' BLOCK:='TRUE'; DEPTH:=DEPTH+1; + SDBASE:=DBASE; DBASE:=NODEC; SNADR:=NADR; + SILFP:=ILFP; + 'END'; + 'IF' LIST 'THEN' WRITE(DEVT,"<",SIZE-2,">"); + + 'IF' TYPE<4 'THEN' DTV + + 'ELSE''IF' TYPE<10 'THEN' + 'BEGIN''IF' PLS 'THEN' + 'BEGIN' LDEC(JPPL); PLS:='FALSE''END'; + 'IF' TYPE=8 'THEN' + 'BEGIN''INTEGER' NOS,NOSL; + DTV; CHFAIL(7000,45); CODE(47); LABEL(NEWLAB); + DECL:=NODEC; PUTOUT; + JPPL:=NLAB; JMP(NEWLAB); + LDEC(JPPL-1); NOSL:=NLAB; + LABEL(NEWLAB);NOS:=0; + PLS:='TRUE'; +SEL: NOS:=NOS+1; IDENT; TYPE:=14; SFR; LABEL(ADDR); + 'IF' BS=44 'THEN' + 'BEGIN' ABS; 'GOTO' SEL 'END'; + SEMI(46); + 'IF' BITSTR 'THEN''BEGIN' + IOC(21); BITQ(NOSL,2); BS2(1); BITQ(NOS,0); + 'END''ELSE''BEGIN' SKIP(DEV); ITEM:=0; + WRITE(DEV,"L",NOSL,"=",NOS); SKIP(DEV); + 'END'; + 'END' DECLARE SWITCH TYPE=8 + 'ELSE''BEGIN' + 'IF''NOT' ABM 'THEN' + 'BEGIN' ABM:='TRUE'; ADEPTH:=ADEPTH+1 'END'; + DARR(BYTES); + 'END' DECLARE ARRAY T<10 BUT NOT 8 + 'END' DECLARE ARRAY OR SWITCH TYPE<10 + 'ELSE''BEGIN''IF''NOT' PLS 'THEN' + 'BEGIN' JPPL:=JMPNEW; PLS:='TRUE' + 'END'; + DPROC; + 'END' TYPE>=10; + 'GOTO' NDEC; + 'END' DECLARATIONS TYPE#0; + +'IF' PLS 'THEN' LDEC(JPPL); +TAIL: STATEMENT; + 'IF' BS=59 'THEN''BEGIN' ABS; COMMENT; 'GOTO' TAIL + 'END' + 'ELSE''IF' BS#214 'THEN' + 'BEGIN' FAIL(16); 'GOTO' TAIL 'END'; +ECOM: ABS; 'IF''NOT' TERM 'THEN''GOTO' ECOM; + +'IF' BLOCK 'THEN' +'BEGIN' +'IF' ABM 'THEN''BEGIN' CODE(61); ADEPTH:=ADEPTH-1; + CODE(PDEPTH); CODE(ADEPTH) 'END'; +NODEC:=DBASE; DBASE:=SDBASE; NADR:=SNADR; +ILFP:=SILFP; +EBLOCK; +'END' BLOCK +'END' BLOCK OR COMPOUND; + +'END' STATEMENT; + +'PROCEDURE' EBLOCK; +'BEGIN''INTEGER' I,J,K,L,M; +DEPTH:=DEPTH-1; +'IF' LDPT#0 'THEN' +'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' +'IF' FLBD[I]>DEPTH 'THEN' + 'BEGIN' FLBD[I]:=DEPTH; + 'FOR' J:=NODEC 'STEP' -1 'UNTIL' ND1 'DO' + 'BEGIN' K:=ILNP[J]; L:=FRNP[I]; + 'FOR' M:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN''IF' FRN[L+M] # IL[K+M] 'THEN''GOTO' NO; + 'IF' FRN[L+M]=0 'THEN' + 'BEGIN' + 'IF'(VDEP[J]=DEPTH 'OR' VDEP[J]=-DEPTH) 'THEN' + 'BEGIN' + DEFINE(FRLN[I],VADR[J]); D2ELETE(I); I:=I-1; + 'GOTO' EXLOOP; + 'END' DECLARATION FOUND AT RIGHT DEPTH; + 'END' NAMES MATCH; + 'END' LOOK AT CHARACTERS OF NAME; +NO: 'END' DECLARED IDENTIFIER LIST LOOP; +EXLOOP: 'END' FORWARD LABEL SATISFACTION DEPTH CHANGE; +'END' DEAL WITH LABEL LIST AT BLOCK END; + +'INTEGER''PROCEDURE' STAK; +STAK:=FIXSP*2+2; + +'PROCEDURE' DPROC; +'BEGIN''INTEGER' SLTYP; +SLTYP:=TYPE; IDENT; TYPE:=SLTYP; + +'IF' BS=224 'THEN' +'BEGIN' ABS; DLAB('TRUE'); +'END' EXTERNAL REFERENCE + +'ELSE' +'BEGIN''INTEGER' SNADR,SDBASE,SNODEC,SFIXSP,PINL, +SILFP,SDEV,SADEP,SPDEP; +SPDEP:=PDEPTH; PDEPTH:=NPN; NPN:=NPN+1; +'IF' PDEPTH>=BSIZE 'THEN' WARN(23); +DLAB('FALSE'); +'IF' TYPE>10 'THEN' VDEP[NODEC]:=-VDEP[NODEC]; + +'IF' PRECOM 'OR' BS=214 'THEN' + 'BEGIN' 'IF' BS=214 'THEN' ABS; + SDEV:=DEVT; DEVT:=DEV; + 'IF' BITSTR 'THEN' + 'BEGIN' IOC(21); BS2(3); BS2(3); BS2(1); + IOC(22); + 'END' + 'ELSE' 'BEGIN' SKIP(DEV); WRITE(DEV,"'"); + 'END'; + IDOUT; WRITE(DEV,"'"); DEVT:=SDEV; + 'IF' BITSTR 'THEN' + 'BEGIN' IOC(21); BITQ(NLAB-1,1); + 'END' + 'ELSE' WRITE(DEV,"=L",NLAB-1,","); + 'END' PRCOMPILER ENTRY DEFINITION; + +SADEP:=ADEPTH; SDBASE:=DBASE; ADEPTH:=0; DEPTH:=DEPTH+1; +SNODEC:=NODEC; DBASE:=NODEC; SFIXSP:=FIXSP; SNADR:=NADR; +SILFP:=ILFP; +'COMMENT' MAKE BODY BEHAVE LIKE A BLOCK; +FIXSP:=3; NADR:=4; PINL:=NEWLAB; LABEL(PINL); CODE(PDEPTH); + +'IF' BS=40 'THEN' + 'BEGIN''INTEGER' SPTYP; + TYPE:=0; ABS; DTV; CHFAIL(41,21); SEMI(28); + 'IF' FIXSP>103 'THEN' WARN(54); + 'FOR' DECL:=1 'STEP' 1 'UNTIL' 100 'DO' DIG[DECL]:=0; +VALUE: SPTYP:=DTYPE; +'IF' SPTYP=9 'THEN' + 'BEGIN' + LOOP: IDENT; + 'IF''NOT' FOUND 'OR' DECL<=SNODEC 'THEN' + WARN(39) 'ELSE' DIG[DECL-SNODEC]:=1; + 'IF' BS=44 'THEN' + 'BEGIN' ABS; 'GOTO' LOOP 'END' + 'ELSE''BEGIN' SEMI(29); 'GOTO' VALUE + 'END' + 'END' VALUE SPECIFICATION; + 'GOTO' TSP1; +TSPEC: SPTYP:=DTYPE; +TSP1: 'IF' SPTYP#0 'THEN' + 'BEGIN''IF' SPTYP=9 'THEN' WARN(26); +LOP: IDENT; 'IF''NOT' FOUND 'OR' TYPE#0 'THEN' WARN(29) + 'ELSE' 'BEGIN' ILVT[DECL]:=SPTYP; ILBD[DECL]:=PDEPTH; + 'END'; + 'IF' BS=44 'THEN' + 'BEGIN' ABS; 'GOTO' LOP; + 'END' + 'ELSE' 'BEGIN' SEMI(29); 'GOTO' TSPEC; + 'END' + 'END' TYPE SPECIFICATION; + + CODE(FIXSP-3); 'COMMENT' NUMBER OF PARAMETERS; + 'FOR' DECL:=NODEC 'STEP' -1 'UNTIL' NODEC-FIXSP+4 'DO' + 'BEGIN' TYPE:=ILVT[DECL]; + 'IF' TYPE>9 'THEN' ILVT[DECL]:=ILVT[DECL]+5 + 'ELSE''IF' ATYPE 'THEN' + 'BEGIN''IF' DIG[DECL-SNODEC]#0 'THEN' WARN(41); + 'END' FORMAL ARRAY + 'ELSE''IF' TYPE<4 'AND' TYPE>0 'THEN' + 'BEGIN''IF' DIG[DECL-SNODEC]=0 'THEN' + 'BEGIN' TYPE:=TYPE+20; + ILVT[DECL]:=ILVT[DECL]+20; + 'END' NAME PARAMETER + 'END' UNSUBSCRIPTED VARIABLE + 'ELSE' 'IF' TYPE=0 'THEN' WARN(40); + CODE(TYPE); + 'END' CHECK TYPES OF PARAMETERS; + + 'END' PARAMETER SPECIFICATION + 'ELSE' + 'BEGIN' SEMI(29); CODE(0) + 'END' NO PARAMETER CASE; + +STATEMENT; + +'IF' SLTYP>10 'THEN' + 'BEGIN' CODE(195); 'END'; +CODE(10); + +'IF' BITSTR 'THEN' + 'BEGIN' + IOC(21); BITQ(PINL,2); BS2(1); BITQ(STAK,0); + 'END' +'ELSE' 'BEGIN' SKIP(DEV); ITEM:=0; + WRITE(DEV,"L",PINL,"=",STAK); SKIP(DEV); + 'END'; +NADR:=SNADR; DBASE:=SDBASE; NODEC:=SNODEC; +FIXSP:=SFIXSP; ILFP:=SILFP; +'IF' VDEP[NODEC]<0 'THEN' VDEP[NODEC]:=-VDEP[NODEC]; +ADEPTH:=SADEP; PDEPTH:=SPDEP; EBLOCK; +'END' NOT EXTERNAL REFERENCE; + +SEMI(23); +'END' DECLARE PROCEDURE; + + + +'INTEGER''PROCEDURE' SUBSCRIPT; +'BEGIN''INTEGER' STYPE,NOS,SDEC; +STYPE:=TYPE-4; SDEC:=DECL; CHFAIL(27,3); NOS:=1; +NSUB: GET INTEGER; + 'IF' BS=29 'THEN' ABS 'ELSE' + 'BEGIN' CHFAIL(44,4); NOS:=NOS+1; 'GOTO' NSUB + 'END'; +SUBSCRIPT:=NOS; DECL:=SDEC; +'IF' NOS#VADR[DECL]%BSIZE 'AND' VADR[DECL]%BSIZE#0 'THEN' + WARN(20); +TYPE:=STYPE 'END'; + +'PROCEDURE' FETCH; +'BEGIN' +'IF' FRED 'THEN' FRED:='FALSE' 'ELSE' IDENT; +'IF''NOT' FOUND 'THEN' TYPE:=TYPE+10; +'COMMENT' ASSUME UNDECLARED FUNCTION OF CURRENT TYPE; +'IF' TYPE>20 'THEN' + 'BEGIN' TYPE:=TYPE-20; GETOUT; CODE(62); + 'END' NAME PARAMETER +'ELSE''IF' TYPE>10 'THEN' + 'BEGIN' PCALL; TYPE:=TYPE-10 + 'END' +'ELSE' 'IF' TYPE>4 'THEN' + 'BEGIN''INTEGER' N; + N:=SUBSCRIPT; ARIN(68,69,14,DECL); CODE(N); + 'END' +'ELSE' GETOUT; +'END' FETCH VARIABLE; + +'PROCEDURE' EXPRESSION; +'BEGIN''IF' FRED 'THEN' + 'BEGIN' FETCH; FFET:='TRUE'; 'END'; +'IF' BTYPE 'THEN' DBE(3) +'ELSE' 'BEGIN' TYPE:='IF' AE 'THEN' 1 'ELSE' 2; + 'IF' BS=35 'OR' BS=38 'OR' BS=60 'OR' BS=61 + 'OR' BS=62 'OR' BS=63 'THEN' + 'BEGIN' RE; FFET:='TRUE'; SBE; + TYPE:=3; + 'END' CONVERT ARITH TO BOOLEAN; + 'END' EXPRESSION STARTS WITH ARITH ITEM; +'END' EXPRESSION; + +'PROCEDURE' RHS(T); 'VALUE' T; 'INTEGER' T; +'BEGIN' +EXPRESSION; +'IF' T=1 'THEN' + 'BEGIN''IF' TYPE=2 'THEN' CODE(44) + 'ELSE''IF' TYPE=3 'THEN' WARN(59) + 'END' REAL REQUIRED +'ELSE''IF' T=2 'THEN' + 'BEGIN''IF' TYPE=1 'THEN' CODE(43) + 'ELSE''IF' TYPE=3 'THEN' WARN(59) + 'END' INTEGER REQUIRED +'ELSE''IF' TYPE#3 'THEN' WARN(60); +TYPE:=T +'END' ASSIGNMENT RIGHT HAND SIDE; + +'PROCEDURE' ASSIGNMENT(RTYP,RECU,D,S); 'VALUE' RTYPE,RECU,D,S; +'INTEGER' RTYP,D,S; 'BOOLEAN' RECU; +'BEGIN''INTEGER' SS; +'IF' 'NOT' RECU 'THEN' + 'BEGIN''IF' 'NOT' FOUND 'THEN' WARN(17); + D:=DECL; 'IF' ATYPE 'THEN' S:=SUBSCRIPT; RTYP:=TYPE; + 'IF' RTYP>20 'THEN' + 'BEGIN' RTYP:=RTYP-20; GETOUT; + 'END' LEFT PART IS PARAM BY NAME + 'ELSE''IF' RTYP>10 'THEN' + 'BEGIN' RTYP:=RTYP-10; + 'IF' VDEP[D]>0 'THEN' WARN(17); + 'END' ASSIGN TO FUNCTION; + 'END' SETUP FOR NON-RECURSIVE ENTRIES; +CHFAIL(7000,24); +'IF' LETTER 'THEN' + 'BEGIN' IDENT; + 'IF' BS#7000 'THEN' + 'BEGIN''IF' ATYPE 'THEN' + 'BEGIN' SS:=SUBSCRIPT; + 'IF' BS=7000 'THEN''GOTO' MASG + 'ELSE' 'BEGIN' ARIN(68,69,14,DECL); + CODE(SS); FFET:='TRUE'; + 'GOTO' NLHS; + 'END' ARRAY PART OF RHS; + 'END' ARRAY AFTER := + 'ELSE' 'BEGIN' FRED:='TRUE'; 'GOTO' NLHS; + 'END' IDENT NOT ARRAY OF FOLLOWED BY := + 'END' IDENT NOT FOLLOWED BY := + 'ELSE' 'BEGIN''IF' 'NOT' FOUND 'THEN' WARN(17); + 'IF' TYPE>20 'THEN' + 'BEGIN' TYPE:=TYPE-20; GETOUT; + 'END' MULTIPLE ASSIGN TO NAME PARAM + 'ELSE''IF' TYPE>10 'THEN' + 'BEGIN' TYPE:=TYPE-10; + 'IF' VDEP[DECL]>0 'THEN' WARN(17); + 'END' ASSIGN TO FUNCTION; +MASG: 'IF' TYPE#RTYP 'THEN' WARN(43); + ASSIGNMENT(RTYP,'TRUE',DECL,SS); + 'GOTO' GV1; + 'END' ANOTHER LEFT PART FOUND + 'END' LETTER AFTER := +'ELSE' 'BEGIN' +NLHS: RHS(RTYP); + 'IF' RECU 'THEN' + 'BEGIN' CODE(241); +GV1: CODE(209); + 'END' STORE IN V1 FOR MULTIPLES; + TYPE:=ILVT[D]; + 'IF' TYPE>=11 'AND' TYPE<=13 'THEN' TYPE:=TYPE-10; + 'IF' TYPE>20 'THEN' CODE(55) + 'ELSE''IF' ATYPE 'THEN' + 'BEGIN' ARIN(70,71,15,D); CODE(S); + 'END' ASSIGN TO AN ARRAY ELEMENT + 'ELSE''IF' TYPE<4 'THEN' + 'BEGIN' DECL:=D; PUTOUT; + 'END' ASSIGN TO SCALAR OR FUNCTION + 'ELSE' WARN(17); + TYPE:=RTYP; + 'END' DO ACTUAL ASSIGNMENT; + +'END' ASSIGNMENT; + +'PROCEDURE' ARIN(LOC,GLO,ANY,DEC); +'VALUE' LOC,GLO,ANY,DEC; +'INTEGER' LOC,GLO,ANY,DEC; +'BEGIN''INTEGER' LEVEL; +LEVEL:=ILBD[DEC]; +'IF' LEVEL=0 'THEN' +'BEGIN' CODE(GLO); CODE(LOWER(VADR[DEC])) 'END' +'ELSE''IF' LEVEL=PDEPTH 'THEN' +'BEGIN' CODE(LOC); CODE(LOWER(VADR[DEC])) 'END' +'ELSE''BEGIN' CODE(ANY); VINFO(DEC) 'END'; +'END' ARRAY ELEMENT INFORMATION; + + +'PROCEDURE' IDOUT; +'BEGIN''INTEGER' I; +I:=0; +L: CHOUT(DEVT,IDN[I]); I:=I+1; +'IF' IDN[I]#0 'THEN''GOTO' L; +'END' OUTPUT IDENTIFIER; + +'PROCEDURE' WARN(X); 'INTEGER' X; 'VALUE' X; +'BEGIN''INTEGER' I; SKIP(DEVT); +DELETE(DEV); DEV:=0; CHOUT(DEV,0); IOC(17); +WRITE(DEVT,"FAIL ",X," LINE ",LINE," IDENT "); +IDOUT; WRITE(DEVT," SYMBOL ",BS," "); +WRITE(DEVT," IN "); SNAM; + SKIP(DEVT); BUGS:='TRUE'; +'IF' X#2 'THEN' +'BEGIN' +'FOR' I:=1 'STEP' 1 'UNTIL' 100 'DO' +'BEGIN' LBP:=LBP+1; 'IF' LBP=101 'THEN' LBP:=1; + 'IF' LBUF[LBP]#0 'THEN' CHOUT(DEVT,LBUF[LBP]); + LBUF[LBP]:=0; +'END' PRINT RING BUFFER CONTENTS; +'IF' LIST 'THEN''BEGIN' SKIP(DEVT); WRITE(DEVT,"============"); + 'END'; +'END' PRINT ERROR CONTEXT; +CHOUT(0); +'END' FAILURE WARNING; + +'PROCEDURE' FAIL(X); 'INTEGER' X; 'VALUE' X; +'BEGIN' WARN(X); +'IF' TERM 'THEN' ABS; +NEXT: 'IF''NOT' TERM 'THEN''BEGIN' ABS; 'GOTO' NEXT 'END'; +'END' FAILURE OUTPUT; + +'PROCEDURE' CHFAIL(SYM,FNO); 'INTEGER' SYM,FNO; 'VALUE' SYM, FNO; +'BEGIN''IF' BS#SYM 'THEN' WARN(FNO); ABS 'END'; + + +'PROCEDURE' SAVE; +'BEGIN' DECL:=DECL+1; DIG[DECL]:=EXPAND(BS); ABS 'END'; + +'PROCEDURE' RDIG; +L: 'IF' DIGIT 'THEN' + 'BEGIN' SAVE; 'GOTO' L 'END'; + +'PROCEDURE' MAKREAL(R1,R2); +'VALUE' R1,R2; 'BOOLEAN' R1,R2; +'BEGIN' 'IF''NOT' R2 'THEN' CODE(44); +'IF''NOT' R1 'THEN' CODE(51); +'END' MAKE BOTH OPERANDS REAL; + +'BOOLEAN''PROCEDURE' APRIME; +'BEGIN''BOOLEAN' PREAL; +'IF' FFET 'THEN' + 'BEGIN' FFET:='FALSE'; APRIME:=TYPE=1; 'GOTO' EAPR; + 'END' FIRST OPERAND FETCHED; + +'IF' BS=40 'THEN' + 'BEGIN' ABS; PREAL:=AE; CHFAIL(41,12) + 'END' +'ELSE''IF' LETTER 'THEN' + 'BEGIN' 'IF' TYPE>2 'THEN' TYPE:=2; + FETCH; 'IF''NOT' (TYPE=1 'OR' TYPE=2) 'THEN' WARN(38); + PREAL:=TYPE=1 + 'END' +'ELSE' 'BEGIN''INTEGER' I,J,K,L; + PREAL:='FALSE'; DECL:=0; + 'IF' BS=38 'THEN' + 'BEGIN' STCH; + K:=CHAR; L:=0;ABS; 'GOTO' INTOUT; + 'END' CHARACTER LITERAL + 'ELSE''BEGIN' + 'IF' BS=46 'THEN''GOTO' RFRAC + 'ELSE''IF''NOT' DIGIT 'THEN' FAIL(10) + 'ELSE''BEGIN' RDIG; + 'IF' BS=5 'THEN''GOTO' REXP + 'ELSE''IF' BS#46 'THEN''GOTO' LITOUT; +RFRAC: SAVE; PREAL:='TRUE'; RDIG; + 'IF' BS#5 'THEN''GOTO' LITOUT; +REXP: SAVE; PREAL:='TRUE'; + 'IF' BS=43 'OR' BS=45 'THEN' SAVE; + RDIG; + 'END' NUMERIC NOT STARTING WITH SIGN OR POINT + 'END' NUMERIC LITERAL; +LITOUT: 'IF' PREAL 'THEN' + 'BEGIN' CODE(45); + 'IF' BITSTR 'THEN''BEGIN' + IOC(21); BS2(3); BS2(3); BS2(0); IOC(22); + BS8(32); BS8(32); + 'FOR' J:=1 'STEP' 1 'UNTIL' DECL 'DO' + BS8(DIG[J]); + BS8(13); + 'END''ELSE''BEGIN' + SKIP(DEV); WRITE(DEV,"FL "); + 'FOR' J:=1 'STEP' 1 'UNTIL' DECL 'DO' + CHOUT(DEV,DIG[J]); + SKIP(DEV); ITEM:=0; + 'END'; + SIZE:=SIZE+4; + 'END' FLOATING POINT LITERAL + 'ELSE''BEGIN' K:=0; L:=0; + 'FOR' J:=1 'STEP' 1 'UNTIL' DECL 'DO' + 'BEGIN' K:=10*K+DIG[J]-48; L:=L*10; + 'IF' K>=BSIZE 'THEN' + 'BEGIN' L:=L+K%BSIZE; K:=LOWER(K); + 'END'; + 'IF' L>=BSIZE%2 'THEN' WARN(44); + 'END' NUMERIC LITERAL CONVERSION; + INTOUT: 'IF' K=0 'AND' L=0 'THEN' CODE(29) + 'ELSE' 'IF' L=0 'THEN' SIXBIT(K) + 'ELSE''BEGIN' CODE(16); CODE(K); CODE(L) 'END' + 'END'; + 'END'; + +APRIME:=PREAL; +TYPE:='IF' PREAL 'THEN' 1 'ELSE' 2; +EAPR: 'END' ARITHMETIC PRIMARY; + +'BOOLEAN''PROCEDURE' AFAC; +'BEGIN''BOOLEAN' FREAL,SREAL,NEG; +'IF' FRED 'OR' FFET 'THEN' NEG:='FALSE' 'ELSE' +'BEGIN' NEG:=BS=45; + 'IF' BS=43 'OR' BS=45 'THEN' ABS; +'END'; +FREAL:=APRIME; +AFA1: 'IF' BS=30 'THEN' + 'BEGIN''IF' 'NOT' FREAL 'THEN' + 'BEGIN' CODE(44); FREAL:='TRUE' + 'END'; + ABS; CODE('IF' APRIME 'THEN' 49 'ELSE' 18); + 'GOTO' AFA1 + 'END'; +'IF' NEG 'THEN' CODE('IF' FREAL 'THEN' 46 'ELSE' 17); +AFAC:=FREAL; +TYPE:='IF' FREAL 'THEN' 1 'ELSE' 2; +'END' ARITHMETIC FACTOR; + + + +'BOOLEAN''PROCEDURE' ATERM; +'BEGIN''BOOLEAN' FREAL,SREAL; +FREAL:=AFAC; +ATE1: 'IF' BS=42 'THEN' + 'BEGIN' ABS; SREAL:=AFAC; + 'IF' 'NOT' FREAL 'AND''NOT' SREAL 'THEN' CODE(19) + 'ELSE''BEGIN' + MAKREAL(FREAL,SREAL); CODE(50); FREAL:='TRUE' + 'END' REAL MULTIPLY; + 'GOTO' ATE1 + 'END' MULTIPLY CASE +'ELSE''IF' BS=47 'THEN' + 'BEGIN' ABS; SREAL:=AFAC; + MAKREAL(FREAL,SREAL); + CODE(52); FREAL:='TRUE'; 'GOTO' ATE1 + 'END' REAL DIVISION CASE +'ELSE''IF' BS=37 'THEN' + 'BEGIN' ABS; SREAL:=AFAC; + 'IF' FREAL 'OR' SREAL 'THEN' WARN(11); + CODE(20); 'GOTO' ATE1 + 'END' INTEGER DIVISION CASE +'ELSE' 'IF' BS=535 'THEN' + 'BEGIN' ABS; SREAL:=AFAC; + 'IF' FREAL 'OR' SREAL 'THEN' WARN(11); + CODE(76); 'GOTO' ATE1; + 'END' MOD OPERATOR; + +ATERM:=FREAL; +TYPE:='IF' FREAL 'THEN' 1 'ELSE' 2; +'END' ARITHMETIC TERM; + +'BOOLEAN''PROCEDURE' SAE; +'BEGIN''BOOLEAN' FREAL,SREAL; +FREAL:=ATERM; +SAE1: 'IF' BS=43 'OR' BS=45 'OR' BS=33 'OR' BS=521 'OR' BS=169 'THEN' + 'BEGIN''INTEGER' ADDOP; + ADDOP:=BS; ABS; SREAL:=ATERM; + 'IF' 'NOT' FREAL 'AND''NOT' SREAL 'THEN' + 'BEGIN' + CODE('IF' ADDOP=43 'THEN' 13 + 'ELSE''IF'ADDOP=33 'THEN' 73 + 'ELSE''IF'ADDOP=521'THEN' 74 + 'ELSE''IF'ADDOP=169'THEN' 75 'ELSE' 21) + 'END' + 'ELSE''BEGIN' + 'IF' ADDOP=33 'OR' ADDOP=521 'OR' ADDOP=169 'THEN' WARN(11); + MAKREAL(FREAL,SREAL); + CODE('IF' ADDOP=43 'THEN' 53 'ELSE' 54); + FREAL:='TRUE'; + 'END' REAL ADDITION/SUBTRACTION; + 'GOTO' SAE1 + 'END'; +SAE:=FREAL; +TYPE:='IF' FREAL 'THEN' 1 'ELSE' 2; +'END' SIMPLE ARITHMETIC EXPRESSION; + +'BOOLEAN''PROCEDURE' AE; +'IF' BS=366 'THEN' +'BEGIN''BOOLEAN' FREAL,SREAL; 'INTEGER' L1,L2; +L1:=IFCLAUSE; FREAL:=SAE; CHFAIL(212,7); +L2:=JMPNEW; LDEC(L1); +SREAL:=AE; +'IF' FREAL 'AND' SREAL 'OR''NOT' FREAL 'AND''NOT' SREAL 'THEN' LDEC(L2) +'ELSE''IF' FREAL 'THEN' + 'BEGIN' CODE(44); LDEC(L2) + 'END' +'ELSE' 'BEGIN' L1:=JMPNEW; LDEC(L2); CODE(44); + FREAL:='TRUE'; LDEC(L1) + 'END'; +AE:=FREAL; +TYPE:='IF' FREAL 'THEN' 1 'ELSE' 2; +'END' +'ELSE' AE:=SAE; + +'PROCEDURE' SETI(I); 'VALUE' I; 'INTEGER' I; IOC(11); + +'PROCEDURE' SETO(I); 'VALUE' I; +'INTEGER' I; IOC(12); + +'INTEGER' 'PROCEDURE' SWLIST; IOC(16); + +'PROCEDURE' RE; +'BEGIN''INTEGER' SBS; 'BOOLEAN' FREAL,SREAL; +FREAL:=TYPE=1; SBS:=BS; ABS; SREAL:=AE; +'IF''NOT' FREAL 'AND''NOT' SREAL 'THEN' CODE(41) +'ELSE''BEGIN' MAKREAL(FREAL,SREAL); CODE(56); + 'END'; +'IF' SBS=61 'THEN' CODE(22) +'ELSE''IF' SBS=35 'THEN' 'BEGIN' CODE(22); CODE(30) 'END' +'ELSE''IF' SBS=60 'THEN' CODE(24) +'ELSE''IF' SBS=62 'THEN' CODE(23) +'ELSE''IF' SBS=63 'THEN' 'BEGIN' CODE(23); CODE(30) 'END' +'ELSE''IF' SBS=38 'THEN' 'BEGIN' CODE(24); CODE(30) 'END' +'ELSE' FAIL(9); +TYPE:=3; +'END' RELATIONAL BOOLEAN; + +'PROCEDURE' PUTOUT; +'BEGIN''INTEGER' LEVEL, SLOT; +LEVEL:=ILBD[DECL]; +SLOT:='IF' VDEP[DECL]<0 'THEN' 3 + 'ELSE' LOWER(VADR[DECL]); +'IF' LEVEL=0 'THEN' +'BEGIN''IF' SLOT>15 'THEN' + 'BEGIN' CODE(37); CODE(SLOT); 'END' + 'ELSE' CODE(240+SLOT); +'END' +'ELSE''IF' LEVEL=PDEPTH 'THEN' +'BEGIN''IF' SLOT>15 'THEN' + 'BEGIN' CODE(4); CODE(SLOT); 'END' + 'ELSE' CODE(224+SLOT); +'END' +'ELSE' +'BEGIN' CODE(26); CODE(LEVEL); CODE(SLOT); 'END'; +'END' STORE VARIABLE; + +'PROCEDURE' GETOUT; +'BEGIN''INTEGER' LEVEL, SLOT; +LEVEL:=ILBD[DECL]; +SLOT:='IF' VDEP[DECL]<0 'THEN' 3 + 'ELSE' LOWER(VADR[DECL]); +'IF' LEVEL=0 'THEN' +'BEGIN''IF' SLOT>15 'THEN' + 'BEGIN' CODE(38); CODE(SLOT); 'END' + 'ELSE' CODE(208+SLOT); +'END' +'ELSE''IF' LEVEL=PDEPTH 'THEN' +'BEGIN''IF' SLOT>15 'THEN' + 'BEGIN' CODE(12); CODE(SLOT); 'END' + 'ELSE' CODE(192+SLOT); +'END' +'ELSE' +'BEGIN' CODE(25); CODE(LEVEL); CODE(SLOT); 'END'; +'END' FETCH VARIABLE; + +'INTEGER''PROCEDURE' IFCLAUSE; +'BEGIN' ABS; DBE(3); CHFAIL(808,25); +CODE(28); LABEL(NLAB); IFCLAUSE:=NEWLAB 'END' IFCLAUSE; + +'PROCEDURE' BPRIM; +'BEGIN' 'BOOLEAN' NOT; +'IF' FFET 'THEN' + 'BEGIN' FFET:='FALSE'; 'GOTO' EBPRIM; + 'END' BOOLEAN OPERAND FETCHED; +'IF' BS=575 'THEN''BEGIN' NOT:='TRUE'; ABS 'END' + 'ELSE' NOT:='FALSE'; +'IF' BS=818 'THEN' + 'BEGIN' ABS; CODE(84) 'END' +'ELSE''IF' BS=241 'THEN' + 'BEGIN' ABS; CODE(29) 'END' +'ELSE''IF' LETTER 'THEN' + 'BEGIN' TYPE:=3; FETCH; + 'IF''NOT' BTYPE 'THEN' + 'BEGIN' FFET:='TRUE'; 'GOTO' RELAT; + 'END' IDENTIFIER NOT BOOLEAN; + 'END' EXPRESSION STARTS WITH IDENTIFIER +'ELSE''IF' BS=40 'THEN' + 'BEGIN' ABS; DBE(3); CHFAIL(41,14) 'END' +'ELSE' 'BEGIN' TYPE:=2; +RELAT: TYPE:='IF' AE 'THEN' 1 'ELSE' 2; RE; + 'END' RELATIONAL PRIMARY; +'IF' NOT 'THEN' CODE(30); +EBPRIM: 'END' BPRIME; + +'PROCEDURE' BTERM; +'BEGIN' BPRIM; +BTM1: 'IF' BS=118 'THEN' + 'BEGIN' ABS; BPRIM; CODE(31); 'GOTO' BTM1 'END'; +'END' BOOL TERM; + +'PROCEDURE' SBE2; +'BEGIN' BTERM; +SBE1: 'IF' BS=618 'THEN' + 'BEGIN' ABS; BTERM; CODE(32); 'GOTO' SBE1 'END'; +'END' SBE WITHOUT EQUIV; + +'PROCEDURE' SBEQ; +'BEGIN' SBE2; +SBQ2: 'IF' BS=373 'THEN' + 'BEGIN' CODE(30); ABS; SBE2; CODE(32); 'GOTO' SBQ2 'END'; +'END' IMPLIES; + +'PROCEDURE' SBE; +'BEGIN' SBEQ; +SBE3: 'IF' BS=217 'THEN' + 'BEGIN' ABS; SBEQ; CODE(33); 'GOTO' SBE3 'END'; +'END' SIMPLE BOOLEAN EXPRESSION; + +'PROCEDURE' SDBE(DBTYP); 'VALUE' DBTYP; 'INTEGER' DBTYP; +'BEGIN' +'IF' DBTYP=3 'THEN' SBE +'ELSE''IF' BS=40 'THEN' + 'BEGIN' ABS; DBE(DBTYP); CHFAIL(41,14) + 'END' +'ELSE' 'BEGIN' IDENT; + 'IF' FOUND 'THEN' + 'BEGIN' 'IF' TYPE=DBTYP+5 'THEN' GETOUT + 'ELSE''IF' TYPE=8 'THEN' + 'BEGIN''IF' SUBSCRIPT#1 'THEN' WARN(47); + GETOUT; CODE(48); + 'END' EVALUATE SWITCH + 'ELSE''GOTO' SANF + 'END' ACTION WHEN DECLARED + 'ELSE' SANF: 'BEGIN' TYPE:=DBTYP; SFR; + CODE(47); LABEL(ADDR); + 'END' SET ADDRESS OF NON-FORMAL + 'END' SET ADDRESS OF LABEL OR PROCEDURE +'END' SIMPLE DESIGNATIONAL OR BOOLEAN EXPRESSION; + +'PROCEDURE' DBE(DBTYP); 'VALUE' DBTYP; 'INTEGER' DBTYP; +'BEGIN' +'IF' BS#366 'THEN' SDBE(DBTYP) +'ELSE' 'BEGIN''INTEGER' L1,L2; + L1:=IFCLAUSE; SDBE(DBTYP); CHFAIL(212,8); + L2:=JMPNEW; LDEC(L1); + DBE(DBTYP); LDEC(L2); + 'END' CONDITIONAL; +TYPE:=DBTYP; +'END' DESIGNATIONAL OR BOOLEAN EXPRESSION; + +'PROCEDURE' STID(LEN,SADR,TYPE); +'VALUE' LEN,SADR,TYPE; +'INTEGER' LEN,SADR,TYPE; +'BEGIN' DECL:=DECL+1; NODEC:=DECL; ND1:=NODEC+1; + MXV:=NODEC; ILNP[DECL]:=ILFP; + IL[ILFP+LEN]:=0; ILFP:=ILFP+LEN+1; + SETO(IL] + ILFP); + VADR[DECL]:=SADR; ILVT[DECL]:=TYPE; ILBD[DECL]:=0; +'END' STORE STANDARD IDENTIFIER; + + + +ITEM:=0; BSIZE:=256; RSIZE:=2; ILEP:=1; +NAPT:=1; LNAM[1]:=0; + LIST:='FALSE'; BITSTR:='TRUE'; PRECOM:='FALSE'; + LTAB:='FALSE'; IDTAB:='FALSE'; +'FOR' DECL:=1 'STEP' 1 'UNTIL' 100 'DO' LBUF[DECL]:=0; +HOL1:='FALSE'; STRING:='FALSE'; +TLIN:=1; RERUN:='FALSE'; BUGS:='FALSE'; +PDEPTH:=0; NPN:=1; LDPT:=0; FIXSP:=0; DEPTH:=0; +ADEPTH:=0; SIZE:=4; DOLL:='FALSE'; LINE:=1; LBP:=0; +ILFP:=0; FRFP:=0; +NLAB:=1; MAX:=0; NADR:=2; FRED:='FALSE'; FFET:='FALSE'; +AEREAD:='FALSE'; SECOND:='FALSE'; DIAGNOSTICS:='FALSE'; + IOC(8); IOC(3); SETO(SWLIST+13); + WRITE(10,"ALG"); INPUT(INDEV); + 'IF' INDEV>0 'THEN' 'GOTO' IOK; + IOC(5); INPUT(INDEV); + 'IF' INDEV<0 'THEN' 'GOTO' IOCH; IOC(3); IOC(6); 'GOTO' IOK; +IOCH: IOC(2); RERUN:='TRUE'; + SETO(SWLIST+13); WRITE(10,"ALG"); INPUT(INDEV); + 'IF' INDEV<1 'THEN' 'GOTO' IOCH; +IOK: SETO(SWLIST+13); WRITE(10,"OBJ"); OUTPUT(DEV); + SETI(SWLIST); DECL:=1; +GD: CHIN(10,DEVT); + 'IF' DEVT#0 'THEN' + 'BEGIN' DEVT:='IF' DEVT>95 'THEN' DEVT-96 + 'ELSE''IF' DEVT>64 'THEN' DEVT-64 + 'ELSE' DEVT; + DIG[DECL]:=DEVT; DECL:=DECL+1; + 'GOTO' GD; + 'END'; + DIG[DECL]:=59; RDIR; + SETO(SWLIST+13); WRITE(10,"MON"); + OUTPUT(DEVT); + 'IF' DEVT>0 'THEN' IDTAB:='TRUE' 'ELSE' DEVT:=1; + SETO(SWLIST+13); WRITE(10,"ALG"); IOC(7); + IOC(1); + + 'IF' IDTAB 'THEN' + 'BEGIN' SKIP(DEVT); + WRITE(DEVT,"IDENTIFIER TABLE SIZE=",MAXNID); + SKIP(DEVT); + WRITE(DEVT,"FORWARD REFERENCE TABLE SIZE=",MAXLAB); + SKIP(DEVT); + 'END'; + +DECL:=0; SETO(IL]); +WRITE(10,"SKIP"); STID(4,40,10); +WRITE(10,"CHIN"); STID(4,7,12); +WRITE(10,"CLOSE"); STID(5,77,10); +WRITE(10,"READ"); STID(4,3,11); +WRITE(10,"IOC"); STID(3,35,10); +WRITE(10,"TEXT"); STID(4,5,10); +WRITE(10,"RWRITE"); STID(6,48,10); +WRITE(10,"WRITE"); STID(5,6,10); +WRITE(10,"CHOUT"); STID(5,8,10); +WRITE(10,"DELETE"); STID(6,78,10); +WRITE(10,"INPUT"); STID(5,79,12); +WRITE(10,"OUTPUT"); STID(6,80,12); + +WRITE(10,"SQRT"); STID(4,0,11); +WRITE(10,"SIN"); STID(3,0,11); +WRITE(10,"COS"); STID(3,0,11); +WRITE(10,"ARCTAN"); STID(6,0,11); +WRITE(10,"EXP"); STID(3,0,11); +WRITE(10,"LN"); STID(2,0,11); +WRITE(10,"SIGN"); STID(4,0,12); +WRITE(10,"ENTIER"); STID(6,0,12); +WRITE(10,"ABS"); STID(3,0,11); +ND2:=NODEC; + +WRITE(10,"OPSYSIDCODE"); STID(11,81,12); +WRITE(10,"SELECTINPUT"); STID(11,82,10); +WRITE(10,"SELECTOUTPUT"); STID(12,83,10); + +CHIN(INDEV); CHOUT(DEV); +LXX: INCH; 'IF'CHAR=39'THEN'FULL:='FALSE''ELSE' + 'IF'CHAR>64'AND'CHAR<91'THEN'FULL:='TRUE' + 'ELSE''GOTO'LXX; + HOL1:='TRUE'; + +ABS; COMMENT; +'IF' BITSTR 'THEN''BEGIN' +WRITE(DEV,"B"); IOC(17); +BITQ(0,1); +'END''ELSE''BEGIN' SKIP(DEV); WRITE(DEV,"ORG 0"); SKIP(DEV); +WRITE(DEV,"#L0"); SKIP(DEV); +'END'; + +STATEMENT; +'IF' 'NOT' DOLL 'THEN' WARN(6); CODE(63); +'IF' LDPT#0 'THEN' +'FOR' DECL:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'BEGIN' + 'FOR' FIRST:=0 'STEP' 1 'UNTIL' 100 'DO' + IDN[FIRST]:=FRN[FRNP[DECL]+FIRST]; + LINE:=FLINE[DECL]; WARN(2) + 'END'; +'IF' BITSTR 'THEN''BEGIN' +IOC(21); BITQ(0,2); BS2(0); +BS2(3); BS2(0); BS16(STAK); +BS2(3); BS2(3); BS2(3); BS16(0); +IOC(22); +'END''ELSE''BEGIN' +SKIP(DEV); WRITE(DEV,"L0:#",STAK); SKIP(DEV); +WRITE(DEV,"END 0"); SKIP(DEV); +'END'; + +'IF' IDTAB 'THEN' + 'BEGIN' SKIP(DEVT); + WRITE(DEVT,"MAXIMUM IDENTIFIERS IN SCOPE=",MXV); + SKIP(DEVT); + WRITE(DEVT,"MAXIMUM FORWARD REFERNECES=",MAX); + SKIP(DEVT); + 'END'; + +EPROG: CLOSE(DEV); CLOSE(INDEV); CLOSE(DEVT); +SKIP(1); +'IF' BUGS 'THEN' +WRITE(1,"PROGRAM FAILS") +'ELSE' WRITE(1,"COMPILES OK"); +SKIP(1); WRITE(1,"SIZE ",SIZE); +CHOUT(1,7); SKIP(1); SKIP(1); +'IF' RERUN 'THEN' IOC(9); +'END' +'END' OF RML ALGOL COMPILER +$$$$$ + diff --git a/RHA (Minisystems) ALGOL v55/ALGOL60.CNT b/RHA (Minisystems) ALGOL v55/ALGOL60.CNT new file mode 100644 index 0000000..6b08602 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/ALGOL60.CNT @@ -0,0 +1,107 @@ + +1 Introduction +2 Licence agreement - please read this first=Sec_1_1 +2 History=Sec_1_2 +2 Document overview=Sec_1_3 +1 Z80 User manual +2 Z80 manual introduction=Sec_2_1 +2 Language elements +2 Identifiers and symbols=Sec_2_3 +2 Key words=Sec_2_4 +2 Pre-declared identifiers=Sec_2_5 +2 String literals=Sec_2_6 +2 Character literals=Sec_2_7 +2 The structure of an Algol program +2 Program structure=Sec_2_9 +2 Blocks and declarations=Sec_2_10 +2 Program layout and style=Sec_2_11 +2 Conditional compilation=Sec_2_12 +2 Algol program variables +2 Data types=Sec_2_14 +2 Arrays=Sec_2_15 +2 Array memory layout and bound checking=Sec_2_16 +2 Byte arrays=Sec_2_17 +2 Expressions +2 Simple expressions=Sec_2_19 +2 Conditional expressions=Sec_2_20 +2 Statements +2 Conditional statements=Sec_2_22 +2 Assignment statements=Sec_2_23 +2 FOR statements=Sec_2_24 +2 The CASE statement=Sec_2_25 +2 The WHILE statement=Sec_2_26 +2 The REPEAT statement=Sec_2_27 +2 Dummy statements=Sec_2_28 +2 Comments=Sec_2_29 +2 Labels, switches and GOTO statements=Sec_2_30 +2 Designational expressions=Sec_2_31 +2 Procedures +2 Standard functions=Sec_2_33 +2 Operating system identification=Sec_2_34 +2 Procedures without parameters=Sec_2_35 +2 Procedures with parameters=Sec_2_36 +2 Numeric and Boolean parameters by value=Sec_2_37 +2 Variables called by name=Sec_2_38 +2 String and switch procedure parameters=Sec_2_39 +2 Labels and procedures as parameters=Sec_2_40 +2 Summary of points on procedures=Sec_2_41 +2 Differences from the Algol 60 report +2 Differences from the Algol 60 report=Sec_2_43 +2 Language restrictions=Sec_2_44 +2 Language extensions=Sec_2_45 +2 The input/output mechanism +2 Stream or device numbers=Sec_2_47 +2 ALGOL fixed stream numbers=Sec_2_48 +2 Printer position on streams 3 and 6=Sec_2_49 +2 Device names in command Lines=Sec_2_50 +2 Creating a command line for I/O streams=Sec_2_51 +2 Parsing the I/O command line=Sec_2_52 +2 Input/output directly to or from memory=Sec_2_53 +2 Switch lists on I/O selections=Sec_2_54 +2 Closing and deleting files=Sec_2_55 +2 Serial input/output procedures=Sec_2_56 +2 Formatted number output=Sec_2_57 +2 Random access files=Sec_2_58 +2 Input/output support routines=Sec_2_59 +2 Direct BDOS and BIOS CP/M calls=Sec_2_60 +2 Library procedures +2 Library procedures=Sec_2_62 +2 Library inserts=Sec_2_63 +2 Example programs=Sec_2_64 +2 Compiling and running programs +2 Compiling and running programs=Sec_2_66 +2 Compiling=Sec_2_67 +2 Compiler directives=Sec_2_68 +2 Character and bitstream compiler output files=Sec_2_69 +2 Pre-compiled libraries and the linker=Sec_2_70 +2 Runtime program=Sec_2_71 +2 Switches on the loader filename=Sec_2_72 +2 Long integer (32 bit) Algol=Sec_2_73 +2 The chaining mechanism=Sec_2_74 +2 Compiler error messages and diagnostic information +2 Compiler error messages=Sec_2_76 +2 Compiler identifier table and identifier types=Sec_2_77 +2 Compiler representation of basic symbols=Sec_2_78 +2 Run time errors and diagnostic information +2 Run time errors=Sec_2_80 +2 Recovery from run time errors=Sec_2_81 +2 Runtime error numbers=Sec_2_82 +2 Runtime stack organisation=Sec_2_83 +2 Runtime operation codes=Sec_2_84 +2 Summary of ioc() procedure calls=Sec_2_85 +2 Summary of pre-declared procedures=Sec_2_86 +2 Procedures in the library ALIB.ALG=Sec_2_87 +2 Distributed programs and files=Sec_2_88 +1 Rogalgol for the 80x86 +2 Overview of 80x86 Rogalgol=Sec_3_1 +2 Extra features available on the 80x86 versions +2 Using extra data memory beyond 64K=Sec_3_3 +2 The Runtime Debugger=Sec_3_4 +2 File handling under PCDOS and MSDOS +2 Overview of MSDOS file handling=Sec_3_6 +2 File Control Block usage=Sec_3_7 +2 The operating system interface +2 Overview of BIOS and SYSTEM calls=Sec_3_9 +2 BDOS (system) calls under MSDOS/PCDOS=Sec_3_10 +2 BIOS calls under MSDOS/PCDOS=Sec_3_11 +2 Compiling and linking the 80x86 Rogalgol executables=Sec_3_12 diff --git a/RHA (Minisystems) ALGOL v55/ALGOL60.HLP b/RHA (Minisystems) ALGOL v55/ALGOL60.HLP new file mode 100644 index 0000000000000000000000000000000000000000..f0701421981e2ee7438a41e1eaad0b8bd9850647 GIT binary patch literal 142409 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

Y__6_@1_uO1-aW<60Ls(lBl*OP|wj!vSlYSL#K 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 and less than or equals (<=). Identifiers consist of any number of + alphanumeric characters of which the first must be a letter. Letters are in + upper or lower case depending upon the convention being used. Examples are + x, fred, ml, m2, abc123, abc1234. + + Identifiers may have up to 99 characters, all significant. To prevent an + excessive slowing of the compiler, the 99 character limit is not checked. + However, the total number of identifiers and the byte array storing the + names are checked. The tables are optimised for an average identifier length + of 5 characters. If the average is longer, the name array will overflow + first; if it is less the limit on the number of identifiers will be reached + first. + + All identifiers referring to variables and switches must be declared before + they are used so that the compiler knows to what type of object they refer. + Labels and procedures may be used before they are declared because the type + of the identifier can be deduced from the context in which it is used. + + 2.4 Key words + + Some convention is required in Algol to distinguish between the language key + words, e.g. BEGIN, END, ELSE, etc., and identifiers. In textbooks this is + usually done by printing the key words in bold type. In actual compilers + some other convention is needed depending upon the i/o hardware available. + This compiler accepts two possible conventions. The first must be used where + the i/o is restricted to upper case characters only. The second may be used + where both upper and lower case are available. Two small utilities are + provided to convert between these conventions. + + CONVENTION 1. Upper case only. All basic language words must be enclosed + within single quote marks, e.g. + + SUM:=0; + 'FOR' I:=1 'STEP' 1 'UNTIL' MAX 'DO' + SUM:=SUM+(X[I]-XM[I])^2; + RMS:=SQRT(SUM/MAX); + + CONVENTION 2. Upper and lower case. All basic language words must be in + upper case and all identifiers must use only lower case. The above example + now becomes: + + sum:=0; + FOR i:=1 STEP 1 UNTIL max DO + sum:=sum+(x[i]-xm[i])^2; + rms:=sqrt(sum/max); + + The compiler decides which of the two conventions is being used from the + first word of the program, which must be BEGIN, COMMENT or DIRECTIVE. Once + the convention is selected, the compiler expects the remainder of the + program to continue in the same manner. Internally the compiler converts all + identifiers to upper case (which is how they appear if the identifier tables + are printed). The compiler only checks the first 2 letters of the language + key words, then skips until a suitable terminator is found (a closing quote + or a non upper case letter). This implies that in the second convention + adjacent language key words must be separated, e.g. + + THEN GOTO label; and not THENGOTO label; + + Note: In the first convention, decimal exponentiation in the + representation of real numbers is represented by 'E' e.g. X := 1.234E-5, + whereas in the second case a small 'e' must be used e.g. x := 1.234e-5. Note + that when data is being read by the program then a capital 'E' is always + used. + + Note: When switches are applied to file names they are case sensitive in + the same way. Use lower case letters if the program being compiled uses the + upper/lower case convention. + + Users if they so wish may use any of the language key words for the names of + identifiers. As an example the following declaration is perfectly + acceptable: + + BEGIN INTEGER real, begin, end; + + For the sake of readability the examples given in this manual will for the + most part use the upper/lower case convention. + + 2.5 Pre-declared identifiers + + Certain procedure names are recognized by the compiler without declaration. + Such identifiers may be regarded as having been declared in a fictitious + outer block enclosing the entire program and thus in scope everywhere except + where masked out by a local redeclaration. These procedures include the + input/output routines which are discussed later and the standard functions + as defined in the Algol 60 Report. In addition to these there is the + procedure 'ioc' which takes a single integer parameter, e.g.: + + ioc(n) ; + + This routine serves a variety of purposes depending upon the value of n. + These include input/output selection, format control and so on. These uses + will be discussed in the following sections to which they apply. Another use + of this procedure is as a simple way of linking to code routines within the + runtime system. An inspection of the file 'ALIB.ALG' on the distribution + disk shows that the majority of the procedures consist simply of a formal + definition of their parameters with a single call to 'ioc' as the body of + the procedure. Commercial Z80 users may link in their own code routines by + this same method. + + 2.6 String literals + + A string in Algol consists of a sequence of characters enclosed within + double quotes, e.g. + + text(1, "Hello Dolly"); + + All characters within the quotes with an ASCII value less than 32 are + ignored. This includes carriage return, tab, and control characters but + space is permitted. In order that these and other characters may be included + within strings, the following convention is used. The characters '*' + (asterisk) and '^' (circumflex) have special significance and are always + considered in conjunction with the character which immediately follows. + + Control characters + + The sequence ^X will insert CONTROL-X into the string. In general '^' has + the effect of stripping off all but the 5 least significant bits of the + following character. + + Layout characters + + *N Inserts CR-LF (carriage return-line feed) into string. + *C Inserts CR (carriage return). + *I Inserts LF (line feed). + *S Inserts SP (space). A literal space is also allowed. + *T Inserts TAB. + *P Inserts FF (form feed--new page). + + All other characters following * are taken literally; in particular, + + ** Inserts * + *^ Inserts ^ + *" Inserts " + + For example + + text (1, "An example *"STRING*" + *SMight look lik + e this*NX*^2+Y*^2="); + + will print on the console as: + + An example "STRING" might look like this + X^2+Y^2= + + The internal representation of a string is a series of characters stored in + sequential bytes terminated by a zero value. + + 2.7 Character literals + + The literal value of any character may be found using an ampersand "&" + character followed immediately by the required character. For example, to + convert a character digit to a number between 0 and 9 we have + + i:=chin(1) - &0; + + or to output an X then + + chout(1,&X); + + The convention described above involving * and ^ also applies, so to check + for end of file (CONTROL-Z): + + i:=chin(dev); + IF i=&^Z THEN ... + + or to check for a carriage return character: + + IF i=&*C THEN ... + + The two exceptions are &*N and &*" which will lead to the wrong result. The + first generates two characters and the second is written &". + + Character literals are of type integer. + + 2.8 The structure of an Algol program + + 2.9 Program structure + + One of the most important features of the Algol language is that it is + structured. Just as round brackets define sub-expressions within + expressions, so the brackets BEGIN and END enclose a set of statements which + are treated syntactically as a single statement, These bracketed statements + are used in controlling the order of execution of the program and largely + replace the use of labels and GOTOs, since they are obeyed as a whole or not + at all. Such a statement is known as a compound statement or, if it contains + any declarations apart from labels, a block. Statements within a compound + statement are separated by semicolons. Strictly speaking, an Algol program + is one statement, because it must start with BEGIN and end with END. A + complete Algol program can be represented thus: + + BEGIN s1; s2; a3; .......... sn END FINISH + + The statements s1, s2, etc. may be of any type, including compound + statements and blocks. The closing FINISH must be present. It is used by the + compiler to check that there are the same number of BEGINS and ENDs. + + For users not familiar with the use of structured programming it is worth + explaining why the 'converted' consider this such an important feature. An + examination of any Algol program reveals the modular nature of its + structure, each block containing specific declarations of the variables, + arrays and procedures relevant to its operation. Many users new to such + languages are at first irritated by the need to declare explicitly every + identifier in a program. While there may be some justification for such + criticism when considering trivial program examples, the advantages become + obvious as the programs become larger and the declarations become a small + percentage of the program. The block in which an identifier is declared + defines the 'scope' of that identifier. Outside that block the identifier + has no meaning and occupies no memory resource. The system thus takes on the + role of resource management. The allocation of memory to variables is done + dynamically as the program is being executed. On entering a block the system + makes available those resources defined in the declarations and upon exit + from the block these resources are reclaimed and made available for other + uses; thus the memory required is always minimised. The penalty in terms of + runtime speed is negligible as most of the organisation is done by the + compiler. + + The total declarations throughout the program may in fact be in excess of + the memory of the computer, provided it is not all in scope at once. In + languages such as Fortran, on the other hand, the nearest one can get to + this feature is to work out some cumbersome EQUIVALENCE statements which + probably take longer to define than the corresponding Algol declarations. + + Economy of memory can also be achieved using 'dynamic bounds' on array + declarations. The declared bounds can be defined in terms of arithmetic + expressions evaluated at runtime on entering a block. These bounds may be + different each time the block is entered. The size of the arrays can be + chosen to be the smallest that will do the required task. + + Because memory is allocated dynamically in this way, it is important that + programs make no assumptions on entering a block about the initial values of + variables declared therein. Between leaving a block and re-entering it, the + memory used by such variables may have been re-used for other purposes and + indeed, in the case of procedures, the variables need not even occupy the + same memory addresses each time the block is entered. If it is important + that a particular variable should preserve its value between leaving and + entering a block then its declaration should be removed to an outer block + such that it remains 'within scope.' + + The localisation of the scope of variables to that of the block in which + they are declared also economises on the use of identifiers. The same names + can be declared within several blocks without ambiguity. This also helps + when program segments from various sources are combined without leading to + major problems with conflicting identifiers. + + 2.10 Blocks and declarations + + It has been mentioned already that variables must be declared before being + used and that the presence of such declarations makes a compound statement + into a block. All declarations must be placed immediately after a BEGIN or + another declaration. This does not apply to labels, which are set by placing + an identifier terminated by a colon just in front of the statement to be + labelled. The form of a declaration of a set of unsubscripted variables of + the same type is: + + Type ident1, ident2, ......, identn; + + 'Type' may be REAL, INTEGER, or BOOLEAN. The declarations ident1 etc. + represent the names of the identifiers. Variables may be used within the + block in which they are declared from the point of their declaration up + until the corresponding END. Outside this range they do not exist and are + said to be 'out of scope.' Procedures and labels may be used before + declaration, but the declaration must still be such that they are within + scope at the point they are used. Variables and switches must be declared + before they are used. This is so that the compiler can distinguish them from + functions, which may be used before declaration. This restriction is not + made in full Algol, in which variables may be referenced before declaration + as long as they are within scope. To each identifier used in a given block + there must be a corresponding declaration. It follows that all identifiers + declared in a block must be unique. The same identifiers may however be + re-used within other blocks. Where an identifier is used within an inner + block and also an enclosing outer block, then the inner declaration takes + precedence for the duration of the inner block. The outer declaration is + effectively 'masked out' but its value is preserved and again becomes + accessible on leaving the inner block. Consider the following: + + BEGIN REAL x,y,p; INTEGER i,p; + s1; s2; + BEGIN REAL x,z; + s3; + END + END + + Statements s1 and s2 cannot refer to z because it is out of scope; s3 cannot + refer to the first x because the inner declaration will take precedence. + When s3 refers to x it will always be the one declared with z, but s3 may + refer to y and to i. The identifier p is declared twice within the same + block and will generate a compile time error. + + 2.11 Program layout and style + + The layout of an Algol program is almost entirely within the hands of the + programmer. Such concepts as line number or column number have no meaning in + Algol. Layout characters such as new lines, spaces, and tabs are generally + ignored except for the following cases: + + 1. Spaces are significant within strings. + 2. Language key words and double character symbols should contain no + embedded layout characters, e.g. + + BEGIN + a>=b + a:=b + + and not: + + BE GIN + a> =b + a: =b + + In all other contexts the programmer is free to lay out the program as he + wishes. The resulting text may thus range from the very elegant to the + totally unintelligible. As intelligent layout requires no additional work + and results in programs far easier to follow and modify, users are urged to + develop a good layout style which should reflect the block structure + inherent in an Algol program. Use tab stops to indent text with BEGIN and + END pairs aligned as in the examples given in this manual. Labels should + start on a new line to the left of the program statements. Statements are + separated by semicolons or language key words and not by new line + characters, so that if necessary expressions may extend over several lines + of text. Similarly one line may contain several shorter statements. + + Identifiers should reflect the nature of the quantities they represent; + spaces may be included within identifiers if it makes the resulting text + more readable. They will be ignored by the compiler. Frequently used loop + variables and array subscripts are often most conveniently represented by a + single letter identifier, e.g. + + end of file:=char=&^Z ; + total:=total+term; + FOR i:=lower STEP interval UNTIL upper DO .... + volume:=height*length*width; + + Comments should he included where they make the workings of the program more + understandable and are described later. + + 2.12 Conditional compilation + + There are two new Algol basic symbols: CC and EC. CC stands for Conditional + Code and EC for End Conditional. By default these symbols and all + intervening code are ignored. If the compiler is given the directive D + (diagnostics) then the code between the new symbols is compiled. Because the + code is scanned as basic symbols and not as characters, it should not + contain any unmatched single quote characters. + + 2.13 Algol program variables + + 2.14 Data types + + The data in the computer memory which may be manipulated by the program is + either numeric or Boolean. Numeric values may be real or integer. The + difference is that integers have no fractional part and occupy 2 bytes of + memory, while real quantities are held in exponent and mantissa form and + occupy 4 bytes. The Algol system converts numbers from one type to the other + whenever necessary. Arithmetic expressions may contain a mixture of real and + integer quantities. + + Numerical and Boolean data may appear within the program as literal values. + An integer literal is one which has neither a decimal point nor a decimal + exponent part. Examples are 3, -200, +1234. The range of integers is -32768 + to 32767. Real numbers contain either a decimal point or a decimal exponent, + indicated by E or e (depending upon which convention is in use), or both. + Examples are 0.1, -2.345, 1.2E3, 25.7e-7. Real numbers use one byte for the + exponent and three for the mantissa, giving a range of magnitudes from + approximately E-38 to E+38 and between 6 and 7 decimal digits of precision. + + Boolean literals are the language key words TRUE and FALSE. + + An alternative runtime program ARUNL has 32 bit integer operations instead + of floating point. + + 2.15 Arrays + + Subscripted variables in Algol are known as arrays. Real, integer, and + Boolean variables may be subscripted, while byte variables must be + subscripted. Like other variables, arrays are declared at the start of a + block, REAL ARRAY and ARRAY are equivalent. The declaration of an array with + one subscript has the form: + + ARRAY ident [ae:ae]; + + The ae's represent arithmetic expressions defining the bounds of the + subscript. Either or both bounds may be negative or zero, as long as the + second one is not lower than the first. Real ae's will be rounded towards + the nearest integer. If there is more than one subscript, the bound pairs + are separated by commas; there is no limit to the number of subscripts other + than the amount of available memory. If more than one array is to have the + same bounds, the bounds need only be specified after the last one. One + declaration may contain any number of array names: + + INTEGER ARRAY ia[1:30,1:5] ; + BOOLEAN ARRAY ba1, ba2 [1:n,1:3], ba3 [0:20], + ba4, ba5 [1:2*n] ; + + When arrays are declared with variable bounds, care should be taken that the + variables have defined values. This means that they should be declared in an + outer block and have been assigned values. This feature is used to partition + the available storage according to the data. + + When an array is used, an arithmetic expression is put in each subscript + position. The following are possible statements, using the examples above. + Conditional expressions are described later. + + ia[1,4]:=7; + + ia [n,m]:=ia[ia[n,2], ia[n,m]] ; + + Finally a complex example to show what is possible + + ia[n,3]:=IF ba2[3,1] AND ba3[n] THEN + ia[ia[3*n,1], IF ba3[0] THEN 2 ELSE n] + ELSE a; + + 2.16 Array memory layout and bound checking + + The elements of an array occupy a contiguous region of memory. In + multidimensional arrays the last subscript varies most rapidly. For example, + consider a two dimensional array declared as + + a[m:n, p:q] + + The address of element s[i,j] would be given by an equation of the form + + base + size * ((i-m)*(q-p+1)+(j-p)) + + where size is 1, 2 or 4 depending on the type of the array (byte, integer, + or real). At runtime a check is made that the address computed lies within + the limits allocated for the storage of the array. Note that for + multidimensional arrays this does not necessarily mean that all subscripts + lie within the declared bounds. For example, the element a[-1,15] would he + acceptable for an array declared as a[0:9, 0:9]. + + Boolean arrays are stored 8 bits per byte. + + 2.17 Byte arrays + + The introduction of BYTE arrays in Rogalgol is an extension to the language + as defined in the Algol 60 Report. BYTE arrays allow for the efficient use + of memory when string manipulation or small integer values are required. + Within expressions BYTE array elements are treated as type INTEGER, and may + be used in any context where am integer is allowed. + + Within expressions the contents of a byte array element become the integer + value, and the 8 most significant bits of the integer are set to zero. Thus: + + i:=b[n] ; + + will always yield a positive value for i in the range 0 to +255. + + When assigning to a byte array element, the expression on the right hand + side is first converted to type integer if necessary, the eight least + significant bits of which are then assigned to the byte array element, the 8 + most significant bits being discarded without any checking. Thus + + b[1] := -1; + i := b[1] ; + + will assign to i the value +255. The only time the compiler distinguishes + between an INTEGER ARRAY and a BYTE ARRAY is at the declaration. In all + other contexts the two may be used interchangeably. In particular, a formal + procedure parameter specified as type INTEGER ARRAY or BYTE ARRAY will + accept either as the actual parameter, e.g., + + BEGIN INTEGER ARRAY i[0:100]; + BYTE ARRAY b[0:100]; + + PROCEDURE xx(a); INTEGER ARRAY a; + BEGIN ... + END; + xx(i); xx(b); + + will be accepted. + + 2.18 Expressions + + 2.19 Simple expressions + + An expression is a section of program which delivers a result. The result + may be of type REAL, INTEGER, BOOLEAN, LABEL or (an extension to Algol 60) + the address of a procedure. + + The result of a numerical expression is real unless all the variables and + literals within it are integer and it contains no real operators. The real + operators are exponentiation (denoted by ^) and real division %. Arithmetic + expressions are evaluated with due regard to operator priority, and from + left to right where these are equal. Parentheses may be used to change the + order of evaluation. The following is a list of tho arithmetic and logical + operators together with their priorities, + + Operator with their priority and meaning + + (highest priority) + ^ 3 exponentiation + * 2 multiplication + / 2 real division + % 2 integer division + MOD 2 integer modulus + + 1 addition + - 1 subtraction + MASK 1 logical AND + DIFFER 1 logical EXCLUSIVE OR + ! 1 logical OR + (lowest priority) + + The operators MOD, MASK, DIFFER, and ! are additional to those defined in + the Algol 60 Report. + + The operators %, MOD, MASK, DIFFER, and ! take two integer operands and + deliver an integer result. The result of integer division % is truncated + towards zero. The result of integer modulus (MOD) is the remainder lost by + integer division. Note that + + i MOD 0 + + will always return the value zero while + + i%0 or x/0 + + will give a division by zero runtime error. + + The logical operators MASK, DIFFER and | consider each of the two integer + arguments as a pattern of 16 bits thus: + + 3 ! 5 = 7 + 3 MASK 5 = 1 + 3 DIFFER 5 = 6 + + Apart from the cases just discussed, expressions may contain any mixture of + real and integer quantities, and conversion between types will occur + automatically as context dictates. For example + + BEGIN REAL x,y; + INTEGER i,j; + ... + i:=x*y; x:=x*i; i:=x^y; + i:=x^i; x:=i%j; + + are all valid operations. + + In conversion from real to integer the result is rounded towards the nearest + integer value. + + Boolean expressions are made up of Boolean variables, the literals TRUE and + FALSE, arithmetic relations, Boolean procedures, and Boolean operators. The + Boolean operators are in order of precedence from highest to lowest + priorities. + + NOT NOT b: Is FALSE if b is true and TRUE if b is FALSE. + AND b AND c: Is TRUE if both b and c are TRUE otherwise it is + FALSE. + OR b OR c: Is TRUE if either b or 0 is TRUE (regardless of + the other) otherwise it is FALSE. + IMPLIES b IMPLIES c: Is FALSE only if b is TRUE and a is FALSE, + otherwise it is TRUE. + EQUIVALENT b EQUIVALENT c: Is TRUE if b and c have the same truth + value and FALSE otherwise. + + The relational operators are: + + = equals + > greater than + >= greater than or equal + < less than + <= less than or equal + # not equal + + Relational operators are dyadic. Care should be taken with the use of = and + # where either argument is of type real. In this case am exact equal occurs + only if both arguments have exactly the same bit pattern, which in the + context of real quantities involving rounding may not be very meaningful. A + more sensible test to make may be to check whether the absolute difference + is less than (or greater than) some small quantity, e.g. + + replace IF x=y THEN .... + with IF abs(x-y) < 0.0001 THEN + + As with arithmetic expressions, the order of evaluation may be changed by + the use of parentheses to group terms. Examples of Boolean expressions are: + + NOT x < 5 OR bv1 AND (y = 0 OR bv2) + x # (y - 5) + +(x-5)^2 <= 20 + + where x and y are numeric variables or procedures and bv1 and bv2 are + Boolean variables or procedures. + + Note the plus sign before the parentheses in the last example. If this had + been absent, the compiler would have assumed that the bracket enclosed a + Boolean expression and would have indicated an error on finding the closing + bracket instead of the expected relational operator. In the first example + the brackets do enclose a Boolean expression. (This way of forcing the + compiler to recognize a bracketed arithmetic expression within a Boolean + expression is not necessary in full Algol 60). The Rogalgol compiler can + deal with expressions such as x - 5 >= 20 correctly because x must be + numeric. Similarly, in the second example, the expression after the # must + be numeric, so the compiler does not need a plus sign. In this case the + brackets are not essential either. + + 2.20 Conditional expressions + + A conditional expression is one that takes one of several values depending + on the result of one or more Boolean expressions. The general form is: + + IF be THEN se ELSE e + + where be stands for Boolean expression (which may itself be conditional), + se stands for simple expression, which must not be conditional, and e for + any expression. Because e may also be conditional the form can be extended: + + IF be THEN se ELSE IF be THEN se ELSE e + + The expressions must all be numeric, all Boolean or all designational (these + are described later). A conditional expression is made unconditional by + enclosing it in round brackets. The following is legal Algol: + + IF IF bv1 THEN x#3 ELSE y=0 THEN + (IF bv2 THEN 25 ELSE 30) ELSE x+y + + The first be is conditional. The ae (arithmetic expression) within brackets + is conditional and would not be allowed in that context without its + brackets. It is a general rule of Algol that IF must not follow immediately + after THEN. This is because it can result in ambiguous code. Examples of + conditional expressions are: + + a:=IF a>0 THEN a*a ELSE 0; + large:=IF a>b THEN a ELSE b; + max:=IF a>=b AND a>=c THEN a + ELSE IF b>=a AND b>=c THEN b ELSE c; + a:=IF IF x>0 THEN y>0 ELSE y<50 THEN 3*x ELSE 0; + + 2.21 Statements + + 2.22 Conditional statements + + These have the same form as conditional expressions, except that it is not + necessary for there to be an ELSE part. There are consequently two forms of + conditional statement: + + IF be THEN s1 + IF be THEN s1 ELSE s2 + + The statement s1 must not be conditional but s2 may be. In the first case no + statements are obeyed if the be delivers a FALSE result. In the second case + s1 is obeyed if the result is TRUE; otherwise s2 is obeyed. As s2 may be + conditional this form can be extended indefinitely: + + IF be1 THEN s1 ELSE IF be2 THEN s2 ELSE s3 + + Just as expressions are made unconditional by enclosing them in round + brackets, so statements are unconditional if they are enclosed in the + brackets BEGIN and END. Examples of conditional statements are: + + IF a>0 THEN sum:=sum+a; + + IF char=&^Z THEN close(dev); + + IF samp>max THEN max:=samp + ELSE IF sampb AND c>d THEN + BEGIN ... + END ELSE + BEGIN ... + END; + + 2.23 Assignment statements + + The general form is: + + variable:=expression + + The variable on the left hand side is assigned the value of the expression + on the right. Note that in Algol the assignment operator is the double + character symbol ':=' and not the equal sign '=' which is a relational + operator. If the variable is Boolean, the expression must also be Boolean. + If the variable is numeric, the expression may deliver an integer or a real + result; it will he converted to the type of the variable if necessary, real + numbers being rounded towards the nearest integer. Examples: + + i := 3+j ; + x := IF be THEN J%5 ELSE 36.75; + bv := i%7 + + The full Algol-60 multiple assignment syntax is supported. All array + subscripts are evaluated left to right first, then the value of the right + hand side (after the last ':=') and finally this value is assigned to all + the variables to the left of a ':='. All variables assigned to must be of + the same type: INTEGER, BOOLEAN or REAL. + + Examples: + + a := array[i,j] := b := c := (100 * x); + bool1 := bool2 := i = j; + + 2.24 FOR statements + + A FOR statement allows the repeated execution of a statement with different + values of a variable known as the controlled variable. The general form is: + + FOR variable:=fle, fle, ... fle DO s1 + + The statement s1 may be conditional. The controlled variable must be real or + integer and not subscripted. (In full Algol 60 subscripted variables are + allowed.) fle stands for "for list element". Lists containing only one + element are allowed. There are three types of for list element: (1) an + arithmetic expression (2) a STEP element and (3) a WHILE element. + + A STEP element has the form 'ae STEP ae2 UNTIL ae3'. After each execution of + the controlled statement the value ae2 is added to the variable. Before each + execution of s1, including the first, the variable is tested against ae3. If + it is greater than ae3 and ae2 is positive, or less than ae3 when ae2 is + negative, then the element is said to be exhausted. It should be noted that + ae2 and ae3 are evaluated each time they are used, so that the value may be + changed by the execution of the controlled statement. A STEP element may + result in the statement not being executed at all, far example if ae>ae3 and + ae2>0. + + A WHILE element has the form 'ae WHILE be'. On each iteration the arithmetic + expression is evaluated and assigned to the variable. The Boolean expression + is then evaluated and if the result is TRUE the statement is executed, + otherwise the element is exhausted. Examples of FOR statements are; + + FOR i:=min STEP 1 UNTIL max DO sum:=sum+s[i]; + FOR i;=1 STEP i UNTIL 1024 DO .... + FOR i:=1, 3, 99, j, -6, 11 DO .... + FOR x:=1, x*2 WHILE x<1O25 DO .... + FOR i:=100 STEP -1 UNTIL -100 DO + FOR x:=0.1, 1, x*5 WHILE x<1000, 20 STEP -5 UNTIL 0 DO.. + + FOR loops can be nested as deeply as desired. For example: + + FOR 1:=1 STEP 1 UNTIL max DO + FOR j:=1 STEP 1 UNTIL i DO a:=a+b[i+j]^2; + + Matrix multiplication might look like: + + FOR i:=1 STEP 1 UNTIL m DO + FOR j:=1 STEP 1 UNTIL n DO + BEGIN x:=0; + FOR k:=i STEP I UNTIL p DO x:=x+a[i,k]*b[[k,4l; + c[i,i]:=x; + END; + + The body of the FOR loop may be a dummy statement, for example to skip to + the start of a new line. + + FOR i:=chin(dev) WHILE i#*C DO ; + + The loop variable may also be a dummy; + + FOR i:=0 WHILE test DO body ; + + In this case body may be a procedure or block which sets a Boolean variable + test, or test could itself be a Boolean procedure. It would be preferable to + use a WHILE statement in this case. + + FOR i:=body1 WHILE test DO body2 ; + + In this example body1 could be an integer or real procedure, test a Boolean + procedure, and body2 a procedure or black, giving several possibilities for + loop construction. + + A FOR loop is not a simple statement and cannot be called following the THEN + part of a conditional statement unless enclosed within a BEGIN and END. It + may however follow the ELSE clause without needing an enclosing BEGIN and + END. + + 2.25 The CASE statement + + This allows the execution of just one of a number of statements, depending + on the value of an arithmetic expression. The statements are labelled by one + or more positive integer labels. The result of the selecting arithmetic + expression is rounded down to an integer. The statement is terminated by an + END, or by ELSE ;. If none of the statements is selected and the + terminator is END, program execution continues with the next statement; if + terminated by ELSE then the is obeyed. Note that there is no ';' + before the END or ELSE. + + Example: + + CASE i+j OF + 0: x := 3.4 ; + 3:4: BEGIN x := 3; y := 4; END; + 10: y := 10 + END end comment; + + CASE n OF + 2: GOTO fred; + 1234: GOTO jim + ELSE GOTO bert; + + 2.26 The WHILE statement + + The syntax is: + + WHILE DO ; + + The may be any type. The Boolean expression is first evaluated + and if true the statement is executed. This process is repeated until the + Boolean expression is false, when program execution continues at the next + statement. + + 2.27 The REPEAT statement + + The syntax is: + + REPEAT (; ) UNTIL ; + + The syntax is not usual for Algol; it has been made identical to the Pascal + REPEAT statement. (Algol would require a BEGAN after the REPEAT and an END + before the UNTIL if more than one statement were to be repeated.) The + statement or statements are obeyed at least once. They are obeyed + repetitively until the Boolean expression is true, when execution continues + with the next statement. + + 2.28 Dummy statements + + A dummy statement is one in which there is nothing before the terminating + END, ELSE or semi-colon. Examples are: + + BEGIN END + IF be THEN ; + ; ; + BEGIN s1; END + IF be THEN ELSE ; + PROCEDURE dummy; ; + + 2.29 Comments + + Rogalgol allows three types of comment. Any symbols appearing after an END + until the first occurrence of semicolon, FINISH, END, or ELSE are ignored. + These are known as END comments, e.g. + + END this is ignored; + END so is this ELSE + END and this also FINISH + + The other form is + + COMMENT any sequence not containing semicolon; + + This form is allowed after a semi-colon or after a BEGIN. Within comments + single quotes must be matched. + + An alternative to using the key word COMMENT is to enclose text within + braces. This is an extension to the Algol 60 Report. Such comments may + contain embedded matching braces, or embedded unmatched single quotes. + This form of comment may be used anywhere that COMMENT may be used. e.g. + + {this {comment} is ignored} + + Full Algol 60 also allows an additional type of comment within procedure + calls and declarations. + + 2.30 Labels, switches and GOTO statements + + Any statement may be labelled by preceding it with an identifier and a + colon. The scope of the label is the block in which it occurs. Program + control is transferred to a labelled statement by a GOTO statement. + + BEGIN REAL x; + s1; s2; + GOTO lab; s3; + lab: s4 + END + + The following is not allowed because the label is not within scope: + + GOTO lab; + BEGIN REAL x; s1; s2; + lab: s3 + END + + Labels in an outer block may however be accessed from within an inner block, + e.g. + + BEGIN REAL q; + lab: s1; s2; + BEGIN REAL y; + s3; GOTO lab; + END + END + + It should be noted that a compound statement does not become a block because + there is a labelled statement within it. The second example would have been + allowed but for the declaration of x. For the same reason labels in + different compound statements but within the same block must have different + names. + + A switch is a list of labels declared at the start of a block. All the + labels must be within scope at the declaration. + + SWITCH s:=lab1, lab2. lab3; + + The simplest use of a switch is in a GOTO statement + + GOTO s[ae] + + The ae is evaluated and is used as an index to the list of labels in the + declaration. If for example the ae has the value 2, the effect of the + statement is the same as GOTO Lab2. If the value of ac is either less than + 1 or greater than the number of labels in the declaration, then the effect + is that the statement is treated as a dummy statement. Example: + + BEGIN SWITCH sw:=case1, case2, case3; + try: text(1,"casenunber="); + GOTO sw[chin(1)-&0] ; + text(1,"*Nillegal value"); GOTO try; + case1: .... + case2: .... + case3: .... + + 2.31 Designational expressions + + Designational expressions are like arithmetic or Boolean expressions. In a + designational expression the elements may be labels or switch elements. The + full definition of a GOTO statement is: + + GOTO de + + where de stands for designational expression. An example: + + GOTO IF x=0 THEN lab1 ELSE IF b THEN s[i+3] ELSE lab2 + + Designational expressions may also result in the address of a procedure, as + will be described in the section on procedure parameters. This is an + extension of Algol 60, in which designational expressions are only allowed + for labels. + + 2.32 Procedures + + 2.33 Standard functions + + sin(x) x is in radians + cos(x) x is in radians + arctan(x) the result is in radians in the range -pi/2 to +pi/2. + ln(x) natural logarithm + exp(x) e to the power x + sqrt(x) square root of x + abs(x) absolute value of x + sign(x) delivers -1, 0, or +1 according to whether x is negative, + zero or positive. + entier(x) returns the largest integer less or equal to x. Thus if x + = 3.3 the result is 3. If x = -3.3 the result is -4. + Note: As the result is integer the value of x must lie within the valid + integer range of -32768 to 32767. + + In each of the above procedures x is called by VALUE and thus the actual + parameter may be an expression. + + 2.34 Operating system identification + + INTEGER PROCEDURE opsysidcode(n) is a new pre-declared identifier. If n = 0 + the value returned is as follows + + 1 if running under CP/M-80 + 2 if running under CP/M-86 + 3 if running under MSDOS or PC-DOS + + If n is non-zero the version number word is returned. This word has a + different format under CP/M or MSDOS. + + 2.35 Procedures without parameters + + A procedure is a statement which is declared at the start of a block, but it + is not executed when the block is entered. It is given an identifier and the + appearance of its name causes the statement to be executed. The simplest + type of procedure has no parameters and does not deliver a result. + + BEGIN + PROCEDURE dothis; stat; + s1; s2; dothis; s3; dothis + END + + The statement stat is executed when dothis appears in the program. It is + known as the body of the procedure. Even if stat has the form of a compound + statement or a single statement, it is treated as a block. This is to + prevent GOTO statements from leading into a procedure which is not active. + + A procedure may deliver a result of type REAL, INTEGER, or BOOLEAN. Such a + procedure is known as a 'type procedure' or function. Its name can then be + used in expressions, which will cause the procedure to be executed and the + result to be used in evaluating the expression. Within the procedure body + the value which will be returned is set by assigning it to the name of the + procedure. Such an assignment statement may occur anywhere within the + procedure body and there can be any number of them. Execution of the + procedure continues until either the end is reached or a GOTO leads out of + it. If the name of the procedure occurs within the procedure body itself, + except on the left of an assignment as just explained, then the procedure + will call itself and is said to be recursive. The following example + illustrates several points: + + BEGIN INTEGER i; + INTEGER PROCEDURE j; + IF i<0 THEN GOTO nogood + ELSE IF i=1 THEN j:=0 ELSE + BEGIN i:=i-1; + j:=j+1 + END procedure j; + i:=10; i:=j; + nogood: + END + FINISH + + The procedure refers to variable i which is declared in the main program in + the same block as the procedure. The declaration of i must come first or the + compiler would have assumed that it referred to an as yet undeclared + procedure of type Boolean (lines 3 and 4) or integer (line 6). Line 5 would + have failed because the identifier to the left of := must be already + declared. There must always be some condition which causes a recursive + procedure to deliver a result or exit without recursing, as on lines 3 and + 4. If this had not been done, or if i had not been decremented on line 5, + the procedure would have called itself until the available storage was used + up. The label nogood is attached to a dummy statement. Note also that the + body of the procedure does not have to be enclosed by BEGIN and END; in this + case it is a conditional statement. + + 2.36 Procedures with parameters + + The action of a procedure can be made to depend upon data supplied to it + through a list of parameters at the time it is called. The procedure + declaration contains a list of formal parameters. These are the names which + are used within the body of the procedure. The type of each formal parameter + is given in a specification, which looks rather like a set of unsubscripted + variable declarations. The list of formal parameters is enclosed in round + brackets and is placed immediately after the name of the procedure. The + identifiers are separated by commas. Only the names are given, not + subscripts or procedure parameters. For example: + + REAL PROCEDURE p(x,y,a,r,lab); + VALUE y; REAL x,y; + REAL ARRAY a; + REAL PROCEDURE r; + LABEL lab; + + In full Algol 60 a more complicated type of parameter separator (the 'fat + comma') is also allowed. + + 2.37 Numeric and Boolean parameters by value + + This is the simplest type of parameter. When the procedure is called the + actual parameters are evaluated and the value is passed to the procedure. + Within the procedure body a parameter called by value acts in every way like + a variable declared within the procedure, except that it is assigned an + initial value when the procedure is entered. The value may be changed within + the procedure but the new value is not accessible once the procedure has + finished. + + PROCEDURE p(i,x,b); VALUE x,b,i; + REAL x; BOOLEAN b; INTEGER i; + BEGIN IF b THEN s:=x+i ELSE a:=x-i; + x:=2*i; a:=x+i; + END + + The variable 'a' has been previously declared outside the procedure. Note + that the VALUE specification must come before the part specifying the types + of the parameters. The Rogalgol system converts between INTEGER and REAL if + the types of the actual and formal parameters are not the same. No other + type conversions are allowed. A possible call of this procedure is: + + p(5.32, 2.5*y, z>0) + + where x and z are numeric variables, the last parameter is Boolean by value. + + It is a restriction is that a Boolean expression or variable should not be + enclosed in brackets when used as a procedure parameter. The brackets are + redundant, so the restriction is not a real one. This is due to the compiler + making only one pass through the source code. + + 2.38 Variables called by name + + Any formal parameter which is not specified to be VALUE is said to be called + by NAME. Instead of a value being passed to the procedure, the address of + the variable is transmitted. It follows that the actual parameter must be + the name of a variable of the correct type. (In full Algol 60 an expression + is allowed and the address of a routine to evaluate it is transmitted.) When + a variable called by name is assigned to within the procedure body the + variable specified in the call is changed. Thus, variables called by name do + not act like locally declared variables. The formal name stands for the + actual name used in the call. The actual parameter is brought within the + scope of the procedure body. In Rogalgol, array parameters must be called by + name. (The full Algol 60 call of array names by value involves making a + local copy of the whole array.) The actual parameter is the name of the + array, without subscripts. Within the procedure body the formal array name + is used with subscripts. There must be the same number of subscripts as in + the original declaration of the array whose name was used as a parameter. + Array elements (an array name followed by subscripts) may be used within or + as an actual parameter, but only when the formal parameter is by value. This + compiler accepts the use of BYTE ARRAY and INTEGER ARRAY interchangeably in + procedure calls. (See the section on byte arrays). + + Objects called by name may be passed on from procedure to procedure through + the parameter list. Unsubscripted variables called by name may be used as + the controlled variable in a FOR statement. + + BEGIN ARRAY ar[1:20]; + REAL x; INTEGER i; + + REAL PROCEDURE rp: rp:=i*2+2; + + PROCEDURE p(a,k,z); VALUE a; + REAL a; INTEGER k; ARRAY z; + FOR k:=1,2 DO z[k]:=rp*a; + ar[1]:=10; + p(ar[l],i,ar) ; + END + FINISH + + When procedure p is called, the value of the parameter a is initialised to + be 10.0 and k within the procedure becomes equivalent to i in the main + program. When rp is called for the first time, i has the value 1 so the + result of tire expression which is assigned to rp is 3.0. The value of + 3.0*10.0 is assigned to z[1], which means that ar[i] becomes 30.0. Next + time, when i=2, tire value of rp is 6.0 but a still has the value 10.0 so + the effect of the statement is ar[2]:=60.0. + + 2.39 String and switch procedure parameters + + When the formal parameter is a string, the actual parameter may be either a + string of characters enclosed in double quote marks or, if the call is + within a procedure having a string parameter, the name of such a string. + String parameters cam only be used as actual parameters in further procedure + calls, so it follows that the information in the string (as opposed to the + address of the string, which is the information transmitted to the called + procedure) can be used only by machine code called from within the + procedure. This may be done by using the pre-declared procedure + text(device,string), or string handling procedures in ALIB.ALG e.g. + + PROCEDURE moan(message,num); + VALUE num; INTEGER num; STRING message; + BEGIN text(1,"*NError at line "); + write(1,num); text(1,message); + END; + + The use of switch parameters is straightforward. The actual parameter is the + name of a switch. When this name is used within the procedure body (with a + subscript) the effect is as if it had been used in the block in which the + switch was declared. However, in Rogalgol (but not in full Algol 60) if the + execution of a parametric switch leads to within a procedure which has been + called recursively, then the return is to the most recent call of the + recursive procedure. If this consideration is important, the Rogalgol + programmer should use several label parameters instead of a switch. Rogalgol + finds the correct incarnation of a recursive procedure if it is jumped into + through a label parameter. A procedure has been called recursively if there + is more than one call in force. If A calls B, B calls C, and C calls A, then + A has been used recursively. In practice this restriction is unlikely to + prove to be a limitation. + + 2.40 Labels and procedures as parameters + + The treatment of parameters of type LABEL, PROCEDURE, REAL PROCEDURE, + INTEGER PROCEDURE and BOOLEAN PROCEDURE is similar. The actual parameter is + a designational expression which in Rogalgol (but not in full Algol 60) must + be preceded by a type specification. This requirement is included so that + the one-pass Rogalgol compiler may allow as yet undeclared procedures and + labels to be used in procedure actual parameters. As with variables called + by name, arrays, and switches, it is the address of the label or procedure + which is passed to the procedure being called. The actual parameter must be + in scope at the point of call but need not be within the scope of the called + procedure; its use as a parameter effectively brings it within scope. If a + procedure body contains a label declared with the same identifier as a + formal parameter of the procedure, then the formal parameter will take + precedence until after the declaration of the label. (In full Algol 60 the + block structure always determines the order of precedence.) + + The pre-declared functions and input/output names cannot be used as + procedure parameters, where the formal parameter is a procedure. A dummy + procedure which calls the pre-declared one must be used. This is because the + pre-declared procedures are not treated in the same way as those declared by + the user, in order to shorten compiled programs and to increase the speed of + execution. (In full Algol 60 the pre-declared procedure names can be used in + this way.) The pre-declared procedures can of course be used in expressions + where the formal parameter is a value parameter; sin(cos(3)), for example, + is allowed. + + The Rogalgol compiler does not differentiate between name and value calls of + parameters which are switches, strings, labels, and procedures. Where the + actual parameter is a designational expression (only allowed for labels and + procedure types) the value is calculated on procedure entry only, and not + each time the parameter is used within the procedure body. The calls of all + these parameters are therefore by value, although the compiler does not + force the user to specify this. + + To illustrate these points, suppose that two procedures have the following + headings: + + PROCEDURE p(s,lab,rp,at); + SWITCH s; STRING st; LABEL lab; + REAL PROCEDURE rp; + + REAL PROCEDURE x(y,st); VALUE y; + REAL y; STRING st; + + A possible call] is + + p(sw, LABEL IF be THEN labl ELSE lab2, + REAL PROCEDURE x ,"abc") + + A designational expression has been used as an actual parameter of type + LABEL. As with arrays and switches only the name of the real procedure is + used as a parameter. The parameters of the parametric procedure are included + when the procedure is actually called, and not otherwise. A possible call of + x within the body if p is: + + rp (rp(3,"DEF"),st) + + 2.41 Summary of points on procedures + + On entering a procedure the memory required is allocated dynamically + according to the declarations. It follows that procedures are intrinsically + recursive in nature, the limit on the depth of recursion being set by the + available memory. + + The body of a procedure is a 'statement'; this may range from a simple (even + dummy) statement to a compound statement or block. Within such a block there + may of course be further procedure declarations, so that the following is a + valid structure. + + PROCEDURE tom; + BEGIN + PROCEDURE dick; + BEGIN + PROCEDURE harry; + BEGIN + s1; ... + END; + s2; ... + END; + s3; ... + END; + + The scope of these procedures follows the normal rules of scoping, so that + statements s1 and s2 may refer to tom, dick or harry; statement s3 may refer + to tom and dick but not harry. + + Statements within a procedure may make reference to any variable that is 'in + scope', not just those passed through the parameter list. In Fortran a + COMMON statement would be necessary. It is also possible to jump out of a + procedure by means of a GOTO statement to any label that is within scope. + + There is a problem regarding the scoping of procedures in the case where the + user declares a procedure of the same name as one of the pre-declared ones. + This results from the fact that these pre-declared functions are compiled + differently from those declared by the user, to make them faster and to + economise on memory. + + BEGIN INTEGER i; + + PROCEDURE abc; + BEGIN ... + z:=sin(y); + ... + END; + + REAL PROCEDURE sin(x); + VALUE x; REAL x; + BEGIN + ... + END ; + END + FINISH + + According to the Algol 60 Report the scope of the two procedures 'abc' and + 'sin' is the block in which they are declared. The statement 'z:=sin(y)' in + the first procedure is referring to the second procedure in the block. In + this compiler however the statement will generate code corresponding to a + built-in procedure identifier that it already knows about. No error message + is given. The problem could be avoided in this case by simply reversing the + order of the two procedures, or better still changing the name so that no + ambiguity can exist. There is no problem with procedures having names + different from the built-in ones. As a general rule all procedure names are + best kept unique amongst themselves and also from the variables. + + 2.42 Differences from the Algol 60 report + + 2.43 Differences from the Algol 60 report + + The Rogalgol language is Algol 60 with a few restrictions. Some of these are + a result of the one-pass nature of the compiler. For example, variables must + be declared before use. In other possible ambiguous situations that a + multi-pass compiler could resolve, this compiler may require a 'clue' as to + the type of object being translated. These differences are described in the + following sections. A number of extensions to the language have been + introduced. These include the data type BYTE ARRAY, logical and MOD + operators, and a significant number of functions. Appendix 3 gives a summary + of the differences from the Algol 60 Report. + + This manual describes the syntax of the language. The distribution kit + includes a number of example programs which are described later. Users new + to structured programming may find it beneficial to refer to an introductory + manual on the language and also to the Algol 60 Report. + + 2.44 Language restrictions + + No OWN variables. + + No integer labels except in the CASE statement. + + Variables must be declared before use. + + Call by NAME is restricted to the case where the actual parameter is a + variable name, i.e. as per call by reference in Fortran or call by location + in CORAL 66. + + Array parameters must be called by name. + + The controlled variable in a FOR statement must not be subscripted. + + The 'fat comma' is not implemented. + + Boolean procedure parameters may not be enclosed entirely in round brackets. + + An opening bracket enclosing an arithmetic expression at the start of a + Boolean expression must be preceeded by a plus or minus sign. + + 2.45 Language extensions + + Data type: BYTE ARRAY. + + Operators: MOD, !, DIFFER, MASK. + + Comments may be enclosed within matching braces e.g. {like this}. + + Procedure names may be the result of designational expressions. + + The CASE, WHILE and REPEAT statements. + + Additional functions include string handling, direct disk i/o, block move, + clear array, etc. + + 2.46 The input/output mechanism + + 2.47 Stream or device numbers + + In Algol the exact form of Input/Output is not strictly defined but left up + to the implementer to make best use of whatever facilities are available. + Input/Output takes place through a series of procedures built into the + runtime system. + + Input/Output is device independent and is associated with a stream or device + number, which is the first parameter of all the built in input/output + procedures. These numbers are in turn associated with a device name or a + file name. The usual way of obtaining the stream numbers is to parse a + command line with the procedures INPUT and OUTPUT. For disc files the number + is 64 or greater and is an index to a CP/M file control block. Non + file-structured devices such as the console and printer have lower numbers + and Input/Output can be performed by simply choosing the appropriate device + number. + + In the case of disk files some dialogue is necessary to open or create a + specified named file. In this case the corresponding stream numbers are + allocated dynamically by the system. The procedures to perform this dialogue + are described in a later section. In the case of disk files we also have the + choice of serial or random access. + + The command line parser maps all other device names to a device number, the + one you can also use directly in the i/o procedures. The parser makes an + additional check that the named device is suitable for the operation (input + or output) requested. For example, the command line CON:=LST: is in error as + LST: cannot be an input device. This will give runtime error 27. + + 2.48 ALGOL fixed stream numbers + + 0 Dummy. Output is thrown away, input always returns ^Z. + + 1 Output goes direct to the console screen via CP/M function 2. Input + comes from the console keyboard one character at a time, but is checked for + (a) ^C which causes a warm boot and (b) carriage return which causes a + linefeed to be echoed as well. CP/M function 1 is used which echoes all + characters typed. + + 2 PUN: on output and RDR: on input, AUX under MSDOS. Uses CP/M + functions 3 and 4. + + 3 On output this goes to LST:, PRN under MSDOS, via CP/M function 5. + Used for input it reads the keyboard without echo via CP/M function 6. Zero + is returned If no character is waiting. Under CP/M V1.x ^Z is always + returned. + + 4 This Is nearly the same as device 1. The only difference is that on + input there is no check for ^C or linefeed. + + 5 The CP/M reader and punch devices via CP/M functions 3 and 4. The + same as device 2. + + 6 On output the CP/M list device via CP/M function 5. On input the + current printer column number is returned. + + 7 Buffered console input with echo. The buffer may be filled either + from the keyboard or by using output device 7. When input is obtained from + the keyboard (for example READ (7)) CP/M function 10 is used. This means + that the CP/M line editing is in operation and nothing can be returned to + the program until RETURN is typed. Linefeed is sent to the program as well. + You can force input to begin afresh by wiping out the buffer contents before + reading from device 7. When used for output, device 7 writes characters to + the input buffer. + + 8 Used for output it sets the printer column count. Input returns ^Z + always. + + 9 Dummy (as device 0). + + 10 I/O directly to memory. + + The device numbers 1-7 use calls to CP/M or MSDOS system calls. No BIOS + calls are made. + + 2.49 Printer position on streams 3 and 6 + + When output is sent to either of these printer streams a record of the + carriage position is kept. Tabs are assumed to be at intervals of 8 columns. + If the printer uses a different interval the position returned will be + incorrect if any actual tab characters have been sent. + + A count is kept of the column number currently under the print head using + the following logic. All characters sent which have the value 32 (space) or + greater increment the count. All lower value codes are ignored except as + follows: + + 8 (backspace) decrements the count. + 9 (tab) steps on to the next multiple of 8. + 12 and 13 (form feed and carriage return) zero the count. + + The current count is obtained by CHIN(6). Some printers accept escape + sequences containing printing characters but which do not move the carriage. + To correct the count after such a sequence is sent CHOUT(8,N) may be used. + The column count is set to N. + + 2.50 Device names in command Lines + + When a command line is parsed by the procedure INPUT or OUTPUT, device names + are converted to the device numbers previously listed according to the + following table. + + Name Device Operations + + NL: 0 Input, output + CON: 4 Input, output + RDR: 5 Input + PUN: 5 Output + LST: 6 Output + TI: 1 Input + VT: 1 Output + TTY: 2 Input, output + LP: 3 Output + TIB: 7 Input + KBD: 3 Input (CP/M version 1 returns a negative number) + + A: to P: are discs and require a filename. Only A: to D: are allowed under + CP/M version 1. File names may contain a drive letter, but no path. + + Switch options recognized by the parser are: + + B Block i/o (random access). + M Modify access (random access write). + + 2.51 Creating a command line for I/O streams + + The Rogalgol system allows the user the ability to select input/output files + or devices from within the program or from the console keyboard. For this + purpose there exists a buffer into which a command line containing I/O + selections is placed. The placement is achieved either through I/O stream + number 7, or through a number of calls to ioc() which create a console + prompt. The basic sequence of events consists of: + + 1. Place an I/O selection string into the buffer. + + 2. Call a command string interpreter to read the contents of the buffer and + copy the string into an 'input list' and/or 'output list' as appropriate. + + 3. A call of predeclared procedures 'input' or 'output' reads the next entry + in the 'input list' or 'output list' and returns to the program the + appropriate stream number, having opened or created any necessary files. + + Input from stream 7 is buffered and only made available to the program when + a carriage return character is entered. Incorrect characters can he removed + using the rubout key. There are two pointers associated with stream 7, one + with input and the other output. As characters are entered or read from the + buffer the appropriate pointer is advanced by 1. These pointers may be reset + using the following ioc calls. + + ioc(0) Reset the input pointer. The next call of chin(7) will return the + value of the first character in the buffer. + + ioc(1) Reset output pointer and write a string terminator into the first + buffer position. The next call of chout(7,char) will place the value of char + into the first position of the buffer and advance the position of the string + terminator. Note that following the use of ioc(2) through ioc(5) described + below, before reading from stream 7 the programmer should issue both an + ioc(0) and an ioc(1) to reset the pointer and wipe out the current buffer + contents. + + ioc(2) This produces a prompt on the console of the form: + + OUT=IN? + + The user than enters a command string of the general form: + + outputlist=inputlist + + When the carriage return character is given to terminate the command + line the command string interpreter is called. Every character up to the + separating equal sign (or carriage return if no equal sign is present) is + copied and stored as the current 'output list' and everything after the + equal sign is copied and stored as the current 'input list'. A pointer is + associated with each of these lists and if a new input or output list entry + is found then the corresponding pointer is reset to the start of that list. + The detailed form of these lists is described later. + + ioc(3) This is similar to ioc(2) but the text is taken directly from the + contents of the buffer without any user prompt. A typical calling sequence + to set up an input/output list might be: + + ioc(1); text(7,"outputlist=inputlist"); ioc(3); + + ioc(4) This produces a prompt on the console of the form: + + INPUT= + + The user then enters a command string of the general form: + + inputlist + + This string then becomes the current 'input list', the output list remaining + unchanged. + + ioc(5) This is similar to ioc(4) but the text is taken directly from the + contents of the buffer without any user prompt. A typical calling sequence + might be: + + ioc(1); text(7,"inputlist"); ioc(5); + + Note: A call of ioc(3) or ioc(5) leaves the contents of the buffer + unaffected. The same string may if desired be parsed twice to set up both + input and output files of the same names. This is done within the compiler + to select its input and output. + + The general form of the input and output lists consists of a sequence of one + or more device or file specifications separated by commas e.g. + + CON:,A:OUT1,,LST:=DATA.DAT[B],RDR: + + In the above example 4 output channels and 2 input channels are specified. A + call of the pre-declared procedures input or output (described later) will + scan the appropriate list from the current position up to the next + occurrence of a comma or end of list indicator. A stream number will be + returned corresponding to the entry found. + + A CP/M file specification is of the general form: + + FILENAME.EXT + + The characters recognized within file names are letters, digits, "$" and + '?'; the latter should be reserved for specifying ambiguous file names. + Lower case letters are converted to upper case as per the normal CP/M + convention. All characters less than apace (ASCII 0 to 32) are ignored + within I/O lists. + + The FILENAME consists of from I to 8 characters. The file extension '.EXT' + if present consists of from 1 to 3 characters. If no extension is given a + default value will be assumed; this is initially set to three spaces. The + method of changing the default file extension is described under library + procedure 'swlist' in the section 'Input/Output directly to or from memory'. + It is possible to force the use of the default file extension regardless of + what is given by the call ioc(20) + + In order to return to the default situation where a specified file extension + takes precedence call ioc(21) + + consists of one of A:, B:, C;, D: or may be omitted. When used with + CP/M version 2 disk drive names extending from A: to P: are accepted. If + omitted a default is assumed according to the following rules. At the start + of each line the assumed drive is the 'logged on drive' when the program is + first entered. Any subsequent drive specified within the list then becomes + the default for following entries. + + Switch options may be added to any input/output device or file specification + and consists of a series of up to 12 characters enclosed within square + brackets. Lower case letters are converted to upper case. Switch options + must not contain a comma or equal sign. Certain switches are recognized by + the runtime system and acted upon; in the example given above the input file + DATA.DAT[[B] the switch [B] causes the file to be opened for 'random access' + reading. Other switches not used by the system may be used by the program. A + facility exists for the program to read the switch list directly. + + The occurrence of two adjacent commas within an I/O list is equivalent to + specifying the 'null' input/output device NL: (stream 0). + + 2.52 Parsing the I/O command line + + The ioc calls described in the previous topic will have set up input/output + lists. These lists may now be used to assign files or devices through the + predeclared procedures INPUT and OUTPUT. + + dev:=input; + + will read the next entry in the 'input list'. If the entry is found to be a + device then dev will be assigned a value corresponding to that device name. + If a disk file was specified then that file will be opened. A buffer region + will be allocated to contain the file control block and sector buffer (if + serial access). The stream number returned will be from 64 upwards, the + actual value indicating which buffer is allocated to that file. + + A negative value for dev indicates an error, e.g. bad syntax, no entry found + in input list or no file found of that name. + + dev:=output; + + Similar to input but for output files or devices. A number of options exist + regarding what action is to be taken if an output file name specified is + found already to exist. These options are selected by calls to ioc which set + the appropriate flags within the runtime system. The first is the default + case. + + ioc(13) No checks are made. A second file of the same name will be created. + A problem may be encountered later on trying to access such files. + + ioc(14) The existing file of the name specified will be deleted before the + new file is created. + + ioc(15) If a file name is found already to exist, the call of output will + return a stream number of -100. No new file is created. + + 2.53 Input/output directly to or from memory + + As an aid to text processing and related manipulation, e.g. setting up file + extensions or reading the switch list a facility exists to read or write + using the standard input output routines directly to or from anywhere in + memory. Such i/o is associated with stream number 10. A number of string + handling routines relevant to the following are described in the section on + "library procedures'. Before i/o can be performed via memory it is necessary + for the user to set up pointers to where input/output is to occur. As each + character is read/written the corresponding pointer is advanced by one. The + following procedures to manipulate these pointers are in ALIB.ALG. + + seti(a) + + Set the INPUT pointer to the address a. + + seto(a) + + Set the OUTPUT pointer to the address a. + + In practice a call of location would probably have been used to find the + address. In order to find the current values of the input/output pointers: + + i:=ipoint + + Returns in i the current address of the input pointer. + + i:=opoint + + Returns in i the current address of the output pointer. + + A typical sequence might be; + + BEGIN BYTE ARRAY buf[0:1000]; + seto(location(buf[0]); + seti(location(buf[0]); + rwrite(l0,x,0,6); + i:=opoint; + x:-read(10); + + It is the user's responsibility to ensure that such I/O stays within the + declared bounds of the array buffer used. + + 2.54 Switch lists on I/O selections + + The memory I/O feature described in the previous topic is used to gain + access to the switch lists associated with I/O streams. + + i:=swlist + + Returns in i the address of the switch list. + + The user can check if any switch options have been specified following a + call of "input" or "output" by reading the contents of this switch list. + These switches (a maximum of 12 characters) can be read using input stream + 10. A typical sequence might be: + + seti(swlist); + i:=chin(10); + + The first switch is now in i. The list is terminated with a zero value. The + switch list always contains information relevant to the most recent call of + the procedures "input" or "output". + + The default file extension is stored in the 3 bytes following the switch + list. This can conveniently be set up by writing 3 (and only 3) characters + into the appropriate buffer by means of output to stream 10, e.g. + + seto(swlist+13); + text (10, "XYZ"); + + This sequence will set the default file extension to XYZ. On entry the + default extension is set to null, i.e. 3 spaces. + + This technique can also be used as a way of reading small quantities of data + in a manner similar to the DATA statement of BASIC, e.g. + + seti(sloc("1.32 99.6 ... ")) ; + FOR i:= 1 STEP I UNTIL 20 DO x[i] := read(10); + + The procedure sloc is described in the section on library procedures. + Another example involving text can be found in the program VDU.ALG on the + distribution disk. + + 2.55 Closing and deleting files + + When the use of a file is completed it should be closed by a call of the + predeclared procedure: + + close(dev) + + This will close the file associated with stream dev by a previous input or + output call. If dev does not correspond to a disk file, nothing happens. + NOTE: If an OUTPUT FILE is not closed its contents will be LOST. Input files + should also be closed, as this call also serves to release the buffer and + file control block associated with that file and makes it available for + further use. + + delete(dev) + + This will delete the file associated with dev by a previous input or output + call and release the file control block and buffer for reuse. + + 2.56 Serial input/output procedures + + In all of the predeclared i/o procedures the first parameter is the stream + number denoted by dev. The name val indicates a REAL variable and ival an + INTEGER variable. As the formal parameters are called by VALUE the actual + parameters may contain expressions; the system will convert between integer + and real values if necessary. + + PROCEDURE skip(dev) ; + + Outputs a carriage return/linefeed to dev. + + INTEGER PROCEDURE chin(dev); + + Read the next character from dev. The result of the procedure is the value + of the character. In the case of disk input the character CONTROL-Z is + returned at the end of file. + + REAL PROCEDURE read(dev); or REAL PROCEDURE read(dev,lahel); + + Read a floating point number or integer number from dev. The number is in + free format, and is terminated by any character which cannot be part of a + number. Decimal exponentiation is indicated by 'E'. Spaces, tabs and blank + lines preceding the number are ignored but other characters will give an + error. A space will terminate the number except between the 'E' and the + exponent field. Integers may be read without rounding errors provided they + appear as valid integers in the input, i.e., without decimal point or + exponent parts. To allow the possibility of reading a file of unknown + length, the second form given above may be used. In the event of passing the + end of file, control is passed to the label. The name is not preceded by the + LABEL indication as the compiler knows that the second parameter must be a + label or a designational expression. End of file is a legal terminator; the + jump will not happen unless another read is done. If the optional label is + not given a runtime error occurs if end of file is passed. Examples of valid + number formats are: + + 0.123 +1.23E -3 -123 + + The read routine will also accept the following, although the output + routines never generate such formats: + + E-3 .123 -123. + + It may be desirable to read a data source containing text comments. The read + routine can be instructed to ignore any character preceding the number which + cannot be part of the number by the call: + + ioc(18); + + A consequence of the use of this mode of reading data is that numbers of the + form: + + E-6 or .45 + + are no longer valid. The leading 'E' or '.' is regarded as comment; the + actual numbers read in this case would be -6 and 45. To return to the + default mode where comments are not permitted call: + + ioc(19); + + PROCEDURE text(dev,"string"); + + Output a string to dev. See the section on strings regarding interpretation + of format and control characters. The string may also be a string parameter + of the procedure in which text is called, in which case the actual parameter + is the string identifier, e.g. + + PROCEDURE message(s); STRING a; + BEGIN text(1,s); ... + + PROCEDURE chout(dev,ival); + + Outputs a single byte to dev. If a character is to be output, its ASCII + value must be used. This can be found by using the character literal + facility. For example: + + chout(1,&X); + + will print X on the terminal. + + PROCEDURE write(dev,ivai); or PROCEDURE write(dev,ival,radix); + + Prints ival as an integer on dev. The default radix is decimal. + Non-significant characters are not printed. If formatted print is required + use rwrite. Output in octal or hexadecimal is possible by including the + optional third parameter. + + radix=0 for decimal + radix=1 for octal + radix=2 for hexadecimal + + Any other value for radix will lead to a runtime error. + + END OF FILE REPORTING + + The CHIN function returns -1 at end of file, allowing embedded CTRL/Z to be + processed. Text files normally have a CTRL/Z at the end, unless the last + record is exactly filled. + + 2.57 Formatted number output + + PROCEDURE rwrite(dev,val,a,b); or PROCEDURE rwrite(dev,val) + + Floating point output to dev; val is the value to output; a and b define the + format such that: + + a = total number of characters including sign and decimal point. + + b = number of digits after the decimal point. + + If b is zero then we have formatted integer output. If the value of a is + inconsistent with that of b some large value will be substituted, + + If a = 0 then exponent format is used with b decimal digits. If both a and b + are zero or if they are omitted altogether as in the above example then the + program defaults to exponent format with 6 decimal digits. + + Various aspects of the output formatting can be controlled by calls to the + predeclared procedure ioc. These calls have the effect of setting flags + within the runtime system which remain in effect until some further call is + made to change then. These calls to ioc can be considered in 3 groups. The + first of each group is the default state in effect when the program starts. + The various calls within each group are mutually exclusive. + + The first group is concerned with what action is to be taken if the value to + be output is too large to he accommodated by the specified format. + + ioc (6) The routine first attempts to accommodate the number by moving along + the decimal point while maintaining the total field width constant. If this + fails the routine will use exponent format provided the field width can he + maintained else a row of asterisks '****' is printed indicating an out of + range number. + + ioc(7) No format changes whatsoever are allowed. If the number cannot be + accommodated then a row of asterisks is printed. + + ioc(8) No error print allowed. When this ioc call is in effect the error + print indicated by a row of asterisks is never used. Format changes are + allowed; if necessary exponent print will be used regardless of the field + width specified. + + The second group is concerted with the representation of space within the + output format. + + ioc(9) Set the 'default space character' to space (ASCII 32). Leading zeros + are printed as spaces. + + ioc(10) Set the 'default space character' to null (ASCII 0). Leading zeros + will be suppressed. The number is left-justified. (The null character is + trapped by the routine and not actually sent to the output stream). + + The third group is concerned with the representation of positive numbers. + + ioc(11) Use the current default space character (see group 2 above) where a + positive sign is expected. Initially the default space character is apace. + If ioc(11) is called after ioc(10) the result is to suppress the character + slot reserved to indicate e positive result. + + ioc(12) Print '+' to indicate a positive number. + + NOTE: Calls to rwrite and write are terminated by printing the 'default + space character' (see group 2 above). This is initially set to space which + serves as a terminator to separate output such that it can be reread by the + read routine. + + More flexible number formatting is available using ioc(49), which allows + independent control of the following three character positions, which are + all affected by ioc calls 9-12. They are: + + 1. Leading spaces (rwrite only). + 2. The positive sign (rwrite only; '-' is always printed). + 3. Trailing spaces (rwrite and write). + + IOC(49) must be called from within a procedure whose first parameter is an + integer by value. The value is 256 * x + y, where y is the character or null + which is to be printed and x is 0, 1 or 2 corresponding to leading spaces, a + positive sign and the trailing space. If x falls outside this range the + ioc(49) call has no effect; y can be any character at all. + + By default all characters will be spaces. The following sequence will + suppress the '+' sign and trailing spaces, but will right justify the + number. + + PROCEDURE format(n); VALUE n; INTEGER n; ioc(49); + + format(&*S); {Leading space} + format (256); {Suppress the '+' sign} + format(512); {Suppress the trailing character} + + 2.58 Random access files + + A file may be opened to be read by random access rather than serial access. + Such files are opened as 'input' files with a switch [B] set to signify + block I/O. If the file is to be updated, i.e. written to, then an additional + switch is needed [BM] where the 'M' indicates 'modify'. These rules imply + that only pre-existing files may be opened for random access. As example of + an 'input' specification. + + DATA1.DAT[B],DATA2.DAT[BM] + + The first file is opened for random access reading and the second for + reading/writing. + + i:=rblock(dev,a.h,n) + + will read n blocks from the disk file associated with stream dev, starting + at block number b, writing the contents In memory starting at address a. The + length of the transfer is 128*n bytes. The first block of the file is block + number 0. The address in general will correspond to part of an array set up + by means of procedure location (see section on library procedures) e.g. + + i:=rblock(dev,location(buf[0]),b,10) ; + + On exit i will have the following meaning. + + i=0 successful read. + i=1 read past end of file. + i=2 reading unwritten data. + i=3 hard error. + + The user should ensure that the declared array is large enough to accept the + transfer. Any part of a selected transfer extending beyond the end of file + will be set to zero. + + i:=wblock(dev,a,b,n); + + Will write n blocks to disk; the parameters are the same as for rblock. On + completion i can take the following values. + + i=a successful write. + i=1 error in extending file. + i=2 end of disk file. + i=3 hard error. + i=255 no more directory space available. + + 2.59 Input/output support routines + + The following additional procedures are recognized by the runtime system and + are made known to the compiler by including the text of ALIB.ALG with the + program source. + + rewind(dev); + + The serial input or output file associated with dev is (first closed in the + case of output files and) rewound for reading from the beginning. + + dev := findinput ("string"); + + This call will open the file or device defined in "string" for input on + stream dev. If the first character of "string" is found to be a question + mark "?" then the effect is as follows. The remainder of the string is + printed on the console as a prompt to the operator who enters the required + input file or device name, e.g. + + dev:=findinput("?Source file="); + + will prompt the operator: + + Source file= + + who then enters the required name: + + dev:=findinput("DATA.DAT"); + + opens the file DATA.DAT on the logged on drive. + + The input specification may in fact consist of an 'input list' the first + entry of which will be used and assigned to dev. Note that the use of this + procedure will wipe out any previous input specifications waiting in the + input list. + + dev:=findoutput("string") + + This is analogous to findinput but for output. The output specifications may + if desired be generalised to be a complete input/ontput list as described + under ioc(2) and ioc(3) above. + + i:=rename; + + This procedure renames a file. The old filename and drive information are + taken as the next entry in the 'inputlist'. The new filenane is taken from + the next entry in the 'outputlist', e.g. + + ioc(1); + text(7,"FRED.ABC=B:JOE.XYZ"); + ioc(3); + i:=rename; + + will rename file JOE.XYZ on drive B: as FRED.ABC. Note that the CP/M rename + utility will rename all files that satisfy the input specification. On exit: + + i=-1 implies a failure, e.g. file not found or illegal syntax. + i=255 CP/M reply from rename regardless of success or failure. + + The default file extension will be used if none is specified, or if ioc(20) + is in effect, will be used regardless. If a file of the same name as the new + name given is found already to exist, then the result will be the same as + described under procedure 'output' with regard to calls of ioc(13) to + ioc(15), namely: + + ioc(13) No checks are made. + ioc(14) Erase any pre-existing files of the same name. + ioc(15) Return the value -100 in i. + + i:=newext(j, "XYZ"); + + The file associated with stream j by a previous call of input or output is + closed and its file extension changed to the 3 character string given as the + second parameter. This string becomes the default file extension, e.g. + + j:=findinput("FRED.ABC"); + i:=newext(J ,"XYZ"); + + will rename the file FRED.ABC as FRED.XYZ. No checks are made as to the + pre-existence of files of the same name. A negative result in i implies a + failure; the expected reply is 255. + + i:=fcblock(dev); + + This returns in i the address of the file control block associated with file + stream dev. This can be useful only to users who wish to manipulate CP/M + facilities directly. + + i:=exflt(a,t); + + Extend the file control block list. The Rogalgol system is initially set up + to allow 4 serial files end 2 random access files open at any time. Should + users require more than this number of files then this procedure may be used + to extend the list of file control blocks available. Each call extends the + length of the list by one. On exit a negative value in I indicates an + attempt has been made to extend beyond its maximum length of 16 entries. The + parameters to exflt are; + + a = address of buffer to use + t = file type + If t=0 then serial file else random access + + The buffers used are user declared array, the address of which is found + using procedure location, e.g. + + BEGIN BYTE ARRAY buf[0;160]; + I:=exflt(location(buf[0]),0); + + The buffer sizes required are for serial files 164 bytes (36 for the file + control block + 128 for the sector buffer) and for random access files 36 + bytes. It is the user's responsibility to ensure that the array is large + enough to accommodate the buffer and that such buffers do not overlap or + become overwritten. + + 2.60 Direct BDOS and BIOS CP/M calls + + Direct call to CP/M BDOS is made by doing ioc(48) within a procedure whose + first two parameters are the call number and the address to be placed In DE. + These must both be VALUE parameters. The second parameter receives the + returned HL value after the call ioc(48). Note that the new value is only + accessible from within the procedure as the DE parameter is by value. You + can either assign this value to the function or to an external variable. In + either case you need to add a statement to the library procedure CP/M after + the ioc(48). + + a:=cpm(c,de) + + This procedure performs a direct call to CP/M where + + c = contents of C register on entry (0 to 27). + de = contents of BE register pair on entry. + a = result in A register on exit. + + Refer to the CP/M Interface Guide for details. + + a:=bios(n,bc) ; + + This procedure performs a direct call through the BIOS jump vector where: + + n = entry in the jump table (0 to 14) + bc= contents of BC register pair on entry. + a = contents in A register on exit. + + Refer to the CP/M System Alteration Guide for details. The body of the + procedure contains the call ioc(47). + + 2.61 Library procedures + + 2.62 Library procedures + + The following procedures are built into the runtime system and can be made + known to the compiler by including the source of file "ALIB.ALG" with the + program. Some of the following are machine dependent. See the text of + 'ALIB.ALG' for the formal definitions of the procedure parameters. + + MEMORY MANIPULATION + + i:=location(x); + + This returns with i set to the address of variable x; x may be REAL, + INTEGER, or an array element of type REAL, INTEGER, or BYTE. In the case of + REAL or INTEGER arguments the address returned is that of the slot assigned + to that variable (see description of the workings of the runtime system). + Each slot occupies 4 bytes and in the case of INTEGERs only the upper half + is used so that in this case 2 should be added to get the actual address + containing the integer. Array elements as arguments always return the + correct address. The procedure works by recalling the moat recent variable + address computed; as the argument is called by value the compiler will in + fact accept any expression as the actual parameter, although the result will + correspond to the final variable specified. Users who wish to find the + address of Boolean variables may construct a similar procedure with the same + body as location but with a formal parameter of type Boolean by value, + + i:=fspace; + + This returns the number of bytes free (allowing for a safety margin for + stack operations). Note that on large systems the result may exceed 32K and + thus appear to have a negative value in two's complement representation. + + blmove(s,f,len); + + Block move of len bytes starting at address 5 to the block starting at + address f. In general the use of procedure location (see above) would be + used to set up the addresses, e.g. + + blmove(location(a[0]),location(b[0]),100); + + It is the user's responsibility to ensure that such block moves stay within + the limits of the declared arrays. This procedure will work correctly if the + two blocks overlap. + + i:=peek(a) + + Returns the byte value contained within the address given by a. + + poke(a,i) + + Sets the contents of address given by a to the value of (the 8 least + significant bits of) i. + + clarr (a,len) + + Clear array area of length len bytes starting at address a. + + SHIFTS AND ROTATES + + In the following procedures v is the value (type INTEGER) and n is the + number of places to shift or rotate. Note that only the 4 least significant + bits of n are used so its value should be in the range 0 to 15. + + i:=shl(v,m) Shift LEFT. + i:=lsr(v,n) Logical shift RIGHT. + i:=asr(v,n) Arithmetic shift RIGHT. + i:=rotl(v,n) Rotate LEFT. + i:=rotr(v,n) Rotate RIGHT. + + Arithmetic shift right extends the sign bit whereas logical shift right + always places zeros into vacated positions. + + INPUT/OUTPUT + + dpb(u,t,a,a) + + Set up the disk parameters, u=unit number (0 to 3), t=track, s=sector, a=DMA + address. + + i:=rdisk + + Read the disk directly using information set up in a previous call to dpb. + The result from the CP/M call will be in i. + + i:=wdisk + + Write to disk directly using information set up by a previous call to dpb. + The result from the CP/M call will be in i. + + STRING MANIPULATION + + i:=sloc("string") + + Returns in i the address of the start of the string. The actual parameter + may also be a string parameter of a procedure, e.g. + + PROCEDURE x(s); STRING s; + BEGIN INTEGER i; + i:=sloc(s); + i:=sloc("XYZ"); + + Strings consist of a series of characters stored in sequential bytes + terminated by a zero. + + atext(dev,s); + + This is similar to the pre-declared procedure "text' but the second + parameter is the address of the string. e.g. + + text(dev,"XYZ"); is equivalent to atext(dev,sloc("XYZ")); + + i:=tlen(s) + + Returns the length of the string whose address is at s, e.g. + + i:=tlen(sloc("XYZ")); + + returns the value 3. + + i:=smatch(long,short) + + This procedure compares two strings looking for the first match within the + long string corresponding to the contents of the short string. The + parameters are the addresses of the strings. If a match is found the value + of i is set to the address within the long string corresponding to the start + of the match. If no match is found i will be set to zero. Additional matches + may be found by giving as the starting address of long the value one greater + than the result of the previous match. + + MISCELLANEOUS + + b:=parity(i) + + This Boolean procedure returns TRUE if the character value of i (8 least + significant bits) has EVEN parity else FALSE. + + x:=random + + Returns a pseudorandom number in the range 0 to 1. + + 2.63 Library inserts + + A facility exists which allows the contents of 'library' source files to be + included with the body of the program at compile time, e.g. + + LIBRARY "B:ALIB.ALG" + + or, using the upper case convention, + + 'LIBRARY' "B:ALIB" + + The effect at compile time is that on encountering the language key word + LIBRARY the compiler looks for an input file specification enclosed within + string quotes. This file is opened and its contents included with the + program source at the points the call is found. In the above case the file + ALIB.ALG on drive 3: is read, the default extension being '.ALG'. The + default drive is the logged on drive. This capability allows the user to + construct libraries of frequently used procedures, thus avoiding duplication + of text and excessive editing. + + BEGIN INTEGER i,j,k; + + LIBRARY "ALIB" + LIBRARY "lOLIB" + LIBRARY "STATLIB" + + PROCEDURE abc; ... + + This example would include the contents of three library files in turn when + compiling. These files may if desired themselves contain LIBRARY directives. + The limit on the depth of such calls is set by the maximum number of input + and output files that may be open at any one time. In the compiler as + distributed this limit is set to five. + + 2.64 Example programs + + The following examples illustrate various aspects of the language. The first + four are fairly straightforward; the final two examples assume a fairly + advanced knowledge of mathematics. Further examples can be found on the + distribution disk. + + The first example lists a table of integers up to 20, together with their + square roots, on the console. + + BEGIN INTEGER i; + + FOR i:=0 STEP 1 UNTIL 20 DO + BEGIN rwrite(1,i,5,0); + rwrite(1,sqrt(i),0,6); + skip(1) + END + END FINISH + + The second example lists a file on the console. On detecting the end of file + it loops back for further files to list. + + BEGIN INTEGER i, d; + + { Get input file } + loop: ioc(4); d:=input; + { Check if valid file } + IF d<64 THEN text(1,"*NTry again") + ELSE + BEGIN {list file on console } + FOR i:= chin(d) WHILE i#^Z DO chout(1,i); + close(d); {realease fcb} + END; + GOTO loop; + END FINISH + + The next example is a procedure to illustrate string handling. The routine + makes use of several procedures from ALIB.ALG. It scans a piece of text + starting at address "old" and substitutes every occurrence of a given string + "olds" by that given in "news". The source is itself in the form of a + string, i.e. terminated with a zero value. The resultant string will start + at address "new". The calling sequence + + la:=location(a[0]); + lb:=location(b[0]); + substitute(lb, la, "Jack","%1"); + substitute(la, lb, "Jill","%1"); + + will replace every occurrence of "%1" by "Jack" and "%2" by "Jill". Both the + initial string text and the resultant string start at location a[0]. The + array b is used as working space. + + PROCEDURE substitute (new, old, news, olds) ; + VALUE new, old, INTEGER new, old ; + STRING news, olds ; + BEGIN INTEGER i, j, ns, os, nl ol, oldfin ; + ns := sloc(news) ; + os := sloc(olds) ; + nl := tlen(ns) ; + ol := tlen(os) ; { lengths of strings } + { address of closing zero of input string } + { look for matches } + FOR i := smatch(old, os,) WHILE i # 0 DO + BEGIN + j := i - old ; { length of text to copy } + blmove(old, new, j) ; { move over portion of text } + new := new + j ; { update pointers } + old := old + j + ol ; { skip old string } + blmove(ns, new, nl) ; { copy in new string } + new := new + nl ; { update pointer } + END ; + blmove(old, new, oldfin - old) ; { copy remainder } + END substitute ; + + The fourth example, quicksort, is a sorting algorithm originally developed + by C.A.R Hoare. An array of values is sorted into ascending order. The + method involves reordering terms such that it can be partitioned in the + form: + + a[low],a[low+1], ... a[i-1] < a[i] <= a[i+1],a[i+2], ... a[high] + + The pivot value in this case is arbitrarily chosen as the value of the + final element on entry. The procedure then calls itself recursively for + each side of the above expression until each partition contains only one + term. The following coding exploits a feature of this compiler that the + value of the loop variable on exit from a loop will be that which led to + the loop's termination. This may not be the case on other Algol compilers. + + PROCEDURE quicksort(a,low,high); + VALUE low,high; INTEGER low,bigh; + INTEGER ARRAY a; + IF lowi AND y>=pivot DO j:=j-1; + IF i= abs(obs) THEN + count:=count+i + ELSE + IF n # 1 THEN + BEGIN br(n-1,l,sun); br(n-1,-1,sun) + END + END br; + + text(1,"*Nnumher of pairs?"); j:=read(7); + obd := D; + FOR i:= i STEP 1 UNTIL j DO + BEGIN a:= read(7); b:= read(7); + obs := obs + a - h; + d[i] := ahs(a - h); + END ; + text(1,"*Nsum of differences"); + rwrite(1,obs,8,2); count:=0; + br(j,-1,0); br(j,1,0); + text (1, + "*NProbahility of same or greater with random signs"); + rwrite(1,count/2^j ,7,3); + END + FINISH + + The final example is a procedure for solving simultaneous equations. The + left hand side matrix is set up in a two dimensional array a[row,colunm] and + the right hand side in a vector b[row]. The array names (a and b are only + examples) are passed to the procedure to correspond to the names lhs and + rhs, together with an integer giving the number of equations and a label to + exit to if there is no solution. The answers are left in the right hand side + vector. The method uses a Gaussian elimination with partial pivoting. + + PROCEDURE solve(order,Iha,rhs,fail); + VALUE order; + INTEGER order; ARRAY Ihs,rhs; + LABEL fail; + BEGIN INTEGER row,col,rawl,orderl,i,j; + REAL max; + + FOR order1:=order STEP -1 UNTIL 2 DO + BEGIN max:=0; + FOR J:=1 STEP 1 UNTIL order1 DO + IF abs(lhs[j,order1]) > max THEN + BEGIN max:=abs(lhs[j,orderi]); row:=j; + END + IF row#order1 THEN + BEGIN max:=rhs[order1] ; + rhs[order1]:=rhs[row]; + rhs[row]:=max; + FOR col:=I STEP 1 UNTIL order I DO + BEGIN max:=lhs[order1,col] ; + lhs[order1, col]:=lhs[row. col] ; + lhs[row,col]:=max + END + END swop equations; + IF lhs[order1,order1]=0 THEN + nosol: BEGIN text(1,"*Nno solution"); + GOTO fail + END + FOR j:=STEP 1 UNTIL order1-1 DO + BEGIN rmax:=Ihs[[i,order1]/lhs[orderl,order1]; + rhs[J]:=rhs[j]-rhs[order1]*max; + FOR col:=i STEP I UNTIL order1 DO + BEGIN lhs[j,col]:= + Ihs[j,col]-lhs[order1,coI]*max + END zero one element; + END zero one column; + END triangularise the left hand side; + IF lhs[1,1]=0 THEN GOTO nosol; + FOR row:=1 STEP 1 UNTIL order DO + BEGIN rhs[row]:=rhs[row) / lho[row,row] ; + FOR row1:=row+1 STEP I UNTIL order DO + rho[row1]:=rhs[row1]-lhs[row1,row]*rhs[row]; + END + END solve simultaneous equations; + + 2.66 Compiling and running programs + + Running Rogalgol is a two stage process: + + 1. Compiling. The program source is read by the compiler to produce an + output file in a form to be read by the runtime system. + + 2. Running. This stage loads the file output from the compiler and runs it. + + The simplest sequence of commands given a program source in a single file + 'PROG.ALG' would consist of: + + ALGOL PROG + ARUN PROG + + The default disk drive for input and output files is the logged on drive. + The default file extensions are: + + Source files .ALG + Compiler output .OBJ + Monitor file .MON + + 2.67 Compiling + + In the simplest case given above the compiler reeds the program source from + the file specified; if no file extension is given then the default will be + used. The output file created is given the same name as the source file but + with the extension '.OBJ'. Any pre-existing file of the same name as the + output file will be deleted before the new output file is created. If the + compiler detects any errors in the program source the output file is deleted + but compilation continues until the end of the source, checking for further + errors. Error messages are sent to the console. At the of compilation the + size of the resulting program is printed and control is returned to CP/M. + + A more general form of calling the compiler is: + + ALGOL outlist=inlist + + For example: + + ALGOL OUT=IOL1B,B:MATHS,PROG + + Using this method, the input source is read from a series of files in turn; + typically these files would consist of groups of commonly required + procedures, ending with the file containing the program. It should be + remembered that the overall source should correspond to the required Algol + block structure, from the first BEGIN to the final corresponding END and + FINISH. Files may be taken from several drives; if the drive is not + specifically included then the current default will be used. This is + discussed in the section on i/o selection. In the example IOLIB.ALG is taken + from the logged on drive and MATHS.ALG and FROC.ALG from drive B:. The + output OUT.OBJ goes to the logged on disk. An alternative (and perhaps + better) way of combining source files is by the use of the LIBRARY facility + previously discussed. It must he remembered however that the use of such + library calls is restricted to the final file specified in the input list; + the remaining input file specifiers will otherwise be overwritten. This is + discussed in the details of library procedure 'findinput'. + + If a second output stream is specified, then a listing of the compiler + identifier tables will be generated. Compiler error messages will also be + seat to this stream along with an indication of the maximum table size the + system can support. + + ALGOL OUT1,OUT2:=PROG + + will send the compiler output to OUT1.OBJ, and all compiler error messages + and identifier tables go to OUT2.MON. + + ALGOL OUT1,CON:=PROG + + will send errors and identifier tables to the console. + + If no input/output is specified in the call, or if an error exists, e.g. bad + syntax or a non-existent source file is given, then the compiler will prompt + for i/o. For example, a call of the form: + + ALGOL + + will result in a prompt of the form: + + OUT=IN? + + The user may now specify a list of input and output files as for the above + case. + + The output from the compiler is about the same length as the corresponding + source text. + + If the i/o files were specified in the initial calling lime, i.e. 'ALGOL + PROG', then upon completion the compiler will return to CP/M. If the i/o + files were given as the result of a prompt from the compiler, then upon + completion the compiler will be restarted, to allow further programs to he + compiled. A reply of CONTROL-C in this case will return control to CP/M. + + 2.68 Compiler directives + + A 'DIRECTIVE' ; may be included anywhere that 'COMMENT' is allowed. + They are now allowed before the first 'BEGIN' of the program (not standard + ALGOL-6O). The string may contain any basic symbols except ';' and does not + have to be delimited by quotes. If the upper/lower case convention is being + used, then the directive letters must be in lower case, not as below. Only + the following symbols are significant: + + + Any significant letters following will turn the facility ON. This is + the default condition. + + - Any significant letters following will turn the facility OFF. This + remains in force until a '+' is + + B Controls whether Bitstream output is produced. This should only be + used before the first begin. The default is bitstream; character output + requires a special loader version of ALINK, ARUN will not accept it.The + character format output can be decoded using the list of operation codes. + + L Controls whether the input source with added line numbers is + reproduced on the listing device. Default OFF. + + T Controls whether a full identifier table is listed. Default OFF. + + S Causes a shortened identifier table containing only labels and + procedures to be sent to the list file. If 'T' is in force as well as 'S' a + full table is produced. Default OFF. + + P Causes all procedures and function which are not EXTERNAL to be ENTRY + points. Default OFF. See the Linker document. + + The tables and source reproduction are sent to the listing file, the second + output file in the CP/M command line. If none was specified, the console is + used. Giving a listing file in the command line (i.e. ALGOL OUT,LIST=INPUT) + in effect causes an automatic 'DIRECTIVE' T-L; + + Directives may be given in the CP/M command line which runs the compiler. A + list of options attached to the output file will be analysed in the same way + as a 'DIRECTIVE' string. For example to force a listing on the terminal: + + >ALGOLC PROGRAM[L] + + Specific ENTRY and EXTERNAL declarations + + The symbols ENTRY and EXTERNAL may be placed after the name in a procedure + declaration to allow linking of separate program modules as described in the + linker document. + + Directive 'P' may be used to make all procedures which are not EXTERNAL into + ENTRY points. + + 2.69 Character and bitstream compiler output files + + Under default conditions a bitstream is output instead of ASCII characters. + You can force ASCII output by using directive -B. This can help in + debugging, but the loader and standard linker accept only bitsream format. + The special linker ALINKS does accept character format compiler output. + + Data is in chunks of 2, 8 or 16 bits. Each chunk is the right way round but + chunks start at the least significant end of each byte. Floating point + literals and entry point/external names are in ASCII starting on a byte + boundary. Floating point numbers are terminated by 13 and names by the + character '. Label numbers are short or long depending on whether the number + will fit into 8 bits. + + 2 bit codes and their meanings + + 0 Byte value follows. + + 1 Short label number follows. The value of the label expanded to 16 bits to + be loaded or used as definition as required. + + 2 Short label definition follows. After the 8 bit label number, a further + code indicates the type of definition. + + 0 Colon definition, value = load address. + 1 Equate value. Read from top to find it. + 2 Label is equated to global name which follows. + + 3 Second code follows. + + 0 Word value follows. + + 1 Long label number follows, value of label is to be loaded or used as + definition. + 2 Long label definition follows, then third code as for code 2 above. + 3 Third code follows + + 0 Floating point literal follows. + 1 Global symbol definition. After the name in ASCII read from the top + to get its value. + 3 End of load module. + + 2.70 Pre-compiled libraries and the linker + + Commencing with version 5.0, the Rogalgol system allows a program to be + compiled in sections. One section (or module) must contain the complete main + program. The procedures may be split over as many modules as is desired, or + may be included with the text of the main program as in previous versions. + Each program module must be a complete program, but individual procedures + may be defined as being EXTERNAL or ENTRY POINTS. An EXTERNAL procedure is + one which is a reference to a procedure which is declared as an entry point + in another program module. Usually, a library of procedures all defined as + ENTRY points would be incorporated into a program with no main program + statements, only the procedure declarations. A linker takes the output of + any number of separate compiler runs and consolidates them into a single + relocatable core image file. + + The form of an external procedure declaration is: + + PROCEDURE name EXTERNAL ; + + Note that no parameter list is given. The only variation from this form is + that BOOLEAN, REAL or INTEGER may precede PROCEDURE to indicate an external + function. The compiler gives the procedure a label number but no code is + generated. + + EXTERNAL procedures do not receive a procedure number as they are unable to + access variables within the procedures of the main program. Therefore, they + do not count towards the limit of 255 procedures. This effectively allows a + program to have access to more than 255 procedures. + + There are two ways to tell the compiler that a procedure or function is to + be an ENTRY point. First, if DIRECTIVE P is in force all procedures are + available outside the module, unless they are defined as EXTERNAL. Second, + the symbol ENTRY may be placed after the procedure name and before the + parameter list (which may be empty, of course). It does not matter if ENTRY + is used when directive P is in force. An example might be: + + REAL PROCEDURE compadd ENTRY (x1,x2,y1,y2); etc. + + The runtime program loader does not reecognise entry points or external + definitions and will give an error during loading. The linker must be used + to create a single core image file for the loader. + + Ordering of the linked program modules + + The first module of a linked program is the one whose main program is + executed. The main programs of any other modules are not accessible. There + is no check on duplicate entry point names; the first declaration + encountered will be the one used at runtime. This allows the use of modules + which have some procedure names in common. Apart from this the ordering of + modules is not important. + + Use of main program variables in linked modules + + Since each module is a separate program, the compiler will allocate storage + for main program variables starting at the same address in each. It is + therefore quite possible to use main program variables to communicate + between library procedures and the master program. Great care must be + exercised, since the compiler cannot check the number or type of these + variables. The variables in each module are simply overlaid. Arrays will + function as well as unsubscripted variables because they use only one slot + on the variable stack, which contains a pointer to the array Itself. + + It is recommended that library procedures should not access main program + variables, since they will not then be of universal application. If you do + decide to use this form of global storage check that the stack slots + assigned to the variables (obtained from an identifier table at compile + time) correspond in the main program and the libraries it is to use. + + Procedure numbers of external procedures + + External procedures are not allocated a procedure number and do not count + towards the maximum of 255 allowed within any module. However, all other + procedures are allocated a number starting at 1 within each compiled module. + Thus, there will in general be a number of procedures all with the same + procedure number in the linked program. When a runtime error occurs (not + trapped by the program as on page 38) the procedure number in the message + (PROC) may not be unique. The module in which the procedure occurs may + however be deduced from the LOC column, which is the error address relative + to the start of the compiled program. The linker gives the next load address + after each module is processed and this is also relative to the start of the + compiled program. It is therefore straightforward to determine in which + module the error was detected. The list of procedures for that module is + then consulted to find the name corresponding to PROC. + + RUNNING THE LINKER + + The linker is named ALINK, with extra characters indicating variants; ALINKL + indicates long integer version and ALINKS accepts ASCII symbolic compiler + output instead of the default bitstream. + + It is essential to use the correct version of the linker, ALINKL if the long + integer version ARUNL is to be used, otherwise ALINK. + + The linker is driven by command lines. The start of a link is heralded by a + command line containing an '=' sign. The prompt for such a line is + + Output=input list : + + If just is typed the linker returns to CP/M. Otherwise it tries to + open the first input file. It keeps asking for this command line until a + valid input file is given (the output file may be omitted). You can list as + many input files on the line as you wish, subject to a maximum line length + of 96 characters. Any file which fails to open (including the first) is + treated as the end of the line. + + The linker processes the input files, after each one checking whether there + are any outstanding unresolved external procedure names If there are none + the output file is written and the linker requests another initial command + line. If when all files have been read there remain outstanding externals + the names of more input files are requested. Again a list may be typed but + in this case an '=' sign preceding the file names is NOT required. The + reason for this difference is to synchronise the start of linking should + there be any error and the lines are being read from a command file (see + later section). If at this stage an empty line is given the linker writes + the output file anyway, with a warning message on the terminal. As with the + initial command line, any input file which does not open is treated as a + line terminator. + + The default extension for input and output files is ASC. + + Identifier table output + + There are three types of identifier table which may be output on the + terminal under the control of an option letter attached to the first input + file. + + (a) The current table, including both unresolved references and entry + points, the latter being marked with '*' and having their addresses relative + to the start of the program. This is output after each input file has been + loaded. + + (b) A list of as yet unresolved names, output after each input file. + + (c) The entry point table listed at the end of linking. + + The default (no option letter) is for list (b) only to be typed. Option 'N' + means no tables at all, 'F' means all three of the tables and 'G' means (b) + after each file plus the global list (c) at the end of linking. + + Example command lines: + + Output=input list : PROGRAM=MAIN[N],LIB1,LIB2 + Input files : LIB3 + + The first line means link a program to be called PROGRAM using MAIN as the + main program, to use library procedures in files LIB1 and LIB2. No tables + are to be listed on the terminal. The second form of line is used when there + are outstanding externals after all the input files of previous lines have + been processed. + + Indirect command files + + The input lines may be obtained from a command file, default filename + extension .LNK. If the first character of the first command line of a link + (the one with '=' in it) is '@', then the filename following will be opened + and used instead of the terminal as a source of input. Command lines are + still echoed on the terminal so that you can watch the progress of the + linker. + + Command files may be chained by using '@' on the last line of a file. The + current file will be closed and a replacement opened. The files are not + nested. + + The first command line may be typed as a parameter to the call of the + linker, and this may nominate an indirect command file. For example: + + >ALINK @LINKIT + + The linker will attempt to open the file LINKIT.LNK on the current default + drive. The command file should not contain any blank lines except at the end + as these tell the linker return to CP/M. + + >ALINK FRED=JIM + + The linker takes compiler output file JIM.ASC and creates a relocatable core + image file FRED.ASC, assuming that JIM contains no external references. This + performs the same function as using option 's' on the runtime loader except + that the output file name may be different from the input file name. + + 2.71 Runtime program + + Given a successfully compiled program, the output file so created may mow be + rum by a calling the runtime system as follows: + + ARUN filename + + The assumed file extension is '.ASC'. The file specified will be loaded and + them executed. If no input is specified or if an error is found, e.g. bad + syntax or non-existent filename them the runtime system will prompt the user + for am input file. For example a call of the form: + + ARUN + + will prompt for input: + + INPUT= + + to which the user responds with the required filename. + + Upon completion of the program the system prints '^' on the console and + waits for an operator response. Typing CONTROL-P will rerun the program or + CONTROL-C will return control to CP/M. + + If a runtime error is detected then suitable diagnostic information is sent + to the console (see section on runtime errors). Unless the user is making + use of the error handling facility (see procedure 'error' in library + section) the system will mow wait for the operator to investigate the cause + of the error. The program may be rerun from the beginning by typing + CONTROL-P or control returned to CP/M by typing CONTROL-C. + + The return to CP/M upon completion or upon detecting a runtime error can be + made automatic by a call ioc(22) within the program. + + A call of the form ioc(60) causes am immediate restart of the program from + the beginning. Any files open at the time will not be closed although all + file control blocks are released. + + 2.72 Switches on the loader filename + + A previous topic describes how to examine the switch list associated with + the last file opened. Since the loader uses the same routines as the Algol + interpreter, the Algol program can examine the switch list associated with + the program begin run. Obviously, this must be done before either INPUT or + OUTPUT is used. The loader itself only acts on the first character of the + list, and ignores all except B and M (which will cause an error). The + programmer can determine if the debugger is active by looking for D or W at + the start of the list, and thus can arrange for the switch to be propagated + over a chain. + + 2.73 Long integer (32 bit) Algol + + ARUNL is a version of the Rogalgol runtime system in which real variables + are represented not in the normal mantissa/exponent form but rather as 32 + bit 2's complement integers. This runtime system is useful for those + applications where greater precision is desirable but without the need to + extend the number range to the extent allowed by the floating point + representation, e.g. business programs. The number range allowed is from + (2^31)-1 to -(2^31), (about +-2.15*10^9). The compiler itself remains + unchanged. Variables declared as integers will still be represented as 16 + bit 2's complement numbers. This document outlines the differences from the + Algol system described in the manual. + + STANDARD FUNCTIONS + + The following functions have been removed: + + sin, cos, sqrt, arctan, ln, exp + + The function entier exists but is equivalent to a real to integer + assignment. For example, the statements + + i := entier(x); + i := x ; + + have the same effect. + + LIBRARY PROCEDURES + + The standard library file 'ALIB.ALG' can be used with ARUNL with the + following exception that random has been removed, + + Two additional library procedures can be found in file 'ARUNL.ALG' + + pow10(n) + lrem(t,b) + + DIVISION + + Real division (/) always truncates the result towards zero in the same way + as with integer division (%). A procedure has been added to the library + (lrem) to give the remainder term lost by the division. + + z := lrem(t, b) ; + + gives the remainder lost by the division: + + u := t / b ; + + The result of lrem will always have the same sign as the quotient (or zero) + in the same way as the MOD operator does for the integer case, e.g. + + t b t/b lrem(t,b) + + 35 8 4 3 + -35 8 -4 -3 + 35 -8 -4 -3 + -35 -8 4 3 + + INPUT/OUTPUT + + The decimal input/output routines (read and rwrite) are unchanged except for + the addition of a scaling factor. A call of the ALIBL.ALG routine: + + pow10(n); + + where 'n' is a small integer causes all subsequent calls to read to be + scaled by a factor of 10^n. The digit string representing the number + (including fractional and exponent fields) is read and the result scaled by + 1O^n. Any fractional part is then disregarded before returning the result. + For example with n=2, on reading the number 123.4567 the result would be + 12345. On output the converse scaling is performed. The value to be output + is first converted internally into a digit string; the decimal point is then + effectively shifted left by `n' digits before printing the result in the + required format. The meaning of the fopitat parameters remain unchanged. + This scaling on output applies only to rwrite; the integer print routine + (write) is unchanged. + + RUNTIME ERROR MESSAGES + + The following changes to the runtime error numbers given in the manual have + been made. + + 8 Real (long integer) division by zero or lrem(t,0). + 9 Overflow in real multiply. + 16 Overflow in real addition. + 17 Overflow in real subtraction. + 18 Illegal standard function called e.g. sin, cos etc. + 19 Largest negative number -(2^31) with no corresponding positive + representation. This error can occur from abs, *, /, rem, rwrite etc. + + 2.74 The chaining mechanism + + The call ioc(60) re-runs the program from the start, while ioc(22) will + cause exit to CP/M when execution reaches the end of the program. If ioc(22) + is called before ioc(60) chaining is initiated, in which the leader reads + another compiler output file. The name of the new file is obtained from the + keyboard buffer. Note that the filename must be given in full unless the + default extension has been placed in the three bytes following the switch. + + All buffers are reset after loading; therefore all files should be closed + before chaining. The correct sequence is: + + ioc(1); text(7,"NEXTPROG.ASC"); + { Put the filename into the keyboard buffer } + + ioc(22); ioc(6O); + + If the nominated file cannot be opened the prompt + + INPUT= + + will be given, as when ARUN is called from the console. + + 2.75 Compiler error messages and diagnostic information + + 2.76 Compiler error messages + + FAIL X ON LINE Y IDENT Z SYMBOL S + + The name of the current library file, or 'MAIN SOURCE' is printed along with + the error number. + + After the error line, the program is reproduced from either: + + (a) 100 characters before; + + (b) the start of the program; or + + (c) the end of the previous error message, whichever is the shorter. + + If the whole text is being reproduced (see below) then the error text is + ended with a line of '=========='. + + When the whole text is being sent to the listing file (directive 'L') line + numbers are prefixed. The first number is counting from the start of the + program and the second is a count within each file. These line numbers + correspond exactly to the line numbers in the error messages. + + Line numbers in error messages are counted from the start of the current + file, except for undeclared labels (error 2). In this case the numbering Is + from the start regardless of whether the lines are coming from libraries or + not. + + A selective symbol table containing only labels and procedures may be + obtained by directive 'S'. + + Procedures and labels are highlighted in the symbol table by being indented. + The procedure numbers are further highlighted by enclosure in brackets. + + If a symbol table but no listing is specified then the start and end of + library files are marked in the symbol table. + + X is the failure number (see below), Y the line on which it occurred, Z the + last identifier read, and S the decimal value of the last symbol (see + section entitled 'compiler representation of basic symbols'). 'LINE UP TO + ERROR' is a copy of the input line up to and including the symbol at which + the error was found. The compiler output is switched off and the file + deleted. The compiler however continues to check the syntax of the remainder + of the program. In all compilers a tradeoff is made between the amount of + error information given and the size and speed of the compiler. In this + implementation the emphasis has been to produce a compiler that can be used + on a very modest sized computer. There is always a danger, particularly with + a one pass compiler, that following the detection of a genuine error, the + system may fail to synchronize fully and thus produce additional spurious + errors. + + 1 Identifier declared twice in same block. + 2 Undeclared identifier. + 3 No '[' after array name, except as a procedure parameter, or ordinary + procedure used as a function. + 4 No ')' at end of subscript list. + 5 More than 255 variables in the main program or a procedure. + 6 No FINISH at end of program. (Too many ENDs). + 7 No ELSE part of a conditional arithmetic expression. + 8 No ELSE part of a conditional Boolean or conditional designational + expression. + 9 Relational operator not found where expected. Will occur if the first + arithmetic expression of a Boolean relational expression is totally enclosed + in round brackets. + 10 Arithmetic primary does not start with '+', '-', '.', '(', digit or + identifier. + 11 '%', MOD, '!', MASK, or DIFFER does not have two integer operands. + 12 ')' missing in arithmetic expression. + 13 Controlled variable in FOR is undeclared or subscripted. + 14 ')' missing in Boolean or designational expression. + 15 More identifiers in scope than the tables can accommodate. The + compiler automatically makes the tables as large as possible on a given + system. + 16 Statement starts incorrectly. If this occurs at the terminating + FINISH is means there are not enough ENDs. + 17 Undeclared or unsuitable identifier on left of ':=' + 18 Array declaration faulty. + 19 Type specification of actual parameter is not LABEL, PROCEDURE, REAL + PROCEDURE, BOOLEAN PROCEDURE or INTEGER PROCEDURE. + 20 Wrong number of subscripts. In the case of formal arrays, this error + cannot be detected until runtime. + 21 No ')' after actual parameter list. + 22 FOR statement element not terminated by ',' or DO. + 23 More than 255 non-external procedures OR. + 23 Procedure body not delimited by ';'. + 24 ':=' not found where expected. + 23 No THEN after IF. + 26 VALUE specification is not the first specification of procedure + formal parameters. + 27 FINISH in middle of program. Possibly an unmatched BEGIN, '"' or '''. + 28 No ';' after parameter list. + 29 Parameter specified twice, or is not in formal list, or specification + not terminated by ';'. + 30 Forward reference list full. + 31 UNTIL not found where expected. + 32 No '(' after name of standard procedure (except input or output). + 33 THEN followed immediately by IF. + 34 Procedure actual parameter starts with an undeclared identifier. + 35 Function or variable used as procedure. + 36 procedure input or output is followed by a '('. + 38 Arithmetic expression contains Boolean variable in illegal context. + 39 Parameter specified VALUE is not in formal list. + 40 Parameter specification not complete. + 41 Am array has been called by value. + 42 Input/output procedure call error. + 43 Left parts of multiple assignment have different types. + 44 Integer literal not in range. + 45 Switch identifier not followed by ':='. + 46 Switch list does not end with ';'. + 47 Switch has more than one subscript. + 48 Word BYTE not followed by ARRAY. + 49 Input files exhausted without end of program recognized. + 50 A procedure used before its declaration was assumed to be of a type + different from the actual type. Try reordering procedures to eliminate the + forward reference. + 51 Input file specified in a LIBRARY call not found. + 52 Subset compiler as for 50 but forward reference clash. + 53 Subset compiler as for 50 but at block end resolution. + 54 More than 100 procedure parameters. + 56 No DO after WHILE. + 57 No UNTIL after REPEAT. + 58 Case statement syntax error. + 59 Boolean expression in context where arithmetic one needed. + 60 Arithmetic expression where a Boolean one is needed. + 61 Array declaration not terminated by ';'. + + 2.77 Compiler identifier table and identifier types + + The compiler may be instructed to print on the console or to the monitor + file a list of all the identifiers declared, together with information about + their type and the addresses they will occupy in the memory. Variables are + placed on a stack and the variable number is the position on the stack + relative to a pointer. The pointer is held in location PBASE in the runtime + program. The address of the variable is found by multiplying the variable + number by 4 and adding this to the contents of PBASE. + + Four numbers are printed after each identifier in the compiler identifier + table. + + The first of these is the stack position except for labels and procedures. + For labels and procedures the symbolic label number is printed. This is the + digits part of a symbol such as L123 which is output by the compiler. + + The second number is the procedure number of the enclosing procedure in + which the identifier is declared. The main program is 0, and the procedures + are numbered serially as they are encountered, regardless of depth of + declaration. As an exception, the actual number of a procedure is printed, + instead of the number of the enclosing procedure. + + The third number is the line number of the source program. + + The fourth number is the current size of the compiled code. This information + can be related to the position given when runtime errors are detected. + + The type information of the identifier is then listed as follows. The + numbers represent the internal representation of the data types. + + 0 procedure formal parameter (type not yet known) + 1 real + 2 integer + 3 Boolean + 5 real array + 6 integer array + 6 byte array + 7 Boolean array + 8 switch + 10 procedure + 11 real procedure + 12 integer procedure + 13 Boolean procedure + 14 label + + The compiled code of a procedure contains a list of the types of the + parameters. The following types may appear, in addition to those above. + + 4 string + 21 real by name + 22 integer by name + 23 Boolean by name + + 2.78 Compiler representation of basic symbols + + These are the decimal values which are printed in a compiler error message. + Language key words are represented in the Algol source by the word enclosed + in single quotes or in upper case and in the compiler by 40*1st + letter+second letter. + + If a compiler error message contains a symbol which is not on the list, an + illegal compound symbol has been detected. The usual cause of this is an + unmatched single quote. + + 1-26 letters A-Z + 27 [ + 29 ] + 30 ^ (exponentiation) + 7000 := + 33 ! + 34 " (string delimiter) + 35 # (not equal to) + 36 $ + 37 % (integer divide) + 38 >= (greater or equal to) + 40 ( + 41 ) + 42 * (multiply) + 43 + + 44 , + 45 - + 46 . + 47 / (real divide) + 48-57 digits 0-9 + 58 : + 59 ; + 60 < (less than) + 61 = + 62 > (greater than) + 63 <= (less or equal to) + 85 BEGIN + 95 BOOLEAN + 105 BYTE + 118 AND + 121 CASE + 122 ARRAY + 123 CC + 135 COMMENT + 169 DIFFER + 175 DO + 212 ELSE + 214 END + 217 EQUIVALENT + 224 EXTRA + 241 FALSE + 249 FINISH + 255 FOR + 295 GOTO + 366 IF + 373 IMPLIES + 374 INTEGER + 481 LABEL + 489 LIBRARY + 512 MASK + 535 MOD + 575 NOT + 606 OF + 618 OR + 658 PROCEDURE + 725 REAL + 726 REPEAT + 780 STRING + 780 STEP + 783 SWITCH + 808 THEN + 818 TRUE + 854 UNTIL + 881 VALUE + 928 WHILE + + 2.79 Run time errors and diagnostic information + + 2.80 Run time errors + + In the event of an error condition being detected during program execution, + a message is sent to output device 1 (console or video screen generally) of + the form: + + ERROR n + ADD PBASE PROC LOC + aaaa bbbb p1 d1 + aaaa bbbb p2 d2 + ... + aaaa bbbb 0 d0 + + where: + n error number (see following list) + p1 procedure number where error was detected + aaaa address of program counter + bbbb value of PBASE at error + (see section on runtime system) + d1 location of program counter relative + to the start of the program + + Both aaaa and bbbb are printed in hexadecimal. The procedure number can be + found by counting procedures from the beginning of the program starting from + 1. The main program is given the number 0. This information can be found in + the compiler identifier table output. If p1 is non-zero the calling sequence + is then printed on the following lines until the outermost level (p=0) is + reached. This traceback information can be used to investigate the nature of + failure in greater detail if required (see section describing working of the + runtime system). The information given in dl etc can be related to the + corresponding information given in the compiler identifier tables to help + locate the position of errors. The program may be restarted from the + beginning by typing CONTROL-P or control returned to CP/M by typing + CONTROL-C. + + 2.81 Recovery from run time errors + + In normal operation a program is terminated by the detection of a runtime + error. It is possible however to continue following an error, allowing the + program to exit in a controlled manner, e.g. close output files, give more + useful diagnostic information, values of variables and so on. This recovery + is achieved by including a call of procedure 'error' (in ALIR.ALC) in the + program before the failure occurs, e.g. + + error(LABEL crash); + + On detecting an error, the runtime system will place the error information + given above and then transfer control to the label (or designational + expression) 'crash' in the user's program. It is advisable that the label be + located at an outermost program level as it may only be reached if it is + within scope at be time of the error. The error number responsible for the + failure can be found by means of a call to chin(13), e.g. + + crash: i := chin(13); + IF i > 30 THEN GOTO cpmbug ELSE ... + + 2.82 Runtime error numbers + + 0 Undefined error. This implies that an error has been detected which + has no corresponding entry in the error list. This hopefully will only occur + where the user has made modifications to the runtime system and failed to + update the error list. + 1 Variable space used up (stack overflow). Probably the result of + excessive recursion or array declarations too large for the available + memory. The error traceback may fail under these circumstances (the first + lime should always be correct). Overflow is checked following block or + procedure entry and array declarations. + 2 Procedure called with the wrong number of parameters. + 3 Procedure called where the actual and the formal parameter types do + not match. + 4 Array used with the wrong number of subscripts. + 5 Array subscript out of range (below base of array). + 6 Array subscript out of range (above top of array). + 7 Integer division by zero. + 8 Real or integer division by zero. + 9 Real overflow. ?? overflow in multiply + 10 Real to integer conversion overflow, also long integer + 11 Real overflow detected during normalisation after real arithmetic + operation, or by integer overflow during add or subtract. + 12 Error in READ. Character read which is not a legitimate part of a + number (ASCII value is less than 48 ie <&0). + 13 As for 12 but ASCII value is greater than 57 (i.e. >&9). + 14 Error in READ. Number contains two or more decimal points. + 15 Error in READ. A character '+', '-', '.' or 'E' found with no + associated digits. + 16 Square root of a negative number. + 17 Exponential argument too large (>87). + 18 Exponential argument marginally too large. + 19 Logarithm of a negative number. + 20 Logarithm of zero. + 21 Table item out of range (below). Found in ioc(n), chin(n), chout(n,c) + etc where n<0. + 22 As for 21 but where a is greater than maximum value specified in + list. + 23 End of file detected during READ. + + LOADER ERRORS + + 24 Loader syntax error. Output from compiler has been corrupted?. + 25 End of input is indicated (CONTROL-Z read) but no program has been + loaded. Selecting input device 0 will produce this effect. + 26 On completion of input there remain unresolved forward references. + Input source is corrupt? + 27 An input device name has been used as an output device in a command + string, or vice versa. + 28 Label tables overlap program. Program is too large for available + memory. + 29 Forward reference tables full. This error should be rare but can he + avoided by reordering procedures so that they generate fewer forward + references, i.e., try to arrange that procedures are declared before they + are called. + 30 Non-relocatable core image input file is not compatible with this + runtime system. + + OPERATING SYSTEM ERRORS + + 31 Channel number is out of range. + 32 No directory space found during output. + 33 Attempt to read from channel not open for input. + 34 Attempt to read from a non-serial channel. + 35 Attempt to reed past end of file. + 36 Attempt to write to a channel without write access. + 37 Attempt to write to a non-serial file. + 38 Error in extending file. + 39 Attempt to output to random access file without write access. + 40 Attempt at random access to a serial access channel. + 41 Channel not open. + 42 Attempt to rewind a random access file. + 43 Random access with a negative block number. + 44 No slot available for input or output. + 45 Attempt to create an output file for random access. + 46 Random access transfer attempted with a block count less than zero or + greater than 255. + + 2.83 Runtime stack organisation + + The stack extends from the end of the runtime program to the end of + available memory, as found by interrogating the system. The variable stack + grows upwards from the end of the program and a working stack, used in + evaluating expressions, passing procedure parameters, and CALL instructions, + grows downwards from the end of memory. The variable stack consists of a + number of frames, one for the main program and one for each procedure call. + Within each stack frame is an array stack, which contains an array frame for + each depth of array declaration. In the following section "word" refers to a + 16 bit (2 byte) quantity. + + The following pointers are used. Their addresses can be found from the + listing in the section entitled 'adding code sections'. + + PBASE points at the current variable stack frame + + MBASE points at the main program stack frame. When the main program is + executing locations PBASE and MBASE contain the same value. + + WSBAS points at the base of the working stack in the current level. It is + used to delete floaters from the working stack at Algol labels. + + ABAS points at the current array frame + + FSPT points at the next free location in the variable stack. + + FPARAG in 80x86 versions holds the next free paragraph in extra memory. + + The following registers are also of significance. + + SP points at the top item of the working stack, It must be saved and + restored if used by any machine code added. It is also used for CALL + instructions. + + IX should also be restored if used. It is the Algol interpretive code + program pointer. + + IY must be restored if used. It points to a series of flags and working + space. + + Each stack frame is divided into two parts, a variable part and an array + part. The variable part is divided into slots which are each two words (four + bytes) long. The actual address of a slot is found by multiplying the slot + number by 4 and adding this to the base address which is held in PBASE or + MBASE. In the main program frame the first declared variable is in slot 2 + and the word pointed at by MBASE contains 0, the level number of the main + program. In procedure level frames slot 3 is used for the result of a + function and is unused in procedures which do not deliver a result. The + procedure parameters occupy slots 4 and upwards, followed by variables + declared within the procedure. The first word of each procedure in the + compiled program contains the number of variable slots required by the + procedure. The first word of the main program points at the last word of the + compiled program which contains the number of variables slots required by + the main program. + + In procedure frames the first three slots are used for linking information. + Starting at the word pointed at by PBASE (slot 0) the words contain the + following information. + + Word 1 The number of the procedure. + Word 2 The return address + Word 3 PHASE of calling level + Word 4 WSBAS of calling level + Word 5 ABAS of calling level + Word 6 FPARAG of calling level in 8086 version + + A variable stack slot may contain any of the following types of item: + + 1. A real number which is held in the standard four byte format. + 2. An integer number or Boolean value which is held in the highest addressed + word of a slot. Booleans use only the least significant byte of this word. + 3. A label or procedure address, always a procedure parameter. The address + itself is in the highest addressed word and in the word below it is the + value of PHASE at the tine the address was evaluated. + 4. The address of an array or a switch either as a declared variable or a + procedure parameter. The address is in the highest addressed word of the + slot, the remaining word being unused. + 5. The address of a string or an unsubscripted variable for procedure + parameters of type string and variables called by name. + + The address in a switch variable points to the switch vector. The word + pointed at contains the number of elements in the switch and subsequent + words the addresses of the labels in the switch list. + + The array part of a stack frame contains a number of array levels, numbered + by depth of declaration within a procedure or the main program. Level 0 + always exists and is located immediately above the end of the variables. + ABAS points at the base of the current level, which contains the depth of + that level. The next word (except in level 0) contains a pointer to the + level below. Above the level information are the dope vectors and array + elements. + + An array variable points at the start of its dope vector. This contains 2*(N + + 1) words, where N is the number of subscripts. The first* word of the dope + vector contains the number of bytes occupied by each element (1, 2 or 4), + the second the number of subscripts and the third the lower bound of the + first subscript. + + There are two additional words for each additional subscript. The first + contains a multiplier for the previously accumulated element number and the + second the lower bound of the next subscript. The final word of the dope + vector contains the address of the word beyond the end of the array + elements. Array elements themselves are stored immediately after the dope + vector. + + 2.84 Runtime operation codes + + These are the operation codes which are output by the compiler. The list + gives their number in decimal. The compiler can be forced to output in + character format by using the switch [-B] (quoted convention) or [-b] + (upper/lower case convention). + + Expressions are evaluated using a working stack. The top element is referred + to as S1, the next one down as S2 and so on. The stack pointer 'SP' is used + for this stack (and also for CALL instructions). It grows down from the top + of available memory. + + Some of the interpretive routines take data from the program. N1 refers to + the next byte after the code, N2 to the next, and so on. In the following + section 'word' refers to a 16 bit (2 byte) quantity. + + 0 No operation. + 1 Declare array. N1=depth of declaration. N2=nunber of declarations in + multiple. N3-variable number of first declaration. N4=number of bytes in + each element. N5=number of subscripts S1=upper bound of last subscript. + S2=lower bound of last subscript. S3, S4, etc., bounds of other subscripts. + 2 Formatted print. S1=b, S2=a, S3=value, S4=device number. + 3 Read to S1 from input device in S1. + 4 Store local variable from S1. N1=variable number. + 5 Print string. Followed by 7 bit ASCII character, terminated by zero. + Device number is in S1. + 6 Integer print S1=radix, S2=value, S3=device number. + 7 Read next character to S1 from device number in S1. + 8 Print S1 as character, 52-device number. + 9 Jump. Location is in next word. + 10 Leave procedure. + 11 Enter procedure with no parameters. Address is in next word. + 12 Get local variable to S1. N1=variable number. + 13 Integer add. SI:-82+Sl + 14 Get array element. N1=procedure number, N2=variable number, N3=number + of subscripts. The subscripts are on the stack. The main program is + procedure number 0. + 15 Store array element. S1=value, other information as code 14 except + subscripts are in S2 etc. + 16 Set 16 bit constant in S1 from NI and N2. + 17 Integer negate. SI:=-S1 + 18 Real ^ Integer. S1:=S2^S1 + 19 Integer multiply. S1:=S2*S1 + 20 Integer divide. S1:=S2/S1 + 21 Integer subtract. S1:=S2-S1 + 22 S1:=S1=0 + 23 S1:=S1>0 + 24 S1:=S1<0 + 25 Get any variable to S1. NI=procedure number, N2=variable number. + 26 Store to any variable from S1. N1, N2 as for 25. + 27 Standard function. Followed by another code. + 2 sqrt 3 sin 4 cos + 5 arctan 6 exp 7 ln + 8 sign 9 entier 10 abs + 28 Jump if S1=FALSE. Address in next word. + 29 Set zero ln S1. + 30 S1:=NOT S1 + 31 S1:=S1 AND S2 + 32 S1:=S1 OR S2 + 33 S1:=S1 EQUIV S2 + 34 For statement calculator. S1=address of controlled variable. S2=final + value. S3=lncrement. S4=0 for no increment at the first test, else -1. + N1=type of control variable (0=REAL else INTEGER). The following word + contains the exit address for loop completion. + 35 'ioc'. Parameter in S1 + 36 Enter procedure. N1=number of parameters. S1=type of last parameter. + S2=value of last parameter, and so on, in reverse order. The address of the + procedure is in N2 and N3. The first word of a procedure is the fixed space + on the variable stack required by the procedure. The following bytes contain + the procedure number and the number of parameters expected, followed by the + type specification of the parameters, in reverse order. + 37 Store outer block variable from S1. N1=variable number. + 38 Fetch outer block variable to S1. N1=variable number. + 39 Set in S1 the address of the variable whose procedure number is in + N1, variable number in N2. + 40 Skip, device number in S1. + 41 Integer S1:=sign(S2-S1) + 42 Set 8 bit constant in S1 from N1. + 43 Fix S1. + 44 Float Sl. + 45 Set floating point constant from next 4 program bytes. + 46 Floating negate. + 47 Set label in S1. Address in next word. Second word of S1 becomes + variable stack base pointer. + 48 Evaluate switch address. S1=address of element O, S2=subscript. On + exit S1 contains address. + 49 Real ^ real. S1:=S2^S1 + 50 Floating multiply. S1:=S2*S1 + 51 Float S2. + 52 Floating divide. S1:=S2/S1 + 53 Floating add. S1:=S2+Sl + 54 Floating subtract. S1:=S2-S1 + 55 Store parameter called by name. S1=value, S2=address. + 56 Floating S1:=sign(S2-S1). + 57 Jump to address in S1. + 58 Enter procedure without parameters whose address is in S1. + 59 As 58 but number of parameters in N1. For 59 the rest of stack is set + up as for Code 36. + 60 Print string whose address is in S1, S2=device number. + 61 Set stack depth. N1=procedure number. N2=array depth required. + 62 Fetch parameter called by name. S1=address. + 63 Stop, end of program. Prints '^' on console or returns to CP/M. + 64 Store an address in the program in a local variable. Followed by the + variable number in N1 and the address ln the next whole word. + 65 Jump to the address in local variable number N1. + 66 Set in S1 the address of local variable number N1. + 67 As for 66 but main program variable. + 68 Get local array element. + 69 Get main program array element. + 70 Store local array element. + 71 Store main program array element. Codes 68-71 are followed by the + variable number in N1, not by the level number and then the variable number + as for codes 14 and 15. + 72 Read a floating point number, check for end of file. S1=address of + label to go to on end of file. S2=device number. + 73 Logical OR. Sl:=S2 OR 51 + 74 Logical AND. S1:=S2 AND S1 + 75 Logical EXCLUSIVE OR. Sl:=S2 XOR Si. + 76 Integer MOD. S1:=S2 MOD S1 + 77 Close file, stream number in S1. + 78 Delete file, stream number in S1. + 79 Open INPUT and assign to stream number S1. + 80 Create OUTPUT and assign to stream number S1. + + Extended opcodes + + Compression of the compiler output is achieved by defining the opcodes + below. They combine one of the opcodes in the table above with its argument. + + 0xxxxxxx (0-127) Existing opcodes. + 10xxxxxx (128-191) Set xxxxxx+1 on the stack (range 1-64). + 1100xxxx (192-207) Fetch local variable xxxx (range 0-15). + 1101xxxx (208-223) Fetch global variable. + 1110xxxx (224-239) Store local variable. + 1111xxxx (240-255) Store global variable. + + A similar extension has been made to the compiler opcodes: + + 00xxxxxx (0-63) Existing opcodes. + 01xxxxxx (64-127) Set integer contant range 1-64. + 1000xxxx (128-143) Fetch local variable 0-15. + 1001xxxx (144-159) Store local variable 0-15. + 101xxxxx (160-191) Store global variable 0-31. + 11xxxxxx (192-255) Fetch global variable 0-63. + + 2.85 Summary of ioc() procedure calls + + Utility calls ioc(n), the range of numbers n is in the left hand column. + + 0-5 input/output selection + + 6-12 rwrite format control + + 13-15 output file options + + 16-17 interrupt option on disk i/o + + 18-19 read options + + 20-21 file extension options + + 22 reboot CF/M on completion + + 49 More flexible formatted number output + + 60 rerun program from start + + Others are linked to procedures in ALIB.ALG + + 2.86 Summary of pre-declared procedures + + Utility pre-declared function + + ioc + + Standard functions + + abs, arctan, cos, entier, exp, ln, sign, sin, sqrt + + Input/Output + + chin, chout, read, rwrite, skip, text, write + + 2.87 Procedures in the library ALIB.ALG + + These must be compiled in with the program, or linked with the Algol object + file. Most of these procedures are implemented by an ioc() call within the + body of the procedure. A number preceding the name is the ioc procedure + parameter. Not all these are implemented in MSDOS Rogalgol. + + Input/output procedures + + findinput + findoutput + 26 rblock + 27 wblock + 28 rewind + 30 seti + 31 seto + 32 ipoint + 33 opoint + 34 exflt + 38 fcblock + 39 swlist + 47 bios + 48 cpmd + 58 rename + 59 newext + + Other library procedures + + 23 error + 24 location + 29 fspace + 35 blmove + 36 peek + 37 poke + 51 in + 52 out + dpb + rdisk + wdisk + 40 parity + 41 shl + 42 lsr + 43 asr + 44 rotl + 45 rotr + 46 random + 50 clarr + 55 sloc + 54 slen + 56 smatch + 53 atext + 25 emt (not implemented, RML hardware only) + 49 wait (not implemented, RML hardware only) + 62 chpos (not implemented, RML hardware only) + 61 point (not implemented, RML hardware only) + 63 line (not implemented, RML hardware only) + + 2.88 Distributed programs and files + + ALGOL.EXE and ARUN.EXE + + The Algol compiler and runtime system. + + ARUNL.EXE + + The runtime program which uses 32 bit integers in place of real + numbers. + + ALINK.EXE, ALINKL.EXE and ALINKS.EXE + + The floating point linker, the long integer linker, and a floating + point linker which accepts character format (directive -b) compiler output + files. + + ALIB.ALG + + The standard Algol library routines. + + UCASE.ALG and UCASE.ASC + + This program will convert Algol source files written using convention 1 + (all upper case with key words enclosed in quotes) into convention 2 + (upper/lower case). The program prompts for input and output file names. The + default file extension is 'ALG'. + + UCASE.ALG and UCASE.ASC + + This in the complement to LCASE.ALG just described. Files are converted + from convention 2 into convention 1. + + MMIND.ALC and MMIND.ASC + + Mastermind. Game 1 allows 6 colours and no blanks. Game 2 allows 6 + colours and blanks. + + VDU.ALC and VDU.ASC + + This program is designed as an editing aid for creating Algol source + files. The program prompts for an output file name, the default extension is + '.ALC'. If the upper case convention with key words enclosed within quotes + is required then give a [U] switch option with the file specification. Now + start typing in your program. The program detects language key words. As + soon as sufficient characters have been entered to uniquely define the key + word the program will supply the rest. Corrections can be made to the + current line being entered using the rubout key. Other special keys are. + + CONTROL-U Erase the current line. + CONTROL-R Retype the current line after cleanup. + CONTROL-X Switch off the auto keyword facility. A second call + will switch it on again. This allows strings etc. to be entered without + extra characters being added + CONTROL-Z End of program. Close file and return to the start. + CONTROL-C In response to the prompt for a file specification will + return control to CP/M. + + Other example programs may also be included. + +3 Rogalgol for the 80x86 + + 3.1 Overview of 80x86 Rogalgol + Overview of 80x86 Rogalgol + + As far as the Algol programmer is concerned, the CP/M-86 and MSDOS/PCDOS + Algol can be considered as virtually identical to the CP/M-Z80 version. + There is no difference in the language. The operation of the runtime program + has been made as compatible as possible. Programs not making system calls + using the library procedures CPMD and BIOS run without change and without + re-compilation, as will most others. + + The only difference likely to affect program running is that the RANDOM + library function always starts with the same value on 80x86 versions. Other + changes can be grouped under the headings extra feature, file handling + issues and the operating system interface. + + The compiler is called ALGOL, the floating time runtime and linker programs + are called ARUN and ALINK. The long integer versions are called ARUNL and + ALINKL. The .CMD (or .EXE) files try to claim a data segment of 64 KB. The + total memory used is around 76 KB if sufficient RAM for a 64k data segment + is available. + + Rogalgol 8088-8086 automatically makes use of more memory than 64K because + the compiler, linker and runtime programs are divided into a code segment + and a data segment. In ARUN, the data segment holds the compiled Algol code + and the variables. This allows all the library functions which use + addresses, (such as LOCATION, ATEXT etc.) to work exactly as on the Z80, + because only 16 address bits are needed. Since all disk transfers and indeed + BDOS and BIOS calls are data-segment relative, these also function in a way + very similar to CP/M-80. + + The pre-declared function OPSYSIDCODE can be used to find out which + operating system is being used. Alternate code can then be executed for + system-dependent parts of the program. + + 3.2 Extra features available on the 80x86 versions + + 3.3 Using extra data memory beyond 64K + Using extra data memory beyond 64K + + The normal data area is limited to 64K to allow all the library procedures + to work. Memory above this limit can be used to hold arrays by giving them + the EXTRA attribute. Compatibility with Z80 Algol is maintained as the EXTRA + attribute is ignored under CP/M-80. The library procedures which manipulate + addresses do not work on EXTRA arrays. A fast copy mechanism between the 64K + block and extra memory is provided. + + If the symbol EXTRA is placed after an array declaration it has the + following effect at runtime: The dope vector for the array stays in its + usual place, but the last word of it, instead of containing the address of + the byte beyond the end of the array, contains the paragraph (segment) + address of the start of the array in extra memory. It follows that extra + arrays always start on a 16 byte boundary and that there is no check for a + subscript being over the top of the declared bounds. Algol statements to + fetch and store the elements of extra arrays work exactly as for normal + arrays. However, LOCATION will return the wrong address and the library + procedures depending on it cannot work. A new call, ioc(66), has been + introduced to allow copying between normal and extra memory, analogous to + BLMOVE. + + ioc(66) must be called from within a procedure having four parameters as + follows: + + 1. An integer by value. This is zero to copy from the 64K area to extra + memory and non-zero to copy the other way. + + 2. An integer by value specifying the number of bytes to copy. + + 3. An integer by value which is the LOCATION of the start of the block in + normal memory. + + 4. A Boolean or real (as appropriate) by value to give the address in extra + memory. The actual value is not used. The runtime program keeps a record of + the last calculated address in extra memory and it is this address which is + important. An example: + + INTEGER ARRAY normal[1:10] ; + INTEGER ARRAY EXTRA extra[1:10] ; + + PROCEDURE copymem(d,l,n,e); + VALUE d,l,n,e; INTEGER d,l,n; REAL e; ioc(66); + + {Copy from normal to extra memory} + copymem(0,20,location(normal[1]),extra[1]); + + ioc(67) returns the number of remaining free paragraphs (units of 16 bytes) + and it must be called from within an INTEGER PROCEDURE. The result of the + function is the free paragraph count. You should always make this call + because the amount of free memory varies with the number of programs loaded + and can be zero. + + 3.4 The Runtime Debugger + The Runtime Debugger + + A major new facility available on the 16-bit Algol versions is the + trace/debug module. Space considerations led to the decision not to add it + to the Z80 version. It is activated by appending the [D] switch to the + loader input file. The switch is not preserved across a chain. The filename + supplied to the chained program mechanism must have [D] appended to cause + the chained program to be run with debugging facilities. The switch [W] is + used to activate both debugging and force FCB file system calls. + + The format of the compiler listing file has been changed to include a + display of the program pointer at the end of each statement. Line numbers + appear at the left margin, as before, but are terminated by '>' to delimit + them more clearly from the program text (and identifier table if one is + begin produced). The program pointer appears as a decimal number enclosed by + '< >'. This is relative to the start of the program. It corresponds to the + last number of the identifier table. When modules are linked you will have + to add the starting location of each module, as given by the linker. The + addresses in the root module will be correct. + + After loading a program with the [D] switch, the debug module announces that + the stack area has been set up, and gives the limits of the loaded program + in HEX relative to the DS register. Next the first 100 bytes of the program + are listed. You can use this to check that the expected code has been + loaded, by comparing the numbers with the compiler output, which is legible + if the -B directive is used. + + The debugger works by stopping the program when a chosen address is reached, + allowing the user to examine the memory before execution is resumed. The + breakpoint 2 is set initially. This is the address of the first opcode, so + in effect the debugger is entered before any codes are executed. + + When a breakpoint is reached, two lines are output to the terminal. The + first shows the current program pointer, followed by the next few bytes of + the Algol program. The first byte is the opcode which is about to be + executed. The second line shows which procedure number is currently being + executed, and then gives a list of the available command letters. For + example: + + Algol PC, opcodes 2, 29 42 35 1 1 1 8 1 Procedure 0 G/T/R/D/V/M/B/S ? + + This is the initial breakpoint at location 2. The first opcode is 29, set + zero on the stack. Next comes 42, set 6 bit constant, so 35 will be set on + the stack. Next comes opcode 1, declare an array. The full meaning of the + opcodes and their parameters can be found at the end of the user manual. + Since the program is just starting the procedure number is 0, the main + program level. The possible commands will now be described. The letters may + be typed in upper or lower case. + + Command G. This means GO to the next breakpoint. The breakpoint is set by + typing a decimal number immediately after the G. Any non-digit will + terminate the number. If you make a mistake type DELETE (RUBOUT) before any + terminator, and then re-type the whole number. Using the example above, G5 + will cause the program to stop before declaring the array. If you type no + number or 0, the effect is that no breakpoint is set, because the first + executable opcode is at location 2. The program will run normally and never + re-enter the debugger. + + Command T. This means Trace. One opcode will be executed and the debugger + will be re-entered. Command R. Reset the variable stack pointer to the top + level. See next command D for an explanation. + + Command D. Descend one level down the variable stack. When the program is + interrupted, the variables available for examination are those belonging to + the currently executing procedure as indicated on the second line of the + display Command D causes the variables of the calling level to be made + available. The command has no effect if the current level is 0. Successive + commands D will eventually result in level 0 being available. Command R + resets the top level as the available one. It is not possible to go back up + one at a time because the stack does not hold the required information (it + is never needed to run the program). Commands G and T cause an automatic + command R. + + Command V. Examine a variable. Follow immediately with the decimal number of + the variable to be examined. The variable numbers may be obtained from the + identifier list output by the compiler. The variable will be printed both as + an integer and as a floating point number. If the variable does not conform + to the standard floating point format a row of asterisks is printed. If the + variable is an array it will point to the dope vector and elements which can + be examined using the M command to be described next. + + Command M. Examine memory as a series of words. Follow immediately by a + decimal address. The contents of 16 words will be displayed, starting at the + address given. Each is shown as an integer and a floating point number. Most + useful for looking at the contents of arrays. + + Command B. Examine memory as a series of bytes. Follow immediately by a + decimal address. Sixteen bytes will be printed first in decimal and then as + an ASCII string. + + Command S. Display the Algol stack. Each stack item is shown as an integer + and a floating point number. The top of the stack that is the last value set + is printed first. Only the items deposited by the current procedure will be + displayed. Using the example above, if the program is stopped at location 5 + the values 35 and 0 will be on the stack. + + If an error occurs which has not been trapped by the programmer, then DEBUG + is entered after the error message has been output. The Algol program + counter is reset to point at the opcode which caused the error. You can + examine the memory, but do not try to restart the program. The already + partly executed opcode will have altered the contents of memory. You can + determine from the location given in the error message how many bytes of + program after the opcode had been used as parameters. + + 3.5 File handling under PCDOS and MSDOS + + 3.6 Overview of MSDOS file handling + Overview of MSDOS file handling + + MSDOS and PCDOS have a file interface which has a high degree of + compatibility with CP/M and CP/M-86. Although there are differences in + detail, the Algol programmer has been isolated from them, so that with three + exceptions the system runs exactly as under CP/M. The exceptions will not + affect most programs. The compatibility between CP/M and PCDOS/MSDOS extends + as far as the device names in Algol command lines, (e.g. KBD: and VT:), + because these are interpreted as appropriate system calls. To access the + AXO: and AXI: devices, use the names RDR: and PUN:. Rogalgol makes no BIOS + calls, so results are identical under MSDOS and PCDOS. + + The known exceptions to CP/M-MSDOS compatibility are + + 1. CP/M supports sparsely populated random access files, whereas MSDOS does + not. This will only affect your programs if you write to random access files + with high record numbers, expecting the gaps below not to occupy physical + disc space. Under CP/M no physical space is required; under MSDOS it is. + + 2. MSDOS will not create duplicate files of the same name on the same + device. If you open a file for output, any previous file of that name is + deleted. CP/M creates another file of the same name. IOC calls 13, 14, and + 15 have no effect under PCDOS and MSDOS. + + 3. The CP/M system pads out the last record of a file with CONTROL-Z. MSDOS + pads with zeros, possibly after a single CONTROL-Z. Sequential files written + by Algol are padded with CONTROL-Z on both systems. Algol returns -1 at + physical end of file on both systems. + + 3.7 File Control Block usage + File Control Block usage + + Under MSDOS-PCDOS, the operating system version number is tested before any + file operations. If the version is 1, then the CP/M type system calls using + File Control Blocks are utilised. Under version 2 or later, the newer + Pathname XENIX compatible calls are used by default. System calls in the + range 0FH to 24H are converted to calls in the range 3AH to 42H and 56H. + This applies only to calls made by the interpreter out of programmer + control. Direct calls using the CPMD function are not intercepted, except + that function 0 (exit program) is converted to 4CH. + + This change is transparent to the Algol programmer and has been made because + Microsoft suggests that the old calls should not be used. Compatibility + across all versions is maintained because the Algol still uses an FCB, with + slightly altered contents. For MSDOS-PCDOS versions 2 up, the filename at + the start of the FCB is used to create a pathname in a dedicated area of + memory. The FCB of an open file contains the handle at offset 18H. For + random access operations, the record number at offset 21H is used to + calculate the required byte offset into the file. The price of compatibility + is that you cannot used full pathnames with the INPUT and OUTPUT + pre-declared file opening mechanism. You must use the CPMD function to use + full pathnames. + + For testing purposes, it is possible to force the interpreter to use the FCB + calls. The switch [V] is added to the loader input file to achieve this, but + the loader itself will always use the new XENIX calls. Note that the switch + setting is not preserved across a chain, which starts the interpreter right + from the beginning, including all installation. The Algol program can + propagate the switch, if required. The 'V' switch is useful for checking + that file handling problems really were due to using the FCB system calls. + + 3.8 The operating system interface + + 3.9 Overview of BIOS and SYSTEM calls + Overview of BIOS and SYSTEM calls + + BIOS calls are made using the library function BIOS or lOC(47) within an + Integer Procedure. There is a high degree of compatibility between CP/M and + CP/M-86. The BIOS mechanism is quite different under MSDOS and CP/M; they + are therefore TOTALLY INCOMPATIBLE, BIOS calls copied from CP/M will not + work at all under MSDOS. + + BIOS calls under CP/M-86 + + Functions less than 21 (decimal) are converted to the BDOS function 50 in a + way transparent to the programmer. The results are exactly the same as using + the BIOS library routine under CP/M-80. + + Under CP/M-86, BI0S functions higher than 20 are interpreted as a request to + make an interrupt. The mechanism is exactly like the MSDOS interrupt request + calls described in the next topic, except that there is no special action + for interrupts 37 and 38 (25H and 26H). Under CP/M-80 BIOS functions higher + than 20 produce unpredictable results, + + BDOS (system) calls under CP/M86 + + The BDOS functions which return an address in BX (27 1BH) and 31 (1FH)) are + intercepted by the IOC(48) routine called by the library function CPMD. + Special treatment is required because the addresses of ALLOC and DPB have a + different segment base to the Algol variable area. To overcome this problem, + the second parameter of the procedure in which IOC(48) is called is used to + pass an address to which the DPB or ALLOC vector is copied. If the second + parameter is zero the information is not copied and no meaningful results + are returned. It is the programmer's responsibility to ensure that a valid + address (an array or the common area) is used and that the array (or the 256 + byte common area) is big enough. The DPB is fixed in size and should be + examined first to calculate the array size required for ALLOC. The problem + does not arise with the DMA transfer address as its segment base is the same + as that of the Algol variables. + + Calls to BDOS (system calls in MSDOS terminology) using the CPMD library + routine or IOC(48) are in many case compatible across all the operating + systems. BDOS and BIOS calls under MSDOS are described the next topics. + + 3.10 BDOS (system) calls under MSDOS/PCDOS + BDOS (system) calls under MSDOS/PCDOS + + There are three groups of system calls to be considered: + + (a) Those with function number 36 or less are CP/M compatible, although some + (such as 27 and 31) are meaningless under MSDOS/PCDOS. Care is required + because of slight differences from CP/M. + + (b) Those with higher numbers are specific to MSDOS and will not occur in + programs written for CP/M. A new calling mechanism using a register array + has been provided. Calls less than 56 (38H) return their result in AL and + this register is returned as the result of CPMD, as for group (a). + + (c) System functions 38H (56D) and higher numbers use the carry flag to + indicate success or failure. Instead of returning AL, the CPMD function + returns the status register. The value of AL can still be found in the + register array. + + Further details on how to use these three groups follow. + + (a) CP/M compatible system calls. + + A careful study should be made of the MSDOS Operating System Programmers + Reference Manual, as the slight differences between the systems (mainly with + regard to return codes) may affect the running of the program. Some + differences do not matter, for example the SEARCH FIRST and SEARCH NEXT + functions return 0, 1, 2 or 3 for success under CP/M but always 0 under + MSDOS. + + None of the CP/M compatible calls returns information except in the register + AL; this is returned to the Algol program as the value of the function CPMD, + as under CP/M-8O. + + (b) MSDOS functions higher than 36 (24H) must use a new calling sequence. + + The first parameter of CPMD is the function code as for CP/M compatible + calls. You must provide as the second parameter of the procedure calling + IOC(48) the address of a block of 4 words (a 4 element integer of 8 element + byte array is most convenient). The registers are set up from this block + before the function is called, and their values on return are placed there. + The function code to be in AH is however obtained from the first parameter + and not the register array. The lowest address contains AX, followed by BX, + CX and DX in that order. The least significant byte is at the lower address + if you use a byte array. A few functions (get time, get date, get free space + on disc) do not require any registers to be set up on entry. + + (c) MSDOS function calls higher than 55 (37H) + + The success/error status of these functions is returned in the carry + register, not AL. To allow them to be used with the CPMD direct system + function call, the return value is the flag register. A register array is + used in the way just described under group (b) and the returned value of AL + can be found there. The carry is the least significant bit of the flag + register, so doing MASK 1 will result in zero for success or 1 for an error. + + This mechanism allows nearly all the system functions to be called from + Algol. The exceptions are those which require values to be set in SI or DI + or ES. This group includes 56H, rename. However, the Algol library function + RENAME can be used. By using CPMD for file access instead of the built in + mechanism, full pathnames may be utilised for all function except RENAME. + + 3.11 BIOS calls under MSDOS/PCDOS + BIOS calls under MSDOS/PCDOS + + Under MSDOS/PCDOS the Algol BIOS call generates an interrupt. The two + parameters of the BIOS library routine are (1) the interrupt number and (2) + the address of an array containing the desired contents of the registers on + entry. This latter is set up in the same way as described above under 'MSDOS + functions higher than 36'. However, unlike the BDOS call, register AH is set + up from the register array. On return, the register array is updated to + reflect the new contents of the registers. The result of the function is the + hardware flag register on return from the interrupt, as for system function + calls higher than 37H. + + Under MSDOS/PCDOS, but not CP/M-86, the stack is balanced by POPing the + flags after interrupts 37 and 38, absolute sector disc read and write. This + is as described in the MSDOS Programmer's Reference Manual. These interrupts + return the success code in the C flag, which is why the value of BIOS + function is the flag register and not AX. + + 3.12 Compiling and linking the 80x86 Rogalgol executables + + The runtime interpreters and the linker are constructed by including source + modules with the extension .INC. These files are identical for CP/M-86 and + MSDOS, except for two short ones which have different names under the two + operating systems. The subset compiler has been changed so that it can + generate code for both 16 bit systems and CP/M-80. You are asked to type a + number on the terminal indicating the target system. + + 1. CP/M-86 + + This system has no object module linker, so the necessary include files all + appear in the same assembly. + + 1a. Subset and full compiler + + Assemble CRUN.A86. Run ICOM to generate ICOM86.A86 from ICOM.IAG. The origin + is 1772. Assemble the resulting file to get ICOM86.M86. Then concatenate + using PIP: + + PIP ICOM.M86=CRUN.M86[I],ICOM86.H86[H] + + Then generate the command file by + + GENCMD lCOM DATA[XFFF] + + The procedure for the full compiler is exactly the same, except that you use + ALGOL instead of lCOM and you must leave off the [H] switch. PIP runs out of + memory and reports a non-existent error. The [I] switch on CRUN.H86 is + vital. + + CP/M-86 Runtime and linker programs + + Assembly is straightforward: + + ASM86 ARUN $Ax Hx Px Zx (x is your choice of device) + + In generating the runtime program you can choose how much memory is to be + allowed for the compiled algol + data area. The following line is + appropriate if you do not require EXTRA arrays: + + GENCMD ARUN DATA[XFFF] + + To allow as much memory as possible use XFFFF instead of XFFF. The hex + number following X is the maximum number of paragraphs required. + + The procedure for ARUNL is Identical. The two linkers are generated in a + similar way, but there is no point in giving them more than FFF paragraphs: + + 2. MS-DOS + + The assembler cannot take long source files, but a linker is provided. The + system is therefore put together by linking object modules. The source files + for the modules use the same include files as the CP/M version. + + 2a. The subset compiler + + This is CRUN+AIOPAK+ICOM. The first two are obtained by using MASM on the + source files of the same name. ICOM.OBJ is obtained by assembling ICOM.ASM, + which is in turn the output of ICO.EXE compiling ICOM.IAG. The origin to + give for MS-DOS is 1772. Note that you cannot use the same version of + ICOM.ASM as under CP/M86 because the source code conventions are different. + + 2b. The full compiler. + + The procedure should in theory be the same as for the subset compiler. + However, MASM may not assemble ALGOL.ASM because it's too big. If so it must + be pre-processd by the program LABELS. This removes all symbolic labels, + reducing the subset compiler output to a list of pure decimal numbers. Call + it like this: + + LABELS ALGOLX.ASM=ALGOL.ASM + + It will ask OUT-IN? like other Algol programs, If it can't open the files + (or if you called it without giving any). + + Either ALGOL.ASM itself or the output of LABELS can be assembled by MASM. + Then link it with CRUN+AIOPAK. + + CRUN+AIOPAK+ALGOL(X) + + 2c.The MS-DOS runtime programs and linkers. + + These are linked using object modules as follows: + + All object modules are obtained by assembling the source file of the same + name. + + ARUN+AFPP+AIOC+AFINT+AIOPAK for the floating point interpreter. + + ARUN+ALIAP+AIOC+AFINT+AIOPAK for the long integer interpreter. + + ARUN+AIOC+AFINT+AIOPAK for the floating point linker. + + ARUN+ALIAP+AFINT+AIOPAK for the long integer linker. + + The MSDOS linker automatically generates a .EXE file which, when loaded, + claims all available memory. diff --git a/RHA (Minisystems) ALGOL v55/ALIB.ALG b/RHA (Minisystems) ALGOL v55/ALIB.ALG new file mode 100644 index 0000000..bfe7559 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/ALIB.ALG @@ -0,0 +1,47 @@ +'PROCEDURE' ERROR 'EXT' ; + +'INTEGER' 'PROCEDURE' LOCATION 'EXT'; + +'INTEGER' 'PROCEDURE' RBLOCK 'EXT'; + +'INTEGER' 'PROCEDURE' WBLOCK 'EXT'; + +'INTEGER' 'PROCEDURE' FSPACE 'EXT'; + +'PROCEDURE' SETI 'EXT'; + +'PROCEDURE' SETO 'EXT'; + +'INTEGER' 'PROCEDURE' IPOINT 'EXT'; + +'INTEGER' 'PROCEDURE' OPOINT 'EXT'; + +'INTEGER' 'PROCEDURE' EXFLT 'EXT'; + +'PROCEDURE' BLMOVE 'EXT'; + +'INTEGER' 'PROCEDURE' SWLIST 'EXT'; + +'INTEGER' 'PROCEDURE' FINDINPUT 'EXT'; + +'INTEGER' 'PROCEDURE' FINDOUTPUT 'EXT'; + +'PROCEDURE' GETLIST 'EXT'; + +'PROCEDURE' OUT 'EXT'; + +'PROCEDURE' ATEXT 'EXT'; + +'INTEGER' 'PROCEDURE' TLEN 'EXT'; + +'INTEGER' 'PROCEDURE' SLOC 'EXT'; + +'INTEGER' 'PROCEDURE' SMATCH 'EXT'; + +'PROCEDURE' POINT 'EXT'; + +'PROCEDURE' CHPOS 'EXT'; + +'PROCEDURE' LINE 'EXT'; + + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/ALIB.ASC b/RHA (Minisystems) ALGOL v55/ALIB.ASC new file mode 100644 index 0000000000000000000000000000000000000000..14efd09e552ed2f00a5190ba49236b4ca320280b GIT binary patch literal 896 zcmaiyO>EOh6vt=mN$VP`a?`ZxLRq;@+Hu6k#;8K+(gi!I(^$B+X$+KGfF9V(iUkfm zcqPX~D~hUaC5nVr93no{N)*&XSZSq#^1)a65EX$V2tkp61Il3!dqQ{`I5UTl=J)^4 zd-L9#1e~>8%1K(IxMe^F6eEJ$E5EPUueLwK^Hq*6`qeB?y^SKlARq#}j5^B?KwRy!Kft?*$#rGBv}-+JHg< zhuk)h7jn!7-Dl@0;1YTOd7X|rp3-f6=v0~V%alb@rW!j_o=@nb<^dHSo`W<^-hFAh zkWIxG%J(w|buDA#UyBM2E|4(4A+Os>X~wW-So>}K`|}(PdHJyrL2IxlJS4RWe$ecQ z_<#96ahdyVV*3MCzS%;a5SAM@AuWpDk9|kdQ_hHLuP2%spb+F&%ZxjnWu&35XOQ}{ z+cKovSF&&<^0(X5JV)o1{!mR}J10wRXZt`}V$flM?K&a<8}aY4Gx^g|$4`r|UP&M_ z%&lQ@A;{gRM-^KgxAFBm9>HK+SbPxV{;5m0t{V8}S_MJIdgM>?eUQCfmook!@hwCL zAfF|aX=m^GbX2jEX?!=543N;<{8|foEMA>&boA-sbmZuBCXnednpG;e32EUl7 z62JUYSUlFwy{bob%~0{nJlzyn|0PV8lR7S()TNG#N4X7~#3c&0byq7*?4s zVD}>G{A_G><`&?+@X&-+lUIT-7 zhidZR!x&KLkCDg(&sTMNEmYI#cWjPFcJDAe&*bF32vmJG7zOqK IuYY 'THEN' + 'BEGIN' M:=XX; R:=XX%2; S:=YY; + SX:=SXX; SY:=0; + 'END' 'ELSE' + 'BEGIN' M:=YY; R:=YY%2; S:=XX; + SX:=0; SY:=SYY; + 'END' ; + POINT(XC,YC,Z); + 'FOR' I:=1 'STEP' 1 'UNTIL' M 'DO' + 'BEGIN' R:=R-S; + 'IF' R<0 'THEN' + 'BEGIN' XC:=XC+SXX; + YC:=YC+SYY; + R:=R+M + 'END' 'ELSE' + 'BEGIN' XC:=XC+SX; + YC:=YC+SY + 'END' ; + POINT(XC,YC,Z) + 'END' +'END' ; +'END''FINISH' + + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/ALIBL.ALG b/RHA (Minisystems) ALGOL v55/ALIBL.ALG new file mode 100644 index 0000000..5d22747 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/ALIBL.ALG @@ -0,0 +1,10 @@ + +'PROCEDURE' POW10(N); +'VALUE' N; 'INTEGER' N; +IOC(46); + +'REAL' 'PROCEDURE' LREM(T,B); +'VALUE' T,B; 'REAL' T,B; +IOC(63); + + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/ALINK.EXE b/RHA (Minisystems) ALGOL v55/ALINK.EXE new file mode 100644 index 0000000000000000000000000000000000000000..307e8b5fb675fc347011d4c091b339b3f8891b8f GIT binary patch literal 15488 zcmeHtYgiOlw&>nf{lJ!2P(VSO!XYN{(Q!y_Oqe!NI;|l@1zHWzpUGgv#2FORRAnT& zGxQ{$*i>aa+?gbkhs>a!bK`u;+-YWD5+RcTO3*woAh{9IJbWdqtvEgsyX9f`UAr2T zc)mOL{yBfn2mN(d?Y-Atd+oK?d$YWB3CSQF5eOlX$U-iKB!%%+Z~v8BOn%G}@;ZJe z{{CxnAW*^w*6@K}^MM010`KvGTQdWTGRJSVz_u%$6xeF5>BMc@HIu!@&m<+bT^Z~( zC4-a}t1g>jO(ibdo>a2awre^ms4uqdnNEt`s(edNTlCZ07XA2cQJWs>&XiABPK!aC z_ugber6li2f@E>Eng~DOy`{$8ovC_9;(u|)J9694zx9r!Nv7JA`=|!qk?GS?YAm~BM8PF+eu>-j!6Gja+ZGWb8T}OJ7rGSdeU$GPTD_01lK;Pt_ ziTtxndF3p*@&{LXkM=TF_(@Z)zT;wb4es&Mb6ttbfHtX4Z?w*(a_my?AQ3Iz_Qk#g zN0&Lr(Hz72PSkh@1(Cu}YVMs@sHz#Pvvck@(8eiuZ;CCs-liRjV!WCak33qFkEaz|m?0;TwwboLICoq}hj}r4t zM1?g&SqXNFhchrbA4ySB#Wq%y3mdD1&6T3CZlhQwddkZ-2^%Uso61CFZk*-eB}FUp zRxA_d&lk3MDj)aY=o4jCg0$IFUR7D~RQYSJc64xhJqizEsg5N(x^!z62^ zBx28^je38@#wsz|y{w{gU0H>&xolIpAeODGD9_QSuf7p4>&DgAmv7j(85gUn-n6c= zqDqHdQNC3aDk{s?3uWuqBRN%UIhR=G5rxVPNER-|Mse1r%Jou3IZkqvZDu>I+)}<- zc&u{Mrn1fJby{&qvCiXat=afpfL|M@Sd&rfUc~R~T*E6Io)@n@P?z1d`xUOiOR{S8 zj)isd!DiCxB@VxkW3J-StUAK)OW$eMx|Thh@(<;be2Xt@spI4oA2dfT8L+`kuq86bv6gD|l#%eU20ZS;?uU!10hhSL8GeR#SM4DF`3MVz0BImB33JICv!eJVNiFS_3qou|*2Lg5O48cEC$StHp2t^7%k~1h%8w;RD79 zh79^~*KjbG4_pqzW};n!-w`AVZs*}10?Tj_#Qc63m$d2|e=iK#(at8;$p`)zhJ{3n zse?IDWM(dKZv@Jce2B!2zo9PYU(A}#G1^54M$j!>jL271SqjOk zgR=8-&*wb@Y$dcIXp%1aoR@v8gFY#wLR^x3!Ou`#w#T5skpY?g+D%MbloWRA=>s^+ zJt(h@pa}o#G&UfoI^>1<{D7R`kZ)H|pY#qk!Vh40;k!Mb9f<{}ZtwG@I(!Qui*I<1 zvoA$V3k~of56>8M4%FzIV?!&%3^+0bpC!F#g8rmF)7ZH(B=Fu46b?m?Z-Fk0Oo!pl zq^*1)=PLXm=?N3;;B?g!;~+H&(%6V_RXYv8O1j%5&%TZG&E8Mt*>mvOiO;$C?4sV~ zR};sO!ulK6d=QBl)QJ`i_GL);FZeF!2!+znPI>n1QG~aQBD^(9)zdepIP!(*D| zOZ3lyu0(V%?d<1WTyKnf+xr|2OWTwImvR=PC)kyk>vrkPKJP|Wqf-hj8Xj*vl2di# zq4LMj528vk*jnog`XMnURq^oGkb)ihS=6TNK<9Kg0$w5|Dexn0#LTP}i0Eh?4RG)gf?nvYd+3vW_ z=GU1&$FI&Pv`{SSX3YhR4+D}BUW^A5{2W7VH1tB4!RP0LKLV42T36KG7-38N8>Z&b zIN|&F#Cck!Vtn{B0>Ps3>GC>a;2G86>+s z%Ud9~qq}-a?&P|jOZ9C^N;;9h^q#JfyW~rMCYbrB6Wg8) z5;{>-ptRdUv(rftmI|=rR0-c+GNpH?yM*s8uA+-w_4pIqFG%Lzlf6A9d4=pDe=c8< zKPi?k6kB@KVn!4pD%#qArEt%;qr`bn)_k8nw4F1)l{dPU-7-5}qpi!p@ zD-_sw$@^7}d_+FwC%tET``OnPx(kaIy=RMba(mB~%$l!);}OG@o?wT!I)MSR(eVB!&4F$DIo<4yOzu%_AyWoH zgPo{zN3Y!|M+=mWQrlddo!+yv+8jC@IwsLvHeLP>?j^Vru3oLL9`SzQMX^9IonW;X zUZV2Hs=GM5t-z&Sx}yz~DbWx*=Jyu-nfx^s!v%JNNRAjAM$v(1F7_Z*YIAC^V=>zJ z@F6^@j^0x}hgtrjy@O{uCVO{!+Dijv(XuAR34y%xEMojeR)C;%X~1IU5`13uDG z@FD)HUaQhsp@*w*X9OM$LoW$CIoXM&9FY$%=OJ$rqKikgR$Sx`O#W`y8b^nr;Q~Tv z$HU7F+7UQ-QFfw^N;3|ae3Xy_CYdg#T1Fl2B09jsmJ89DmT;SBl6(Fd;Ro=j`41%% zJV3MsbxiV(-aw~|X%@-}E4RTcQjfX7g%RegmX8FT1}~~C{5`C~Zo)h-)0t?nEi<#l zTsXR9orx*f!<@SAzJr}!32S#5WOAEi9-TM&eer&9V*#o*?z&{chmqd-RX1HHq0|kZ z45LLiPHq#E;Pr@3mp%;d4r@JVS0Rk~_~-E5)7R1M6$prp8|62F%E z7jo@f8`mlKqn&BvI?x1k;IqBT{G3XwxNuvobuG=RK~|AkoC15VDz=;HbDgoZYlzcX z`v_6@desuN=Htki6$!k1zNEO+T~G*b@Ye^B^0Z+nGz5NkzW94Hlpf_MEFEDsCh+X} zQr*_@fvxA6I0l|P@0*Wh6RuM-G@G<`Z^P7AOzRQW_2ib@;A}0w)UL~guX}zdR z*Vzf{24TaX_AY|97E+}zci-e|3G9meXrin_##NY2eQS+SHN4A5nJL{R<0FH>lSAWh zr3^yapnPp-HhpKoe#~v->u}HT%0FNYfo()(Y{q@l@Il!256C6pBHGu;A_{jASWo;; zSjpIeW(q4i__Eh4a>0JNKf4XZ7aA?#KPPu!(d0Ixtm0#q5zm45iYEVjNHMAn_ak4W z%c{J|=wARvBNlQ{hq0oArDYpjHX!f5M&>h1g2D6y6ypO#@|oc}+&P5nHel7M!z&qJ zE>Te&A&dDL1J^E2cW5bfaz_E{Od!E_uSgv%h1cs-(ZdMXhwO=4c{ri@Q|ENapo_D7 zkeTV8qf=QD_nm4v+!~4Caqe`~BOMNG;{#>&j~e`GINa3}_L#gUzd$?W{Xjt8@UVM$ z9Iu}qhWsnz+Ev4F{z~`|+vTS!Y#tB#dO;VT}DbN zJQ9Mt#?NaUhF@QSdBYGtzW4QEcz*oCLqpIJf)^sKRu2A!8%I(95X6Sy^pL!kzDp*|>%#coT>^_}h1kDS_?7_L$-7X{_QJxF9e^5bwmp*bVN=A%o~Cq2jT9a z)(j5XD87uFl{f@1h2X=pkT||~Xb_~(IH)(zLMx`~l-*8Y5rO4nQr}1@_xJ)0laXcUuqg>{Fl%ArFDCm9sX?UvqO*43dt0 z%_`Y8CAC;RV0xJ*VC3=&O(H5&3LcphR2NIJN=hn)_ae0^FXKKtFi|>)VObe%c_~xV zZUCH4;Uxro1p!|j1$>mY6eA!ey=6G^20oYI-i_$yi#wG5y)z*JX~wWEd0RdrsL|z3sQB z?1|DPRY}2Hln>c`kDhR1G)dK5`y%l+tgo`LDSDfNzM5UAutfhFgjt8c)OYlng<-Hi$Cnn{W)g1d}s?GZ7yYpK9O$=Jort*+%D#~8gf(yuh#>?#M7 z$N)RpCA#-0g!@mHXy=p^c17f&a|e(bteUa<$4~HvC=Iu|1-br2^j>MK6PhBKR(L)P zN5U%XjZCw`(_xqy!3%)A6$PtTEn;TusephXd~6 zl@FOgQsVQhS}c3!ThagQdz=1+*FJt{Kb`*?l>tk>`jN4qBk*g2DMGq^9v=Pk#GWH& zVkp1R?iQDUiIsuEow@$FoKESGW~@_EeAFLSTi?L_AoIR+=#O)L9bs@&E$WZaPP-aO>)SLcjQWC;X|BE+Pwi{PL@ew2%>Kza?c!&SaJ$y;4m=jgt;L0W zMply$Qybo3@*CslTbn3GfBqQ63qI1Ymv!euJHgsed1UvSbnjwuHi}ilTR4E5DU38U zF%WZ8;3je;56GP2p`CbXeXn+Mrb2ir))$LIsXD3++K!}nEe?K zRp$w6>uYHD8DF}kL3~$pIz2y<59*}eQ6vXiUK?XAhAM)VTxXvnrr8Bgiao~@V_)Kl zx4Ww>K65Uc|7odO>c&blrnt0qFU7<~Ox4dNcdu6rj&V#njkUR*(N?{xkK=9VUau6B z(}~iQt9^q-Ble~r1`;Z$?4I^bG^zV(OB2OQW;0gMbo1cI#bqz3c)ubi;C(bIax-zD zNw{kZ9lKZQGNdV&*=^cQYPj7WVM$aP3Ac}ZisT-6kCv(pYpA*#zpmCb6!jgolekrT ztQf)~wjrE=?~|lh*=&f(x`M|$3EP6_^RU^iHWGLzf-}r$q%6cAXXlahz^pH@zczxp zagfTl2Rj8c1&^N$cH$)tJbKb0Cxp!oC3SmWVKd>6`phNac8t}w_px#yR1zp9@GF+o zMJF>mGG}!1EPZmjF999(l)6UZOMv?b%p|+nRVTFDGcBS^2*+D?#pQjE8!nqCo~D zLDQ#cjcM=#%fWD;Xy)*o`r+S+Y?cAfkgDuT8{UdI8WZ8@myJ{4lP^^Vcp@&`nWN<` zioraVvu?Qe%5G~;jur#)ID@6CenB4YbaXkffNRE;;xL$aPGw>81rSbTJ5e{JZ!olp z^`hjeYaVvN%U{-7AExd{A7MF6RstStArgK%Qc?)-5HoPeblpIRQ=7cLa^9bYg+RHS4}XLW>7ssE z=G`BlInr71hcIKor(d9ivnnUs*!Mj8c<(;({{O`Re@a98-_mCperfoa)?u~fpZ&## z*?&U(GoZ*!{tx^fZVwlIrt|*{U34sgB>lgEu0bquIku#5WDEYaZ|Qha_3W=&@zDau z%0qV+-G4Z_VD+J!A98&%d)50lt@$K#)vBY}5B2eEgrd!UXCG4oq-h uf&&vAnBc$!2PQZ$!GQ@5OmJX=0}~vW;J^e2CO9y`fe8*waNxfh2mTN8B!@Qu literal 0 HcmV?d00001 diff --git a/RHA (Minisystems) ALGOL v55/ALINKL.EXE b/RHA (Minisystems) ALGOL v55/ALINKL.EXE new file mode 100644 index 0000000000000000000000000000000000000000..f813b089430997621a2ce2820da3aabdc2a6897e GIT binary patch literal 14080 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
`g*xA* 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 I-;4wQ30=!KMgRZ+ literal 0 HcmV?d00001 diff --git a/RHA (Minisystems) ALGOL v55/ARUN.EXE b/RHA (Minisystems) ALGOL v55/ARUN.EXE new file mode 100644 index 0000000000000000000000000000000000000000..83926207ad0f7ee043e3c797d38b4a0d2df1078e GIT binary patch literal 15744 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 0 DO BEGIN + a[ n ] := 1; + n := n - 1; + END; + + a[ 1 ] := 2; + a[ 0 ] := 0; + + WHILE high > 9 DO BEGIN + n := high; + high := high - 1; + WHILE 0 # n DO BEGIN + a[ n ] := x MOD n; + x := 10 * a[ n - 1 ] + x % n; + n := n - 1; + END; + write( 1, x ); + END; + + text( 1, "*Ndone*N" ); + ioc(22); +END; + +main; + +END +FINISH + diff --git a/RHA (Minisystems) ALGOL v55/HELLO.ALG b/RHA (Minisystems) ALGOL v55/HELLO.ALG new file mode 100644 index 0000000..678cf4a --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/HELLO.ALG @@ -0,0 +1,26 @@ +BEGIN + +INTEGER ARRAY board[0:8]; + +PROCEDURE winner; +BEGIN + INTEGER t, p; + text( 1, "hello from winner" ); + + p := 0; + t := board[ 0 ]; + IF 0 # t THEN BEGIN + IF ( ( ( t = board[1] ) AND ( t = board[2] ) ) OR + ( ( t = board[3] ) AND ( t = board[6] ) ) ) THEN + p := t; + END; + +END winner; + + text( 1, "hello from algol, dave" ); + winner; + ioc(22); + +END +FINISH + diff --git a/RHA (Minisystems) ALGOL v55/ICOM.EXE b/RHA (Minisystems) ALGOL v55/ICOM.EXE new file mode 100644 index 0000000000000000000000000000000000000000..6d4087615dc0a7f54f0c3e95403a8880b8277846 GIT binary patch literal 12969 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 + BS:=CHAR; 'END''ELSE' + 'IF' CHAR<65 'THEN''BEGIN' BS:=CHAR; + 'IF' BS=58 'THEN''BEGIN' + INCH; 'IF' CHAR=61 'THEN' BS:=33 + 'ELSE' HOL1:='TRUE'; + 'END''ELSE''IF' BS=60 'THEN''BEGIN' + INCH; 'IF' CHAR=61 'THEN' BS:=63 + 'ELSE' HOL1:='TRUE'; + 'END''ELSE''IF' BS=62 'THEN''BEGIN' + INCH; 'IF' CHAR=61 'THEN' BS:=38 + 'ELSE' HOL1:='TRUE'; + 'END'; + LETTER:='FALSE'; DIGIT:='FALSE'; DOLL:='FALSE'; + 'END' BS<65 + 'ELSE''BEGIN' BS:=CHAR-64; + LETTER:=BS<27; DIGIT:='FALSE'; DOLL:='FALSE'; + 'END' CHAR>=65; +'END' ABS; + +'BOOLEAN''PROCEDURE' TERM; +TERM:=BS=214 'OR' BS=59 'OR' BS=212 'OR' BS=36; + +'PROCEDURE' SEMI(FNO); 'VALUE' FNO; 'INTEGER' FNO; +'BEGIN' CHFAIL(59,FNO); COMMENT 'END'; + +'PROCEDURE' COMMENT; +L: 'IF' BS=135 'THEN' + 'BEGIN' CL: INCH; 'IF' CHAR#59 'THEN''GOTO' CL 'ELSE' + 'BEGIN' ABS; 'GOTO' L + 'END' + 'END' CHECK FOR COMMENT; + +'BOOLEAN''PROCEDURE' BTYPE; +BTYPE:=TYPE=3 'OR' TYPE=7 'OR' TYPE=13; + +'PROCEDURE' DEFINE(L1,L2); 'VALUE' L1,L2; 'INTEGER' L1,L2; +'BEGIN' SKIP(); WRITE(,"L",L1); + 'IF' DOS=2 'THEN' WRITE(," EQU ") 'ELSE' WRITE(,"="); + WRITE(,"L",L2); SKIP(); + ITEM:=0; +'END'; + +'INTEGER''PROCEDURE' LOWER(X); 'VALUE' X; 'INTEGER' X; +LOWER:=X-X%256*256; + +'PROCEDURE' IDENT; +'BEGIN''INTEGER' I,J; +IDN[0]:='IF' BS<27 'THEN' BS+64 'ELSE' BS+21; +I:=1; +NCH: INCH; +'IF' CHAR>64 'AND' CHAR<91 'THEN' + 'BEGIN' + IDN[I]:=CHAR; I:=I+1; 'GOTO' NCH; + 'END' +'ELSE''IF' CHAR>47 'AND' CHAR<58 'THEN' + 'BEGIN' + IDN[I]:=CHAR; I:=I+1; 'GOTO' NCH; + 'END' +'ELSE''IF' CHAR<33 'THEN''GOTO' NCH; +IDN[I]:=0; HOL1:='TRUE'; ABS; FOUND:='FALSE'; +'FOR' DECL:=NODEC 'STEP' -1 'UNTIL' 1 'DO' + 'BEGIN' J:=ILNP[DECL]; + 'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN''IF' IL[J+I] # IDN[I] 'THEN''GOTO' ID5; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' FOUND:='TRUE'; + TYPE:=ILVT[DECL]; ADDR:=VADR[DECL]; + 'GOTO' ESRC; + 'END' IDENTIFIER FOUND; + 'END' LOOK AT ONE CHARACTER; +ID5: 'END' LOOK AT ONE IDENTIFIER; +ESRC: +'END' SEARCH DECLARATION LIST; + +'PROCEDURE' CODE(X); 'VALUE' X; 'INTEGER' X; +'BEGIN' 'IF' ITEM=0 'THEN' + 'BEGIN' SKIP(); + 'IF' DOS>1 'THEN' WRITE(," DB "); + 'END' + 'ELSE' WRITE(,","); + WRITE(,X); ITEM:=ITEM+1; + 'IF' ITEM>8 'THEN' ITEM:=0; + SIZE:=SIZE+1; +'END' CODE OUTPUT; + +'PROCEDURE' SIXBIT(CONST); 'VALUE' CONST; 'INTEGER' CONST; +'IF' CONST=0 'THEN' CODE(29) +'ELSE''IF' CONST>64 'THEN' + 'BEGIN' CODE(42); CODE(CONST) 'END' +'ELSE' CODE(63+CONST); + +'PROCEDURE' LDEC(LNO); 'VALUE' LNO; 'INTEGER' LNO; +'BEGIN' SKIP(); WRITE(,"L",LNO); +'IF' DOS=3 'THEN' + 'BEGIN' WRITE(,"="); CHOUT(,36) 'END' + 'ELSE' WRITE(,":"); + ITEM:=0; +'END'; + +'PROCEDURE' LABEL(LNO); 'VALUE' LNO; 'INTEGER' LNO; +'BEGIN' SKIP(); +'IF' DOS>1 'THEN' WRITE(," DW OFFSET L") + 'ELSE' WRITE(,"#L"); +WRITE(,LNO); SIZE:=SIZE+2; ITEM:=0; +'END'; + +'INTEGER''PROCEDURE' JMPNEW; +'BEGIN' JMP(NLAB); +JMPNEW:=NLAB; NLAB:=NLAB+1 'END'; + +'PROCEDURE' JMP(LNO); 'VALUE' LNO; 'INTEGER' LNO; +'BEGIN' CODE(9); LABEL(LNO) 'END'; + +'INTEGER''PROCEDURE' CJMP; +'BEGIN' CODE(28); LABEL(NLAB); +CJMP:=NLAB; NLAB:=NLAB+1 'END'; + +'PROCEDURE' SID; +'BEGIN''INTEGER' I; +'IF' TABLES 'THEN' + 'BEGIN' SKIP(DEVT); IDOUT; + WRITE(DEVT," ",ADDR," ",TYPE); CHOUT(DEV); + 'END'; +'IF' NODEC=MAXNID 'THEN' WARN(15) 'ELSE' NODEC:=NODEC+1; +'IF' FOUND 'AND' DECL>DBASE 'THEN' WARN(1); +'IF' TYPE#4 'AND' TYPE<10 'THEN' + 'BEGIN' 'IF' ADDR>FIXSP 'THEN' FIXSP:=ADDR; + 'IF' ADDR>255 'THEN' WARN(5) + 'END'; +ILNP[NODEC]:=ILFP; +'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' IL[ILFP+I]:=IDN[I]; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' ILFP:=ILFP+I+1; + 'IF' ILFP>=MAXNID*6 'THEN' WARN(15); + 'GOTO' SID1; + 'END' END OF NAME; + 'END'; +SID1: +ILVT[NODEC]:=TYPE; ILBD[NODEC]:=DEPTH; +VADR[NODEC]:=ADDR; +'END' STORE IDENT IN LIST; + +'PROCEDURE' DARR; +'BEGIN''INTEGER' FIRST, COUNT,STYP; + STYP:=TYPE; +DAR1: FIRST:=NADR; COUNT:=1; +DAR2: IDENT; TYPE:=STYP; + ADDR:=NADR; NADR:=NADR+1; SID; + 'IF' BS=44 'THEN''BEGIN' COUNT:=COUNT+1; + ABS; 'GOTO' DAR2 'END'; + CHFAIL(27,18); GET INTEGER; + CHFAIL(58,18); GET INTEGER; + CHFAIL(29,18); +'IF' STYP=8 'THEN' CODE(53) 'ELSE' CODE(1); +CODE(COUNT); CODE(FIRST); +'IF' BS#59 'THEN''BEGIN' CHFAIL(44,18); 'GOTO' DAR1 'END'; +ABS; COMMENT 'END' DECLARE ARRAY; + +'PROCEDURE' DTV; +'BEGIN''INTEGER' STYP; STYP:=TYPE; +DTV1: IDENT; TYPE:=STYP; ADDR:=NADR; NADR:=NADR+1; +SID; 'IF' BS=44 'THEN''BEGIN' ABS; 'GOTO' DTV1 'END'; +'IF' BS=59 'THEN''BEGIN' ABS; COMMENT 'END''ELSE' ABS; +'END' DECLARE VARIABLE LIST; + + +'PROCEDURE' GET INTEGER; +AE; + +'PROCEDURE' SFR; +'BEGIN''INTEGER' I,J,K; +'IF' FOUND 'AND' (DECL<=10 'OR' TYPE>9 'OR' + DEPTH=ILBD[DECL]) 'THEN''GOTO' ESFR; +'IF' LDPT#0 'THEN' + 'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'BEGIN' J:=FRNP[I]; + 'FOR' K:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' 'IF' IDN[K] # FRN[J+K] 'THEN''GOTO' NO; + 'IF' IDN[K]=0 'THEN' + 'BEGIN''IF' DEPTH=FLBD[I] 'OR' TYPE>9 'THEN' + 'BEGIN' ADDR:=FRLN[I]; + 'IF' FLVT[I]#TYPE 'THEN' WARN(52); + 'GOTO' ESFR; + 'END' FORWARD REFERENCE EXISTS ALREADY; + 'GOTO' NO; + 'END' NAME MATCHES; + 'END' LOOK AT ONE CHARACTER; +NO: 'END' LOOK AT ONE FORWARD REFERNECE; + +'IF' LDPT=MAXLAB 'THEN' WARN(30) 'ELSE' LDPT:=LDPT+1; +'IF' LDPT>MAX 'THEN' MAX:=LDPT; +FRNP[LDPT]:=FRFP; +'FOR' I:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' FRN[FRFP+I]:=IDN[I]; + 'IF' IDN[I]=0 'THEN' + 'BEGIN' FRFP:=FRFP+I+1; + 'GOTO' SFR1; + 'IF' FRFP>=MAXLAB*6 'THEN' WARN(30); + 'END' END OF NAME; + 'END'; +SFR1: +FLVT[LDPT]:=TYPE; FLBD[LDPT]:=DEPTH; +ADDR:=NLAB; FRLN[LDPT]:=NLAB; NLAB:=NLAB+1; FLINE[LDPT]:=LINE; +ESFR: +'END' RETURN PROCEDURE LABEL IF DECLARED, ELSE SET FORWARD REF; + +'PROCEDURE' DLAB; +'BEGIN''INTEGER' I,J,K; +ADDR:=NLAB; SID; LDEC(NLAB); NLAB:=NLAB+1; +'IF' LDPT#0 'THEN' + 'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'BEGIN' J:=FRNP[I]; + 'FOR' K:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN' 'IF' IDN[K] # FRN[J+K] 'THEN''GOTO' NO; + 'IF' IDN[K]=0 'THEN' + 'BEGIN''IF' DEPTH=FLBD[I] 'OR' TYPE>9 'THEN' + 'BEGIN' DEFINE(FRLN[I],ADDR); + 'IF' FLVT[I]#TYPE 'THEN' WARN(52); + D2ELETE(I); I:=I-1; + 'END' DELETE SATISFIED REFERENCE; + 'GOTO' NO; + 'END' NAME MATCHES; + 'END' LOOK AT ONE CHARACTER; +NO: 'END' LOOK AT ONE FORWARD REFERNECE; +'END' PUT LABEL OR PROCEDURE DECLARATION IN LIST; + +'PROCEDURE' D2ELETE(ITEM); 'VALUE' ITEM; 'INTEGER' ITEM; +'IF' ITEM=LDPT 'THEN' +'BEGIN' LDPT:=LDPT-1; FRFP:=FRNP[ITEM]; +'END' DELETE LAST ITEM +'ELSE' +'BEGIN''INTEGER' I,J,K,LEN; +FRNP[LDPT+1]:=FRFP; FRFP:=FRNP[ITEM]; +'FOR' I:=ITEM 'STEP' 1 'UNTIL' LDPT-1 'DO' + 'BEGIN' K:=FRNP[I+1]; LEN:=FRNP[I+2] - K; + FRNP[I]:=FRFP; + 'FOR' J:=0 'STEP' 1 'UNTIL' LEN-1 'DO' + FRN[FRFP+J]:=FRN[K+J]; + FRFP:=FRFP + LEN; + FLVT[I]:=FLVT[I+1]; FLBD[I]:=FLBD[I+1]; + FLINE[I]:=FLINE[I]+1; FRLN[I]:=FRLN[I+1]; + 'END' MOVE 1 ITEM DOWN; +LDPT:=LDPT-1; +'END' DELETE INTERNAL ITEM; + +'PROCEDURE' PCALL; 'BEGIN' 'INTEGER' STYP; STYP:=TYPE; +'IF' FOUND 'AND' DECL<=10 'THEN' +'BEGIN' CHFAIL(40,32); +'IF' ADDR=1 'THEN' + 'BEGIN''IF' BS#41 'THEN' + 'BEGIN' GET INTEGER; CODE(2); + 'END' DEVICE NUMBER GIVEN; + CODE(40); 'GOTO' ECAL + 'END' COMPILE SKIP +'ELSE''IF' ADDR=2 'THEN' + 'BEGIN''IF' BS#44 'THEN' + 'BEGIN' GET INTEGER; CODE(49); + 'END' DEVICE GIVEN; +CAL1: 'IF' BS#44 'THEN''GOTO' ECAL; ABS; + CODE(3); IDENT; PUTOUT; 'GOTO' CAL1 + 'END' COMPILE READ +'ELSE''IF' ADDR=3 'THEN' + 'BEGIN''IF' BS#44 'THEN' + 'BEGIN' GET INTEGER; CODE(2); + 'END' DEVICE NUMBER GIVEN; +CAL2: 'IF' BS#44 'THEN''GOTO' ECAL; ABS; + 'IF' BS=34 'THEN' + 'BEGIN' + STRING:='TRUE'; INCH; CODE(5); +CAL3: CODE(CHAR); INCH; + 'IF' CHAR#34 'THEN''GOTO' CAL3; + ABS; CODE(0); + SKIP(); ITEM:=0; STRING:='FALSE'; 'GOTO' CAL2 + 'END' +'ELSE''BEGIN' GET INTEGER; CODE(6); + 'GOTO' CAL2 + 'END' + 'END' COMPILE WRITE +'ELSE''IF' ADDR=4 'THEN' + 'BEGIN''IF' BS#44 'THEN' + 'BEGIN' GET INTEGER; CODE(49); + 'END' DEVICE NUMBER GIVEN; + 'IF' BS#44 'THEN''GOTO' ECAL; ABS; + CODE(7); IDENT; PUTOUT + 'END' COMPILE CHIN +'ELSE''IF' ADDR=5 'THEN' + 'BEGIN''IF' BS#44 'THEN' + 'BEGIN' GET INTEGER; CODE(2); + 'END' DEVICE NUMBER GIVEN; + 'IF' BS#44 'THEN''GOTO' ECAL; ABS; + GET INTEGER; CODE(8); + 'END' COMPILE CHOUT +'ELSE''IF' ADDR=6 'THEN''BEGIN' GET INTEGER; CODE(39) + 'END' COMPILE IOC +'ELSE' 'IF' ADDR=7 'THEN' 'BEGIN' GETINTEGER; CODE(48) + 'END' COMPILE CLOSE +'ELSE' 'IF' ADDR=8 'THEN' + 'BEGIN' GETINTEGER; CODE(50) 'END' COMPILE DELETE +'ELSE' 'IF' ADDR=9 'OR' ADDR=10 'THEN' + 'BEGIN' CODE(42+ADDR); IDENT; PUTOUT 'END' COMPILE INPUT AND OUTPUT +'END' CALL OF BUILT IN ROUTINES +'ELSE''BEGIN' 'INTEGER' COUNT,PRAD; + SFR; 'IF' BS#40 'THEN' + 'BEGIN' CODE(11); LABEL(ADDR); 'GOTO' ECL2 + 'END' CALL OF PARAMETERLESS PROCEDURE; + COUNT:=0; PRAD:=ADDR; ABS; +NPAR: 'IF' 'NOT' LETTER 'THEN' + 'BEGIN' 'IF' BS=575 'OR' BS=818 'OR' BS=241 'THEN' BE + 'ELSE' AE + 'END' PARAMETER NOT STARTING WITH LETTER + 'ELSE' + 'BEGIN' IDENT; 'IF''NOT' FOUND 'THEN' WARN(29); + FRED:='TRUE'; EXPRESSION; + 'END' PARAM STARTING WITH IDENT; + COUNT:=COUNT+1; 'IF' BS=44 'THEN' + 'BEGIN' ABS; 'GOTO' NPAR + 'END'; + 'IF' COUNT<5 'THEN' + 'BEGIN' CODE(COUNT+42); LABEL(PRAD) + 'END' + 'ELSE''BEGIN' CODE(36); + CODE(COUNT); LABEL(PRAD); + 'END' +'END' USER DECLARED PROCEDURE CALL; +ECAL: CHFAIL(41,21); +ECL2: TYPE:=STYP 'END' PROCEDURE CALL; + + +'PROCEDURE' STATEMENT; +'BEGIN' +ST: +'IF' LETTER 'THEN' +'BEGIN' IDENT; +'IF' BS=58 'THEN' + 'BEGIN' TYPE:=4; DLAB; ABS; 'GOTO' ST 'END' +'ELSE''IF' BS=27 'OR' BS=33 'THEN' ASSIGNMENT +'ELSE' 'BEGIN' TYPE:=10; PCALL 'END' +'END' UNCONDITIONAL NON-GOTO + +'ELSE''IF' BS=366 'THEN' +'BEGIN''INTEGER' L1,L2; +L1:=IFCLAUSE; STATEMENT; +'IF' BS#212 'THEN' LDEC(L1) +'ELSE''BEGIN' ABS; L2:=JMPNEW; LDEC(L1); + STATEMENT; LDEC(L2) 'END' +'END' CONDITIONAL + +'ELSE' 'IF' BS=295 'THEN' +'BEGIN' ABS; IDENT; TYPE:=4; SFR; +JMP(ADDR); +'END' GOTO STATEMENT + +'ELSE' 'IF' BS=255 'THEN' +'BEGIN''INTEGER' L1,L2,L3,CVA,GLOBAL; +ABS; IDENT; 'IF''NOT' FOUND 'OR' TYPE#2 'THEN' WARN(13); +CVA:=ADDR; +GLOBAL:='IF' DECL<=HMPD 'AND' CPR 'THEN' 0 'ELSE' 2; +ASSIGNMENT; CHFAIL(780,22); +L1:=NLAB; L2:=NLAB+1; NLAB:=NLAB+2; +JMP(L1); LDEC(L2); +GET INTEGER; CHFAIL(854,22); +GET INTEGER; CHFAIL(175,22); +CODE(34); CODE(GLOBAL); CODE(CVA); +L3:=CJMP; LDEC(L1); STATEMENT; +JMP(L2); LDEC(L3); +'END' FORSTATEMENT + +'ELSE' 'IF' BS=85 'THEN' +'BEGIN''INTEGER' I,J,SDBASE,SNADR,SILFP,JPPL; +'BOOLEAN' PLS,BLOCK; +ABS; COMMENT; PLS:='FALSE'; BLOCK:='FALSE'; +NDEC: 'IF' BS=374 'OR' BS=95 'THEN' + 'BEGIN' 'IF''NOT' BLOCK 'THEN' + 'BEGIN' BLOCK:='TRUE'; DEPTH:=DEPTH+1; + SDBASE:=DBASE; DBASE:=NODEC; SNADR:=NADR; + SILFP:=ILFP; + 'END'; + TYPE:='IF' BS=374 'THEN' 2 'ELSE' 3; ABS; + 'IF' BS=658 'THEN' + 'BEGIN' ABS; 'IF' 'NOT' PLS 'THEN' + 'BEGIN' JPPL:=JMPNEW; PLS:='TRUE' + 'END'; + DPROC; 'GOTO' NDEC + 'END' TYPE PROCEDURE + 'ELSE' 'IF' BS=122 'THEN' + 'BEGIN' ABS; + ADEC: 'IF' PLS 'THEN' + 'BEGIN' LDEC(JPPL); PLS:='FALSE' + 'END'; + TYPE:=TYPE+4; DARR; 'GOTO' NDEC + 'END' INTEGER OR BOOLEAN ARRAY + 'ELSE' + 'BEGIN' DTV; 'GOTO' NDEC; + 'END' UNSUBSCRIPTED VARIABLE + 'END' DECLARATION STARTS INTEGER OR BOOLEAN + 'ELSE''IF' BS=658 'THEN' + 'BEGIN' 'IF''NOT' BLOCK 'THEN' + 'BEGIN' BLOCK:='TRUE'; DEPTH:=DEPTH+1; + SDBASE:=DBASE; DBASE:=NODEC; SNADR:=NADR; + SILFP:=ILFP; + 'END'; + TYPE:=0; ABS; 'IF' 'NOT' PLS 'THEN' + 'BEGIN' JPPL:=JMPNEW; PLS:='TRUE' + 'END'; + DPROC; 'GOTO' NDEC + 'END' PROCEDURE + 'ELSE''IF' BS=105 'THEN' + 'BEGIN' ABS; + 'IF' BS=122 'THEN' ABS; + TYPE:=4; 'GOTO' ADEC; + 'END' BYTE ARRAY; + +'IF' PLS 'THEN''BEGIN' PLS:='FALSE'; LDEC(JPPL) 'END'; +TAIL: STATEMENT; 'IF' BS=59 'THEN' + 'BEGIN' ABS; COMMENT; 'GOTO' TAIL 'END' + 'ELSE''IF' BS#214 'THEN' FAIL(16); +ECOM: ABS; 'IF''NOT' TERM 'THEN''GOTO' ECOM; + +'IF' BLOCK 'THEN' +'BEGIN' +DEPTH:=DEPTH-1; NODEC:=DBASE; DBASE:=SDBASE; NADR:=SNADR; +ILFP:=SILFP; RESOLVE; +'END' BLOCK END +'END' BLOCK OR COMPOUND; +'END' STATEMENT; + +'PROCEDURE' RESOLVE; +'BEGIN''INTEGER' I,J,K,L,M,FTYP; +'IF' LDPT#0 'THEN' +'FOR' I:=1 'STEP' 1 'UNTIL' LDPT 'DO' +'IF' FLBD[I]>DEPTH 'THEN' +'BEGIN' FLBD[I]:=DEPTH; FTYP:=FLVT[I]; +'FOR' J:=NODEC 'STEP' -1 'UNTIL' 11 'DO' + 'BEGIN' K:=ILNP[J]; L:=FRNP[I]; + 'FOR' M:=0 'STEP' 1 'UNTIL' 100 'DO' + 'BEGIN''IF' FRN[L+M] # IL[K+M] 'THEN''GOTO' NO; + 'IF' FRN[L+M]=0 'THEN' + 'BEGIN' + 'IF' ILBD[J]=DEPTH 'OR' FTYP>9 'THEN' + 'BEGIN' DEFINE(FRLN[I],VADR[J]); + 'IF' FTYP#ILVT[J] 'THEN' + WARN(53); + D2ELETE(I); I:=I-1; 'GOTO' EXLOOP; + 'END' DECLARATION FOUND, CORRECT DEPTH; + 'END' NAME MATCHES; + 'END' CHARACTER LOOP; +NO: 'END' DECLARED VARIABLE; +EXLOOP: +'END' FORWARD LABEL SATISFACTION DEPTH CHANGE; +'END' RESOLVE LABELS AT BLOCK/PROCEDURE END; + +'PROCEDURE' DPROC; + 'BEGIN' 'INTEGER' SNADR,SDBASE,SFIXSP,SILFP, + PINL,SLTYP; + CPR:='TRUE'; + SLTYP:=TYPE+10; IDENT; TYPE:=SLTYP; DLAB; + SILFP:=ILFP; HMPD:=NODEC; SFIXSP:=FIXSP; SNADR:=NADR; + SDBASE:=DBASE; DBASE:=NODEC; DEPTH:=DEPTH+1; + FIXSP:=3; NADR:=4; LABEL(NLAB); + PINL:=NLAB; NLAB:=NLAB+1; + 'IF' BS=40 'THEN' + 'BEGIN' ABS; TYPE:=0; DTV 'END'; + SEMI(28); +LOOP: 'IF' BS=881 'THEN' + 'BEGIN' + LOP: ABS; 'IF' BS#59 'THEN''GOTO' LOP; + ABS; 'GOTO' LOOP + 'END' IGNORE VALUE + 'ELSE''IF' BS=374 'OR' BS=95 'THEN' + 'BEGIN' 'BOOLEAN' BOOL; BOOL:=BS=95; ABS; + LOP: IDENT; 'IF''NOT' FOUND 'OR' TYPE#0 'THEN' WARN(29) + 'ELSE' + ILVT[DECL]:='IF' BOOL 'THEN' 3 'ELSE' 2; + ILBD[DECL]:=DEPTH; + 'IF' BS=44 'THEN''BEGIN' ABS; 'GOTO' LOP 'END' + 'ELSE''BEGIN' SEMI(43); 'GOTO' LOOP 'END' + 'END' TYPE SPECIFICATION; + 'FOR' DECL:=NODEC 'STEP' -1 'UNTIL' DBASE+1 'DO' + 'IF' ILVT[DECL]=0 'THEN' WARN(40); + STATEMENT; + CODE('IF' SLTYP>10 'THEN' 47 'ELSE' 10); + SKIP(); ITEM:=0; + WRITE(,"L",PINL); + 'IF' DOS=2 'THEN' WRITE(," EQU ") 'ELSE' WRITE(,"="); + WRITE(,FIXSP); SKIP(); ITEM:=0; + NADR:=SNADR; NODEC:=HMPD; FIXSP:=SFIXSP; + ILFP:=SILFP; DBASE:=SDBASE; DEPTH:=DEPTH-1; + SEMI(23); CPR:='FALSE'; +RESOLVE; +'END' DECLARE PROCEDURE; + +'PROCEDURE' SUBSCRIPT; +'BEGIN''INTEGER' STYPE; STYPE:=TYPE-4; +'IF' STYPE=4 'THEN' STYPE:=2; 'COMMENT' BYTE ARRAY; +CHFAIL(27,3); GETINTEGER; CHFAIL(29,4); +TYPE:=STYPE 'END'; + +'PROCEDURE' FETCH; +'BEGIN' +'IF' FRED 'THEN' FRED:='FALSE''ELSE' IDENT; +'IF' 'NOT' FOUND 'THEN' TYPE:=TYPE+10; +'IF' TYPE>10 'THEN' + 'BEGIN' PCALL; TYPE:=TYPE-10 + 'END' +'ELSE' 'IF' TYPE>4 'THEN' + 'BEGIN' 'INTEGER' SDEC,STYP; + 'IF' BS=29 'THEN' + 'BEGIN' ABS; 'GOTO' GETV; + 'END' FETCH ADDRESS OF ELEMENT 0; + STYP:=TYPE; SDEC:=DECL; + SUBSCRIPT; + 'IF' STYP=8 'THEN' CODE(54) 'ELSE' CODE(14); + CODE(VADR[SDEC]); + 'END' ARRAY NAME +'ELSE' +GETV: GETOUT; +'END' FETCH VARIABLE; + +'PROCEDURE' EXPRESSION; +'IF' BTYPE 'THEN' BE 'ELSE' AE; + +'PROCEDURE' ASSIGNMENT; +'BEGIN' 'IF''NOT' FOUND 'THEN' WARN(17); +'IF' TYPE>10 'THEN' + 'BEGIN' CHFAIL(33,24); TYPE:=TYPE-10; EXPRESSION; + CODE(147); 'COMMENT' STORE LOCAL 3; + 'END' +'ELSE''IF' TYPE>4 'THEN' + 'BEGIN' 'INTEGER' SDEC,STYP; + STYP:=TYPE; SDEC:=DECL; + SUBSCRIPT; CHFAIL(33,24); EXPRESSION; + 'IF' STYP=8 'THEN' CODE(55) 'ELSE' CODE(15); + CODE(VADR[SDEC]); + 'END' +'ELSE''BEGIN''INTEGER' SDECL; + SDECL:=DECL; CHFAIL(33,24); EXPRESSION; + ADDR:=VADR[SDECL]; DECL:=SDECL; PUTOUT; + 'END' +'END' ASSIGNMENT; + +'PROCEDURE' IDOUT; +'BEGIN''INTEGER' I; I:=0; +L: CHOUT(DEVT,IDN[I]); I:=I+1; +'IF' IDN[I]#0 'THEN''GOTO' L; +'END' OUTPUT IDENTIFIER; + +'PROCEDURE' WARN(X); 'VALUE' X; 'INTEGER' X; +'BEGIN' SKIP(DEVT); DELETE(DEV); DEV:=0; +WRITE(DEVT,"FAIL ",X," LINE ",LINE, + " CHAR ",CHAR," BS ",BS," IDENT "); +IDOUT; WRITE(DEVT," TYPE ",TYPE); +CHOUT(0); +'END' FAILURE WARNING; + +'PROCEDURE' FAIL(X); 'VALUE' X; 'INTEGER' X; +'BEGIN' WARN(X); 'IF' TERM 'THEN' ABS; +NEXT: ABS; 'IF''NOT' TERM 'THEN''BEGIN' ABS; 'GOTO' NEXT 'END'; +'END' FAILURE OUTPUT; + +'PROCEDURE' CHFAIL(SYM,FNO); 'VALUE' SYM,FNO; 'INTEGER' SYM,FNO; +'BEGIN''IF' BS#SYM 'THEN' WARN(FNO); ABS 'END'; + +'PROCEDURE' APRIME; +'BEGIN''BOOLEAN' NEG; +'IF' FRED 'THEN''BEGIN' FETCH; 'GOTO' EAPR + 'END'; +'IF' BS=43 'THEN''BEGIN' ABS; NEG:='FALSE' 'END' +'ELSE''IF' BS=45 'THEN''BEGIN' ABS; NEG:='TRUE' 'END' +'ELSE' NEG:='FALSE'; + +'IF' BS=40 'THEN' + 'BEGIN' ABS; AE; CHFAIL(41,12) + 'END' +'ELSE''IF' LETTER 'THEN' + 'BEGIN' TYPE:=2; + FETCH; 'IF' TYPE#2 'THEN' WARN(17); + 'END' +'ELSE''IF' BS=38 'THEN' + 'BEGIN' CHIN(,CHAR); SIXBIT(CHAR); ABS; + TYPE:=2; + 'END' CHARACTER LITERAL +'ELSE' 'BEGIN''INTEGER' I,J,K,L; I:=0; + 'IF''NOT' DIGIT 'THEN' FAIL(10); +APR1: I:=I+1; DIG[I]:=BS; + ABS; 'IF' DIGIT 'THEN''GOTO' APR1; + K:=0; L:=0; + 'FOR' J:=1 'STEP' 1 'UNTIL' I 'DO' + 'BEGIN' K:=10*K+DIG[J]-48; L:=L*10; + 'IF' K>=256 'THEN' + 'BEGIN' L:=L+K%256; + K:=K-256*(K%256) + 'END'; + 'IF' L>255 'THEN' WARN(44); + 'END'; + 'IF' K=0 'AND' L=0 'THEN' CODE(29) + 'ELSE' 'IF' L=0 'THEN' + 'BEGIN' SIXBIT(K) 'END' + 'ELSE' + 'BEGIN' CODE(16); CODE(K); CODE(L) 'END' + 'END'; +'IF' NEG 'THEN' CODE(17); +EAPR: 'END' ARITHMETIC PRIMARY; + +'PROCEDURE' AFAC; +'BEGIN' APRIME; +AFA1: 'IF' BS=30 'THEN' + 'BEGIN' ABS; APRIME; CODE(18); + 'GOTO' AFA1 + 'END'; +'END' ARITHMETIC FACTOR; + + + +'PROCEDURE' ATERM; +'BEGIN' +AFAC; +ATE1: 'IF' BS=42 'THEN' + 'BEGIN' ABS; AFAC; CODE(19); + 'GOTO' ATE1 + 'END' MULTIPLY CASE +'ELSE''IF' BS=47 'THEN' WARN(19) +'ELSE''IF' BS=37 'THEN' + 'BEGIN' ABS; AFAC; + CODE(20); 'GOTO' ATE1 + 'END' INTEGER DIVISION CASE; +'END' ARITHMETIC TERM; + +'PROCEDURE' SAE; +'BEGIN' ATERM; +SAE1: 'IF' BS=43 'THEN' + 'BEGIN' ABS; ATERM; + CODE(13); 'GOTO' SAE1 + 'END' ADDITION CASE +'ELSE''IF' BS=45 'THEN' + 'BEGIN' ABS; ATERM; + CODE(21); 'GOTO' SAE1 + 'END' SUBTRACTION CASE; +'END' SIMPLE ARITHMETIC EXPRESSION; + +'PROCEDURE' AE; +'IF' BS=366 'THEN' +'BEGIN' 'INTEGER' L1,L2; +L1:=IFCLAUSE; SAE; CHFAIL(212,7); +L2:=JMPNEW; LDEC(L1); AE; +LDEC(L2); +'END' +'ELSE' SAE; + + + +'PROCEDURE' SETO(I); 'VALUE' I; +'INTEGER' I; IOC(12); + +'INTEGER' 'PROCEDURE' SWLIST; IOC(16); + + +'PROCEDURE' RE; +'BEGIN''INTEGER' SBS; +AE; SBS:=BS; ABS; AE; +'IF' SBS=61 'THEN' CODE(22) +'ELSE''IF' SBS=35 'THEN' CODE(23) +'ELSE''IF' SBS=60 'THEN' CODE(24) +'ELSE''IF' SBS=62 'THEN' CODE(25) +'ELSE''IF' SBS=63 'THEN' CODE(26) +'ELSE''IF' SBS=38 'THEN' CODE(27) +'ELSE' FAIL(9); +'END' RELATIONAL BOOLEAN; + +'PROCEDURE' PUTOUT; +'IF' DECL<=HMPD 'THEN' +'BEGIN' 'IF' ADDR>31 'THEN' + 'BEGIN' CODE(37); CODE(ADDR); + 'END' STORE GLOBAL>31 + 'ELSE' CODE(160+ADDR) +'END' GLOBAL VARIABLE +'ELSE' +'BEGIN' 'IF' ADDR>15 'THEN' + 'BEGIN' CODE(4); CODE(ADDR); + 'END' STORE LOCAL>15 + 'ELSE' CODE(144+ADDR) +'END' LOCAL VARIABLE; + +'PROCEDURE' GETOUT; +'IF' DECL<=HMPD 'THEN' +'BEGIN' 'IF' ADDR>63 'THEN' + 'BEGIN' CODE(38); CODE(ADDR); + 'END' FETCH GLOBAL >63 + 'ELSE' CODE(192+ADDR); +'END' FETCH GLOBAL +'ELSE' +'BEGIN' 'IF' ADDR>15 'THEN' + 'BEGIN' CODE(12); CODE(ADDR); + 'END' FETCH LOCAL>15 + 'ELSE' CODE(128+ADDR); +'END' FETCH LOCAL; + +'INTEGER''PROCEDURE' IFCLAUSE; +'BEGIN' ABS; BE; CHFAIL(808,25); +IFCLAUSE:=CJMP 'END' IFCLAUSE; + +'PROCEDURE' BPRIM; +'BEGIN' 'BOOLEAN' NOT; +'IF' FRED 'THEN''BEGIN' FETCH; 'GOTO' EBPRIM 'END'; +'IF' BS=575 'THEN''BEGIN' NOT:='TRUE'; ABS 'END''ELSE' NOT:='FALSE'; +'IF' BS=818 'THEN' + 'BEGIN' ABS; CODE(29); CODE(30) 'END' +'ELSE''IF' BS=241 'THEN' + 'BEGIN' ABS; CODE(29) 'END' +'ELSE''IF' LETTER 'THEN' + 'BEGIN' TYPE:=3; IDENT; FRED:='TRUE'; + 'IF' BTYPE 'THEN' FETCH 'ELSE' RE; TYPE:=3; + 'END' +'ELSE''IF' BS=40 'THEN' + 'BEGIN' ABS; BE; CHFAIL(41,14) 'END' +'ELSE' RE; +'IF' NOT 'THEN' CODE(30); +EBPRIM: +'END' BPRIME; + +'PROCEDURE' BTERM; +'BEGIN' BPRIM; +BTM1: 'IF' BS=118 'THEN' + 'BEGIN' ABS; BPRIM; CODE(31); 'GOTO' BTM1 'END'; +'END' BOOL TERM; + +'PROCEDURE' SBE; +'BEGIN' BTERM; +SBE1: 'IF' BS=618 'THEN' + 'BEGIN' ABS; BTERM; CODE(32); 'GOTO' SBE1 'END'; +'END' SIMPLE BOOLEAN EXPRESSION; + +'PROCEDURE' BE; +'BEGIN''IF' BS#366 'THEN' SBE 'ELSE' + 'BEGIN''INTEGER' L1,L2; + L1:=IFCLAUSE; SBE; CHFAIL(212,8); + L2:=JMPNEW; LDEC(L1); + BE; LDEC(L2) 'END'; +'END' BOOLEAN EXPRESSION; + +'PROCEDURE' STID(LEN); 'VALUE' LEN; 'INTEGER' LEN; +'BEGIN' DECL:=DECL+1; ILNP[DECL]:=ILFP; +IL[ILFP+LEN]:=0; ILFP:=ILFP+LEN+1; SETO(IL] + ILFP); +ILVT[DECL]:=10; ILBD[DECL]:=0; +VADR[DECL]:=DECL; +'END' PUT STANDARD IDENTIFIER IN THE LIST; + +ITEM:=0; MAX:=0; +STRT: SKIP(1); +WRITE(1,"RHA (Minisystems) Ltd subset Algol compiler"); SKIP(1); + +WRITE(1,"CP/M-80, CP/M-86 or MS-DOS [1, 2 or 3] : "); +READ(1,DOS); +'IF' DOS<0 'OR' DOS>3 'THEN''GOTO' STRT; +'IF' DOS>1 'THEN' +'BEGIN' WRITE(1,"Origin in decimal : "); READ(1,FIRST); +SKIP(1); +'END'; + +HOL1:='FALSE'; CPR:='FALSE'; STRING:='FALSE'; +HMPD:=0; LDPT:=0; FIXSP:=0; DEPTH:=0; DOLL:='FALSE'; LINE:=1; +NLAB:=1; NODEC:=10; NADR:=1; FRED:='FALSE'; SECOND:='FALSE'; +ILFP:=0; FRFP:=0; SIZE:=4; + IOC(8); IOC(3); SETO(SWLIST+13); + WRITE(10,"IAG"); INPUT(INDEV); + 'IF' INDEV>0 'THEN' 'GOTO' IOK; + IOC(5); INPUT(INDEV); + 'IF' INDEV<0 'THEN' 'GOTO' IOCH; IOC(3); IOC(6); 'GOTO' IOK; +IOCH: IOC(2); SETO(SWLIST+13); WRITE(10,"IAG"); + INPUT(INDEV); 'IF' INDEV<0 'THEN' 'GOTO' IOCH; +IOK: SETO(SWLIST+13); + 'IF' DOS=1 'THEN' WRITE(10,"ZSM") + 'ELSE''IF' DOS=2 'THEN' WRITE(10,"A86") + 'ELSE' WRITE(10,"ASM"); + OUTPUT(DEV); + SETO(SWLIST+13); WRITE(10,"MON"); OUTPUT(DEVT); + SETO(SWLIST+13); WRITE(10,"IAG"); IOC(7); + TABLES:=DEVT>0; +'IF' DEVT<1 'THEN' DEVT:=1; +'IF' TABLES 'THEN''BEGIN' SKIP(DEVT); +WRITE(DEVT,"IDENTIFIER TABLE SIZE = ",MAXNID); SKIP(DEVT); +'END'; + +SKIP(DEV); +'IF' DOS=1 'THEN' + 'BEGIN' WRITE(DEV,"BASE QUERY 'ORIGIN'"); + SKIP(DEV); WRITE(DEV,"ORG BASE"); SKIP(DEV); + WRITE(DEV,"#L0"); + 'END' +'ELSE' 'BEGIN' + 'IF' DOS=3 'THEN' + WRITE(DEV,"DATA SEGMENT COMMON 'ALGOL'") + 'ELSE' WRITE(DEV,"DSEG"); + SKIP(DEV); WRITE(DEV,"ORG ",FIRST,"D"); + SKIP(DEV); WRITE(DEV," DW OFFSET L0"); + 'END'; +SKIP(DEV); + +DECL:=0; SETO(IL]); +WRITE(10,"SKIP"); STID(4); +WRITE(10,"READ"); STID(4); +WRITE(10,"WRITE"); STID(5); +WRITE(10,"CHIN"); STID(4); +WRITE(10,"CHOUT"); STID(5); +WRITE(10,"IOC"); STID(3); +WRITE(10,"CLOSE"); STID(5); +WRITE(10,"DELETE"); STID(6); +WRITE(10,"INPUT"); STID(5); +WRITE(10,"OUTPUT"); STID(6); + +CHOUT(DEV); CHIN(INDEV); ABS; STATEMENT; +'IF' BS#36 'THEN' WARN(6); CODE(18); +'IF' LDPT#0 'THEN' +'FOR' DECL:=1 'STEP' 1 'UNTIL' LDPT 'DO' + 'BEGIN' + 'FOR' FIRST:=0 'STEP' 1 'UNTIL' 100 'DO' + IDN[FIRST]:=FRN[FRNP[DECL]+FIRST]; + LINE:=FLINE[DECL]; WARN(2) + 'END'; +FIXSP:=FIXSP+FIXSP+2; + +SKIP(DEV); +'IF' DOS=3 'THEN' + 'BEGIN' WRITE(DEV,"L0="); CHOUT(,36); 'END' + 'ELSE' WRITE(DEV,"L0:"); +SKIP(); +'IF' DOS=1 'THEN' WRITE(,"#") 'ELSE' WRITE(," DW "); +WRITE(,FIXSP); +'IF' DOS=3 'THEN' + 'BEGIN' SKIP(DEV); WRITE(DEV,"DATA ENDS"); 'END'; +SKIP(DEV); WRITE(DEV,"END"); +SKIP(DEV); + +EPROG: CLOSE(DEV); CLOSE(INDEV); CLOSE(DEVT); SKIP(1); +WRITE(1,"SIZE ",SIZE); +WRITE(1," MAX ",MAX); +'END' IDENT TABLE BLOCK +'END' OF INTEGER SUBSET COMPILER +$$$$$$$$ + + diff --git a/RHA (Minisystems) ALGOL v55/KEY.ALG b/RHA (Minisystems) ALGOL v55/KEY.ALG new file mode 100644 index 0000000..006561b --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/KEY.ALG @@ -0,0 +1,13 @@ +BEGIN INTEGER c, dev; + +start: +text(1,"Input device ? "); dev:=read(1); +IF dev < 0 OR dev > 10 THEN GOTO start; + +REPEAT + REPEAT c:=chin(dev) UNTIL c#0; + skip(1); rwrite(1,c,4,0); + IF c>32 THEN chout(1,c) +UNTIL c=3; +END FINISH + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/LCASE.ALG b/RHA (Minisystems) ALGOL v55/LCASE.ALG new file mode 100644 index 0000000..e9f730d --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/LCASE.ALG @@ -0,0 +1,65 @@ +'BEGIN' 'INTEGER' IN,OUT,C; + + +'COMMENT' THIS PROGRAM CONVERTS FROM +THE UPPER CASE IN QUOTES MODE TO THE +UPPER/LOWER CASE CONVENTION; + +'PROCEDURE' SETO(A); +'VALUE' A; 'INTEGER' A; IOC(31); + +'INTEGER' 'PROCEDURE' SWLIST; +IOC(39); + +'PROCEDURE' GETC; +'BEGIN' C:=CHIN(IN); + 'IF' C<0 'OR' C=&^Z 'THEN' 'GOTO' FIN +'END' ; + + + + SETO(SWLIST+13); + TEXT(10,"ALG"); {DEFAULT EXTENSION} +A1: IOC(2); IN:=INPUT; + 'IF' IN<1 'THEN' 'GOTO' A1; + OUT:=OUTPUT; + 'IF' OUT<1 'THEN' + 'BEGIN' CLOSE(IN); 'GOTO' A1; + 'END' ; +LOOP: GETC; +A2: 'IF' C=&' 'THEN' + 'BEGIN' +A3: GETC; + 'IF' C=&' 'THEN' + 'BEGIN' GETC; + 'IF' C>&*S 'AND' C#&; 'THEN' + CHOUT(OUT,&*S); 'GOTO' A2; + 'END' 'ELSE' + 'IF' C<&A 'OR' C>&Z 'THEN' 'GOTO' A2 + 'ELSE' CHOUT(OUT,C); + 'GOTO' A3 + 'END' 'ELSE' + 'IF' C>=&A 'AND' C<=&Z 'THEN' C:=C+32; + CHOUT(OUT,C); + 'IF' C=&& 'THEN' + 'BEGIN' GETC; CHOUT(OUT,C); + 'IF' C=&** 'OR' C=&*^ 'THEN' + 'BEGIN' GETC; CHOUT(OUT,C); + 'END' + 'END' 'ELSE' + 'IF' C=&" 'THEN' + 'BEGIN' +A4: GETC; CHOUT(OUT,C); + 'IF' C=&** 'THEN' + 'BEGIN' GETC; CHOUT(OUT,C); + 'END' 'ELSE' + 'IF' C=&" 'THEN' 'GOTO' LOOP; + 'GOTO' A4; + 'END' ; + 'GOTO' LOOP; +FIN: CHOUT(OUT,&^Z); CLOSE(OUT); + CLOSE(IN); 'GOTO' A1; +'END' +'FINISH' + + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/MMIND.ALG b/RHA (Minisystems) ALGOL v55/MMIND.ALG new file mode 100644 index 0000000..9ea21bc --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/MMIND.ALG @@ -0,0 +1,111 @@ + +'BEGIN''INTEGER' COLOR1,COLOR2,COLOR3,COLOR4, + ROW,COL,OLDROW,OLDCOL,MAXCOL; +'INTEGER''ARRAY' HYP[1:4],BOARD[1:10,1:4],WHITES,BLACKS[1:10]; +'BOOLEAN''ARRAY' OLDMAT,NEWMAT[1:4]; + +'PROCEDURE' PATERN(ROW); 'VALUE' ROW; 'INETEGR' ROW; +'BEGIN''INTEGER' COL; + 'FOR' COL:=1,2,3,4 'DO' + 'IF' BOARD[ROW,COL]=1 'THEN' TEXT(1,"RED ") + 'ELSE''IF' BOARD[ROW,COL]=2 'THEN' TEXT(1,"BLUE ") + 'ELSE''IF' BOARD[ROW,COL]=3 'THEN' TEXT(1,"GREEN ") + 'ELSE''IF' BOARD[ROW,COL]=4 'THEN' TEXT(1,"YELLOW ") + 'ELSE''IF' BOARD[ROW,COL]=5 'THEN' TEXT(1,"BLACK ") + 'ELSE''IF' BOARD[ROW,COL]=6 'THEN' TEXT(1,"WHITE ") + 'ELSE' TEXT(1,"SPACE "); +'END' PRINT PATTERN; + +'PROCEDURE' PRINTROW; +'BEGIN' TEXT(1,"*NMy guess "); WRITE(1,ROW); + TEXT(1," is: "); +PATERN(ROW); +'END' PRINT THE CURRENT ROW; + + + +START: TEXT(1,"*N*NMastermind Codebreaker*NVersion 1 or 2 ?"); + MAXCOL:=READ(7); + 'IF''NOT' (MAXCOL=1 'OR' MAXCOL=2)'THEN''GOTO' START; + MAXCOL:=MAXCOL+5; +ROW:=1; + + 'FOR' COLOR1:=1 'STEP' 1 'UNTIL' MAXCOL 'DO' + 'FOR' COLOR2:=2 'STEP' 1 'UNTIL' MAXCOL,1 'DO' + 'FOR' COLOR3:=3 'STEP' 1 'UNTIL' MAXCOL,1,2 'DO' + 'FOR' COLOR4:=4 'STEP' 1 'UNTIL' MAXCOL,1,2,3 'DO' + 'BEGIN' +'INTEGER' BLACK,WHITE; + HYP[1]:=COLOR1; HYP[2]:=COLOR2; + HYP[3]:=COLOR3; HYP[4]:=COLOR4; +'COMMENT' SET UP THE HYPOTHESIS ROW. +A ROW IS CONSISTENT WITH ALL PREVIOUS ROWS IF IT +GIVES RISE TO THE SAME NUMBER OF BLACK AND WHITE INFORMATION +PEGS AS THOSE ROWS; +'FOR' OLDROW:=1 'STEP' 1 'UNTIL' ROW-1 'DO' +'BEGIN' + BLACK:=0; + 'FOR' COL:=1,2,3,4 'DO' + 'BEGIN''BOOLEAN' TEMP; + TEMP:=OLDMAT[COL]:=NEWMAT[COL]:= HYP[COL]=BOARD[OLDROW,COL]; + 'IF' TEMP 'THEN' BLACK:=BLACK+1; + 'END'; + 'IF' BLACK#BLACKS[OLDROW] 'THEN''GOTO' NOT VIABLE; + WHITE:=0; + 'FOR' COL:=1,2,3 'DO' + 'FOR' OLDCOL:=COL+1 'STEP' 1 'UNTIL' 4 'DO' + 'BEGIN' + 'IF' HYP[COL]=BOARD[OLDROW,OLDCOL] 'THEN' + 'BEGIN''IF''NOT' (NEWMAT[COL] 'OR' OLDMAT[OLDCOL]) 'THEN' + 'BEGIN' NEWMAT[COL]:=OLDMAT[OLDCOL]:='TRUE'; + WHITE:=WHITE+1; + 'END'; + 'END'; + 'IF' HYP[OLDCOL]=BOARD[OLDROW,COL] 'THEN' + 'BEGIN''IF''NOT' (NEWMAT[OLDCOL] 'OR' OLDMAT[COL]) 'THEN' + 'BEGIN' NEWMAT[OLDCOL]:=OLDMAT[COL]:='TRUE'; + WHITE:=WHITE+1; + 'END'; + 'END'; + 'END'; + 'IF' WHITE#WHITES[OLDROW] 'THEN''GOTO' NOT VIABLE; +'END' LOOK AT EACH PREVIOUS ROW; +'COMMENT' AT THIS POINT THE HYPOTHESIS ROW IS VIABLE; + 'FOR' COL:=1 'STEP' 1 'UNTIL' 4 'DO' BOARD[ROW,COL]:=HYP[COL]; + PRINTROW; +JUNK: TEXT(1,"*NHow many black pegs ? "); + BLACKS[ROW]:=READ(7); + 'IF' BLACKS[ROW]=4 'THEN' + 'BEGIN' TEXT(1,"Thanks for the game"); + 'GOTO' START; + 'END' PROBLEM SOLVED + 'ELSE''IF' BLACKS[ROW]=3 'THEN' WHITES[ROW]:=0 + 'ELSE' + 'BEGIN' + 'IF' BLACKS[ROW]<0 'OR' BLACKS[ROW]>4 'THEN' + 'BEGIN' TEXT(1,"TWIT !!"); 'GOTO' JUNK; + 'END'; + TEXT(1,"How many white pegs ? "); + WHITES[ROW]:=READ(7); + 'IF' WHITES[ROW]<0 'OR' + WHITES[ROW]+BLACKS[ROW]>4 'THEN' + 'BEGIN' TEXT(1,"TWIT !!"); 'GOTO' JUNK; + 'END'; + 'END'; + ROW:=ROW+1; + 'IF' ROW=10 'THEN' + 'BEGIN' + TEXT(1,"*NWELL DONE, YOU WIN !!"); + 'GOTO' START; + 'END'; + +NOT VIABLE: +'END' LOOK AT EACH POSSIBLE ROW; + + TEXT(1,"*NTwit !!! you made a mistake"); + 'GOTO' START; +'END' OF MASTERMIND CODEBREAKER +'FINISH' + + + diff --git a/RHA (Minisystems) ALGOL v55/MMIND.ASC b/RHA (Minisystems) ALGOL v55/MMIND.ASC new file mode 100644 index 0000000000000000000000000000000000000000..d50e7cfedb8f98850e8785fcf3d571cc4ff5c8d0 GIT binary patch literal 1152 zcmbW0O-vI(6vt;~+rmNtM!D1Jb@|1 z?4xQwMdIs?iZT30bG>K*L0+!oYIYNS@)nm{S8(Ll;V5jt z!FIyl9VoHOOPI_ZsSOe=$Q^F>J?v{F;vr%H_&MYOf*c9}F;XlRRVUso!XF&+d|Hb( z;1I-gTk&^PP zQv4@d@k4{2O;xfQ{Ao3)c%eV9Q;1Vy&~Dq=Ee z+gt%(myNG^96l`CKN3@q(ut9A8Xt^VZqOpkshx%2`IKdsRO VO(pd#d=u70JqY!lK&}7#`vt6QEKmRd literal 0 HcmV?d00001 diff --git a/RHA (Minisystems) ALGOL v55/QSORT.ALG b/RHA (Minisystems) ALGOL v55/QSORT.ALG new file mode 100644 index 0000000..6a41339 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/QSORT.ALG @@ -0,0 +1,32 @@ +'BEGIN''ARRAY' A[1:100]; +'INTEGER' I,N,INDEV; + +'PROCEDURE' QSORT(ARR,LOW,HIGH); 'VALUE' LOW,HIGH; +'ARRAY' ARR; 'INTEGER'LOW,HIGH; +'IF' LOW=ARR[HIGH] 'AND' TOP>BOTTOM + 'THEN''GOTO' LOOP2; +'IF' TOP>BOTTOM 'THEN' + 'BEGIN' X:=ARR[TOP]; ARR[TOP]:=ARR[BOTTOM]; + ARR[BOTTOM]:=X; 'GOTO' LOOP1; + 'END'; +X:=ARR[HIGH]; ARR[HIGH]:=ARR[BOTTOM]; ARR[BOTTOM]:=X; +QSORT(ARR,LOW,BOTTOM-1); QSORT(ARR,BOTTOM+1,HIGH); +'END' QSORT; + +START: IOC(4); INDEV:=INPUT; 'IF' INDEV<0 'THEN''GOTO' START; +N:=READ(INDEV); 'FOR' I:=1 'STEP' 1 'UNTIL' N 'DO' + A[I]:=READ(INDEV); +QSORT(A,1,N); +'FOR' I:=1 'STEP' 1 'UNTIL' N 'DO' + 'BEGIN' RWRITE(1,A[I],8,0); + 'IF' I=I%5*5 'THEN' SKIP(1); + 'END'; +CLOSE(INDEV); 'GOTO' START; +'END''FINISH' + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/QSORT.DAT b/RHA (Minisystems) ALGOL v55/QSORT.DAT new file mode 100644 index 0000000..3c9d9d0 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/QSORT.DAT @@ -0,0 +1,6 @@ +50 +12,-3,4,9,33,-3,7,2,0,10,3,45,87,45,23, +43,-55,26,8,-56,33,66,11,-9,0,28,-65,56,62,-1, +64,-82,387,43,-2,45,81,-93,-9,10, +-11,-12,13,6,99,88,-99,18,19,20 + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/SCALE.ALG b/RHA (Minisystems) ALGOL v55/SCALE.ALG new file mode 100644 index 0000000..e820079 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/SCALE.ALG @@ -0,0 +1,415 @@ +BEGIN ARRAY scale, freq, just[0:25], fifths[1:12]; +INTEGER ARRAY major, minor[1:6], title[1:100]; +INTEGER note, base, interval, char; +REAL ARRAY minorerror, majorerror[0:12]; +REAL ARRAY lminorerror, lmajorerror[0:12]; +REAL ARRAY tminorerror, tmajorerror[0:12]; +REAL scalecents, justcents, cfreq; +REAL minorsum, majorsum, minorbigsum, majorbigsum; +REAL lminorsum, lmajorsum, lminorbigsum, lmajorbigsum; +REAL purefifth, pythag, syntonic, logmult; +INTEGER xcount, starcount, goodcount; +INTEGER outdev; + +PROCEDURE format(n); VALUE n; INTEGER n; ioc(49); + +PRODECURE circle heading; +BEGIN text(1, +" C-G G-D D-A A-E E-B B-F# F#-C# C#-G# G#-D# D#-A# A#-F F-C"); +skip(1); +END circle heading; + +PROCEDURE circle echo; +BEGIN INTEGER f, c; + text(outdev, +" C-G G-D D-A A-E E-B B-F# F#-C# C#-G# G#-D# D#-A# A#-F F-C*N "); + ioc(0); note := 0; + FOR f := 1 STEP 1 UNTIL 12 DO + BEGIN WHILE note <= &*S AND note # 13 DO note := chin(7); + FOR c := 1 STEP 1 UNTIL 7 DO + BEGIN IF note > &*S THEN + BEGIN chout(outdev, note); note := chin(7); + END + ELSE chout( outdev, &*S ); + END; + END; + skip(outdev); + note := 0; + FOR f := 1 STEP 1 UNTIL 12 DO + BEGIN scalecents := abs( 3.0*freq[note] - 2.0*freq[note+7] ); + rwrite( outdev, scalecents*60, 6, 0); + note := note + 7; IF note > 11 THEN note := note - 12; + END; + skip(outdev); + note := 0; + FOR f := 1 STEP 1 UNTIL 12 DO + BEGIN scalecents := abs( 3.0*freq[note] - 2.0*freq[note+7] ); + rwrite( outdev, scalecents, 6, 2); + note := note + 7; IF note > 11 THEN note := note - 12; + END; + skip(outdev); +END circle echo; + +PROCEDURE write note( note ); +INTEGER note; +BEGIN IF note > 11 THEN note := note - 12; +CASE note OF +0: text(outdev, "C " ); +1: text(outdev, "C#" ); +2: text(outdev, "D " ); +3: text(outdev, "D#" ); +4: text(outdev, "E " ); +5: text(outdev, "F " ); +6: text(outdev, "F#" ); +7: text(outdev, "G " ); +8: text(outdev, "G#" ); +9: text(outdev, "A " ); +10: text(outdev, "A#" ); +11: text(outdev, "B " ) +ELSE text(outdev, "??" ); +END write note; + +PROCEDURE set just scale; +BEGIN logmult := 1200.00/ln(2); + just[0] := 0; just[12] := 1200.00; just[24] := 2400.00; + just[1] := 111.73; just[2] := logmult*ln(1.125); + just[3] := logmult*ln(1.2); just[4] := logmult*ln(1.25); + just[5] := logmult*ln(4.0/3.0); just[6] := 590.22; + just[7] := logmult*ln(1.5); just[8] := logmult*ln(1.6); + just[9] := logmult*ln(5.0/3.0); just[10] := logmult*ln(16.0/9.0); + just[11] := logmult*ln(1.875); + + purefifth := just[7]; + pythag := 12.00 * purefifth - 8400.00; + syntonic := 4.00 * purefifth - 2400.00 - just[4]; + + FOR note := 1 STEP 1 UNTIL 11 DO + just[note+12] := just[note]+1200.00; + + major[1] := 2; major[2] := 4; major[3] := 5; + major[4] := 7; major[5] := 9; major[6] := 11; + + minor[1] := 2; minor[2] := 3; minor[3] := 5; + minor[4] := 7; minor[5] := 8; minor[6] := 11; +END set just scale; + +PROCEDURE ay38912( octave ); VALUE octave; REAL octave; +BEGIN + +text(outdev, "*N "); +FOR note := 0 STEP 1 UNTIL 11 DO + rwrite( outdev, entier(125000.00/(freq[note]*octave) + 0.5), 8, 0 ); + +text(outdev, "*N "); +FOR note := 0 STEP 1 UNTIL 11 DO + rwrite( outdev, (freq[note]*octave), 8, 2 ); + +text(outdev, "*N "); +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN interval := entier(125000.00/(freq[note]*octave) + 0.5); + rwrite( outdev, 125000.00/interval, 8, 2 ); +END; + +text(outdev, "*N "); +cfreq := freq[0]*octave; +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN interval := entier(125000.00/(freq[note]*octave) + 0.5); + scalecents := 125000.00/interval; + rwrite( outdev, logmult*ln(scalecents/cfreq) - scale[note], 8, 2 ); +END; +END ay38912; + +PROCEDURE write scale error( error, lerror ); +VALUE error, lerror; REAL error, lerror; +BEGIN IF error > 90.00 THEN format( 512+&X ) + ELSE IF error > 60.00 THEN format( 512+&** ) + ELSE IF error < 40.00 THEN format( 512+&= ) + ELSE IF (error < 48.80) OR (error < 48.90 AND lerror < 33.20) + THEN format( 512+&E ); + rwrite(outdev, error, 8, 2); + format( 512+&*S ); +END; + +PROCEDURE scale from fifths; +BEGIN scale[0] := scalecents := 0; interval := 0; + FOR note := 1 STEP 1 UNTIL 11 DO + BEGIN interval := interval + 7; + scalecents := scalecents + fifths[note]; + IF interval > 11 THEN + BEGIN interval := interval - 12; + scalecents := scalecents - 1200.00; + END; + scale[interval] := scalecents; + END; + FOR note := 0 STEP 1 UNTIL 11 DO + BEGIN scale[note+12] := scale[note]+1200.00; + scalecents := scale[note] - scale[9]; + freq[note] := 440.0 * exp(scalecents/logmult); + freq[note+12] := 2.0 * freq[note]; + END; + +END scale from fifths; + +PROCEDURE readcents; +BEGIN + text( 1, "*NType 11 cent offsets from C*N" ); + scale[0] := 0; + FOR note := 1 STEP 1 UNTIL 11 DO + BEGIN scale[note] := read(7); + END; + FOR note := 1 STEP 1 UNTIL 12 DO + fifths[note] := scale[note+6] - scale[note-1]; + FOR note := 0 STEP 1 UNTIL 11 DO + BEGIN scale[note+12] := scale[note]+1200.00; + scalecents := scale[note] - scale[9]; + freq[note] := 440.0 * exp(scalecents/logmult); + freq[note+12] := 2.0 * freq[note]; + END; +END readcents; + +PROCEDURE readfifths; +BEGIN text( 1, "*NCircle of 11 fifths in cents from C*N" ); + + circle heading; + scalecents := 0; + FOR note := 1 STEP 1 UNTIL 11 DO + BEGIN fifths[note] := read(7); + scalecents := scalecents + fifths[note]; + END; + fifths[12] := 8400.00 - scalecents; + scale from fifths; +END readfifths; + +PROCEDURE readcommas; +BEGIN INTEGER sign, num, den; + text(1, "*NCircle of 12 fifths in commas commas from C"); + text(1, "*N0= pure, or <+|->, e.g. +1P, -1/4P, +1/2S*N"); + + circle heading; + scalecents := 0; + FOR note := 1 STEP 1 UNTIL 11 DO + BEGIN + next fifth: + char := chin(7); + IF char = &0 THEN sign := 0 + ELSE IF char = &- THEN sign := -1 + ELSE IF char = &+ THEN sign := 1 + ELSE GOTO next fifth; + + IF sign = 0 THEN fifths[note] := purefifth + ELSE + BEGIN num := den := 0; + char := chin(7); + WHILE char >= &0 AND char <= &9 DO + BEGIN num := 10*num + char - &0; char := chin(7); + END; + IF char = &/ THEN + BEGIN char := chin(7); + WHILE char >= &0 AND char <= &9 DO + BEGIN den := 10*den + char - &0; + char := chin(7); + END; + IF den = 0 THEN den := 1; + END + ELSE den := 1; + + interval := char MASK 223; + IF interval = &P THEN fifths[note] := pythag + ELSE fifths[note] := syntonic; + fifths[note] := purefifth+fifths[note]*sign*num/den; + END; + scalecents := scalecents + fifths[note]; + END; + fifths[12] := 8400.00 - scalecents; + scale from fifths; +END readcommas; + +{ Main program start } + +set just scale; + +outdev := 1; + +get streams: +ioc(0); ioc(1); ioc(15); ioc(2); +outdev := output; +IF outdev < 0 THEN GOTO get streams; + +skip(outdev); +text(1,"Title: "); +ioc(0); ioc(1); base := 1; +title char: char := chin(7); +IF char >= &*S THEN BEGIN title[base] := char; base := base+1; GOTO title char END; +title[base] := 0; + +get input type: +ioc(0); ioc(1); +text(1, "*NNotes (cents), Fifths (cents) or fifths Commas N/F/C ? "); +note := chin(7) MASK 223; +IF note = &N THEN readcents +ELSE IF note = &F THEN readfifths +ELSE IF note = &C THEN readcommas +ELSE GOTO get input type; + +base := 1; +WHILE title[base] # 0 DO +BEGIN chout( outdev, title[base] ); base := base+1; +END; + +skip( outdev ); +circle echo; + +text(outdev, "*NAY3 8912, True frequency, generated frequency, error in cents*N"); +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN text(outdev, " "); write note( note ); +END; +ay38912( 0.25 ); +skip( outdev ); +ay38912( 0.5 ); +skip( outdev ); +ay38912( 1.0 ); +skip( outdev ); +ay38912( 2.0 ); +skip( outdev ); +ay38912( 4.0 ); + +text(outdev, "*NPure fifth "); rwrite(outdev, purefifth, 8, 3); +text(outdev," Pythagorean comma "); rwrite(outdev, pythag, 8, 3); +text(outdev," Syntonic comma "); rwrite(outdev, syntonic, 8, 3); + +text(outdev, +"*N*NKey: E equal tempered, = just, ** error greater than 10 cents, X syntonic comma error"); +text(outdev,"*N"); +text(outdev,"*NJust scale (cents), this one (cents, Hz)*N"); +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN text(outdev, " "); write note( note ); +END; + +text(outdev,"*N "); +FOR note := 0 STEP 1 UNTIL 11 DO + rwrite( outdev, just[note], 8, 2 ); +text(outdev,"*N "); +FOR note := 0 STEP 1 UNTIL 11 DO + rwrite( outdev, scale[note], 8, 2 ); +text(outdev,"*N "); +FOR note := 0 STEP 1 UNTIL 11 DO + rwrite( outdev, freq[note], 8, 2 ); + +xcount := starcount := goodcount := 0; + +text(outdev, "*NIntervals from each note*N" ); +FOR note := 1 STEP 1 UNTIL 11 DO +BEGIN text(outdev, " "); write note( note ); +END; + +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN skip( outdev ); write note( note ); + FOR interval := 1 STEP 1 UNTIL 11 DO + BEGIN scalecents := scale[note+interval]-scale[note]; + justcents := just[interval]; + IF abs(scalecents-justcents) >= 21.49 THEN + BEGIN format( 512+&X ); + xcount := xcount + 1; + END + ELSE IF abs(scalecents-justcents) > 10.00 THEN + BEGIN format( 512+&** ); + starcount := starcount + 1; + END + ELSE IF abs(scalecents-justcents) < 1.00 THEN + BEGIN format( 512+&= ); + goodcount := goodcount + 1; + END + ELSE IF abs(scalecents-100.0*interval) < 1.00 THEN + format( 512+&E ); + rwrite( outdev, scalecents, 8, 2 ); + format( 512+&*S); + END; +END; + +minorsum := majorsum := minorbigsum := majorbigsum := 0; +lminorsum := lmajorsum := lminorbigsum := lmajorbigsum := 0; + +text(outdev, "*N*NAccumulated errors in each major and minor scale"); +text(outdev, +"*NKey: = very good, E better than equal temperament, ** poor, X intolerable"); +text(outdev, "*NEqual temp"); +rwrite(outdev, 48.88, 8, 2); rwrite(outdev, 48.88, 8, 2); +text(outdev, " 3rd to 6th "); +rwrite(outdev, 33.24, 8, 2); +rwrite(outdev, 33.24, 8, 2); +text(outdev, " scale+internals "); +rwrite(outdev, 168.15, 8, 2); rwrite(outdev, 207.25, 8, 2); + +FOR note := 0 STEP 1 UNTIL 11 DO +BEGIN skip(outdev); write note( note ); + text(outdev, " scale "); + minorerror[note] := majorerror[note] := 0; + lminorerror[note] := lmajorerror[note] := 0; + FOR interval := 1 STEP 1 UNTIL 6 DO + BEGIN + scalecents := scale[note+minor[interval]] - scale[note]; + justcents := just[minor[interval]]; + minorerror[note] := minorerror[note] + abs(justcents - scalecents); + IF interval > 1 AND interval < 6 THEN + lminorerror[note] := lminorerror[note] + + abs(justcents - scalecents); + scalecents := scale[note+major[interval]] - scale[note]; + justcents := just[major[interval]]; + majorerror[note] := majorerror[note] + abs(justcents - scalecents); + IF interval > 1 AND interval < 6 THEN + lmajorerror[note] := lmajorerror[note] + + abs(justcents - scalecents); + END; + + minorsum := minorsum + minorerror[note]; + majorsum := majorsum + majorerror[note]; + write scale error( majorerror[note], lmajorerror[note] ); + write scale error( minorerror[note], lminorerror[note] ); + + text(outdev, " 3rd to 6th "); + lminorsum := lminorsum + lminorerror[note]; + lmajorsum := lmajorsum + lmajorerror[note]; + rwrite(outdev, lmajorerror[note], 8, 2); + rwrite(outdev, lminorerror[note], 8, 2); + + text(outdev, " scale+internals "); + tminorerror[note] := minorerror[note]; + tmajorerror[note] := majorerror[note]; + FOR base := 1 STEP 1 UNTIL 5 DO + FOR interval := base+1 STEP 1 UNTIL 6 DO + BEGIN + scalecents := scale[note+minor[interval]] - scale[note+minor[base]]; + justcents := just[minor[interval]-minor[base]]; + tminorerror[note] := tminorerror[note] + abs(justcents - scalecents); + scalecents := scale[note+major[interval]] - scale[note+major[base]]; + justcents := just[major[interval]-major[base]]; + tmajorerror[note] := tmajorerror[note] + abs(justcents - scalecents); + END; + + minorbigsum := minorbigsum + tminorerror[note]; + majorbigsum := majorbigsum + tmajorerror[note]; + + rwrite(outdev, tmajorerror[note], 8, 2); + rwrite(outdev, tminorerror[note], 8, 2); +END; + +text(outdev, "*N"); write(outdev, goodcount); text(outdev,"just intervals, "); +write(outdev, starcount); text(outdev,"errors > 10 cents, and "); +write(outdev, xcount); text(outdev,"syntonic comma errors"); + +text(outdev, "*NTotal errors. Equal temperament "); +rwrite(outdev, 586.58, 8, 2); rwrite(outdev, 586.54, 8, 2); +text(outdev, " 3rd to 6th "); rwrite(outdev, 398.87, 8, 2); +rwrite(outdev, 398.83, 8, 2); +text(outdev, " with internal errors "); +rwrite(outdev, 2017.78, 8, 2); rwrite(outdev, 2487.04, 8, 2); +text(outdev, "*NTotal errors. This temperament "); +rwrite(outdev, majorsum, 8, 2); rwrite(outdev, minorsum, 8, 2); +text(outdev, " 3rd to 6th "); +rwrite(outdev, lmajorsum, 8, 2); rwrite(outdev, lminorsum, 8, 2); +text(outdev, " with internal errors "); +rwrite(outdev, majorbigsum, 8, 2); rwrite(outdev, minorbigsum, 8, 2); + +chout( outdev, &*P ); + +END FINISH diff --git a/RHA (Minisystems) ALGOL v55/SCALE.ASC b/RHA (Minisystems) ALGOL v55/SCALE.ASC new file mode 100644 index 0000000000000000000000000000000000000000..d968b7bceea90d1104ce9c28718e7b56534c1a4d GIT binary patch literal 4608 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 7 THEN GOTO get dev; + +text(1,"Type away*N"); ioc(0); ioc(1); +loop: +char := chin(dev); +IF NOT (dev = 3 AND char = 0 ) THEN +BEGIN chout(1, char); write(1,char) END; +IF char # 3 THEN GOTO loop; + +END FINISH + diff --git a/RHA (Minisystems) ALGOL v55/TESTDEV.ASC b/RHA (Minisystems) ALGOL v55/TESTDEV.ASC new file mode 100644 index 0000000000000000000000000000000000000000..2fa2c31c1707c78035bac3ad873461c0b44bff71 GIT binary patch literal 256 zcmZ=_lwh!BU|>*SHCf;wly@MIT~=X2V4G}aPaqpd$rM9&+0+vUnK(+GFuF@B>M2bXxmfr$+ItP>V9Fa$A(RvrNAPrM`OCdaG6 z;J^-4`-tHS(4I>&2K^>YOA-#6$N~v=xdImkh06*ICro4|JQyx>Olo44D+oE@&HN;S Q!Jf&0gTbDGL5h|D0B}b&TL1t6 literal 0 HcmV?d00001 diff --git a/RHA (Minisystems) ALGOL v55/TTT.ALG b/RHA (Minisystems) ALGOL v55/TTT.ALG new file mode 100644 index 0000000..6339947 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/TTT.ALG @@ -0,0 +1,242 @@ +BEGIN + +COMMENT scoreWin 6 ; +COMMENT scoreTie 5 ; +COMMENT scoreLose 4 ; +COMMENT scoreMax 9 ; +COMMENT scoreMin 2 ; +COMMENT scoreInvalid 0 ; +COMMENT pieceX 1 ; +COMMENT pieceY 2 ; +COMMENT pieceBlank 0 ; + +INTEGER movecount; +INTEGER ARRAY board[0:8]; +INTEGER ARRAY isodd[0:8]; + +INTEGER PROCEDURE winner; +BEGIN + INTEGER t, p; + + p := 0; + t := board[ 0 ]; + IF 0 # t THEN BEGIN + IF ( ( ( t = board[1] ) AND ( t = board[2] ) ) OR + ( ( t = board[3] ) AND ( t = board[6] ) ) ) THEN + p := t; + END; + + IF 0 = p THEN BEGIN + t := board[1]; + IF ( 0 # t ) AND ( t = board[4] ) AND ( t = board[7] ) THEN + p := t + ELSE BEGIN + t := board[2]; + IF ( 0 # t ) AND ( t = board[5] ) AND ( t = board[8] ) THEN + p := t + ELSE BEGIN + t := board[3]; + IF ( 0 # t ) AND ( t = board[4] ) AND ( t = board[5] ) THEN + p := t + ELSE BEGIN + t := board[6]; + IF ( 0 # t ) AND ( t = board[7] ) AND ( t = board[8] ) THEN + p := t + ELSE BEGIN + t := board[4]; + IF ( 0 # t ) THEN BEGIN + IF ( ( ( t = board[0] ) AND ( t = board[8] ) ) OR + ( ( t = board[2] ) AND ( t = board[6] ) ) ) THEN + p := t; + END; + END; + END; + END; + END; + END; + + winner := p; +END winner; + +INTEGER PROCEDURE winner2( move ); + VALUE move; + INTEGER move; +BEGIN + INTEGER x; + x := board[ move ]; + CASE move OF + 0: BEGIN + IF NOT ( ( ( x = board[1] ) AND ( x = board[2] ) ) OR + ( ( x = board[3] ) AND ( x = board[6] ) ) OR + ( ( x = board[4] ) AND ( x = board[8] ) ) ) + THEN x := 0; + END; + 1: BEGIN + IF NOT ( ( ( x = board[0] ) AND ( x = board[2] ) ) OR + ( ( x = board[4] ) AND ( x = board[7] ) ) ) + THEN x := 0; + END; + 2: BEGIN + x := board[ 2 ]; + IF NOT ( ( ( x = board[0] ) AND ( x = board[1] ) ) OR + ( ( x = board[5] ) AND ( x = board[8] ) ) OR + ( ( x = board[4] ) AND ( x = board[6] ) ) ) + THEN x := 0; + END; + 3: BEGIN + x := board[ 3 ]; + IF NOT ( ( ( x = board[4] ) AND ( x = board[5] ) ) OR + ( ( x = board[0] ) AND ( x = board[6] ) ) ) + THEN x := 0; + END; + 4: BEGIN + x := board[ 4 ]; + IF NOT ( ( ( x = board[0] ) AND ( x = board[8] ) ) OR + ( ( x = board[2] ) AND ( x = board[6] ) ) OR + ( ( x = board[1] ) AND ( x = board[7] ) ) OR + ( ( x = board[3] ) AND ( x = board[5] ) ) ) + THEN x := 0; + END; + 5: BEGIN + x := board[ 5 ]; + IF NOT ( ( ( x = board[3] ) AND ( x = board[4] ) ) OR + ( ( x = board[2] ) AND ( x = board[8] ) ) ) + THEN x := 0; + END; + 6: BEGIN + x := board[ 6 ]; + IF NOT ( ( ( x = board[7] ) AND ( x = board[8] ) ) OR + ( ( x = board[0] ) AND ( x = board[3] ) ) OR + ( ( x = board[4] ) AND ( x = board[2] ) ) ) + THEN x := 0; + END; + 7: BEGIN + x := board[ 7 ]; + IF NOT ( ( ( x = board[6] ) AND ( x = board[8] ) ) OR + ( ( x = board[1] ) AND ( x = board[4] ) ) ) + THEN x := 0; + END; + 8: BEGIN + x := board[ 8 ]; + IF NOT ( ( ( x = board[6] ) AND ( x = board[7] ) ) OR + ( ( x = board[2] ) AND ( x = board[5] ) ) OR + ( ( x = board[0] ) AND ( x = board[4] ) ) ) + THEN x := 0; + END + ELSE text( 1, "unexpected move" ); + + winner2 := x; +END winner2; + +INTEGER PROCEDURE minmax( alpha, beta, depth, move ); + VALUE alpha, beta, depth, move; + INTEGER alpha, beta, depth, move; +BEGIN + INTEGER value, p, score, pm; + value := 0; + movecount := movecount + 1; + + IF depth >= 4 THEN BEGIN +comment winner2 is faster than winner + p := winner2( move ); + IF p # 0 THEN BEGIN + IF p = 1 THEN value := 6 + ELSE value := 4; + END + ELSE BEGIN + IF depth = 8 THEN value := 5; + END; + END; + + IF value = 0 THEN BEGIN + IF 1 = isodd[ depth ] THEN BEGIN + value := 2; + pm := 1; + END + ELSE BEGIN + value := 9; + pm := 2; + END; + + p := 0; + WHILE p <= 8 DO BEGIN + IF board[ p ] = 0 THEN BEGIN + board[ p ] := pm; + score := minmax( alpha, beta, depth + 1, p ); + board[ p ] := 0; + + IF 1 = isodd[ depth ] THEN BEGIN + IF score > value THEN BEGIN + value := score; + IF ( ( value = 6 ) OR ( value >= beta ) ) THEN + p := 10 + ELSE BEGIN + IF ( value > alpha ) THEN alpha := value; + END; + END; + END + ELSE BEGIN + IF score < value THEN BEGIN + value := score; + IF ( value = 4 ) OR ( value <= alpha ) THEN + p := 10 + ELSE BEGIN + IF ( value < beta ) THEN beta := value; + END; + END; + END; + END; + + p := p + 1; + END; + END; + + minmax := value; +END minmax; + +PROCEDURE findsolution( move ); + VALUE move; + INTEGER move; +BEGIN + INTEGER score; + + board[ move ] := 1; + score := minmax( 2, 9, 0, move ); + board[ move ] := 0; +END findsolution; + +PROCEDURE main; +BEGIN + INTEGER i; + + FOR i:=0 STEP 1 UNTIL 8 DO BEGIN + board[ i ] := 0; + END; + + FOR i:=0 STEP 2 UNTIL 8 DO BEGIN + isodd[ i ] := 0; + END; + + FOR i:=1 STEP 2 UNTIL 7 DO BEGIN + isodd[ i ] := 1; + END; + + FOR i:=0 STEP 1 UNTIL 9 DO BEGIN + movecount := 0; + findsolution( 0 ); + findsolution( 1 ); + findsolution( 4 ); + END; + + text( 1, "moves: " ); + write( 1, movecount ); + text( 1, "*N" ); + + ioc(22); +END main; + +main; + +END +FINISH + diff --git a/RHA (Minisystems) ALGOL v55/UCASE.ALG b/RHA (Minisystems) ALGOL v55/UCASE.ALG new file mode 100644 index 0000000..5402bd4 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/UCASE.ALG @@ -0,0 +1,68 @@ +'BEGIN' 'INTEGER' IN,OUT,C; + +'COMMENT' THIS PROGRAM CONVERTS FROM +THE UPPER/LOWER CASE CONVENTION TO +THE UPPER CASE IN QUOTES CONVENTION; + +'PROCEDURE' SETO(A); +'VALUE' A; 'INTEGER' A; IOC(31); + +'INTEGER' 'PROCEDURE' SWLIST; +IOC(39); + +'PROCEDURE' GETC; +'BEGIN' C:=CHIN(IN); + 'IF' C<0 'OR' C=&^Z 'THEN' 'GOTO' FIN +'END' ; + + +'PROCEDURE' UOUT; +'IF' C>=97 'AND' C<=122 'THEN' CHOUT(OUT,C-32) +'ELSE' CHOUT(OUT,C); + + + SETO(SWLIST+13); + TEXT(10,"ALG"); {DEFAULT EXTENSION} +A1: IOC(2); IN:=INPUT; + 'IF' IN<1 'THEN' 'GOTO' A1; + OUT:=OUTPUT; + 'IF' OUT<1 'THEN' + 'BEGIN' CLOSE(IN); 'GOTO' A1; + 'END' ; + +LOOP: GETC; + 'IF' C=&" 'THEN' + 'BEGIN' UOUT; +A2: GETC; UOUT; + 'IF' C=&** 'THEN' + 'BEGIN' GETC; UOUT; + 'END' 'ELSE' + 'IF' C=&" 'THEN' 'GOTO' LOOP; + 'GOTO' A2; + 'END' 'ELSE' + 'IF' C=&*C 'THEN' + 'BEGIN' UOUT; 'GOTO' LOOP 'END' 'ELSE' + 'IF' C=&& 'THEN' + 'BEGIN' UOUT; GETC; UOUT; + 'IF' C=&** 'OR' C=&*^ 'THEN' + 'BEGIN' GETC; UOUT + 'END' ; + 'GOTO' LOOP; + 'END' 'ELSE' + 'IF' C>=&A 'AND' C<=&Z 'THEN' + 'BEGIN' CHOUT(OUT,&'); UOUT; +A3: GETC; + 'IF' C>=&A 'AND' C<=&Z 'THEN' + 'BEGIN' UOUT; 'GOTO' A3 + 'END' ; + CHOUT(OUT,&'); UOUT; + 'GOTO' LOOP; + 'END' 'ELSE' UOUT; + 'GOTO' LOOP; + +FIN: CHOUT(OUT,&^Z); CLOSE(OUT); + CLOSE(IN); 'GOTO' A1 +'END' +'FINISH' + + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/VDU.ALG b/RHA (Minisystems) ALGOL v55/VDU.ALG new file mode 100644 index 0000000..d21f5f2 --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/VDU.ALG @@ -0,0 +1,218 @@ + +'BEGIN' +'INTEGER' D,I,J,S,L,LC; +'BOOLEAN' WFLAG,FILL,UCASE; +'INTEGER' 'ARRAY' LET[&A:&Z+1]; +'BYTE' 'ARRAY' W[1:40,1:10],LINE[1:150]; + + +'INTEGER' 'PROCEDURE' LOCATION(I); +'VALUE' I; 'INTEGER' I; IOC(24); + + +'PROCEDURE' SETI(A); +'VALUE' A; 'INTEGER' A; IOC(30); + + +'PROCEDURE' SETO(A); +'VALUE' A; 'INTEGER' A; IOC(31); + + +'INTEGER' 'PROCEDURE' PEEK(A); +'VALUE' A; 'INTEGER' A; IOC(36); + + +'INTEGER' 'PROCEDURE' SWLIST; +IOC(39); + +'INTEGER' 'PROCEDURE' SLOC(S); +'STRING' S; IOC(55); + + +'INTEGER' 'PROCEDURE' FINDINPUT(S); +'STRING' S; +'BEGIN' GETLIST(S); IOC(5); + FINDINPUT:=INPUT; IOC(1) +'END'; + + +'INTEGER' 'PROCEDURE' FINDOUTPUT(S); +'STRING' S; +'BEGIN' GETLIST(S); IOC(3); + FINDOUTPUT:=OUTPUT; IOC(1) +'END'; + + +'PROCEDURE' GETLIST(S); +'STRING' S; +'BEGIN' 'INTEGER' I; + IOC(0); IOC(1); TEXT(7,S); + CHOUT(7,0); + I:=CHIN(7); + 'IF' I=&? 'THEN' + 'BEGIN' 'FOR' I:=CHIN(7) 'WHILE' + I#0 'DO' CHOUT(1,I); + I:=CHIN(7) + 'END'; + IOC(0); +'END'; + + +'PROCEDURE' CLARR(A,L); +'VALUE' A,L; 'INTEGER' A,L; +IOC(50); + + + +'PROCEDURE' CHAR; +'BEGIN' +LOOP: I:=CHIN(1); + 'IF' I=&^X 'THEN' + 'BEGIN' WFLAG:='NOT' WFLAG; + 'GOTO' LOOP; + 'END' 'ELSE' + 'IF' I=&^Z 'OR' I=&^C 'THEN' + 'BEGIN' CLOSE(D); 'GOTO' FLOOP + 'END' 'ELSE' + 'IF' I=127 'THEN' + 'BEGIN' 'IF' LC>0 'THEN' + 'BEGIN' CHOUT(1,LINE[LC]); + LC:=LC-1; + 'END'; + FILL:='FALSE' ; + 'GOTO' LOOP + 'END' 'ELSE' + 'IF' I=&^U 'THEN' + 'BEGIN' LC:=0; TEXT(1,"*^U*N"); + FILL:=WFLAG; + 'GOTO' LOOP + 'END' 'ELSE' + 'IF' I=&^R 'THEN' + 'BEGIN' SKIP(1); + 'FOR' I:=1 'STEP' 1 'UNTIL' LC 'DO' + CHOUT(1,LINE[I]); + 'END' 'ELSE' + 'IF' I<&A 'OR' I>&Z 'THEN' FILL:=WFLAG 'ELSE' + 'IF' I<&*T 'OR' I>&*C 'AND' I<&*S 'THEN' 'GOTO' LOOP +'END' ; + + +'PROCEDURE' OUTL(I); 'VALUE' I; 'INTEGER' I; +'BEGIN' LC:=LC+1; LINE[LC]:=I +'END' ; + + +'PROCEDURE' OUTW(M,L); +'VALUE' M,L; 'INTEGER' M,L; +'BEGIN' 'INTEGER' K; +LOOP: L:=L+1; K:=W[M,L]; + 'IF' L<11 'AND' K#0 'THEN' + 'BEGIN' OUTL(K); CHOUT(1,K); + 'GOTO' LOOP + 'END' ; + 'IF' UCASE 'THEN' + 'BEGIN' OUTL(&'); CHOUT(1,&'); + 'END' ; + OUTL(&*S); CHOUT(1,&*S); + FILL:=WFLAG; +'END' ; + + +'PROCEDURE' GETWORD; +'BEGIN' 'INTEGER' L,MN,MX; + L:=1; FILL:='FALSE'; + MN:=LET[I]; + 'IF' MN<0 'THEN' 'GOTO' FIN; + MX:=MN; + 'FOR' MX:=MX+1 'WHILE' W[MX,1]=I 'DO' ; + MX:=MX-1; +L1: 'IF' MX=MN 'THEN' + 'BEGIN' OUTW(MN,L); 'GOTO' FIN; + 'END'; + L:=L+1; CHAR; OUTL(I); +L2: 'IF' I=W[MN,L] 'THEN' 'GOTO' L3; + MN:=MN+1; + 'IF' MN>MX 'THEN' 'GOTO' FIN 'ELSE' 'GOTO' L2; +L3: 'IF' I=W[MX,L] 'THEN' 'GOTO' L1; + MX:=MX-1; + 'IF' MX>=MN 'THEN' 'GOTO' L3; +FIN: +'END' ; + + +{SET UP KEY WORDS} +SETI(SLOC(" +< + AND ARRAY + BEGIN BOOLEAN BYTE + COMMENT + DIFFER DO + ELSE END EQUIVALENT + FALSE FINISH FOR + GOTO + IF IMPLIES INTEGER + LABEL LIBRARY + MASK MOD + NOT + OR + PROCEDURE + REAL + STEP STRING SWITCH + THEN TRUE + UNTIL + VALUE + WHILE +> ")); + + 'FOR' I:=&A 'STEP' 1 'UNTIL' &Z+1 'DO' + LET[I]:=-1; + CLARR(LOCATION(W[1,1]),400); + 'FOR' J:=CHIN(10) 'WHILE' J#&< 'DO' ; + I:=0; S:=0; + 'FOR' J:=CHIN(10) 'WHILE' J#&> 'DO' + 'BEGIN' 'IF' J<=&*S 'THEN' + 'BEGIN' 'FOR' J:=CHIN(10) 'WHILE' J<=&*S 'DO' ; + 'IF' J=&> 'THEN' 'GOTO' DONE; + I:=I+1; L:=1; + 'IF' J#S 'THEN' + 'BEGIN' S:=J; LET[J]:=I; + 'END' ; + 'END' ; + W[I,L]:=J; L:=L+1; + 'END' ; + +{GET OUTPUT FILE} + +{DEFAULT EXTENSION} +DONE: SETO(SWLIST+13); TEXT(10,"ALG"); +FLOOP: D:=FINDOUTPUT("?FILE ="); + 'IF' D<1 'THEN' 'GOTO' FIN; + UCASE:=PEEK(SWLIST)=&U; {UPPER CASE CONVENTION ?} + WFLAG:='TRUE' ; {SWITCH ON AUTO FILL} + FILL:=WFLAG; + LC:=0; {# CHARS ON LINE} + TEXT(1,"*^*N"); {PROMPT} + +INLOOP: CHAR; {GET NEXT CHARACTER} + 'IF' I=&*C 'THEN' + 'BEGIN' 'FOR' I:=1 'STEP' 1 'UNTIL' LC 'DO' CHOUT(D,LINE[I]); + LC:=0; SKIP(D); + 'END' 'ELSE' + 'IF' 'NOT' FILL 'THEN' OUTL(I) 'ELSE' + 'IF' UCASE 'THEN' + 'BEGIN' OUTL(I); + 'IF' I=&' 'THEN' + 'BEGIN' CHAR; OUTL(I); + 'IF' I>=&A 'AND' I<=&Z 'THEN' + GETWORD + 'END' + 'END' 'ELSE' + 'BEGIN' OUTL(I); + 'IF' I>=&A 'AND' I<=&Z 'THEN' + GETWORD; + 'END' ; + 'GOTO' INLOOP; +FIN: +'END' +'FINISH' + \ No newline at end of file diff --git a/RHA (Minisystems) ALGOL v55/m.bat b/RHA (Minisystems) ALGOL v55/m.bat new file mode 100644 index 0000000..6e4691a --- /dev/null +++ b/RHA (Minisystems) ALGOL v55/m.bat @@ -0,0 +1,7 @@ +ntvdm algol %1 + +ntvdm -c -p arun %1.OBJ + + + +