|
@@ -0,0 +1,3137 @@
|
|
|
+#include <em_spec.h>
|
|
|
+#include <em_pseu.h>
|
|
|
+#include <em_mnem.h>
|
|
|
+#include <em_mes.h>
|
|
|
+#include <em_reg.h>
|
|
|
+#include <pc_size.h>
|
|
|
+
|
|
|
+{
|
|
|
+ (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
|
|
+
|
|
|
+ This product is part of the Amsterdam Compiler Kit.
|
|
|
+
|
|
|
+ Permission to use, sell, duplicate or disclose this software must be
|
|
|
+ obtained in writing. Requests for such permissions may be sent to
|
|
|
+
|
|
|
+ Dr. Andrew S. Tanenbaum
|
|
|
+ Wiskundig Seminarium
|
|
|
+ Vrije Universiteit
|
|
|
+ Postbox 7161
|
|
|
+ 1007 MC Amsterdam
|
|
|
+ The Netherlands
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+{if next line is included the compiler itself is written in standard pascal}
|
|
|
+{#define STANDARD 1}
|
|
|
+
|
|
|
+{Author: Johan Stevenson Version: 32}
|
|
|
+{$l- : no source line numbers}
|
|
|
+{$r- : no subrange checking}
|
|
|
+{$a- : no assertion checking}
|
|
|
+#ifdef STANDARD
|
|
|
+{$s+ : test conformancy to standard}
|
|
|
+#endif
|
|
|
+
|
|
|
+program pem(input,em,errors);
|
|
|
+{ This Pascal compiler produces EM code as described in
|
|
|
+ - A.S.Tanenbaum, J.W.Stevenson & H. van Staveren,
|
|
|
+ "Description of a machine architecture for use with
|
|
|
+ block structured languages" Informatika rapport 81.
|
|
|
+ NOTE: this version is modified to produce the modified EM code of
|
|
|
+ januari 1981. it is not possible, using this compiler, to generate
|
|
|
+ code for machines with 1 or 4 byte wordsize.
|
|
|
+ A description of Pascal is given in
|
|
|
+ - K.Jensen & N.Wirth, "PASCAL user manual and report", Springer-Verlag.
|
|
|
+ Several options may be given in the normal pascal way. Moreover,
|
|
|
+ a positive number may be used instead of + and -. The options are:
|
|
|
+ a: interpret assertions (+)
|
|
|
+ c: C-type strings allowed (-)
|
|
|
+ d: type long may be used (-)
|
|
|
+ i: controls the number of bits in integer sets (16)
|
|
|
+ l: insert code to keep track of source lines (+)
|
|
|
+ o: optimize (+)
|
|
|
+ r: check subranges (+)
|
|
|
+ s: accept only standard pascal programs (-)
|
|
|
+ t: trace procedure entry and exit (-)
|
|
|
+ u: treat '_' as letter (-)
|
|
|
+}
|
|
|
+{===================================================================}
|
|
|
+#ifdef STANDARD
|
|
|
+label 9999;
|
|
|
+#endif
|
|
|
+
|
|
|
+const
|
|
|
+{fundamental constants}
|
|
|
+ MB1 = 7; MB2 = 15; {MB4 = 31}
|
|
|
+ NB1 = 8; NB2 = 16; {NB4 = 32}
|
|
|
+
|
|
|
+ MI1 = 127; MI2 = 32767; {MI4 = 2147483647}
|
|
|
+ NI1 = 128; {NI2 = 32768} {NI4 = 2147483648}
|
|
|
+
|
|
|
+ MU1 = 255; {MU2 = 65535} {MU4 = 4294967295}
|
|
|
+ NU1 = 256; {NU2 = 65536} {NU4 = 4294967296}
|
|
|
+
|
|
|
+{maximal indices}
|
|
|
+ idmax = 8;
|
|
|
+ fnmax = 14;
|
|
|
+ smax = 72;
|
|
|
+
|
|
|
+{opt values}
|
|
|
+ off = 0;
|
|
|
+ on = 1;
|
|
|
+
|
|
|
+{for push and pop: }
|
|
|
+ global = false;
|
|
|
+ local = true;
|
|
|
+
|
|
|
+{for sizeof and posaddr: }
|
|
|
+ wordmult = false;
|
|
|
+ wordpart = true;
|
|
|
+
|
|
|
+{ASCII characters}
|
|
|
+ ascht = 9;
|
|
|
+ ascnl = 10;
|
|
|
+ ascvt = 11;
|
|
|
+ ascff = 12;
|
|
|
+ asccr = 13;
|
|
|
+
|
|
|
+{miscellaneous}
|
|
|
+ maxcharord = 127; {maximal ordinal number of chars}
|
|
|
+ maxargc = 13; {maximal index in argv}
|
|
|
+ rwlim = 34; {number of reserved words}
|
|
|
+ spaces = ' ';
|
|
|
+
|
|
|
+{-------------------------------------------------------------------}
|
|
|
+type
|
|
|
+{scalar types}
|
|
|
+ symbol= (comma,semicolon,colon1,colon2,notsy,lbrack,ident,
|
|
|
+ intcst,charcst,realcst,longcst,stringcst,nilcst,minsy,
|
|
|
+ plussy,lparent,arrow,arraysy,recordsy,setsy,filesy,
|
|
|
+ packedsy,progsy,labelsy,constsy,typesy,varsy,procsy,
|
|
|
+ funcsy,beginsy,gotosy,ifsy,whilesy,repeatsy,forsy,
|
|
|
+ withsy,casesy,becomes,starsy,divsy,modsy,slashsy,
|
|
|
+ andsy,orsy,eqsy,nesy,gtsy,gesy,ltsy,
|
|
|
+ lesy,insy,endsy,elsesy,untilsy,ofsy,dosy,
|
|
|
+ downtosy,tosy,thensy,rbrack,rparent,period
|
|
|
+ ); {the order is important}
|
|
|
+ chartype= (lower,upper,digit,layout,tabch,
|
|
|
+ quotech,dquotech,colonch,periodch,lessch,
|
|
|
+ greaterch,lparentch,lbracech,
|
|
|
+ {different entries}
|
|
|
+ rparentch,lbrackch,rbrackch,commach,semich,arrowch,
|
|
|
+ plusch,minch,slash,star,equal,
|
|
|
+ {also symbols}
|
|
|
+ others
|
|
|
+ );
|
|
|
+ standpf= (pread,preadln,pwrite,pwriteln,pput,pget,
|
|
|
+ preset,prewrite,pnew,pdispose,ppack,punpack,
|
|
|
+ pmark,prelease,ppage,phalt,
|
|
|
+ {all procedures}
|
|
|
+ feof,feoln,fabs,fsqr,ford,fchr,fpred,fsucc,fodd,
|
|
|
+ ftrunc,fround,fsin,fcos,fexp,fsqt,flog,fatn
|
|
|
+ {all functions}
|
|
|
+ ); {the order is important}
|
|
|
+ libmnem= (ELN ,EFL ,CLS ,WDW , {input and output}
|
|
|
+ OPN ,GETX,RDI ,RDC ,RDR ,RDL ,RLN ,
|
|
|
+ {on inputfiles}
|
|
|
+ CRE ,PUTX,WRI ,WSI ,WRC ,WSC ,WRS ,WSS ,WRB ,
|
|
|
+ WSB ,WRR ,WSR ,WRL, WSL, WRF ,WRZ ,WSZ ,WLN ,PAG ,
|
|
|
+ {on outputfiles, order important}
|
|
|
+ ABR ,RND ,SINX,COSX,EXPX,SQT ,LOG ,ATN ,
|
|
|
+ {floating point}
|
|
|
+ ABI ,ABL ,BCP ,BTS ,NEWX,SAV ,RST ,INI ,HLT ,
|
|
|
+ ASS ,GTO ,PAC ,UNP, DIS, ASZ, MDI, MDL
|
|
|
+ {miscellaneous}
|
|
|
+ );
|
|
|
+ structform= (scalar,subrange,pointer,power,files,arrays,carray,
|
|
|
+ records,variant,tag); {order important}
|
|
|
+ structflag= (spack,withfile);
|
|
|
+ identflag= (refer,used,assigned,noreg,loopvar,samesect);
|
|
|
+ idclass= (types,konst,vars,field,carrbnd,proc,func);
|
|
|
+ kindofpf= (standard,formal,actual,extern,varargs,forward);
|
|
|
+ where= (blck,rec,wrec);
|
|
|
+ attrkind= (cst,fixed,pfixed,loaded,ploaded,indexed);
|
|
|
+ twostruct= (eq,subeq,ir,ri,il,li,lr,rl,es,se,noteq); {order important}
|
|
|
+
|
|
|
+{subrange types}
|
|
|
+ rwrange= 0..rwlim;
|
|
|
+ byte= 0..MU1;
|
|
|
+
|
|
|
+{pointer types}
|
|
|
+ sp= ^structure;
|
|
|
+ ip= ^identifier;
|
|
|
+ lp= ^labl;
|
|
|
+ bp= ^blockinfo;
|
|
|
+ np= ^nameinfo;
|
|
|
+
|
|
|
+{set types}
|
|
|
+ sos= set of symbol;
|
|
|
+ setofids= set of idclass;
|
|
|
+ formset= set of structform;
|
|
|
+ sflagset= set of structflag;
|
|
|
+ iflagset= set of identflag;
|
|
|
+
|
|
|
+{array types}
|
|
|
+ idarr=packed array[1..idmax] of char;
|
|
|
+ fnarr=packed array[1..fnmax] of char;
|
|
|
+
|
|
|
+{record types}
|
|
|
+ position=record {the addr info of certain variable}
|
|
|
+ ad:integer; {for locals it is the byte offset}
|
|
|
+ lv:integer; {the level of the beast}
|
|
|
+ end;
|
|
|
+
|
|
|
+{records of type attr are used to remember qualities of
|
|
|
+ expression parts to delay the loading of them.
|
|
|
+ Reasons to delay the loading of one word constants:
|
|
|
+ - bound checking
|
|
|
+ - set building.
|
|
|
+ Reasons to delay the loading of direct accessible objects:
|
|
|
+ - efficient handling of read/write
|
|
|
+ - efficient handling of the with statement.
|
|
|
+}
|
|
|
+ attr=record
|
|
|
+ asp:sp; {type of expression}
|
|
|
+ packbit:boolean; {true for part of packed structure}
|
|
|
+ ak:attrkind; {access method}
|
|
|
+ pos:position; {lv and ad}
|
|
|
+ {If ak=cst then the value is stored in ad}
|
|
|
+ end;
|
|
|
+
|
|
|
+ nameinfo=record {one for each separate name space}
|
|
|
+ nlink:np; {one deeper}
|
|
|
+ fname:ip; {first name: root of tree}
|
|
|
+ case occur:where of
|
|
|
+ blck:();
|
|
|
+ rec: ();
|
|
|
+ wrec:(wa:attr) {name space opened by with statement}
|
|
|
+ end;
|
|
|
+
|
|
|
+ blockinfo=record {all info of the current procedure}
|
|
|
+ nextbp:bp; {pointer to blockinfo of surrounding proc}
|
|
|
+ reglb:integer; {data location counter (from begin of proc) }
|
|
|
+ minlb:integer; {keeps track of minimum of reglb}
|
|
|
+ ilbno:integer; {number of last local label}
|
|
|
+ forwcount:integer; {number of not yet specified forward procs}
|
|
|
+ lchain:lp; {first label: header of chain}
|
|
|
+ end;
|
|
|
+
|
|
|
+ structure=record
|
|
|
+ size:integer; {size of structure in bytes}
|
|
|
+ sflag:sflagset; {flag bits}
|
|
|
+ case form:structform of
|
|
|
+ scalar :(scalno:integer; {number of range descriptor}
|
|
|
+ fconst:ip {names of constants}
|
|
|
+ );
|
|
|
+ subrange:(min,max:integer; {lower and upper bound}
|
|
|
+ rangetype:sp; {type of bounds}
|
|
|
+ subrno:integer {number of subr descriptor}
|
|
|
+ );
|
|
|
+ pointer :(eltype:sp); {type of pointed object}
|
|
|
+ power :(elset:sp); {type of set elements}
|
|
|
+ files :(filtype:sp); {type of file elements}
|
|
|
+ arrays,carray:
|
|
|
+ (aeltype:sp; {type of array elements}
|
|
|
+ inxtype:sp; {type of array index}
|
|
|
+ arpos:position {position of array descriptor}
|
|
|
+ );
|
|
|
+ records :(fstfld:ip; {points to first field}
|
|
|
+ tagsp:sp {points to tag if present}
|
|
|
+ );
|
|
|
+ variant :(varval:integer; {tag value for this variant}
|
|
|
+ nxtvar:sp; {next equilevel variant}
|
|
|
+ subtsp:sp {points to tag for sub-case}
|
|
|
+ );
|
|
|
+ tag :(fstvar:sp; {first variant of case}
|
|
|
+ tfldsp:sp {type of tag}
|
|
|
+ )
|
|
|
+ end;
|
|
|
+
|
|
|
+ identifier=record
|
|
|
+ idtype:sp; {type of identifier}
|
|
|
+ name:idarr; {name of identifier}
|
|
|
+ llink,rlink:ip; {see enterid,searchid}
|
|
|
+ next:ip; {used to make several chains}
|
|
|
+ iflag:iflagset; {several flag bits}
|
|
|
+ case klass:idclass of
|
|
|
+ types :();
|
|
|
+ konst :(value:integer); {for integers the value is
|
|
|
+ computed and stored in this field.
|
|
|
+ For strings and reals an assembler constant is
|
|
|
+ defined labeled '.1', '.2', ... This '.' number is then
|
|
|
+ stored in value. For reals value may be negated to
|
|
|
+ indicate that the opposite of the assembler constant
|
|
|
+ is needed. }
|
|
|
+ vars :(vpos:position); {position of var}
|
|
|
+ field :(foffset:integer); {offset to begin of record}
|
|
|
+ carrbnd :(); {idtype points to carray struct}
|
|
|
+ proc,func:
|
|
|
+ (case pfkind:kindofpf of
|
|
|
+ standard:(key:standpf); {identification}
|
|
|
+ formal,actual,forward,extern,varargs:
|
|
|
+ (pfpos:position; {lv gives declaration level.
|
|
|
+ ad is relevant for formal pf's and for
|
|
|
+ functions (no conflict!!).
|
|
|
+ for functions: ad is the result address.
|
|
|
+ for formal pf's: ad is the address of the
|
|
|
+ descriptor }
|
|
|
+ pfno:integer; {unique pf number}
|
|
|
+ maxlb:integer; {bytes of parameters}
|
|
|
+ parhead:ip {head of parameter list}
|
|
|
+ )
|
|
|
+ )
|
|
|
+ end;
|
|
|
+
|
|
|
+ labl=record
|
|
|
+ nextlp:lp; {chain of labels}
|
|
|
+ seen:boolean;
|
|
|
+ labval:integer; {label number given by the programmer}
|
|
|
+ labname:integer; {label number given by the compiler}
|
|
|
+ labdlb:integer {zero means only locally used,
|
|
|
+ otherwise dlbno of label information}
|
|
|
+ end;
|
|
|
+
|
|
|
+{-------------------------------------------------------------------}
|
|
|
+var {the most frequent used externals are declared first}
|
|
|
+ sy:symbol; {last symbol}
|
|
|
+ a:attr; {type,access method,position,value of expr}
|
|
|
+{returned by insym}
|
|
|
+ ch:char; {last character}
|
|
|
+ chsy:chartype; {type of ch, used by insym}
|
|
|
+ val:integer; {if last symbol is an constant }
|
|
|
+ ix:integer; {string length}
|
|
|
+ eol:boolean; {true of current ch is a space, replacing a newline}
|
|
|
+ zerostring:boolean; {true for strings in " "}
|
|
|
+ id:idarr; {if last symbol is an identifier}
|
|
|
+{some counters}
|
|
|
+ lino:integer; {line number on code file (1..n) }
|
|
|
+ dlbno:integer; {number of last global number}
|
|
|
+ holeb:integer; {size of hol-area}
|
|
|
+ level:integer; {current static level}
|
|
|
+ argc:integer; {index in argv}
|
|
|
+ lastpfno:integer; {unique pf number counter}
|
|
|
+ copt:integer; {C-type strings allowed if on}
|
|
|
+ dopt:integer; {longs allowed if on}
|
|
|
+ iopt:integer; {number of bits in sets with base integer}
|
|
|
+ sopt:integer; {standard option}
|
|
|
+ srcchno:integer; {column count for errors}
|
|
|
+ srclino:integer; {source line number after preprocessing}
|
|
|
+ srcorig:integer; {source line number before preprocessing}
|
|
|
+ fildlb:integer; {label number of source string}
|
|
|
+{pointers pointing to standard types}
|
|
|
+ realptr,intptr,textptr,nullset,boolptr:sp;
|
|
|
+ charptr,nilptr,zeroptr,procptr,longptr:sp;
|
|
|
+{flags}
|
|
|
+ giveline:boolean; {give source line number at next statement}
|
|
|
+ including:boolean; {no LIN's for included code}
|
|
|
+ eofexpected:boolean; {quit without error if true (nextch) }
|
|
|
+ main:boolean; {complete programme or a module}
|
|
|
+ intypedec:boolean; {true if nested in typedefinition}
|
|
|
+ fltused:boolean; {true if floating point instructions are used}
|
|
|
+ seconddot:boolean; {indicates the second dot of '..'}
|
|
|
+{pointers}
|
|
|
+ fwptr:ip; {head of chain of forward reference pointers}
|
|
|
+ progp:ip; {program identifier}
|
|
|
+ currproc:ip; {current procedure/function ip (see selector)}
|
|
|
+ top:np; {pointer to the most recent name space}
|
|
|
+ lastnp:np; {pointer to nameinfo of last searched ident }
|
|
|
+{records}
|
|
|
+ b:blockinfo; {all info to be stacked at pfdeclaration}
|
|
|
+ fa:attr; {attr for current file name}
|
|
|
+{arrays}
|
|
|
+ sizes:array[0 .. sz_last] of integer;
|
|
|
+ strbuf:array[1..smax] of char;
|
|
|
+ rw:array[rwrange] of idarr;
|
|
|
+ {reserved words}
|
|
|
+ frw:array[0..idmax] of integer;
|
|
|
+ {indices in rw}
|
|
|
+ rsy:array[rwrange] of symbol;
|
|
|
+ {symbol for reserved words}
|
|
|
+ cs:array[char] of chartype;
|
|
|
+ {chartype of a character}
|
|
|
+ csy:array[rparentch..equal] of symbol;
|
|
|
+ {symbol for single character symbols}
|
|
|
+ lmn:array[libmnem] of packed array[1..4] of char;
|
|
|
+ {mnemonics of pascal library routines}
|
|
|
+ opt:array['a'..'z'] of integer;
|
|
|
+ forceopt:array['a'..'z'] of boolean;
|
|
|
+ {26 different options}
|
|
|
+ undefip:array[idclass] of ip;
|
|
|
+ {used in searchid}
|
|
|
+ iop:array[boolean] of ip;
|
|
|
+ {false:standard input, true:standard output}
|
|
|
+ argv:array[0..maxargc] of
|
|
|
+ record name:idarr; ad:integer end;
|
|
|
+ {save here the external heading names}
|
|
|
+{files}
|
|
|
+ em:file of byte; {the EM code}
|
|
|
+ errors:text; {the compilation errors}
|
|
|
+ source:fnarr;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure initpos(var p:position);
|
|
|
+begin p.lv:=level; p.ad:=0; end;
|
|
|
+
|
|
|
+procedure inita(fsp:sp; fad:integer);
|
|
|
+begin with a do begin
|
|
|
+ asp:=fsp; packbit:=false; ak:=fixed; pos.ad:=fad; pos.lv:=level;
|
|
|
+end end;
|
|
|
+
|
|
|
+function newip(kl:idclass; n:idarr; idt:sp; nxt:ip):ip;
|
|
|
+var p:ip; f:iflagset;
|
|
|
+begin f:=[];
|
|
|
+ case kl of
|
|
|
+ types,carrbnd: {similar structure}
|
|
|
+ new(p,types);
|
|
|
+ konst:
|
|
|
+ begin new(p,konst); p^.value:=0 end;
|
|
|
+ vars:
|
|
|
+ begin new(p,vars); f:=[used,assigned]; initpos(p^.vpos) end;
|
|
|
+ field:
|
|
|
+ begin new(p,field); p^.foffset:=0 end;
|
|
|
+ proc,func: {same structure}
|
|
|
+ begin new(p,proc,actual); p^.pfkind:=actual;
|
|
|
+ initpos(p^.pfpos); p^.pfno:=0; p^.maxlb:=0; p^.parhead:=nil;
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ p^.name:=n; p^.klass:=kl; p^.idtype:=idt; p^.next:=nxt;
|
|
|
+ p^.llink:=nil; p^.rlink:=nil; p^.iflag:=f; newip:=p
|
|
|
+end;
|
|
|
+
|
|
|
+function newsp(sf:structform; sz:integer):sp;
|
|
|
+var p:sp; sflag:sflagset;
|
|
|
+begin sflag:=[];
|
|
|
+ case sf of
|
|
|
+ scalar:
|
|
|
+ begin new(p,scalar); p^.scalno:=0; p^.fconst:=nil end;
|
|
|
+ subrange:
|
|
|
+ new(p,subrange);
|
|
|
+ pointer:
|
|
|
+ begin new(p,pointer); p^.eltype:=nil end;
|
|
|
+ power:
|
|
|
+ new(p,power);
|
|
|
+ files:
|
|
|
+ begin new(p,files); sflag:=[withfile] end;
|
|
|
+ arrays,carray: {same structure}
|
|
|
+ new(p,arrays);
|
|
|
+ records:
|
|
|
+ new(p,records);
|
|
|
+ variant:
|
|
|
+ new(p,variant);
|
|
|
+ tag:
|
|
|
+ new(p,tag);
|
|
|
+ end;
|
|
|
+ p^.form:=sf; p^.size:=sz; p^.sflag:=sflag; newsp:=p;
|
|
|
+end;
|
|
|
+
|
|
|
+function sizeof(fsp:sp; partword:boolean):integer;
|
|
|
+var s:integer;
|
|
|
+begin if fsp=nil then s:=0 else s:=fsp^.size;
|
|
|
+ if s<>0 then
|
|
|
+ if partword and (s<sz_word) then
|
|
|
+ while sz_word mod s <> 0 do s:=s+1
|
|
|
+ else
|
|
|
+ while s mod sz_word <> 0 do s:=s+1;
|
|
|
+ sizeof:=s
|
|
|
+end;
|
|
|
+
|
|
|
+function formof(fsp:sp; forms:formset):boolean;
|
|
|
+begin if fsp=nil then formof:=false else formof:=fsp^.form in forms end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure put1(b:byte);
|
|
|
+begin write(em,b) end;
|
|
|
+
|
|
|
+procedure put2(i:integer);
|
|
|
+var i1,i2:byte;
|
|
|
+begin
|
|
|
+ if i<0 then
|
|
|
+ begin i:=-(i+1); i1:=MU1 - i mod NU1; i2:=MU1 - i div NU1 end
|
|
|
+ else
|
|
|
+ begin i1:=i mod NU1; i2:=i div NU1 end;
|
|
|
+ put1(i1); put1(i2)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure argend;
|
|
|
+begin put1(sp_cend) end;
|
|
|
+
|
|
|
+procedure argcst(i:integer);
|
|
|
+begin
|
|
|
+ if (i >= -sp_zcst0) and (i < sp_ncst0-sp_zcst0) then
|
|
|
+ put1(i + sp_zcst0 + sp_fcst0)
|
|
|
+ else
|
|
|
+ begin put1(sp_cst2); put2(i) end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure argnil;
|
|
|
+begin put1(sp_icon); argcst(sz_addr); argcst(1); put1(ord('0')) end;
|
|
|
+
|
|
|
+procedure argilb(i:integer);
|
|
|
+begin
|
|
|
+ if i<=MU1 then
|
|
|
+ begin put1(sp_ilb1); put1(i) end
|
|
|
+ else
|
|
|
+ begin put1(sp_ilb2); put2(i) end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure argdlb(i:integer);
|
|
|
+begin
|
|
|
+ if i<=MU1 then
|
|
|
+ begin put1(sp_dlb1); put1(i) end
|
|
|
+ else
|
|
|
+ begin put1(sp_dlb2); put2(i) end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure argident(var a:idarr);
|
|
|
+var i,j:integer;
|
|
|
+begin i:=idmax;
|
|
|
+ while (a[i]=' ') and (i>1) do i:=i-1;
|
|
|
+ put1(sp_pnam); argcst(i);
|
|
|
+ for j:=1 to i do put1(ord(a[j]))
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genop(b:byte);
|
|
|
+begin put1(b); lino:=lino+1 end;
|
|
|
+
|
|
|
+procedure gencst(b:byte; i:integer);
|
|
|
+begin genop(b); argcst(i) end;
|
|
|
+
|
|
|
+procedure gensp(m:libmnem; s:integer);
|
|
|
+var i:integer;
|
|
|
+begin genop(op_cal); put1(sp_pnam); argcst(4);
|
|
|
+ for i:=1 to 4 do put1(ord(lmn[m][i]));
|
|
|
+ gencst(op_asp,s)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genpnam(b:byte; fip:ip);
|
|
|
+var n:idarr; i,j:integer;
|
|
|
+begin
|
|
|
+ if fip^.pfpos.lv<=1 then n:=fip^.name else
|
|
|
+ begin n:='_ '; j:=1; i:=fip^.pfno;
|
|
|
+ while i<>0 do
|
|
|
+ begin j:=j+1; n[j]:=chr(i mod 10 + ord('0')); i:=i div 10 end;
|
|
|
+ end;
|
|
|
+ genop(b); argident(n)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genasp(m:byte);
|
|
|
+begin gencst(m,sizeof(a.asp,wordmult)) end;
|
|
|
+
|
|
|
+procedure genlin;
|
|
|
+begin giveline:=false;
|
|
|
+ if opt['l']<>off then if main then gencst(op_lin,srcorig)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genreg(sz,ad,regval:integer);
|
|
|
+begin gencst(ps_mes,ms_reg);
|
|
|
+ argcst(ad); argcst(sz); argcst(regval); argend
|
|
|
+end;
|
|
|
+
|
|
|
+procedure laedlb(d:integer);
|
|
|
+begin genop(op_lae); argdlb(d) end;
|
|
|
+
|
|
|
+procedure exchange(l1,l2:integer);
|
|
|
+var d1,d2:integer;
|
|
|
+begin d1:=l2-l1; d2:=lino-l2;
|
|
|
+ if (d1<>0) and (d2<>0) then
|
|
|
+ begin gencst(ps_exc,d1); argcst(d2) end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure newilb(i:integer);
|
|
|
+begin lino:=lino+1;
|
|
|
+ if i<sp_nilb0 then put1(i+sp_filb0) else argilb(i)
|
|
|
+end;
|
|
|
+
|
|
|
+function newdlb:integer;
|
|
|
+begin lino:=lino+1; dlbno:=dlbno+1; argdlb(dlbno); newdlb:=dlbno end;
|
|
|
+
|
|
|
+function romstr(typ:byte; siz:integer):integer;
|
|
|
+var i:integer;
|
|
|
+begin romstr:=newdlb; genop(ps_rom);
|
|
|
+ put1(typ); if typ<>sp_scon then argcst(siz); argcst(ix);
|
|
|
+ for i:=1 to ix do put1(ord(strbuf[i])); argend
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure error(err:integer);
|
|
|
+{as you will notice, all error numbers are preceded by '+' and '0' to
|
|
|
+ ease their renumbering in case of new errornumbers.
|
|
|
+}
|
|
|
+begin writeln(errors,err,srclino,srcchno);
|
|
|
+ if err>0 then begin gencst(ps_mes,ms_err); argend end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure errid(err:integer; var id:idarr);
|
|
|
+begin write(errors,'''',id); error(err) end;
|
|
|
+
|
|
|
+procedure errint(err:integer; i:integer);
|
|
|
+begin write(errors,i:1); error(err) end;
|
|
|
+
|
|
|
+procedure errasp(err:integer);
|
|
|
+begin if a.asp<>nil then begin error(err); a.asp:=nil end end;
|
|
|
+
|
|
|
+procedure teststandard;
|
|
|
+begin if sopt<>off then error(-(+01)) end;
|
|
|
+
|
|
|
+procedure enterid(fip: ip);
|
|
|
+{enter id pointed at by fip into the name-table,
|
|
|
+ which on each declaration level is organised as
|
|
|
+ an unbalanced binary tree}
|
|
|
+var nam:idarr; lip,lip1:ip; lleft,again:boolean;
|
|
|
+begin nam:=fip^.name; again:=false; assert nam[1]<>' ';
|
|
|
+ lip:=top^.fname;
|
|
|
+ if lip=nil then top^.fname:=fip else
|
|
|
+ begin
|
|
|
+ repeat lip1:=lip;
|
|
|
+ if lip^.name>nam then
|
|
|
+ begin lip:=lip^.llink; lleft:=true end
|
|
|
+ else
|
|
|
+ begin if lip^.name=nam then again:=true; {name conflict}
|
|
|
+ lip:=lip^.rlink; lleft:=false;
|
|
|
+ end;
|
|
|
+ until lip=nil;
|
|
|
+ if lleft then lip1^.llink:=fip else lip1^.rlink:=fip
|
|
|
+ end;
|
|
|
+ fip^.llink:=nil; fip^.rlink:=nil;
|
|
|
+ if again then errid(+02,nam);
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure trace(tname:idarr; fip:ip; var namdlb:integer);
|
|
|
+var i:integer;
|
|
|
+begin
|
|
|
+ if opt['t']<>off then
|
|
|
+ begin
|
|
|
+ if namdlb=0 then
|
|
|
+ begin namdlb:=newdlb; genop(ps_rom); put1(sp_scon); argcst(8);
|
|
|
+ for i:=1 to 8 do put1(ord(fip^.name[i])); argend;
|
|
|
+ end;
|
|
|
+ laedlb(namdlb); genop(op_cal); argident(tname);
|
|
|
+ gencst(op_asp,sz_addr);
|
|
|
+ end;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure expandnullset(fsp:sp);
|
|
|
+var s:integer;
|
|
|
+begin s:=sizeof(fsp,wordmult)-sz_word;
|
|
|
+ if s<>0 then gencst(op_zer,s); a.asp:=fsp
|
|
|
+end;
|
|
|
+
|
|
|
+procedure push(local:boolean; ad:integer; sz:integer);
|
|
|
+begin assert sz mod sz_word = 0;
|
|
|
+ if sz=sz_word then
|
|
|
+ if local then gencst(op_lol,ad) else gencst(op_loe,ad)
|
|
|
+ else if sz=2*sz_word then
|
|
|
+ if local then gencst(op_ldl,ad) else gencst(op_lde,ad)
|
|
|
+ else
|
|
|
+ begin if local then gencst(op_lal,ad) else gencst(op_lae,ad);
|
|
|
+ gencst(op_loi,sz)
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure pop(local:boolean; ad:integer; sz:integer);
|
|
|
+begin assert sz mod sz_word = 0;
|
|
|
+ if sz=sz_word then
|
|
|
+ if local then gencst(op_stl,ad) else gencst(op_ste,ad)
|
|
|
+ else if sz=2*sz_word then
|
|
|
+ if local then gencst(op_sdl,ad) else gencst(op_sde,ad)
|
|
|
+ else
|
|
|
+ begin if local then gencst(op_lal,ad) else gencst(op_lae,ad);
|
|
|
+ gencst(op_sti,sz)
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure lexaddr(lv:integer; ad:integer);
|
|
|
+begin assert level>=lv;
|
|
|
+ if ad>=0 then gencst(op_lxa,level-lv) else gencst(op_lxl,level-lv);
|
|
|
+ gencst(op_adp,ad)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure loadpos(var p:position; sz:integer);
|
|
|
+begin with p do
|
|
|
+ if lv<=0 then push(global,ad,sz) else
|
|
|
+ if lv=level then push(local,ad,sz) else
|
|
|
+ begin lexaddr(lv,ad); gencst(op_loi,sz) end;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure descraddr(var p:position);
|
|
|
+begin if p.lv=0 then laedlb(p.ad) else loadpos(p,sz_addr) end;
|
|
|
+
|
|
|
+procedure loadaddr;
|
|
|
+begin with a,pos do begin
|
|
|
+ case ak of
|
|
|
+ fixed:
|
|
|
+ if lv<=0 then gencst(op_lae,ad) else
|
|
|
+ if lv=level then gencst(op_lal,ad) else lexaddr(lv,ad);
|
|
|
+ pfixed:
|
|
|
+ loadpos(pos,sz_addr);
|
|
|
+ ploaded:
|
|
|
+ ;
|
|
|
+ indexed:
|
|
|
+ gencst(op_aar,sz_word);
|
|
|
+ end; {case}
|
|
|
+ ak:=ploaded;
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure load;
|
|
|
+var sz:integer;
|
|
|
+begin with a do begin sz:=sizeof(asp,packbit);
|
|
|
+ if asp<>nil then
|
|
|
+ case ak of
|
|
|
+ cst:
|
|
|
+ gencst(op_loc,pos.ad); {only one-word scalars}
|
|
|
+ fixed:
|
|
|
+ loadpos(pos,sz);
|
|
|
+ pfixed:
|
|
|
+ begin loadpos(pos,sz_addr); gencst(op_loi,sz) end;
|
|
|
+ loaded:
|
|
|
+ ;
|
|
|
+ ploaded:
|
|
|
+ gencst(op_loi,sz);
|
|
|
+ indexed:
|
|
|
+ gencst(op_lar,sz_word);
|
|
|
+ end; {case}
|
|
|
+ ak:=loaded;
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure store;
|
|
|
+var sz:integer;
|
|
|
+begin with a,pos do begin sz:=sizeof(asp,packbit);
|
|
|
+ if asp<>nil then
|
|
|
+ case ak of
|
|
|
+ fixed:
|
|
|
+ if lv<=0 then pop(global,ad,sz) else
|
|
|
+ if level=lv then pop(local,ad,sz) else
|
|
|
+ begin lexaddr(lv,ad); gencst(op_sti,sz) end;
|
|
|
+ pfixed:
|
|
|
+ begin loadpos(pos,sz_addr); gencst(op_sti,sz) end;
|
|
|
+ ploaded:
|
|
|
+ gencst(op_sti,sz);
|
|
|
+ indexed:
|
|
|
+ gencst(op_sar,sz_word);
|
|
|
+ end; {case}
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure fieldaddr(off:integer);
|
|
|
+begin with a do
|
|
|
+ if (ak=fixed) and not packbit then pos.ad:=pos.ad+off else
|
|
|
+ begin loadaddr; gencst(op_adp,off) end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure loadcheap;
|
|
|
+begin if formof(a.asp,[arrays..records]) then loadaddr else load end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure nextch;
|
|
|
+begin
|
|
|
+ eol:=eoln(input); read(input,ch); srcchno:=srcchno+1; chsy:=cs[ch];
|
|
|
+end;
|
|
|
+
|
|
|
+procedure nextln;
|
|
|
+begin
|
|
|
+ if eof(input) then
|
|
|
+ begin
|
|
|
+ if not eofexpected then error(+03) else
|
|
|
+ if fltused then begin gencst(ps_mes,ms_flt); argend end;
|
|
|
+#ifdef STANDARD
|
|
|
+ goto 9999
|
|
|
+#else
|
|
|
+ halt
|
|
|
+#endif
|
|
|
+ end;
|
|
|
+ srcchno:=0; srclino:=srclino+1;
|
|
|
+ if not including then
|
|
|
+ begin srcorig:=srcorig+1; giveline:=true end;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure options(normal:boolean);
|
|
|
+var ci:char; i:integer;
|
|
|
+
|
|
|
+procedure getc;
|
|
|
+begin if normal then nextch else read(errors,ch) end;
|
|
|
+
|
|
|
+begin
|
|
|
+ repeat getc;
|
|
|
+ if (ch>='a') and (ch<='z') then
|
|
|
+ begin ci:=ch; getc; i:=0;
|
|
|
+ if ch='+' then begin i:=1; getc end else
|
|
|
+ if ch='-' then getc else
|
|
|
+ if cs[ch]=digit then
|
|
|
+ repeat i:=i*10 + ord(ch) - ord('0'); getc;
|
|
|
+ until cs[ch]<>digit
|
|
|
+ else i:=-1;
|
|
|
+ if i>=0 then
|
|
|
+ if not normal then
|
|
|
+ begin forceopt[ci]:=true; opt[ci]:=i end
|
|
|
+ else
|
|
|
+ if not forceopt[ci] then opt[ci]:=i;
|
|
|
+ end;
|
|
|
+ until ch<>',';
|
|
|
+end;
|
|
|
+
|
|
|
+procedure linedirective;
|
|
|
+var i:integer; fname:fnarr;
|
|
|
+begin
|
|
|
+ repeat nextch until (ch='"') or eol;
|
|
|
+ if eol then error(+04) else
|
|
|
+ begin nextch; i:=0;
|
|
|
+ while (ch<>'"') and not eol do
|
|
|
+ begin
|
|
|
+ if ch='/' then i:=0 else
|
|
|
+ begin i:=i+1; if i<=fnmax then fname[i]:=ch end;
|
|
|
+ nextch
|
|
|
+ end;
|
|
|
+ while i<fnmax do begin i:=i+1; fname[i]:=' ' end;
|
|
|
+ including:=fname<>source; while not eol do nextch
|
|
|
+ end;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure putdig;
|
|
|
+begin ix:=ix+1; if ix<=smax then strbuf[ix]:=ch; nextch end;
|
|
|
+
|
|
|
+procedure inident;
|
|
|
+label 1;
|
|
|
+var i,k:integer;
|
|
|
+begin k:=0; id:=spaces;
|
|
|
+ repeat
|
|
|
+ if chsy=upper then ch:=chr(ord(ch)-ord('A')+ord('a'));
|
|
|
+ if k<idmax then begin k:=k+1; id[k]:=ch end;
|
|
|
+ nextch
|
|
|
+ until chsy>digit;
|
|
|
+ {lower=0,upper=1,digit=2. ugly but fast}
|
|
|
+ for i:=frw[k-1] to frw[k] - 1 do
|
|
|
+ if rw[i]=id then
|
|
|
+ begin sy:=rsy[i]; goto 1 end;
|
|
|
+ sy:=ident;
|
|
|
+1:
|
|
|
+end;
|
|
|
+
|
|
|
+procedure innumber;
|
|
|
+label 1;
|
|
|
+const imax = 10;
|
|
|
+ maxintstring = '0000032767';
|
|
|
+ maxlongstring = '2147483647';
|
|
|
+var i,j:integer;
|
|
|
+ is:packed array[1..imax] of char;
|
|
|
+begin ix:=0; sy:=intcst; val:=0;
|
|
|
+ repeat putdig until chsy<>digit;
|
|
|
+ if (ch='.') or (ch='e') or (ch='E') then
|
|
|
+ begin
|
|
|
+ if ch='.' then
|
|
|
+ begin putdig;
|
|
|
+ if ch='.' then
|
|
|
+ begin seconddot:=true; ix:=ix-1; goto 1 end;
|
|
|
+ if chsy<>digit then error(+05) else
|
|
|
+ repeat putdig until chsy<>digit;
|
|
|
+ end;
|
|
|
+ if (ch='e') or (ch='E') then
|
|
|
+ begin putdig;
|
|
|
+ if (ch='+') or (ch='-') then putdig;
|
|
|
+ if chsy<>digit then error(+06) else
|
|
|
+ repeat putdig until chsy<>digit;
|
|
|
+ end;
|
|
|
+ if ix>smax then begin error(+07); ix:=smax end;
|
|
|
+ sy:=realcst; fltused:=true; val:=romstr(sp_fcon,sz_real);
|
|
|
+ end;
|
|
|
+1:if (chsy=lower) or (chsy=upper) then teststandard;
|
|
|
+ if sy=intcst then
|
|
|
+ if ix>imax then error(+08) else
|
|
|
+ begin is:='0000000000'; i:=ix; j:=imax;
|
|
|
+ repeat is[j]:=strbuf[i]; j:=j-1; i:=i-1 until i=0;
|
|
|
+ if is<=maxintstring then
|
|
|
+ repeat j:=j+1; val:=val*10 - ord('0') + ord(is[j]) until j=imax
|
|
|
+ else if (is<=maxlongstring) and (dopt<>off) then
|
|
|
+ begin sy:=longcst; val:=romstr(sp_icon,sz_long) end
|
|
|
+ else error(+09)
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure instring(qc:char);
|
|
|
+begin ix:=0; zerostring:=qc='"';
|
|
|
+ repeat
|
|
|
+ repeat nextch; ix:=ix+1; if ix<=smax then strbuf[ix]:=ch;
|
|
|
+ until (ch=qc) or eol;
|
|
|
+ if ch=qc then nextch else error(+010);
|
|
|
+ until ch<>qc;
|
|
|
+ if not zerostring then
|
|
|
+ begin ix:=ix-1; if ix=0 then error(+011) end
|
|
|
+ else
|
|
|
+ begin strbuf[ix]:=chr(0); if copt=off then error(+012) end;
|
|
|
+ if (ix=1) and not zerostring then
|
|
|
+ begin sy:=charcst; val:=ord(strbuf[1]) end
|
|
|
+ else
|
|
|
+ begin if ix>smax then begin error(+013); ix:=smax end;
|
|
|
+ sy:=stringcst; val:=romstr(sp_scon,0);
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure incomment;
|
|
|
+var stopc:char;
|
|
|
+begin nextch; stopc:='}';
|
|
|
+ if ch='$' then options(true);
|
|
|
+ while (ch<>'}') and (ch<>stopc) do
|
|
|
+ begin stopc:='}'; if ch='*' then stopc:=')';
|
|
|
+ if eol then nextln; nextch
|
|
|
+ end;
|
|
|
+ if ch<>'}' then teststandard;
|
|
|
+ nextch
|
|
|
+end;
|
|
|
+
|
|
|
+procedure insym;
|
|
|
+ {read next basic symbol of source program and return its
|
|
|
+ description in the global variables sy, op, id, val and ix}
|
|
|
+label 1;
|
|
|
+begin
|
|
|
+1:case chsy of
|
|
|
+ tabch:
|
|
|
+ begin srcchno:=srcchno - srcchno mod 8 + 8; nextch; goto 1 end;
|
|
|
+ layout:
|
|
|
+ begin if eol then nextln; nextch; goto 1 end;
|
|
|
+ lower,upper: inident;
|
|
|
+ digit: innumber;
|
|
|
+ quotech,dquotech:
|
|
|
+ instring(ch);
|
|
|
+ colonch:
|
|
|
+ begin nextch;
|
|
|
+ if ch='=' then begin sy:=becomes; nextch end else sy:=colon1
|
|
|
+ end;
|
|
|
+ periodch:
|
|
|
+ begin nextch;
|
|
|
+ if seconddot then begin seconddot:=false; sy:=colon2 end else
|
|
|
+ if ch='.' then begin sy:=colon2; nextch end else sy:=period
|
|
|
+ end;
|
|
|
+ lessch:
|
|
|
+ begin nextch;
|
|
|
+ if ch='=' then begin sy:=lesy; nextch end else
|
|
|
+ if ch='>' then begin sy:=nesy; nextch end else sy:=ltsy
|
|
|
+ end;
|
|
|
+ greaterch:
|
|
|
+ begin nextch;
|
|
|
+ if ch='=' then begin sy:=gesy; nextch end else sy:=gtsy
|
|
|
+ end;
|
|
|
+ lparentch:
|
|
|
+ begin nextch;
|
|
|
+ if ch<>'*' then sy:=lparent else
|
|
|
+ begin teststandard; incomment; goto 1 end;
|
|
|
+ end;
|
|
|
+ lbracech:
|
|
|
+ begin incomment; goto 1 end;
|
|
|
+ rparentch,lbrackch,rbrackch,commach,semich,arrowch,
|
|
|
+ plusch,minch,slash,star,equal:
|
|
|
+ begin sy:=csy[chsy]; nextch end;
|
|
|
+ others:
|
|
|
+ begin
|
|
|
+ if (ch='#') and (srcchno=1) then linedirective else
|
|
|
+ begin error(+014); nextch end;
|
|
|
+ goto 1
|
|
|
+ end;
|
|
|
+ end {case}
|
|
|
+end;
|
|
|
+
|
|
|
+procedure nextif(fsy:symbol; err:integer);
|
|
|
+begin if sy=fsy then insym else error(-err) end;
|
|
|
+
|
|
|
+function find1(sys1,sys2:sos; err:integer):boolean;
|
|
|
+{symbol of sys1 expected. return true if sy in sys1}
|
|
|
+begin
|
|
|
+ if not (sy in sys1) then
|
|
|
+ begin error(err); while not (sy in sys1+sys2) do insym end;
|
|
|
+ find1:=sy in sys1
|
|
|
+end;
|
|
|
+
|
|
|
+function find2(sys1,sys2:sos; err:integer):boolean;
|
|
|
+{symbol of sys1+sys2 expected. return true if sy in sys1}
|
|
|
+begin
|
|
|
+ if not (sy in sys1+sys2) then
|
|
|
+ begin error(err); repeat insym until sy in sys1+sys2 end;
|
|
|
+ find2:=sy in sys1
|
|
|
+end;
|
|
|
+
|
|
|
+function find3(sy1:symbol; sys2:sos; err:integer):boolean;
|
|
|
+{symbol sy1 or one of sys2 expected. return true if sy1 found and skip it}
|
|
|
+begin find3:=true;
|
|
|
+ if not (sy in [sy1]+sys2) then
|
|
|
+ begin error(err); repeat insym until sy in [sy1]+sys2 end;
|
|
|
+ if sy=sy1 then insym else find3:=false
|
|
|
+end;
|
|
|
+
|
|
|
+function endofloop(sys1,sys2:sos; sy3:symbol; err:integer):boolean;
|
|
|
+begin endofloop:=false;
|
|
|
+ if find2(sys2+[sy3],sys1,err) then nextif(sy3,err+1)
|
|
|
+ else endofloop:=true;
|
|
|
+end;
|
|
|
+
|
|
|
+function lastsemicolon(sys1,sys2:sos; err:integer):boolean;
|
|
|
+begin lastsemicolon:=true;
|
|
|
+ if not endofloop(sys1,sys2,semicolon,err) then
|
|
|
+ if find2(sys2,sys1,err+2) then lastsemicolon:=false
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+function searchid(fidcls: setofids):ip;
|
|
|
+{search for current identifier symbol in the name table}
|
|
|
+label 1;
|
|
|
+var lip:ip; ic:idclass;
|
|
|
+begin lastnp:=top;
|
|
|
+ while lastnp<>nil do
|
|
|
+ begin lip:=lastnp^.fname;
|
|
|
+ while lip<>nil do
|
|
|
+ if lip^.name=id then
|
|
|
+ if lip^.klass in fidcls then
|
|
|
+ begin
|
|
|
+ if lip^.klass=vars then if lip^.vpos.lv<>level then
|
|
|
+ lip^.iflag:=lip^.iflag+[noreg];
|
|
|
+ goto 1
|
|
|
+ end
|
|
|
+ else lip:=lip^.rlink
|
|
|
+ else
|
|
|
+ if lip^.name< id then lip:=lip^.rlink else lip:=lip^.llink;
|
|
|
+ lastnp:=lastnp^.nlink;
|
|
|
+ end;
|
|
|
+ errid(+015,id);
|
|
|
+ if types in fidcls then ic:=types else
|
|
|
+ if vars in fidcls then ic:=vars else
|
|
|
+ if konst in fidcls then ic:=konst else
|
|
|
+ if proc in fidcls then ic:=proc else
|
|
|
+ if func in fidcls then ic:=func else ic:=field;
|
|
|
+ lip:=undefip[ic];
|
|
|
+1:
|
|
|
+ searchid:=lip
|
|
|
+end;
|
|
|
+
|
|
|
+function searchsection(fip: ip):ip;
|
|
|
+{to find record fields and forward declared procedure id's
|
|
|
+ -->procedure pfdeclaration
|
|
|
+ -->procedure selector}
|
|
|
+label 1;
|
|
|
+begin
|
|
|
+ while fip<>nil do
|
|
|
+ if fip^.name=id then goto 1 else
|
|
|
+ if fip^.name< id then fip:=fip^.rlink else fip:=fip^.llink;
|
|
|
+1: searchsection:=fip
|
|
|
+end;
|
|
|
+
|
|
|
+function searchlab(flp:lp; val:integer):lp;
|
|
|
+label 1;
|
|
|
+begin
|
|
|
+ while flp<>nil do
|
|
|
+ if flp^.labval=val then goto 1 else flp:=flp^.nextlp;
|
|
|
+1:searchlab:=flp
|
|
|
+end;
|
|
|
+
|
|
|
+procedure opconvert(ts:twostruct);
|
|
|
+var op:integer;
|
|
|
+begin with a do begin genasp(op_loc);
|
|
|
+ case ts of
|
|
|
+ ir, lr: begin asp:=realptr; op:=op_cif; fltused:=true end;
|
|
|
+ ri: begin asp:=intptr ; op:=op_cfi; fltused:=true end;
|
|
|
+ rl: begin asp:=longptr; op:=op_cfi; fltused:=true end;
|
|
|
+ li: begin asp:=intptr ; op:=op_cii end;
|
|
|
+ il: begin asp:=longptr; op:=op_cii end;
|
|
|
+ end;
|
|
|
+ genasp(op_loc); genop(op)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure negate;
|
|
|
+begin if a.asp=realptr then genasp(op_ngf) else genasp(op_ngi) end;
|
|
|
+
|
|
|
+function desub(fsp:sp):sp;
|
|
|
+begin if formof(fsp,[subrange]) then fsp:=fsp^.rangetype; desub:=fsp end;
|
|
|
+
|
|
|
+function nicescalar(fsp:sp):boolean;
|
|
|
+begin
|
|
|
+ if fsp=nil then nicescalar:=true else
|
|
|
+ nicescalar:=(fsp^.form=scalar) and (fsp<>realptr) and (fsp<>longptr)
|
|
|
+end;
|
|
|
+
|
|
|
+function bounded(fsp:sp):boolean;
|
|
|
+begin bounded:=false;
|
|
|
+ if fsp<>nil then
|
|
|
+ if fsp^.form=subrange then bounded:=true else
|
|
|
+ if fsp^.form=scalar then bounded:=fsp^.fconst<>nil
|
|
|
+end;
|
|
|
+
|
|
|
+procedure bounds(fsp:sp; var fmin,fmax:integer);
|
|
|
+begin
|
|
|
+ if fsp=nil then
|
|
|
+ begin fmin:=0; fmax:=0 end
|
|
|
+ else
|
|
|
+ case fsp^.form of
|
|
|
+ subrange:
|
|
|
+ begin fmin:=fsp^.min; fmax:=fsp^.max end;
|
|
|
+ scalar:
|
|
|
+ begin fmin:=0; fmax:=fsp^.fconst^.value end
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genrck(fsp:sp);
|
|
|
+var min,max,sno:integer;
|
|
|
+begin
|
|
|
+ if opt['r']<>off then if bounded(fsp) then
|
|
|
+ begin
|
|
|
+ if fsp^.form=scalar then sno:=fsp^.scalno else sno:=fsp^.subrno;
|
|
|
+ if sno=0 then
|
|
|
+ begin bounds(fsp,min,max); sno:=newdlb;
|
|
|
+ gencst(ps_rom,min); argcst(max); argend;
|
|
|
+ if fsp^.form=scalar then fsp^.scalno:=sno else fsp^.subrno:=sno
|
|
|
+ end;
|
|
|
+ laedlb(sno); gencst(op_rck,sz_word);
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure checkbnds(fsp:sp);
|
|
|
+var min1,max1,min2,max2:integer;
|
|
|
+begin
|
|
|
+ if bounded(fsp) then
|
|
|
+ if not bounded(a.asp) then genrck(fsp) else
|
|
|
+ begin bounds(fsp,min1,max1); bounds(a.asp,min2,max2);
|
|
|
+ if (min2<min1) or (max2>max1) then
|
|
|
+ genrck(fsp);
|
|
|
+ end;
|
|
|
+ a.asp:=fsp;
|
|
|
+end;
|
|
|
+
|
|
|
+function eqstruct(p,q:sp):boolean;
|
|
|
+begin eqstruct:=(p=q) or (p=nil) or (q=nil) end;
|
|
|
+
|
|
|
+function string(fsp:sp):boolean;
|
|
|
+var lsp:sp;
|
|
|
+begin string:=false;
|
|
|
+ if formof(fsp,[arrays]) then
|
|
|
+ if eqstruct(fsp^.aeltype,charptr) then
|
|
|
+ if spack in fsp^.sflag then
|
|
|
+ begin lsp:=fsp^.inxtype;
|
|
|
+ if lsp=nil then string:=true else
|
|
|
+ if lsp^.form=subrange then
|
|
|
+ if lsp^.rangetype=intptr then
|
|
|
+ if lsp^.min=1 then
|
|
|
+ string:=true
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+function compat(p,q:sp):twostruct;
|
|
|
+begin compat:=noteq;
|
|
|
+ if eqstruct(p,q) then compat:=eq else
|
|
|
+ begin p:=desub(p); q:=desub(q);
|
|
|
+ if eqstruct(p,q) then compat:=subeq else
|
|
|
+ if p^.form=q^.form then
|
|
|
+ case p^.form of
|
|
|
+ scalar:
|
|
|
+ if (p=intptr) and (q=realptr) then compat:=ir else
|
|
|
+ if (p=realptr) and (q=intptr) then compat:=ri else
|
|
|
+ if (p=intptr) and (q=longptr) then compat:=il else
|
|
|
+ if (p=longptr) and (q=intptr) then compat:=li else
|
|
|
+ if (p=longptr) and (q=realptr) then compat:=lr else
|
|
|
+ if (p=realptr) and (q=longptr) then compat:=rl else
|
|
|
+ ;
|
|
|
+ pointer:
|
|
|
+ if (p=nilptr) or (q=nilptr) then compat:=eq;
|
|
|
+ power:
|
|
|
+ if p=nullset then compat:=es else
|
|
|
+ if q=nullset then compat:=se else
|
|
|
+ if compat(p^.elset,q^.elset) <= subeq then
|
|
|
+ if p^.sflag=q^.sflag then compat:=eq;
|
|
|
+ arrays:
|
|
|
+ if string(p) and string(q) and (p^.size=q^.size) then compat:=eq;
|
|
|
+ files,carray,records: ;
|
|
|
+ end;
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure checkasp(fsp:sp; err:integer);
|
|
|
+var ts:twostruct;
|
|
|
+begin
|
|
|
+ ts:=compat(a.asp,fsp);
|
|
|
+ case ts of
|
|
|
+ eq:
|
|
|
+ if fsp<>nil then if withfile in fsp^.sflag then errasp(err);
|
|
|
+ subeq:
|
|
|
+ checkbnds(fsp);
|
|
|
+ li:
|
|
|
+ begin opconvert(ts); checkasp(fsp,err) end;
|
|
|
+ il,rl,lr,ir:
|
|
|
+ opconvert(ts);
|
|
|
+ es:
|
|
|
+ expandnullset(fsp);
|
|
|
+ noteq,ri,se:
|
|
|
+ errasp(err);
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure force(fsp:sp; err:integer);
|
|
|
+begin load; checkasp(fsp,err) end;
|
|
|
+
|
|
|
+function newident(kl:idclass; idt:sp; nxt:ip; err:integer):ip;
|
|
|
+begin newident:=nil;
|
|
|
+ if sy<>ident then error(err) else
|
|
|
+ begin newident:=newip(kl,id,idt,nxt); insym end
|
|
|
+end;
|
|
|
+
|
|
|
+function stringstruct:sp;
|
|
|
+var lsp:sp;
|
|
|
+begin {only used when ix and zerostring are still valid}
|
|
|
+ if zerostring then lsp:=zeroptr else
|
|
|
+ begin lsp:=newsp(arrays,ix*sz_char); lsp^.sflag:=[spack];
|
|
|
+ lsp^.aeltype:=charptr; lsp^.inxtype:=nil;
|
|
|
+ end;
|
|
|
+ stringstruct:=lsp;
|
|
|
+end;
|
|
|
+
|
|
|
+function posaddr(var lb:integer; fsp:sp; partword:boolean):integer;
|
|
|
+var sz:integer;
|
|
|
+begin sz:=sizeof(fsp,partword);
|
|
|
+ if lb >= MI2-sz then begin error(+016); lb:=0 end;
|
|
|
+ if not partword or (sz>=sz_word) then
|
|
|
+ while lb mod sz_word <> 0 do lb:=lb+1;
|
|
|
+ posaddr:=lb;
|
|
|
+ lb:=lb+sz
|
|
|
+end;
|
|
|
+
|
|
|
+function negaddr(fsp:sp):integer;
|
|
|
+var sz:integer;
|
|
|
+begin with b do begin
|
|
|
+ sz:=sizeof(fsp,wordmult);
|
|
|
+ if reglb <= -MI2+sz then begin error(+017); reglb:=0 end;
|
|
|
+ reglb:=reglb-sz;
|
|
|
+ while reglb mod sz_word <> 0 do reglb:=reglb-1;
|
|
|
+ if reglb < minlb then minlb:=reglb;
|
|
|
+ negaddr:=reglb
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure temporary(fsp:sp;r:integer);
|
|
|
+begin inita(fsp,negaddr(fsp));
|
|
|
+ genreg(sizeof(fsp,wordmult),a.pos.ad,r)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure genhol;
|
|
|
+begin gencst(ps_hol,posaddr(holeb,nil,false));
|
|
|
+ argcst(-MI2-1); argcst(0); level:=1
|
|
|
+end;
|
|
|
+
|
|
|
+function arraysize(fsp:sp; pack:boolean):integer;
|
|
|
+var sz,min,max,tot,n:integer;
|
|
|
+begin sz:=sizeof(fsp^.aeltype,pack);
|
|
|
+ bounds(fsp^.inxtype,min,max);
|
|
|
+ fsp^.arpos.lv:=0; fsp^.arpos.ad:=newdlb;
|
|
|
+ gencst(ps_rom,min); argcst(max-min); argcst(sz); argend;
|
|
|
+ n:=max-min+1; tot:=sz*n;
|
|
|
+ if sz<>0 then if tot div sz <> n then begin error(+018); tot:=0 end;
|
|
|
+ arraysize:=tot
|
|
|
+end;
|
|
|
+
|
|
|
+procedure treewalk(fip:ip);
|
|
|
+var lsp:sp; i,sz:integer;
|
|
|
+begin
|
|
|
+ if fip<>nil then
|
|
|
+ begin treewalk(fip^.llink); treewalk(fip^.rlink);
|
|
|
+ if fip^.klass=vars then
|
|
|
+ begin if not (used in fip^.iflag) then errid(-(+019),fip^.name);
|
|
|
+ if not (assigned in fip^.iflag) then errid(-(+020),fip^.name);
|
|
|
+ lsp:=fip^.idtype;
|
|
|
+ if level<>1 then if not (noreg in fip^.iflag) then
|
|
|
+ if (refer in fip^.iflag) or formof(lsp,[pointer]) then
|
|
|
+ genreg(sz_addr,fip^.vpos.ad,reg_pointer)
|
|
|
+ else
|
|
|
+ begin sz:=sizeof(lsp,wordmult);
|
|
|
+ if loopvar in fip^.iflag then
|
|
|
+ genreg(sz,fip^.vpos.ad,reg_loop)
|
|
|
+ else if lsp=realptr then
|
|
|
+ genreg(sz,fip^.vpos.ad,reg_float)
|
|
|
+ else
|
|
|
+ genreg(sz,fip^.vpos.ad,reg_any);
|
|
|
+ end;
|
|
|
+ if lsp<>nil then if withfile in lsp^.sflag then
|
|
|
+ if lsp^.form=files then
|
|
|
+ if level=1 then
|
|
|
+ begin
|
|
|
+ for i:=2 to argc do with argv[i] do
|
|
|
+ if name=fip^.name then ad:=fip^.vpos.ad
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin
|
|
|
+ if not (refer in fip^.iflag) then
|
|
|
+ begin gencst(op_lal,fip^.vpos.ad); gensp(CLS,sz_addr)
|
|
|
+ end
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if level<>1 then errid(-(+021),fip^.name)
|
|
|
+ end
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure constant(fsys:sos; var fsp:sp; var fval:integer);
|
|
|
+var signed,min:boolean; lip:ip;
|
|
|
+begin signed:=(sy=plussy) or (sy=minsy);
|
|
|
+ if signed then begin min:=sy=minsy; insym end else min:=false;
|
|
|
+ if find1([ident..stringcst],fsys,+022) then
|
|
|
+ begin fval:=val;
|
|
|
+ case sy of
|
|
|
+ stringcst: fsp:=stringstruct;
|
|
|
+ charcst: fsp:=charptr;
|
|
|
+ intcst: fsp:=intptr;
|
|
|
+ realcst: fsp:=realptr;
|
|
|
+ longcst: fsp:=longptr;
|
|
|
+ ident:
|
|
|
+ begin lip:=searchid([konst]);
|
|
|
+ fsp:=lip^.idtype; fval:=lip^.value;
|
|
|
+ end
|
|
|
+ end; {case}
|
|
|
+ if signed then
|
|
|
+ if (fsp<>intptr) and (fsp<>realptr) and (fsp<>longptr) then
|
|
|
+ error(+023)
|
|
|
+ else if min then fval:= -fval;
|
|
|
+ {note: negating the v-number for reals and longs}
|
|
|
+ insym;
|
|
|
+ end
|
|
|
+ else begin fsp:=nil; fval:=0 end;
|
|
|
+end;
|
|
|
+
|
|
|
+function cstinteger(fsys:sos; fsp:sp; err:integer):integer;
|
|
|
+var lsp:sp; lval,min,max:integer;
|
|
|
+begin constant(fsys,lsp,lval);
|
|
|
+ if fsp<>lsp then
|
|
|
+ if not eqstruct(desub(fsp),lsp) then
|
|
|
+ begin error(err); lval:=0 end
|
|
|
+ else if bounded(fsp) then
|
|
|
+ begin bounds(fsp,min,max);
|
|
|
+ if (lval<min) or (lval>max) then error(+024)
|
|
|
+ end;
|
|
|
+ cstinteger:=lval
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+function typid(err:integer):sp;
|
|
|
+var lip:ip; lsp:sp;
|
|
|
+begin lsp:=nil;
|
|
|
+ if sy<>ident then error(err) else
|
|
|
+ begin lip:=searchid([types]); lsp:=lip^.idtype; insym end;
|
|
|
+ typid:=lsp
|
|
|
+end;
|
|
|
+
|
|
|
+function simpletyp(fsys:sos):sp;
|
|
|
+var lsp,lsp1:sp; lip,hip:ip; min,max:integer; lnp:np;
|
|
|
+ newsubrange:boolean;
|
|
|
+begin lsp:=nil;
|
|
|
+ if find1([ident..lparent],fsys,+025) then
|
|
|
+ if sy=lparent then
|
|
|
+ begin insym; lnp:=top; {decl. consts local to innermost block}
|
|
|
+ while top^.occur<>blck do top:=top^.nlink;
|
|
|
+ lsp:=newsp(scalar,sz_word); hip:=nil; max:=0;
|
|
|
+ repeat lip:=newident(konst,lsp,hip,+026);
|
|
|
+ if lip<>nil then
|
|
|
+ begin enterid(lip); hip:=lip; lip^.value:=max; max:=max+1 end;
|
|
|
+ until endofloop(fsys+[rparent],[ident],comma,+027); {+028}
|
|
|
+ if max<=MU1 then lsp^.size:=sz_byte;
|
|
|
+ lsp^.fconst:=hip; top:=lnp; nextif(rparent,+029);
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin newsubrange:=true;
|
|
|
+ if sy=ident then
|
|
|
+ begin lip:=searchid([types,konst]); insym;
|
|
|
+ if lip^.klass=types then
|
|
|
+ begin lsp:=lip^.idtype; newsubrange:=false end
|
|
|
+ else
|
|
|
+ begin lsp1:=lip^.idtype; min:=lip^.value end
|
|
|
+ end
|
|
|
+ else constant(fsys+[colon2,ident..plussy],lsp1,min);
|
|
|
+ if newsubrange then
|
|
|
+ begin lsp:=newsp(subrange,sz_word); lsp^.subrno:=0;
|
|
|
+ if not nicescalar(lsp1) then
|
|
|
+ begin error(+030); lsp1:=nil; min:=0 end;
|
|
|
+ lsp^.rangetype:=lsp1;
|
|
|
+ nextif(colon2,+031); max:=cstinteger(fsys,lsp1,+032);
|
|
|
+ if min>max then begin error(+033); max:=min end;
|
|
|
+ if (min>=0) and (max<=MU1) then lsp^.size:=sz_byte;
|
|
|
+ lsp^.min:=min; lsp^.max:=max
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ simpletyp:=lsp
|
|
|
+end;
|
|
|
+
|
|
|
+function arraytyp(fsys:sos;
|
|
|
+ artyp:structform;
|
|
|
+ sflag:sflagset;
|
|
|
+ function element(fsys:sos):sp
|
|
|
+ ):sp;
|
|
|
+var lsp,lsp1,hsp:sp; ok:boolean; sepsy:symbol; lip:ip;
|
|
|
+ oksys:sos;
|
|
|
+begin insym; nextif(lbrack,+034); hsp:=nil;
|
|
|
+ repeat lsp:=newsp(artyp,0); initpos(lsp^.arpos);
|
|
|
+ lsp^.aeltype:=hsp; hsp:=lsp; {link reversed}
|
|
|
+ if artyp=carray then
|
|
|
+ begin sepsy:=semicolon; oksys:=[ident];
|
|
|
+ lip:=newident(carrbnd,lsp,nil,+035); if lip<>nil then enterid(lip);
|
|
|
+ nextif(colon2,+036);
|
|
|
+ lip:=newident(carrbnd,lsp,lip,+037); if lip<>nil then enterid(lip);
|
|
|
+ nextif(colon1,+038); lsp1:=typid(+039);
|
|
|
+ ok:=nicescalar(desub(lsp1));
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin sepsy:=comma; oksys:=[ident..lparent];
|
|
|
+ lsp1:=simpletyp(fsys+[comma,rbrack,ofsy,ident..packedsy]);
|
|
|
+ ok:=bounded(lsp1)
|
|
|
+ end;
|
|
|
+ if not ok then begin error(+040); lsp1:=nil end;
|
|
|
+ lsp^.inxtype:=lsp1
|
|
|
+ until endofloop(fsys+[rbrack,ofsy,ident..packedsy],oksys,
|
|
|
+ sepsy,+041); {+042}
|
|
|
+ nextif(rbrack,+043); nextif(ofsy,+044);
|
|
|
+ lsp:=element(fsys);
|
|
|
+ if lsp<>nil then sflag:=sflag + lsp^.sflag * [withfile];
|
|
|
+ repeat {reverse links and compute size}
|
|
|
+ lsp1:=hsp^.aeltype; hsp^.aeltype:=lsp; hsp^.sflag:=sflag;
|
|
|
+ if artyp=arrays then hsp^.size:=arraysize(hsp,spack in sflag);
|
|
|
+ lsp:=hsp; hsp:=lsp1
|
|
|
+ until hsp=nil; {lsp points to array with highest dimension}
|
|
|
+ arraytyp:=lsp
|
|
|
+end;
|
|
|
+
|
|
|
+function typ(fsys:sos):sp;
|
|
|
+var lsp,lsp1:sp; off,sz,min,errno:integer;
|
|
|
+ sflag:sflagset; lnp:np;
|
|
|
+
|
|
|
+function fldlist(fsys:sos):sp;
|
|
|
+ {level 2: << typ}
|
|
|
+var fip,hip,lip:ip; lsp:sp;
|
|
|
+
|
|
|
+function varpart(fsys:sos):sp;
|
|
|
+ {level 3: << fldlist << typ}
|
|
|
+var tip,lip:ip; lsp,headsp,hsp,vsp,tsp,tsp1,tfsp:sp;
|
|
|
+ minoff,maxoff,int,nvar:integer; lid:idarr;
|
|
|
+begin insym; tip:=nil; lip:=nil;
|
|
|
+ tsp:=newsp(tag,0);
|
|
|
+ if sy<>ident then error(+045) else
|
|
|
+ begin lid:=id; insym;
|
|
|
+ if sy=colon1 then
|
|
|
+ begin tip:=newip(field,lid,nil,nil); enterid(tip); insym;
|
|
|
+ if sy<>ident then error(+046) else
|
|
|
+ begin lid:=id; insym end;
|
|
|
+ end;
|
|
|
+ if sy=ofsy then {otherwise you may destroy id}
|
|
|
+ begin id:=lid; lip:=searchid([types]) end;
|
|
|
+ end;
|
|
|
+ if lip=nil then tfsp:=nil else tfsp:=lip^.idtype;
|
|
|
+ if bounded(tfsp) then
|
|
|
+ begin bounds(tfsp,int,nvar); nvar:=nvar-int+1 end
|
|
|
+ else
|
|
|
+ begin nvar:=0; if tfsp<>nil then begin error(+047); tfsp:=nil end end;
|
|
|
+ tsp^.tfldsp:=tfsp;
|
|
|
+ if tip<>nil then {explicit tag}
|
|
|
+ begin tip^.idtype:=tfsp;
|
|
|
+ tip^.foffset:=posaddr(off,tfsp,spack in sflag)
|
|
|
+ end;
|
|
|
+ nextif(ofsy,+048); minoff:=off; maxoff:=minoff; headsp:=nil;
|
|
|
+ repeat hsp:=nil; {for each caselabel list}
|
|
|
+ repeat nvar:=nvar-1;
|
|
|
+ int:=cstinteger(fsys+[ident..plussy,comma,colon1,lparent,
|
|
|
+ semicolon,casesy,rparent],tfsp,+049);
|
|
|
+ lsp:=headsp; {each label may occur only once}
|
|
|
+ while lsp<>nil do
|
|
|
+ begin if lsp^.varval=int then error(+050);
|
|
|
+ lsp:=lsp^.nxtvar
|
|
|
+ end;
|
|
|
+ vsp:=newsp(variant,0); vsp^.varval:=int;
|
|
|
+ vsp^.nxtvar:=headsp; headsp:=vsp; {chain of case labels}
|
|
|
+ vsp^.subtsp:=hsp; hsp:=vsp;
|
|
|
+ {use this field to link labels with same variant}
|
|
|
+ until endofloop(fsys+[colon1,lparent,semicolon,casesy,rparent],
|
|
|
+ [ident..plussy],comma,+051); {+052}
|
|
|
+ nextif(colon1,+053); nextif(lparent,+054);
|
|
|
+ tsp1:=fldlist(fsys+[rparent,semicolon,ident..plussy]);
|
|
|
+ if off>maxoff then maxoff:=off;
|
|
|
+ while vsp<>nil do
|
|
|
+ begin vsp^.size:=off; hsp:=vsp^.subtsp;
|
|
|
+ vsp^.subtsp:=tsp1; vsp:=hsp
|
|
|
+ end;
|
|
|
+ nextif(rparent,+055);
|
|
|
+ off:=minoff;
|
|
|
+ until lastsemicolon(fsys,[ident..plussy],+056); {+057 +058}
|
|
|
+ if nvar>0 then error(-(+059));
|
|
|
+ tsp^.fstvar:=headsp; tsp^.size:=minoff; off:=maxoff; varpart:=tsp;
|
|
|
+end;
|
|
|
+
|
|
|
+begin {fldlist}
|
|
|
+ if find2([ident],fsys+[casesy],+060) then
|
|
|
+ repeat lip:=nil; hip:=nil;
|
|
|
+ repeat fip:=newident(field,nil,nil,+061);
|
|
|
+ if fip<>nil then
|
|
|
+ begin enterid(fip);
|
|
|
+ if lip=nil then hip:=fip else lip^.next:=fip; lip:=fip;
|
|
|
+ end;
|
|
|
+ until endofloop(fsys+[colon1,ident..packedsy,semicolon,casesy],
|
|
|
+ [ident],comma,+062); {+063}
|
|
|
+ nextif(colon1,+064);
|
|
|
+ lsp:=typ(fsys+[casesy,semicolon]);
|
|
|
+ if lsp<>nil then if withfile in lsp^.sflag then
|
|
|
+ sflag:=sflag+[withfile];
|
|
|
+ while hip<>nil do
|
|
|
+ begin hip^.idtype:=lsp;
|
|
|
+ hip^.foffset:=posaddr(off,lsp,spack in sflag);
|
|
|
+ hip:=hip^.next
|
|
|
+ end;
|
|
|
+ until lastsemicolon(fsys+[casesy],[ident],+065); {+066 +067}
|
|
|
+ if sy=casesy then fldlist:=varpart(fsys) else fldlist:=nil;
|
|
|
+end;
|
|
|
+
|
|
|
+
|
|
|
+begin {typ}
|
|
|
+ sflag:=[]; lsp:=nil;
|
|
|
+ if sy=packedsy then begin sflag:=[spack]; insym end;
|
|
|
+ if find1([ident..filesy],fsys,+068) then
|
|
|
+ if sy in [ident..arrow] then
|
|
|
+ begin if spack in sflag then error(+069);
|
|
|
+ if sy=arrow then
|
|
|
+ begin lsp:=newsp(pointer,sz_addr); insym;
|
|
|
+ if not intypedec then lsp^.eltype:=typid(+070) else
|
|
|
+ if sy<>ident then error(+071) else
|
|
|
+ begin fwptr:=newip(types,id,lsp,fwptr); insym end
|
|
|
+ end
|
|
|
+ else lsp:=simpletyp(fsys);
|
|
|
+ end
|
|
|
+ else
|
|
|
+ case sy of
|
|
|
+{<<<<<<<<<<<<}
|
|
|
+arraysy:
|
|
|
+ lsp:=arraytyp(fsys,arrays,sflag,typ);
|
|
|
+recordsy:
|
|
|
+ begin insym;
|
|
|
+ new(lnp,rec); lnp^.occur:=rec; lnp^.nlink:=top; lnp^.fname:=nil; top:=lnp;
|
|
|
+ off:=0; lsp1:=fldlist(fsys+[endsy]); {fldlist updates off}
|
|
|
+ lsp:=newsp(records,off); lsp^.tagsp:=lsp1;
|
|
|
+ lsp^.fstfld:=top^.fname; lsp^.sflag:=sflag;
|
|
|
+ top:=top^.nlink; nextif(endsy,+072)
|
|
|
+ end;
|
|
|
+setsy:
|
|
|
+ begin insym; nextif(ofsy,+073);
|
|
|
+ lsp:=simpletyp(fsys); lsp1:=desub(lsp); errno:=0;
|
|
|
+ if bounded(lsp1) then
|
|
|
+ begin bounds(lsp1,min,sz);
|
|
|
+ if sz div NB1>=sz_mset then errno:=+074
|
|
|
+ end
|
|
|
+ else if bounded(lsp) then {subrange of integer}
|
|
|
+ begin bounds(lsp,min,sz);
|
|
|
+ if (min<0) or (sz>=iopt) then errno:=+075;
|
|
|
+ sz:=iopt-1
|
|
|
+ end
|
|
|
+ else if lsp=intptr then
|
|
|
+ begin sz:=iopt-1; errno:=-(+076) end
|
|
|
+ else
|
|
|
+ errno:=+077;
|
|
|
+ if errno<>0 then
|
|
|
+ begin error(errno); if errno>0 then begin lsp1:=nil; sz:=0 end end;
|
|
|
+ lsp:=newsp(power,sz div NB1 +1); lsp^.elset:=lsp1;
|
|
|
+ end;
|
|
|
+filesy:
|
|
|
+ begin insym; nextif(ofsy,+078); lsp1:=typ(fsys);
|
|
|
+ if lsp1<>nil then if withfile in lsp1^.sflag then error(-(+079));
|
|
|
+ sz:=sizeof(lsp1,wordpart); if sz<sz_buff then sz:=sz_buff;
|
|
|
+ lsp:=newsp(files,sz+sz_head); lsp^.filtype:=lsp1;
|
|
|
+ end;
|
|
|
+{>>>>>>>>>>>>}
|
|
|
+ end; {case}
|
|
|
+ typ:=lsp;
|
|
|
+end;
|
|
|
+
|
|
|
+function vpartyp(fsys:sos):sp;
|
|
|
+begin
|
|
|
+ if find2([arraysy],fsys+[ident],+080) then
|
|
|
+ vpartyp:=arraytyp(fsys,carray,[],vpartyp)
|
|
|
+ else
|
|
|
+ vpartyp:=typid(+081)
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure block(fsys:sos; fip:ip); forward;
|
|
|
+ {pfdeclaration calls block. With a more obscure lexical
|
|
|
+ structure this forward declaration can be avoided}
|
|
|
+
|
|
|
+procedure labeldeclaration(fsys:sos);
|
|
|
+var llp:lp;
|
|
|
+begin with b do begin
|
|
|
+ repeat
|
|
|
+ if sy<>intcst then error(+082) else
|
|
|
+ begin
|
|
|
+ if searchlab(lchain,val)<>nil then errint(+083,val) else
|
|
|
+ begin new(llp); llp^.labval:=val;
|
|
|
+ if val>9999 then teststandard;
|
|
|
+ ilbno:=ilbno+1; llp^.labname:=ilbno; llp^.labdlb:=0;
|
|
|
+ llp^.seen:=false; llp^.nextlp:=lchain; lchain:=llp;
|
|
|
+ end;
|
|
|
+ insym
|
|
|
+ end
|
|
|
+ until endofloop(fsys+[semicolon],[intcst],comma,+084); {+085}
|
|
|
+ nextif(semicolon,+086)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure constdefinition(fsys:sos);
|
|
|
+var lip:ip;
|
|
|
+begin
|
|
|
+ repeat lip:=newident(konst,nil,nil,+087);
|
|
|
+ if lip<>nil then
|
|
|
+ begin nextif(eqsy,+088);
|
|
|
+ constant(fsys+[semicolon,ident],lip^.idtype,lip^.value);
|
|
|
+ nextif(semicolon,+089); enterid(lip);
|
|
|
+ end;
|
|
|
+ until not find2([ident],fsys,+090);
|
|
|
+end;
|
|
|
+
|
|
|
+procedure typedefinition(fsys:sos);
|
|
|
+var lip:ip;
|
|
|
+begin fwptr:=nil; intypedec:=true;
|
|
|
+ repeat lip:=newident(types,nil,nil,+091);
|
|
|
+ if lip<>nil then
|
|
|
+ begin nextif(eqsy,+092);
|
|
|
+ lip^.idtype:=typ(fsys+[semicolon,ident]);
|
|
|
+ nextif(semicolon,+093); enterid(lip);
|
|
|
+ end;
|
|
|
+ until not find2([ident],fsys,+094);
|
|
|
+ while fwptr<>nil do
|
|
|
+ begin assert sy<>ident;
|
|
|
+ id:=fwptr^.name; lip:=searchid([types]);
|
|
|
+ fwptr^.idtype^.eltype:=lip^.idtype; fwptr:=fwptr^.next
|
|
|
+ end;
|
|
|
+ intypedec:=false;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure vardeclaration(fsys:sos);
|
|
|
+var lip,hip,vip:ip; lsp:sp;
|
|
|
+begin with b do begin
|
|
|
+ repeat hip:=nil; lip:=nil;
|
|
|
+ repeat vip:=newident(vars,nil,nil,+095);
|
|
|
+ if vip<>nil then
|
|
|
+ begin enterid(vip); vip^.iflag:=[];
|
|
|
+ if lip=nil then hip:=vip else lip^.next:=vip; lip:=vip;
|
|
|
+ end;
|
|
|
+ until endofloop(fsys+[colon1,ident..packedsy],[ident],comma,+096); {+097}
|
|
|
+ nextif(colon1,+098);
|
|
|
+ lsp:=typ(fsys+[semicolon,ident]);
|
|
|
+ while hip<>nil do
|
|
|
+ begin hip^.idtype:=lsp;
|
|
|
+ if level<=1 then
|
|
|
+ hip^.vpos.ad:=posaddr(holeb,lsp,false)
|
|
|
+ else
|
|
|
+ hip^.vpos.ad:=negaddr(lsp);
|
|
|
+ hip:=hip^.next
|
|
|
+ end;
|
|
|
+ nextif(semicolon,+099);
|
|
|
+ until not find2([ident],fsys,+0100);
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure pfhead(fsys:sos;var fip:ip;var again:boolean;param:boolean);
|
|
|
+ forward;
|
|
|
+
|
|
|
+procedure parlist(fsys:sos; slink:boolean; var tip:ip; var maxlb:integer);
|
|
|
+var lastip,hip,lip,pip:ip; lsp,tsp:sp; iflag:iflagset; again:boolean;
|
|
|
+begin tip:=nil; lastip:=nil;
|
|
|
+ maxlb:=0; if slink then maxlb:=sz_addr;
|
|
|
+ repeat {once for each formal-parameter-section}
|
|
|
+ if find1([ident,varsy,procsy,funcsy],fsys+[semicolon],+0101) then
|
|
|
+ begin
|
|
|
+ if (sy=procsy) or (sy=funcsy) then
|
|
|
+ begin
|
|
|
+ pfhead(fsys+[semicolon,ident,varsy,procsy,funcsy],hip,again,true);
|
|
|
+ hip^.pfpos.ad:=posaddr(maxlb,procptr,false);
|
|
|
+ hip^.pfkind:=formal; lip:=hip;
|
|
|
+ top:=top^.nlink; level:=level-1
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin hip:=nil; lip:=nil; iflag:=[assigned];
|
|
|
+ if sy=varsy then
|
|
|
+ begin iflag:=[refer,assigned,used]; insym end;
|
|
|
+ repeat pip:=newident(vars,nil,nil,+0102);
|
|
|
+ if pip<>nil then
|
|
|
+ begin enterid(pip); pip^.iflag:=iflag;
|
|
|
+ if lip=nil then hip:=pip else lip^.next:=pip; lip:=pip;
|
|
|
+ end;
|
|
|
+ iflag:=iflag+[samesect];
|
|
|
+ until endofloop(fsys+[semicolon,colon1],[ident],comma,+0103);
|
|
|
+ {+0104}
|
|
|
+ nextif(colon1,+0105);
|
|
|
+ if refer in iflag then
|
|
|
+ begin lsp:=vpartyp(fsys+[semicolon]); tsp:=lsp;
|
|
|
+ while formof(tsp,[carray]) do
|
|
|
+ begin tsp^.arpos.ad:=posaddr(maxlb,nilptr,false);
|
|
|
+ tsp:=tsp^.aeltype
|
|
|
+ end;
|
|
|
+ tsp:=nilptr;
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin lsp:=typid(+0106); tsp:=lsp end;
|
|
|
+ pip:=hip;
|
|
|
+ while pip<>nil do
|
|
|
+ begin pip^.vpos.ad:=posaddr(maxlb,tsp,false); pip^.idtype:=lsp;
|
|
|
+ pip:=pip^.next
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+ if lastip=nil then tip:=hip else lastip^.next:=hip; lastip:=lip;
|
|
|
+ end;
|
|
|
+ until endofloop(fsys,[ident,varsy,procsy,funcsy],semicolon,+0107); {+0108}
|
|
|
+end;
|
|
|
+
|
|
|
+procedure pfhead; {forward declared}
|
|
|
+var lip:ip; lsp:sp; lnp:np; kl:idclass;
|
|
|
+begin lip:=nil; again:=false;
|
|
|
+ if sy=procsy then kl:=proc else
|
|
|
+ begin kl:=func; fsys:=fsys+[colon1,ident] end;
|
|
|
+ insym;
|
|
|
+ if sy<>ident then begin error(+0109); id:=spaces end;
|
|
|
+ if not param then lip:=searchsection(top^.fname);
|
|
|
+ if lip<>nil then
|
|
|
+ if (lip^.klass<>kl) or (lip^.pfkind<>forward) then errid(+0110,id) else
|
|
|
+ begin b.forwcount:=b.forwcount-1; again:=true end;
|
|
|
+ if again then insym else
|
|
|
+ begin lip:=newip(kl,id,nil,nil);
|
|
|
+ if sy=ident then begin enterid(lip); insym end;
|
|
|
+ lastpfno:=lastpfno+1; lip^.pfno:=lastpfno;
|
|
|
+ end;
|
|
|
+ level:=level+1;
|
|
|
+ new(lnp,blck); lnp^.occur:=blck; lnp^.nlink:=top; top:=lnp;
|
|
|
+ if again then lnp^.fname:=lip^.parhead else
|
|
|
+ begin lnp^.fname:=nil;
|
|
|
+ if find3(lparent,fsys,+0111) then
|
|
|
+ begin parlist(fsys+[rparent],lip^.pfpos.lv>1,lip^.parhead,lip^.maxlb);
|
|
|
+ nextif(rparent,+0112)
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+ if (kl=func) and not again then
|
|
|
+ begin nextif(colon1,+0113); lsp:=typid(+0114);
|
|
|
+ if formof(lsp,[power..tag]) then
|
|
|
+ begin error(+0115); lsp:=nil end;
|
|
|
+ lip^.idtype:=lsp;
|
|
|
+ end;
|
|
|
+ fip:=lip;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure pfdeclaration(fsys:sos);
|
|
|
+var lip:ip; again,headonly:boolean; markp:^integer; lbp:bp; kind:kindofpf;
|
|
|
+begin with b do begin
|
|
|
+ pfhead(fsys+[ident,semicolon,labelsy..beginsy],lip,again,false);
|
|
|
+ nextif(semicolon,+0116);
|
|
|
+ if find1([ident,labelsy..beginsy],fsys+[semicolon],+0117) then
|
|
|
+ begin headonly:=sy=ident;
|
|
|
+ if headonly then
|
|
|
+ begin kind:=standard;
|
|
|
+ if id='forward ' then kind:=forward else
|
|
|
+ if id='extern ' then kind:=extern else
|
|
|
+ if id='varargs ' then kind:=varargs else errid(+0118,id);
|
|
|
+ if kind<>standard then
|
|
|
+ begin insym; lip^.pfkind:=kind;
|
|
|
+ if kind=forward then
|
|
|
+ if again then errid(+0119,lip^.name) else
|
|
|
+ forwcount:=forwcount+1
|
|
|
+ else
|
|
|
+ begin lip^.pfpos.lv:=1; teststandard end
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+ if not again then
|
|
|
+ if lip^.pfpos.lv<=1 then genpnam(ps_exp,lip) else genpnam(ps_inp,lip);
|
|
|
+ if not headonly then
|
|
|
+ begin lip^.pfkind:=actual;
|
|
|
+#ifndef STANDARD
|
|
|
+ mark(markp);
|
|
|
+#endif
|
|
|
+ new(lbp); lbp^:=b; nextbp:=lbp;
|
|
|
+ reglb:=0; minlb:=0; ilbno:=0; forwcount:=0; lchain:=nil;
|
|
|
+ block(fsys+[semicolon],lip);
|
|
|
+ b:=nextbp^;
|
|
|
+#ifndef STANDARD
|
|
|
+ release(markp);
|
|
|
+#endif
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+ if not main then eofexpected:=forwcount=0;
|
|
|
+ nextif(semicolon,+0120);
|
|
|
+ level:=level-1; top:=top^.nlink;
|
|
|
+end end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure expression(fsys:sos); forward;
|
|
|
+ {this forward declaration cannot be avoided}
|
|
|
+
|
|
|
+procedure selectarrayelement(fsys:sos);
|
|
|
+var isp,lsp:sp;
|
|
|
+begin
|
|
|
+ repeat loadaddr; isp:=nil;
|
|
|
+ if formof(a.asp,[arrays,carray]) then isp:=a.asp^.inxtype else
|
|
|
+ errasp(+0121);
|
|
|
+ lsp:=a.asp;
|
|
|
+ expression(fsys+[comma]); force(desub(isp),+0122);
|
|
|
+ {no range check}
|
|
|
+ if lsp<>nil then
|
|
|
+ begin a.packbit:=spack in lsp^.sflag;
|
|
|
+ descraddr(lsp^.arpos); lsp:=lsp^.aeltype
|
|
|
+ end;
|
|
|
+ a.asp:=lsp; a.ak:=indexed;
|
|
|
+ until endofloop(fsys,[notsy..lparent],comma,+0123); {+0124}
|
|
|
+end;
|
|
|
+
|
|
|
+procedure selector(fsys: sos; fip:ip; iflag:iflagset);
|
|
|
+{selector computes the address of any kind of variable.
|
|
|
+ Four possibilities:
|
|
|
+ 1.for direct accessable variables (fixed), a contains offset and level,
|
|
|
+ 2.for indirect accessable variables (ploaded), the address is on the stack.
|
|
|
+ 3.for array elements, the top of stack gives the index (one word).
|
|
|
+ The address of the array is beneath it.
|
|
|
+ 4.for variables with address in direct accessible pointer variable (pfixed),
|
|
|
+ the offset and level of the pointer is stored in a.
|
|
|
+ If a.asp=nil then an error occurred else a.asp gives
|
|
|
+ the type of the variable.
|
|
|
+}
|
|
|
+var lip:ip;
|
|
|
+begin inita(fip^.idtype,0);
|
|
|
+ case fip^.klass of
|
|
|
+ vars: with a do
|
|
|
+ begin pos:=fip^.vpos; if refer in fip^.iflag then ak:=pfixed end;
|
|
|
+ field:
|
|
|
+ begin a:=lastnp^.wa; fieldaddr(fip^.foffset); a.asp:=fip^.idtype end;
|
|
|
+ func: with a do
|
|
|
+ if fip^.pfkind=standard then errasp(+0125) else
|
|
|
+ if (fip^.pfpos.lv>=level-1) and (fip<>currproc) then error(+0126) else
|
|
|
+ if fip^.pfkind<>actual then error(+0127) else
|
|
|
+ begin pos:=fip^.pfpos; pos.lv:=pos.lv+1;
|
|
|
+ if sy=arrow then error(+0128);
|
|
|
+ end
|
|
|
+ end; {case}
|
|
|
+ if (sy=lbrack) or (sy=period) then iflag:=iflag+[noreg];
|
|
|
+ while find2([lbrack,period,arrow],fsys,+0129) do with a do
|
|
|
+ if sy=lbrack then
|
|
|
+ begin insym; selectarrayelement(fsys+[rbrack,lbrack,period,arrow]);
|
|
|
+ nextif(rbrack,+0130);
|
|
|
+ end else
|
|
|
+ if sy=period then
|
|
|
+ begin insym;
|
|
|
+ if sy<>ident then error(+0131) else
|
|
|
+ begin
|
|
|
+ if not formof(asp,[records]) then errasp(+0132) else
|
|
|
+ begin lip:=searchsection(asp^.fstfld);
|
|
|
+ if lip=nil then begin errid(+0133,id); asp:=nil end else
|
|
|
+ begin packbit:=spack in asp^.sflag;
|
|
|
+ fieldaddr(lip^.foffset); asp:=lip^.idtype
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ insym
|
|
|
+ end
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin insym; iflag:=[used];
|
|
|
+ if asp<>nil then
|
|
|
+ if asp=zeroptr then errasp(+0134) else
|
|
|
+ if asp^.form=pointer then
|
|
|
+ begin
|
|
|
+ if ak=fixed then ak:=pfixed else
|
|
|
+ begin load; ak:=ploaded end;
|
|
|
+ asp:=asp^.eltype
|
|
|
+ end else
|
|
|
+ if asp^.form=files then
|
|
|
+ begin loadaddr; gensp(WDW,sz_addr); gencst(op_lfr,sz_addr);
|
|
|
+ asp:=asp^.filtype; ak:=ploaded; packbit:=true;
|
|
|
+ end
|
|
|
+ else errasp(+0135);
|
|
|
+ end;
|
|
|
+ fip^.iflag:=fip^.iflag+iflag;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure variable(fsys:sos);
|
|
|
+var lip: ip;
|
|
|
+begin
|
|
|
+ if sy=ident then
|
|
|
+ begin lip:=searchid([vars,field]); insym;
|
|
|
+ selector(fsys,lip,[used,assigned,noreg])
|
|
|
+ end
|
|
|
+ else begin error(+0136); inita(nil,0) end;
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+function plistequal(p1,p2:ip):boolean;
|
|
|
+var ok:boolean; q1,q2:sp;
|
|
|
+begin plistequal:=eqstruct(p1^.idtype,p2^.idtype);
|
|
|
+ p1:=p1^.parhead; p2:=p2^.parhead;
|
|
|
+ while (p1<>nil) and (p2<>nil) do
|
|
|
+ begin ok:=false;
|
|
|
+ if p1^.klass=p2^.klass then
|
|
|
+ if p1^.klass<>vars then ok:=plistequal(p1,p2) else
|
|
|
+ begin q1:=p1^.idtype; q2:=p2^.idtype; ok:=true;
|
|
|
+ while ok and formof(q1,[carray]) and formof(q2,[carray]) do
|
|
|
+ begin ok:=eqstruct(q1^.inxtype,q2^.inxtype);
|
|
|
+ q1:=q1^.aeltype; q2:=q2^.aeltype;
|
|
|
+ end;
|
|
|
+ if not (eqstruct(q1,q2) and
|
|
|
+ (p1^.iflag*[refer,samesect] = p2^.iflag*[refer,samesect]))
|
|
|
+ then ok:=false;
|
|
|
+ end;
|
|
|
+ if not ok then plistequal:=false;
|
|
|
+ p1:=p1^.next; p2:=p2^.next
|
|
|
+ end;
|
|
|
+ if (p1<>nil) or (p2<>nil) then plistequal:=false
|
|
|
+end;
|
|
|
+
|
|
|
+procedure callnonstandard(fsys:sos; moreargs:boolean; fip:ip);
|
|
|
+var nxt,lip:ip; l0,l1,l2,l3,sz:integer; lsp,savasp:sp;
|
|
|
+begin with a do begin
|
|
|
+ l0:=lino; sz:=0; nxt:=fip^.parhead;
|
|
|
+ while moreargs do
|
|
|
+ begin l1:=lino;
|
|
|
+ if nxt=nil then
|
|
|
+ begin if fip^.pfkind<>varargs then error(+0137);
|
|
|
+ expression(fsys); load; sz:=sz+sizeof(asp,wordmult)
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin lsp:=nxt^.idtype;
|
|
|
+ if nxt^.klass<>vars then {proc or func}
|
|
|
+ begin inita(procptr,0); sz:=sz+sz_proc;
|
|
|
+ if sy<>ident then error(+0138) else
|
|
|
+ begin lip:=searchid([nxt^.klass]); insym;
|
|
|
+ if lip^.pfkind=standard then error(+0139) else
|
|
|
+ if not plistequal(nxt,lip) then error(+0140)
|
|
|
+ else
|
|
|
+ begin pos:=lip^.pfpos;
|
|
|
+ if lip^.pfkind=formal then load else
|
|
|
+ begin
|
|
|
+ if lip^.pfpos.lv<=1 then gencst(op_zer,sz_addr) else
|
|
|
+ gencst(op_lxl,level-lip^.pfpos.lv);
|
|
|
+ genpnam(op_lpi,lip)
|
|
|
+ end
|
|
|
+ end
|
|
|
+ end
|
|
|
+ end
|
|
|
+ else if not (refer in nxt^.iflag) then {call by value}
|
|
|
+ begin expression(fsys); force(lsp,+0141);
|
|
|
+ sz:=sz+sizeof(asp,wordmult);
|
|
|
+ end
|
|
|
+ else {call by reference}
|
|
|
+ begin variable(fsys); loadaddr; sz:=sz+sz_addr;
|
|
|
+ if samesect in nxt^.iflag then lsp:=savasp else
|
|
|
+ begin savasp:=asp; l2:=lino;
|
|
|
+ while formof(lsp,[carray])
|
|
|
+ and formof(asp,[arrays,carray]) do
|
|
|
+ if (compat(lsp^.inxtype,asp^.inxtype) > subeq) or
|
|
|
+ (lsp^.sflag<>asp^.sflag) then errasp(+0142) else
|
|
|
+ begin l3:=lino; descraddr(asp^.arpos); exchange(l2,l3);
|
|
|
+ sz:=sz+sz_addr; asp:=asp^.aeltype; lsp:=lsp^.aeltype
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ if not eqstruct(asp,lsp) then errasp(+0143);
|
|
|
+ if packbit then errasp(+0144);
|
|
|
+ end;
|
|
|
+ nxt:=nxt^.next
|
|
|
+ end;
|
|
|
+ exchange(l0,l1); moreargs:=find3(comma,fsys,+0145)
|
|
|
+ end;
|
|
|
+ if nxt<>nil then error(+0146);
|
|
|
+ inita(procptr,0); pos:=fip^.pfpos;
|
|
|
+ if fip^.pfkind=formal then
|
|
|
+ with b do
|
|
|
+ begin load; ilbno:=ilbno+2;
|
|
|
+ gencst(op_exg,sz_addr);
|
|
|
+ gencst(op_dup,sz_addr);
|
|
|
+ gencst(op_zer,sz_addr);
|
|
|
+ genop(op_cmp);
|
|
|
+ gencst(op_zeq,ilbno-1);
|
|
|
+ gencst(op_exg,sz_addr);
|
|
|
+ genop(op_cai);
|
|
|
+ gencst(op_asp,sz_addr);
|
|
|
+ gencst(op_bra,ilbno);
|
|
|
+ newilb(ilbno-1);
|
|
|
+ gencst(op_asp,sz_addr);
|
|
|
+ genop(op_cai);
|
|
|
+ newilb(ilbno);
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin
|
|
|
+ if pos.lv>1 then
|
|
|
+ begin gencst(op_lxl,level-pos.lv); sz:=sz+sz_addr end;
|
|
|
+ genpnam(op_cal,fip)
|
|
|
+ end;
|
|
|
+ if sz<>0 then gencst(op_asp,sz);
|
|
|
+ asp:=fip^.idtype;
|
|
|
+ if asp<>nil then genasp(op_lfr)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure fileaddr;
|
|
|
+var la:attr;
|
|
|
+begin la:=a; a:=fa; loadaddr; a:=la end;
|
|
|
+
|
|
|
+procedure callr(l1,l2:integer);
|
|
|
+var la:attr; m:libmnem;
|
|
|
+begin with a do begin
|
|
|
+ la:=a; asp:=desub(asp); fileaddr; m:=RDI;
|
|
|
+ if asp<>intptr then
|
|
|
+ if asp=charptr then m:=RDC else
|
|
|
+ if asp=realptr then m:=RDR else
|
|
|
+ if asp=longptr then m:=RDL else errasp(+0147);
|
|
|
+ gensp(m,sz_addr); genasp(op_lfr);
|
|
|
+ if asp<>la.asp then checkbnds(la.asp);
|
|
|
+ a:=la; exchange(l1,l2); store;
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure callw(fsys:sos; l1,l2:integer);
|
|
|
+var m:libmnem; s:integer;
|
|
|
+begin with a do begin
|
|
|
+ fileaddr; exchange(l1,l2); loadcheap; asp:=desub(asp);
|
|
|
+ if string(asp) then
|
|
|
+ begin gencst(op_loc,asp^.size); m:=WRS; s:=sz_addr+sz_word end
|
|
|
+ else
|
|
|
+ begin m:=WRI; s:=sizeof(asp,wordmult);
|
|
|
+ if asp<>intptr then
|
|
|
+ if asp=charptr then m:=WRC else
|
|
|
+ if asp=realptr then m:=WRR else
|
|
|
+ if asp=boolptr then m:=WRB else
|
|
|
+ if asp=zeroptr then m:=WRZ else
|
|
|
+ if asp=longptr then m:=WRL else errasp(+0148);
|
|
|
+ end;
|
|
|
+ if find3(colon1,fsys,+0149) then
|
|
|
+ begin expression(fsys+[colon1]); force(intptr,+0150);
|
|
|
+ m:=succ(m); s:=s+sz_int
|
|
|
+ end;
|
|
|
+ if find3(colon1,fsys,+0151) then
|
|
|
+ begin expression(fsys); force(intptr,+0152); s:=s+sz_int;
|
|
|
+ if m<>WSR then error(+0153) else m:=WRF;
|
|
|
+ end;
|
|
|
+ gensp(m,s+sz_addr);
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure callrw(fsys:sos; lpar,w,ln:boolean);
|
|
|
+var l1,l2,errno:integer; ftype,lsp,fsp:sp; savlb:integer; m:libmnem;
|
|
|
+begin with b do begin savlb:=reglb; ftype:=textptr;
|
|
|
+ inita(textptr,argv[ord(w)].ad); a.pos.lv:=0; fa:=a;
|
|
|
+ if lpar then
|
|
|
+ begin l1:=lino; if w then expression(fsys+[colon1]) else variable(fsys);
|
|
|
+ l2:=lino;
|
|
|
+ if formof(a.asp,[files]) then
|
|
|
+ begin ftype:=a.asp;
|
|
|
+ if (a.ak<>fixed) and (a.ak<>pfixed) then
|
|
|
+ begin loadaddr; temporary(nilptr,reg_pointer);
|
|
|
+ store; a.ak:=pfixed
|
|
|
+ end;
|
|
|
+ fa:=a; {store doesn't change a}
|
|
|
+ if (sy<>comma) and not ln then error(+0154);
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin if iop[w]=nil then error(+0155);
|
|
|
+ if w then callw(fsys,l1,l2) else callr(l1,l2)
|
|
|
+ end;
|
|
|
+ while find3(comma,fsys,+0156) do with a do
|
|
|
+ begin l1:=lino;
|
|
|
+ if w then expression(fsys+[colon1]) else variable(fsys);
|
|
|
+ l2:=lino;
|
|
|
+ if ftype=textptr then
|
|
|
+ if w then callw(fsys,l1,l2) else callr(l1,l2)
|
|
|
+ else
|
|
|
+ begin errno:=+0157; fsp:=ftype^.filtype;
|
|
|
+ if w then force(fsp,errno) else
|
|
|
+ begin store; lsp:=asp; l2:=lino end;
|
|
|
+ fileaddr; gensp(WDW,sz_addr); gencst(op_lfr,sz_addr);
|
|
|
+ ak:=ploaded; packbit:=true; asp:=fsp;
|
|
|
+ if w then store else
|
|
|
+ begin force(lsp,errno); exchange(l1,l2) end;
|
|
|
+ fileaddr; if w then m:=PUTX else m:=GETX; gensp(m,sz_addr)
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if not ln then error(+0158) else
|
|
|
+ if iop[w]=nil then error(+0159);
|
|
|
+ if ln then
|
|
|
+ begin if ftype<>textptr then error(+0160);
|
|
|
+ fileaddr; if w then m:=WLN else m:=RLN; gensp(m,sz_addr)
|
|
|
+ end;
|
|
|
+ reglb:=savlb
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure callnd(fsys:sos);
|
|
|
+label 1;
|
|
|
+var lsp:sp; int:integer;
|
|
|
+begin with a do begin
|
|
|
+ if asp=zeroptr then errasp(+0161) else asp:=asp^.eltype;
|
|
|
+ while find3(comma,fsys,+0162) do
|
|
|
+ begin
|
|
|
+ if asp<>nil then {asp of form record or variant}
|
|
|
+ if asp^.form=records then asp:=asp^.tagsp else
|
|
|
+ if asp^.form=variant then asp:=asp^.subtsp else errasp(+0163);
|
|
|
+ if asp=nil then constant(fsys,lsp,int) else
|
|
|
+ begin assert asp^.form=tag;
|
|
|
+ int:=cstinteger(fsys,asp^.tfldsp,+0164); lsp:=asp^.fstvar;
|
|
|
+ while lsp<>nil do
|
|
|
+ if lsp^.varval<>int then lsp:=lsp^.nxtvar else
|
|
|
+ begin asp:=lsp; goto 1 end;
|
|
|
+ end;
|
|
|
+1: end;
|
|
|
+ genasp(op_loc)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure call(fsys: sos; fip: ip);
|
|
|
+var lkey: standpf; lpar:boolean; lsp,sp1,sp2:sp;
|
|
|
+ m:libmnem; s:integer; b:byte;
|
|
|
+begin with a do begin fsys:=fsys+[comma];
|
|
|
+ lpar:=find3(lparent,fsys,+0165); if lpar then fsys:=fsys+[rparent];
|
|
|
+ if fip^.pfkind<>standard then callnonstandard(fsys,lpar,fip) else
|
|
|
+ begin lkey:=fip^.key; m:=CLS; lsp:=nil;
|
|
|
+ if not lpar then
|
|
|
+ if lkey in [pput..prelease,fabs..fatn] then error(+0166);
|
|
|
+ if lkey in [pput..ppage,feof,feoln] then
|
|
|
+ begin s:=sz_addr;
|
|
|
+ if lpar then
|
|
|
+ begin variable(fsys); loadaddr end
|
|
|
+ else
|
|
|
+ begin asp:=textptr;
|
|
|
+ if iop[lkey=ppage]=nil then errasp(+0167) else
|
|
|
+ gencst(op_lae,argv[ord(lkey=ppage)].ad)
|
|
|
+ end;
|
|
|
+ if lkey in [pput..prewrite,ppage,feof,feoln] then
|
|
|
+ if not formof(asp,[files]) then
|
|
|
+ begin error(+0168); asp:=textptr end;
|
|
|
+ if lkey in [pnew,pdispose,pmark,prelease] then
|
|
|
+ if not formof(asp,[pointer]) then
|
|
|
+ begin error(+0169); asp:=nilptr end;
|
|
|
+ end;
|
|
|
+ case lkey of
|
|
|
+ pread, preadln, pwrite, pwriteln: {0,1,2,3 resp}
|
|
|
+ callrw(fsys,lpar,lkey>=pwrite,odd(ord(lkey)));
|
|
|
+ pput: m:=PUTX;
|
|
|
+ pget: m:=GETX;
|
|
|
+ ppage: m:=PAG;
|
|
|
+ preset: m:=OPN;
|
|
|
+ prewrite: m:=CRE;
|
|
|
+ pnew: m:=NEWX;
|
|
|
+ pdispose: m:=DIS;
|
|
|
+ ppack:
|
|
|
+ begin sp2:=asp; nextif(comma,+0170); expression(fsys); load;
|
|
|
+ lsp:=asp; nextif(comma,+0171); variable(fsys); loadaddr;
|
|
|
+ sp1:=asp; asp:=lsp; m:=PAC
|
|
|
+ end;
|
|
|
+ punpack:
|
|
|
+ begin sp1:=asp; nextif(comma,+0172); variable(fsys); loadaddr;
|
|
|
+ sp2:=asp; nextif(comma,+0173); expression(fsys); load;
|
|
|
+ m:=UNP
|
|
|
+ end;
|
|
|
+ pmark: m:=SAV;
|
|
|
+ prelease: m:=RST;
|
|
|
+ phalt:
|
|
|
+ begin m:=HLT; teststandard;
|
|
|
+ if lpar then lsp:=intptr else gencst(op_loc,0);
|
|
|
+ end;
|
|
|
+ feof: m:=EFL;
|
|
|
+ feoln: m:=ELN;
|
|
|
+ fodd, fchr: lsp:=intptr;
|
|
|
+ fpred: b:=op_dec;
|
|
|
+ fsucc: b:=op_inc;
|
|
|
+ fround: m:=RND;
|
|
|
+ fsin, fcos, fexp, fsqt, flog, fatn: lsp:=realptr;
|
|
|
+ fabs, fsqr, ford, ftrunc: ;
|
|
|
+ end;
|
|
|
+ if lpar then if lkey in [phalt,fabs..fatn] then
|
|
|
+ begin expression(fsys);
|
|
|
+ force(lsp,+0174); s:=sizeof(asp,wordmult)
|
|
|
+ end;
|
|
|
+ if lkey in [ppack,punpack,fabs..fodd] then
|
|
|
+ asp:=desub(asp);
|
|
|
+ case lkey of
|
|
|
+ ppage, feoln:
|
|
|
+ begin if asp<>textptr then error(+0175); asp:=boolptr end;
|
|
|
+ preset, prewrite:
|
|
|
+ begin s:=sz_addr+sz_word;
|
|
|
+ if asp=textptr then gencst(op_loc,0) else
|
|
|
+ gencst(op_loc,sizeof(asp^.filtype,wordpart));
|
|
|
+ end;
|
|
|
+ pnew, pdispose:
|
|
|
+ begin callnd(fsys); s:=sz_addr+sz_word end;
|
|
|
+ ppack, punpack:
|
|
|
+ begin s:=2*sz_addr+sz_int;
|
|
|
+ if formof(sp1,[arrays,carray])
|
|
|
+ and formof(sp2,[arrays,carray]) then
|
|
|
+ if (spack in (sp1^.sflag - sp2^.sflag)) and
|
|
|
+ eqstruct(sp1^.aeltype,sp2^.aeltype) and
|
|
|
+ eqstruct(desub(sp1^.inxtype),asp) and
|
|
|
+ eqstruct(desub(sp2^.inxtype),asp) then
|
|
|
+ begin descraddr(sp1^.arpos); descraddr(sp2^.arpos) end
|
|
|
+ else error(+0176)
|
|
|
+ else error(+0177)
|
|
|
+ end;
|
|
|
+ pmark, prelease: teststandard;
|
|
|
+ feof: asp:=boolptr;
|
|
|
+ fabs:
|
|
|
+ if asp=intptr then m:=ABI else
|
|
|
+ if asp=longptr then m:=ABL else
|
|
|
+ if asp=realptr then m:=ABR else errasp(+0178);
|
|
|
+ fsqr:
|
|
|
+ begin
|
|
|
+ if (asp=intptr) or (asp=longptr) then b:=op_mli else
|
|
|
+ if asp=realptr then begin b:=op_mlf; fltused:=true end
|
|
|
+ else errasp(+0179);
|
|
|
+ genasp(op_dup); genasp(b)
|
|
|
+ end;
|
|
|
+ ford:
|
|
|
+ begin if not nicescalar(asp) then errasp(+0180); asp:=intptr end;
|
|
|
+ fchr: checkbnds(charptr);
|
|
|
+ fpred, fsucc:
|
|
|
+ begin genop(b);
|
|
|
+ if nicescalar(asp) then genrck(asp) else errasp(+0181)
|
|
|
+ end;
|
|
|
+ fodd:
|
|
|
+ begin gencst(op_loc,1); asp:=boolptr; genasp(op_and) end;
|
|
|
+ ftrunc, fround: if asp<>realptr then errasp(+0182);
|
|
|
+ fsin: m:=SINX;
|
|
|
+ fcos: m:=COSX;
|
|
|
+ fexp: m:=EXPX;
|
|
|
+ fsqt: m:=SQT;
|
|
|
+ flog: m:=LOG;
|
|
|
+ fatn: m:=ATN;
|
|
|
+ phalt:s:=0;
|
|
|
+ pread, preadln, pwrite, pwriteln, pput, pget: ;
|
|
|
+ end;
|
|
|
+ if m<>CLS then
|
|
|
+ begin gensp(m,s);
|
|
|
+ if lkey>=feof then genasp(op_lfr)
|
|
|
+ end;
|
|
|
+ if (lkey=fround) or (lkey=ftrunc) then
|
|
|
+ opconvert(ri);
|
|
|
+ end;
|
|
|
+ if lpar then nextif(rparent,+0183);
|
|
|
+end end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure convert(fsp:sp; l1:integer);
|
|
|
+{Convert tries to make the operands of some operator of the same type.
|
|
|
+ The operand types are given by fsp and a.asp. The resulting type
|
|
|
+ is put in a.asp.
|
|
|
+ l1 gives the lino of the first instruction of the right operand.
|
|
|
+}
|
|
|
+var l2:integer; ts:twostruct; lsp:sp;
|
|
|
+begin with a do begin asp:=desub(asp);
|
|
|
+ ts:=compat(asp,fsp);
|
|
|
+ case ts of
|
|
|
+ eq,subeq:
|
|
|
+ ;
|
|
|
+ il,ir,lr:
|
|
|
+ opconvert(ts);
|
|
|
+ es:
|
|
|
+ expandnullset(fsp);
|
|
|
+ li,ri,rl,se:
|
|
|
+ begin l2:=lino; lsp:=asp; asp:=fsp;
|
|
|
+ convert(lsp,l1); exchange(l1,l2); asp:=lsp
|
|
|
+ end;
|
|
|
+ noteq:
|
|
|
+ errasp(+0184);
|
|
|
+ end;
|
|
|
+ if asp=realptr then fltused:=true
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure buildset(fsys:sos);
|
|
|
+{This is a bad construct in pascal. Two objections:
|
|
|
+ - expr..expr very difficult to implement on most machines
|
|
|
+ - this construct makes it hard to implement sets of different size
|
|
|
+}
|
|
|
+const ncsw = 16; {tunable}
|
|
|
+type wordset = set of 0..MB2;
|
|
|
+var i,j,val1,val2,ncst,l1,l2,sz:integer;
|
|
|
+ cst1,cst2,cst12,varpart:boolean;
|
|
|
+ cstpart:array[1..ncsw] of wordset;
|
|
|
+
|
|
|
+procedure genwordset(s:wordset);
|
|
|
+ {level 2: << buildset}
|
|
|
+var b,i,w:integer;
|
|
|
+begin i:=0; w:=0; b:=-1;
|
|
|
+ repeat
|
|
|
+ if i in s then w:=w-b; b:=b+b; i:=i+1
|
|
|
+ until i=MB2;
|
|
|
+ if i in s then w:=w+b;
|
|
|
+ gencst(op_loc,w)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure setexpr(fsys:sos; var c:boolean; var v:integer);
|
|
|
+ {level 2: << buildset}
|
|
|
+var min:integer; lsp:sp;
|
|
|
+begin with a do begin c:=false; v:=0; lsp:=asp;
|
|
|
+ expression(fsys); asp:=desub(asp);
|
|
|
+ if not eqstruct(asp,lsp^.elset) then
|
|
|
+ begin error(+0185); lsp:=nullset end;
|
|
|
+ if lsp=nullset then
|
|
|
+ begin
|
|
|
+ if bounded(asp) then bounds(asp,min,sz) else
|
|
|
+ if asp=intptr then sz:=iopt-1 else begin errasp(+0186); sz:=0 end;
|
|
|
+ sz:=sz div NB1 + 1; while sz mod sz_word <> 0 do sz:=sz+1;
|
|
|
+ if sz>sz_mset then errasp(+0187);
|
|
|
+ lsp:=newsp(power,sz); lsp^.elset:=asp
|
|
|
+ end;
|
|
|
+ if asp<>nil then if ak=cst then
|
|
|
+ if (pos.ad<0) or (pos.ad div NB1>=sizeof(lsp,wordmult)) then
|
|
|
+ error(+0188)
|
|
|
+ else if sz<=ncsw*sz_word then
|
|
|
+ begin c:=true; v:=pos.ad end;
|
|
|
+ if not c then load; asp:=lsp
|
|
|
+end end;
|
|
|
+
|
|
|
+begin with a do begin {buildset}
|
|
|
+ varpart:=false; ncst:=0; asp:=nullset;
|
|
|
+ for i:=1 to ncsw do cstpart[i]:=[];
|
|
|
+ if find2([notsy..lparent],fsys,+0189) then
|
|
|
+ repeat l1:=lino;
|
|
|
+ setexpr(fsys+[colon2,comma],cst1,val1); cst12:=cst1;
|
|
|
+ if find3(colon2,fsys+[comma,notsy..lparent],+0190) then
|
|
|
+ begin setexpr(fsys+[comma,notsy..lparent],cst2,val2);
|
|
|
+ cst12:=cst12 and cst2;
|
|
|
+ if not cst12 then
|
|
|
+ begin
|
|
|
+ if cst2 then gencst(op_loc,val2);
|
|
|
+ if cst1 then
|
|
|
+ begin l2:=lino; gencst(op_loc,val1); exchange(l1,l2) end;
|
|
|
+ l2:=lino; genasp(op_zer); exchange(l1,l2);
|
|
|
+ genasp(op_loc); gensp(BTS,3*sz_word)
|
|
|
+ end;
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if cst12 then val2:=val1 else genasp(op_set);
|
|
|
+ if cst12 then
|
|
|
+ for i:=val1 to val2 do
|
|
|
+ begin j:=i div NB2 + 1; ncst:=ncst+1;
|
|
|
+ cstpart[j]:=cstpart[j] + [i mod NB2]
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if varpart then genasp(op_ior) else varpart:=true;
|
|
|
+ until endofloop(fsys,[notsy..lparent],comma,+0191); {+0192}
|
|
|
+ ak:=loaded;
|
|
|
+ if ncst>0 then
|
|
|
+ begin
|
|
|
+ for i:=sizeof(asp,wordmult) div sz_word downto 1 do
|
|
|
+ genwordset(cstpart[i]);
|
|
|
+ if varpart then genasp(op_ior);
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if not varpart then genasp(op_zer); {empty set}
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure factor(fsys: sos);
|
|
|
+var lip:ip; lsp:sp;
|
|
|
+begin with a do begin
|
|
|
+ asp:=nil; packbit:=false; ak:=loaded;
|
|
|
+ if find1([notsy..nilcst,lparent],fsys,+0193) then
|
|
|
+ case sy of
|
|
|
+ ident:
|
|
|
+ begin lip:=searchid([konst,vars,field,func,carrbnd]); insym;
|
|
|
+ case lip^.klass of
|
|
|
+ func: {call moves result to top stack}
|
|
|
+ begin call(fsys,lip); ak:=loaded; packbit:=false end;
|
|
|
+ konst:
|
|
|
+ begin asp:=lip^.idtype;
|
|
|
+ if nicescalar(asp) then {including asp=nil}
|
|
|
+ begin ak:=cst; pos.ad:=lip^.value end
|
|
|
+ else
|
|
|
+ begin ak:=ploaded; laedlb(abs(lip^.value));
|
|
|
+ if asp^.form=scalar then
|
|
|
+ begin load; if lip^.value<0 then negate end
|
|
|
+ else
|
|
|
+ if asp=zeroptr then ak:=loaded
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ field,vars:
|
|
|
+ selector(fsys,lip,[used]);
|
|
|
+ carrbnd:
|
|
|
+ begin lsp:=lip^.idtype; assert formof(lsp,[carray]);
|
|
|
+ descraddr(lsp^.arpos); lsp:=lsp^.inxtype; asp:=desub(lsp);
|
|
|
+ if lip^.next=nil then ak:=ploaded {low bound} else
|
|
|
+ begin gencst(op_loi,2*sz_int); genasp(op_adi) end;
|
|
|
+ load; checkbnds(lsp);
|
|
|
+ end;
|
|
|
+ end {case}
|
|
|
+ end;
|
|
|
+ intcst:
|
|
|
+ begin asp:=intptr; ak:=cst; pos.ad:=val; insym end;
|
|
|
+ realcst:
|
|
|
+ begin asp:=realptr; ak:=ploaded; laedlb(val); insym end;
|
|
|
+ longcst:
|
|
|
+ begin asp:=longptr; ak:=ploaded; laedlb(val); insym end;
|
|
|
+ charcst:
|
|
|
+ begin asp:=charptr; ak:=cst; pos.ad:=val; insym end;
|
|
|
+ stringcst:
|
|
|
+ begin asp:=stringstruct; laedlb(val); insym;
|
|
|
+ if asp<>zeroptr then ak:=ploaded;
|
|
|
+ end;
|
|
|
+ nilcst:
|
|
|
+ begin insym; asp:=nilptr; genasp(op_zer); end;
|
|
|
+ lparent:
|
|
|
+ begin insym; expression(fsys+[rparent]); nextif(rparent,+0194) end;
|
|
|
+ notsy:
|
|
|
+ begin insym; factor(fsys); load; genop(op_teq); asp:=desub(asp);
|
|
|
+ if asp<>boolptr then errasp(+0195)
|
|
|
+ end;
|
|
|
+ lbrack:
|
|
|
+ begin insym; buildset(fsys+[rbrack]); nextif(rbrack,+0196) end;
|
|
|
+ end
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure term(fsys:sos);
|
|
|
+var lsy:symbol; lsp:sp; l1:integer; first:boolean;
|
|
|
+begin with a,b do begin first:=true; l1:=lino;
|
|
|
+ factor(fsys+[starsy..andsy]);
|
|
|
+ while find2([starsy..andsy],fsys,+0197) do
|
|
|
+ begin if first then begin load; first:=false end;
|
|
|
+ lsy:=sy; insym; l1:=lino; lsp:=asp;
|
|
|
+ factor(fsys+[starsy..andsy]); load; convert(lsp,l1);
|
|
|
+ if asp<>nil then
|
|
|
+ case lsy of
|
|
|
+ starsy:
|
|
|
+ if (asp=intptr) or (asp=longptr) then genasp(op_mli) else
|
|
|
+ if asp=realptr then genasp(op_mlf) else
|
|
|
+ if asp^.form=power then genasp(op_and) else errasp(+0198);
|
|
|
+ slashsy:
|
|
|
+ begin
|
|
|
+ if (asp=intptr) or (asp=longptr) then
|
|
|
+ begin lsp:=asp;
|
|
|
+ convert(realptr,l1); {make real of right operand}
|
|
|
+ convert(lsp,l1); {make real of left operand}
|
|
|
+ end;
|
|
|
+ if asp=realptr then genasp(op_dvf) else errasp(+0199);
|
|
|
+ end;
|
|
|
+ divsy:
|
|
|
+ if (asp=intptr) or (asp=longptr) then genasp(op_dvi) else
|
|
|
+ errasp(+0200);
|
|
|
+ modsy:
|
|
|
+ begin
|
|
|
+ if asp=intptr then gensp(MDI,2*sz_int) else
|
|
|
+ if asp=longptr then gensp(MDL,2*sz_long) else errasp(+0201);
|
|
|
+ genasp(op_lfr);
|
|
|
+ end;
|
|
|
+ andsy:
|
|
|
+ if asp=boolptr then genasp(op_and) else errasp(+0202);
|
|
|
+ end {case}
|
|
|
+ end {while}
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure simpleexpression(fsys:sos);
|
|
|
+var lsy:symbol; lsp:sp; l1:integer; signed,min,first:boolean;
|
|
|
+begin with a do begin l1:=lino; first:=true;
|
|
|
+ signed:=(sy=plussy) or (sy=minsy);
|
|
|
+ if signed then begin min:=sy=minsy; insym end else min:=false;
|
|
|
+ term(fsys + [minsy,plussy,orsy]); lsp:=desub(asp);
|
|
|
+ if signed then
|
|
|
+ if (lsp<>intptr) and (lsp<>realptr) and (lsp<>longptr) then
|
|
|
+ errasp(+0203)
|
|
|
+ else if min then
|
|
|
+ begin load; first:=false; asp:=lsp; negate end;
|
|
|
+ while find2([plussy,minsy,orsy],fsys,+0204) do
|
|
|
+ begin if first then begin load; first:=false end;
|
|
|
+ lsy:=sy; insym; l1:=lino; lsp:=asp;
|
|
|
+ term(fsys+[minsy,plussy,orsy]); load; convert(lsp,l1);
|
|
|
+ if asp<>nil then
|
|
|
+ case lsy of
|
|
|
+ plussy:
|
|
|
+ if (asp=intptr) or (asp=longptr) then genasp(op_adi) else
|
|
|
+ if asp=realptr then genasp(op_adf) else
|
|
|
+ if asp^.form=power then genasp(op_ior) else errasp(+0205);
|
|
|
+ minsy:
|
|
|
+ if (asp=intptr) or (asp=longptr) then genasp(op_sbi) else
|
|
|
+ if asp=realptr then genasp(op_sbf) else
|
|
|
+ if asp^.form=power then begin genasp(op_com); genasp(op_and) end
|
|
|
+ else errasp(+0206);
|
|
|
+ orsy:
|
|
|
+ if asp=boolptr then genasp(op_ior) else errasp(+0207);
|
|
|
+ end {case}
|
|
|
+ end {while}
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure expression; { fsys:sos }
|
|
|
+var lsy:symbol; lsp:sp; l1,l2:integer;
|
|
|
+begin with a do begin l1:=lino;
|
|
|
+ simpleexpression(fsys+[eqsy..insy]);
|
|
|
+ if find2([eqsy..insy],fsys,+0208) then
|
|
|
+ begin lsy:=sy; insym; lsp:=asp; loadcheap; l2:=lino;
|
|
|
+ simpleexpression(fsys); loadcheap;
|
|
|
+ if lsy=insy then
|
|
|
+ begin
|
|
|
+ if not formof(asp,[power]) then errasp(+0209) else
|
|
|
+ if asp=nullset then genasp(op_and) else
|
|
|
+ {this effectively replaces the word on top of the
|
|
|
+ stack by the result of the 'in' operator: false }
|
|
|
+ if not (compat(lsp,asp^.elset) <= subeq) then errasp(+0210) else
|
|
|
+ begin exchange(l1,l2); genasp(op_inn) end
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin convert(lsp,l2);
|
|
|
+ if asp<>nil then
|
|
|
+ case asp^.form of
|
|
|
+ scalar:
|
|
|
+ if asp=realptr then genasp(op_cmf) else genasp(op_cmi);
|
|
|
+ pointer:
|
|
|
+ if (lsy=eqsy) or (lsy=nesy) then genop(op_cmp) else
|
|
|
+ errasp(+0211);
|
|
|
+ power:
|
|
|
+ case lsy of
|
|
|
+ eqsy,nesy: genasp(op_cms);
|
|
|
+ ltsy,gtsy: errasp(+0212);
|
|
|
+ lesy: {'a<=b' equivalent to 'a-b=[]'}
|
|
|
+ begin genasp(op_com); genasp(op_and); genasp(op_zer);
|
|
|
+ genasp(op_cms); lsy:=eqsy
|
|
|
+ end;
|
|
|
+ gesy: {'a>=b' equivalent to 'a=a+b'}
|
|
|
+ begin gencst(op_dup,2*sizeof(asp,wordmult));
|
|
|
+ genasp(op_asp); genasp(op_ior);
|
|
|
+ genasp(op_cms); lsy:=eqsy
|
|
|
+ end
|
|
|
+ end; {case}
|
|
|
+ arrays:
|
|
|
+ if string(asp) then
|
|
|
+ begin gencst(op_loc,asp^.size);
|
|
|
+ gensp(BCP,2*sz_addr+sz_word);
|
|
|
+ gencst(op_lfr,sz_word)
|
|
|
+ end
|
|
|
+ else errasp(+0213);
|
|
|
+ records: errasp(+0214);
|
|
|
+ files: errasp(+0215)
|
|
|
+ end; { case }
|
|
|
+ case lsy of
|
|
|
+ ltsy: genop(op_tlt);
|
|
|
+ lesy: genop(op_tle);
|
|
|
+ gtsy: genop(op_tgt);
|
|
|
+ gesy: genop(op_tge);
|
|
|
+ nesy: genop(op_tne);
|
|
|
+ eqsy: genop(op_teq)
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ asp:=boolptr; ak:=loaded
|
|
|
+ end;
|
|
|
+end end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure statement(fsys:sos); forward;
|
|
|
+ {this forward declaration can be avoided}
|
|
|
+
|
|
|
+procedure assignment(fsys:sos; fip:ip);
|
|
|
+var la:attr; l1,l2:integer;
|
|
|
+begin
|
|
|
+ l1:=lino; selector(fsys+[becomes],fip,[assigned]); l2:=lino;
|
|
|
+ la:=a; nextif(becomes,+0216);
|
|
|
+ expression(fsys); loadcheap; checkasp(la.asp,+0217);
|
|
|
+ exchange(l1,l2); a:=la;
|
|
|
+ if not formof(la.asp,[arrays..records]) then store else
|
|
|
+ begin loadaddr;
|
|
|
+ if la.asp^.form<>carray then genasp(op_blm) else
|
|
|
+ begin descraddr(la.asp^.arpos); gensp(ASZ,2*sz_addr);
|
|
|
+ gencst(op_lfr,sz_word); gencst(op_bls,sz_word)
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure gotostatement;
|
|
|
+{jumps into structured statements can give strange results. }
|
|
|
+label 1;
|
|
|
+var llp:lp; lbp:bp; diff:integer;
|
|
|
+begin
|
|
|
+ if sy<>intcst then error(+0218) else
|
|
|
+ begin llp:=searchlab(b.lchain,val);
|
|
|
+ if llp<>nil then gencst(op_bra,llp^.labname) else
|
|
|
+ begin lbp:=b.nextbp; diff:=1;
|
|
|
+ while lbp<>nil do
|
|
|
+ begin llp:=searchlab(lbp^.lchain,val);
|
|
|
+ if llp<>nil then goto 1;
|
|
|
+ lbp:=lbp^.nextbp; diff:=diff+1;
|
|
|
+ end;
|
|
|
+1: if llp=nil then errint(+0219,val) else
|
|
|
+ begin
|
|
|
+ if llp^.labdlb=0 then
|
|
|
+ begin dlbno:=dlbno+1; llp^.labdlb:=dlbno;
|
|
|
+ genop(ps_ina); argdlb(dlbno); {forward data reference}
|
|
|
+ end;
|
|
|
+ laedlb(llp^.labdlb);
|
|
|
+ if diff=level-1 then gencst(op_zer,sz_addr) else
|
|
|
+ gencst(op_lxl,diff);
|
|
|
+ gensp(GTO,2*sz_addr);
|
|
|
+ end;
|
|
|
+ end;
|
|
|
+ insym;
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure compoundstatement(fsys:sos; err:integer);
|
|
|
+begin
|
|
|
+ repeat statement(fsys+[semicolon])
|
|
|
+ until endofloop(fsys,[beginsy..casesy],semicolon,err)
|
|
|
+end;
|
|
|
+
|
|
|
+procedure ifstatement(fsys:sos);
|
|
|
+var lb1,lb2:integer;
|
|
|
+begin with b do begin
|
|
|
+ expression(fsys+[thensy,elsesy]);
|
|
|
+ force(boolptr,+0220); ilbno:=ilbno+1; lb1:=ilbno; gencst(op_zeq,lb1);
|
|
|
+ nextif(thensy,+0221); statement(fsys+[elsesy]);
|
|
|
+ if find3(elsesy,fsys,+0222) then
|
|
|
+ begin ilbno:=ilbno+1; lb2:=ilbno; gencst(op_bra,lb2);
|
|
|
+ newilb(lb1); statement(fsys); newilb(lb2)
|
|
|
+ end
|
|
|
+ else newilb(lb1);
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure casestatement(fsys:sos);
|
|
|
+label 1;
|
|
|
+type cip=^caseinfo;
|
|
|
+ caseinfo=record
|
|
|
+ next: cip;
|
|
|
+ csstart: integer;
|
|
|
+ cslab: integer
|
|
|
+ end;
|
|
|
+var lsp:sp; head,p,q,r:cip; l0,l1:integer;
|
|
|
+ ilb1,ilb2,dlb,i,n,m,min,max:integer;
|
|
|
+begin with b do begin
|
|
|
+ expression(fsys+[ofsy,semicolon,ident..plussy]); lsp:=a.asp; load;
|
|
|
+ if not nicescalar(desub(lsp)) then begin error(+0223); lsp:=nil end;
|
|
|
+ l0:=lino; ilbno:=ilbno+1; ilb1:=ilbno;
|
|
|
+ nextif(ofsy,+0224); head:=nil; max:=-MI2; min:=MI2; n:=0;
|
|
|
+ repeat ilbno:=ilbno+1; ilb2:=ilbno; {label of current case}
|
|
|
+ repeat i:=cstinteger(fsys+[comma,colon1,semicolon],lsp,+0225);
|
|
|
+ if i>max then max:=i; if i<min then min:=i; n:=n+1;
|
|
|
+ q:=head; r:=nil; new(p);
|
|
|
+ while q<>nil do
|
|
|
+ begin {chain all cases in ascending order}
|
|
|
+ if q^.cslab>=i then
|
|
|
+ begin if q^.cslab=i then error(+0226); goto 1 end;
|
|
|
+ r:=q; q:=q^.next
|
|
|
+ end;
|
|
|
+1: p^.next:=q; p^.cslab:=i; p^.csstart:=ilb2;
|
|
|
+ if r=nil then head:=p else r^.next:=p;
|
|
|
+ until endofloop(fsys+[colon1,semicolon],[ident..plussy],comma,+0227);
|
|
|
+ {+0228}
|
|
|
+ nextif(colon1,+0229); newilb(ilb2); statement(fsys+[semicolon]);
|
|
|
+ gencst(op_bra,ilb1);
|
|
|
+ until lastsemicolon(fsys,[ident..plussy],+0230); {+0231 +0232}
|
|
|
+ assert n<>0; newilb(ilb1); l1:=lino;
|
|
|
+ dlb:=newdlb; genop(ps_rom); argnil;
|
|
|
+ if (max div 3) - (min div 3) < n then
|
|
|
+ begin argcst(min); argcst(max-min);
|
|
|
+ m:=op_csa;
|
|
|
+ while head<>nil do
|
|
|
+ begin
|
|
|
+ while head^.cslab>min do
|
|
|
+ begin argnil; min:=min+1 end;
|
|
|
+ argilb(head^.csstart); min:=min+1; head:=head^.next
|
|
|
+ end;
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin argcst(n); m:=op_csb;
|
|
|
+ while head<>nil do
|
|
|
+ begin argcst(head^.cslab);argilb(head^.csstart);head:=head^.next end;
|
|
|
+ end;
|
|
|
+ argend; laedlb(dlb); gencst(m,sz_word); exchange(l0,l1)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure repeatstatement(fsys:sos);
|
|
|
+var lb1: integer;
|
|
|
+begin with b do begin
|
|
|
+ ilbno:=ilbno+1; lb1:=ilbno; newilb(lb1);
|
|
|
+ compoundstatement(fsys+[untilsy],+0233); {+0234}
|
|
|
+ nextif(untilsy,+0235); genlin;
|
|
|
+ expression(fsys); force(boolptr,+0236); gencst(op_zeq,lb1);
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure whilestatement(fsys:sos);
|
|
|
+var lb1,lb2: integer;
|
|
|
+begin with b do begin
|
|
|
+ ilbno:=ilbno+1; lb1:=ilbno; newilb(lb1);
|
|
|
+ ilbno:=ilbno+1; lb2:=ilbno;
|
|
|
+ genlin; expression(fsys+[dosy]);
|
|
|
+ force(boolptr,+0237); gencst(op_zeq,lb2);
|
|
|
+ nextif(dosy,+0238); statement(fsys);
|
|
|
+ gencst(op_bra,lb1); newilb(lb2)
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure forstatement(fsys:sos);
|
|
|
+var lip:ip; tosym:boolean; endlab,looplab,savlb:integer;
|
|
|
+ av,at1,at2:attr; lsp:sp;
|
|
|
+
|
|
|
+procedure forbound(fsys:sos; var fa:attr; fsp:sp);
|
|
|
+begin
|
|
|
+ expression(fsys); fa:=a; force(fsp,+0239);
|
|
|
+ if fa.ak<>cst then
|
|
|
+ begin temporary(fsp,reg_any);
|
|
|
+ genasp(op_dup); fa:=a; store
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+begin with b do begin savlb:=reglb; tosym:=false;
|
|
|
+ ilbno:=ilbno+1; looplab:=ilbno; ilbno:=ilbno+1; endlab:=ilbno;
|
|
|
+ inita(nil,0);
|
|
|
+ if sy<>ident then error(+0240) else
|
|
|
+ begin lip:=searchid([vars]); insym;
|
|
|
+ a.asp:=lip^.idtype; a.pos:=lip^.vpos;
|
|
|
+ lip^.iflag:=lip^.iflag+[used,assigned,loopvar];
|
|
|
+ if level>1 then
|
|
|
+ if (a.pos.ad>=0) or (a.pos.lv<>level) then
|
|
|
+ error(+0241);
|
|
|
+ end;
|
|
|
+ lsp:=desub(a.asp);
|
|
|
+ if not nicescalar(lsp) then begin errasp(+0242); lsp:=nil end;
|
|
|
+ av:=a; nextif(becomes,+0243);
|
|
|
+ forbound(fsys+[tosy,downtosy,notsy..lparent,dosy],at1,lsp);
|
|
|
+ if find1([tosy,downtosy],fsys+[notsy..lparent,dosy],+0244) then
|
|
|
+ begin tosym:=sy=tosy; insym end;
|
|
|
+ forbound(fsys+[dosy],at2,lsp);
|
|
|
+ if tosym then gencst(op_bgt,endlab) else gencst(op_blt,endlab);
|
|
|
+ a:=at1; force(av.asp,+0245); a:=av; store; newilb(looplab);
|
|
|
+ nextif(dosy,+0246); statement(fsys);
|
|
|
+ a:=av; load; a:=at2; load; gencst(op_beq,endlab);
|
|
|
+ a:=av; load; if tosym then genop(op_inc) else genop(op_dec);
|
|
|
+ a.asp:=lsp; checkbnds(av.asp); a:=av; store;
|
|
|
+ gencst(op_bra,looplab); newilb(endlab);
|
|
|
+ reglb:=savlb
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure withstatement(fsys:sos);
|
|
|
+var lnp,savtop:np; savlb:integer; pbit:boolean;
|
|
|
+begin with b do begin
|
|
|
+ savlb:=reglb; savtop:=top;
|
|
|
+ repeat variable(fsys+[comma,dosy]);
|
|
|
+ if not formof(a.asp,[records]) then errasp(+0247) else
|
|
|
+ begin pbit:=spack in a.asp^.sflag;
|
|
|
+ new(lnp,wrec); lnp^.occur:=wrec; lnp^.fname:=a.asp^.fstfld;
|
|
|
+ if a.ak<>fixed then
|
|
|
+ begin loadaddr; temporary(nilptr,reg_pointer); store;
|
|
|
+ a.ak:=pfixed;
|
|
|
+ end;
|
|
|
+ a.packbit:=pbit; lnp^.wa:=a; lnp^.nlink:=top; top:=lnp;
|
|
|
+ end;
|
|
|
+ until endofloop(fsys+[dosy],[ident],comma,+0248); {+0249}
|
|
|
+ nextif(dosy,+0250); statement(fsys);
|
|
|
+ top:=savtop; reglb:=savlb;
|
|
|
+end end;
|
|
|
+
|
|
|
+procedure assertion(fsys:sos);
|
|
|
+begin teststandard;
|
|
|
+ if opt['a']=off then
|
|
|
+ while not (sy in fsys) do insym
|
|
|
+ else
|
|
|
+ begin expression(fsys); force(boolptr,+0251);
|
|
|
+ gencst(op_loc,srcorig); gensp(ASS,2*sz_word);
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+procedure statement; {fsys: sos}
|
|
|
+var lip:ip; llp:lp; lsy:symbol;
|
|
|
+begin
|
|
|
+ assert [labelsy..casesy,endsy] <= fsys;
|
|
|
+ assert [ident,intcst] * fsys = [];
|
|
|
+ if find2([intcst],fsys+[ident],+0252) then
|
|
|
+ begin llp:=searchlab(b.lchain,val);
|
|
|
+ if llp=nil then errint(+0253,val) else
|
|
|
+ begin if llp^.seen then errint(+0254,val) else llp^.seen:=true;
|
|
|
+ newilb(llp^.labname)
|
|
|
+ end;
|
|
|
+ insym; nextif(colon1,+0255);
|
|
|
+ end;
|
|
|
+ if find2([ident,beginsy..casesy],fsys,+0256) then
|
|
|
+ begin if giveline then if sy<>whilesy then genlin;
|
|
|
+ if sy=ident then
|
|
|
+ if id='assert ' then
|
|
|
+ begin insym; assertion(fsys) end
|
|
|
+ else
|
|
|
+ begin lip:=searchid([vars,field,func,proc]); insym;
|
|
|
+ if lip^.klass=proc then call(fsys,lip) else assignment(fsys,lip)
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin lsy:=sy; insym;
|
|
|
+ case lsy of
|
|
|
+ beginsy:
|
|
|
+ begin compoundstatement(fsys,+0257); {+0258}
|
|
|
+ nextif(endsy,+0259)
|
|
|
+ end;
|
|
|
+ gotosy:
|
|
|
+ gotostatement;
|
|
|
+ ifsy:
|
|
|
+ ifstatement(fsys);
|
|
|
+ casesy:
|
|
|
+ begin casestatement(fsys); nextif(endsy,+0260) end;
|
|
|
+ whilesy:
|
|
|
+ whilestatement(fsys);
|
|
|
+ repeatsy:
|
|
|
+ repeatstatement(fsys);
|
|
|
+ forsy:
|
|
|
+ forstatement(fsys);
|
|
|
+ withsy:
|
|
|
+ withstatement(fsys);
|
|
|
+ end
|
|
|
+ end;
|
|
|
+ end
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure body(fsys:sos; fip:ip);
|
|
|
+var i,dlb,l0,l1,ssp:integer; llp:lp; spset:boolean;
|
|
|
+begin with b do begin
|
|
|
+{produce PRO}
|
|
|
+ genpnam(ps_pro,fip); argend;
|
|
|
+ gencst(ps_mes,ms_par);argcst(fip^.maxlb); argend;
|
|
|
+ l0:=lino; dlb:=0; trace('procentr',fip,dlb);
|
|
|
+{global labels}
|
|
|
+ llp:=lchain; spset:=false;
|
|
|
+ while llp<>nil do
|
|
|
+ begin
|
|
|
+ if llp^.labdlb<>0 then
|
|
|
+ begin
|
|
|
+ if not spset then
|
|
|
+ begin spset:=true;
|
|
|
+ temporary(nilptr,reg_pointer); ssp:=a.pos.ad;
|
|
|
+ gencst(op_lor,1); store
|
|
|
+ end;
|
|
|
+ argdlb(llp^.labdlb); lino:=lino+1; genop(ps_rom);
|
|
|
+ argilb(llp^.labname); argcst(ssp); argend;
|
|
|
+ end;
|
|
|
+ llp:=llp^.nextlp
|
|
|
+ end;
|
|
|
+{the body itself}
|
|
|
+ currproc:=fip;
|
|
|
+ compoundstatement(fsys,+0261); {+0262}
|
|
|
+ trace('procexit',fip,dlb);
|
|
|
+{undefined labels}
|
|
|
+ llp:=lchain;
|
|
|
+ while llp<>nil do
|
|
|
+ begin if not llp^.seen then errint(+0263,llp^.labval);
|
|
|
+ llp:=llp^.nextlp
|
|
|
+ end;
|
|
|
+{finish and close files}
|
|
|
+ treewalk(top^.fname);
|
|
|
+ if level=1 then
|
|
|
+ begin l1:=lino;
|
|
|
+ genop(op_fil); argdlb(fildlb); {temporarily}
|
|
|
+ dlb:=newdlb; gencst(ps_con,argc+1);
|
|
|
+ for i:=0 to argc do with argv[i] do
|
|
|
+ begin argcst(ad);
|
|
|
+ if (ad=-1) and (i>1) then errid(+0264,name)
|
|
|
+ end;
|
|
|
+ argend; gencst(op_lxl,0); laedlb(dlb); gencst(op_lae,0);
|
|
|
+ gencst(op_lxa,0); gensp(INI,4*sz_addr);
|
|
|
+ exchange(l0,l1); gencst(op_loc,0); gensp(HLT,0)
|
|
|
+ end
|
|
|
+ else
|
|
|
+ begin inita(fip^.idtype,fip^.pfpos.ad);
|
|
|
+ if fip^.klass=func then
|
|
|
+ begin load;
|
|
|
+ if not (assigned in fip^.iflag) then
|
|
|
+ errid(-(+0265),fip^.name);
|
|
|
+ end;
|
|
|
+ genasp(op_ret);
|
|
|
+ end;
|
|
|
+ gencst(ps_end,-minlb);
|
|
|
+end end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure block; {forward declared}
|
|
|
+begin with b do begin
|
|
|
+ assert [labelsy..withsy] <= fsys;
|
|
|
+ assert [ident,intcst,casesy,endsy,period] * fsys = [];
|
|
|
+ if find3(labelsy,fsys,+0266) then labeldeclaration(fsys);
|
|
|
+ if find3(constsy,fsys,+0267) then constdefinition(fsys);
|
|
|
+ if find3(typesy,fsys,+0268) then typedefinition(fsys);
|
|
|
+ if find3(varsy,fsys,+0269) then vardeclaration(fsys);
|
|
|
+ if fip=progp then
|
|
|
+ begin
|
|
|
+ if iop[true]<>nil then
|
|
|
+ begin argv[1].ad:=posaddr(holeb,textptr,false);
|
|
|
+ iop[true]^.vpos.ad:=argv[1].ad
|
|
|
+ end;
|
|
|
+ if iop[false]<>nil then
|
|
|
+ begin argv[0].ad:=posaddr(holeb,textptr,false);
|
|
|
+ iop[false]^.vpos.ad:=argv[0].ad
|
|
|
+ end;
|
|
|
+ genhol; genpnam(ps_exp,fip);
|
|
|
+ end; {externals are also extern for the main body}
|
|
|
+ fip^.pfpos.ad:=negaddr(fip^.idtype); {function result area}
|
|
|
+ while find2([procsy,funcsy],fsys,+0270) do pfdeclaration(fsys);
|
|
|
+ if forwcount<>0 then error(+0271); {forw proc not specified}
|
|
|
+ nextif(beginsy,+0272);
|
|
|
+ body(fsys+[casesy,endsy],fip);
|
|
|
+ nextif(endsy,+0273);
|
|
|
+end end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure programme(fsys:sos);
|
|
|
+var stdin,stdout:boolean; p:ip;
|
|
|
+begin
|
|
|
+ nextif(progsy,+0274); nextif(ident,+0275);
|
|
|
+ if find3(lparent,fsys+[semicolon],+0276) then
|
|
|
+ begin
|
|
|
+ repeat
|
|
|
+ if sy<>ident then error(+0277) else
|
|
|
+ begin stdin:=id='input '; stdout:=id='output ';
|
|
|
+ if stdin or stdout then
|
|
|
+ begin p:=newip(vars,id,textptr,nil);
|
|
|
+ enterid(p); iop[stdout]:=p;
|
|
|
+ end
|
|
|
+ else
|
|
|
+ if argc<maxargc then
|
|
|
+ begin
|
|
|
+ argc:=argc+1; argv[argc].name:=id; argv[argc].ad:=-1
|
|
|
+ end;
|
|
|
+ insym
|
|
|
+ end
|
|
|
+ until endofloop(fsys+[rparent,semicolon],[ident],comma,+0278); {+0279}
|
|
|
+ if argc>maxargc then
|
|
|
+ begin error(+0280); argc:=maxargc end;
|
|
|
+ nextif(rparent,+0281);
|
|
|
+ end;
|
|
|
+ nextif(semicolon,+0282);
|
|
|
+ block(fsys,progp);
|
|
|
+ if opt['l']<>off then
|
|
|
+ begin gencst(ps_mes,ms_src); argcst(srcorig); argend end;
|
|
|
+ eofexpected:=true; nextif(period,+0283);
|
|
|
+end;
|
|
|
+
|
|
|
+procedure compile;
|
|
|
+var lsys:sos;
|
|
|
+begin lsys:=[progsy,labelsy..withsy];
|
|
|
+ repeat eofexpected:=false;
|
|
|
+ main:=find2([progsy,labelsy,beginsy..withsy],lsys,+0284);
|
|
|
+ if main then programme(lsys) else
|
|
|
+ begin
|
|
|
+ if find3(constsy,lsys,+0285) then constdefinition(lsys);
|
|
|
+ if find3(typesy,lsys,+0286) then typedefinition(lsys);
|
|
|
+ if find3(varsy,lsys,+0287) then vardeclaration(lsys);
|
|
|
+ genhol;
|
|
|
+ while find2([procsy,funcsy],lsys,+0288) do pfdeclaration(lsys);
|
|
|
+ end;
|
|
|
+ error(+0289);
|
|
|
+ until false; { the only way out is the halt in nextln on eof }
|
|
|
+end;
|
|
|
+
|
|
|
+{===================================================================}
|
|
|
+
|
|
|
+procedure init1;
|
|
|
+var c:char;
|
|
|
+begin
|
|
|
+{reserved words}
|
|
|
+ rw[ 0]:='if '; rw[ 1]:='do '; rw[ 2]:='of ';
|
|
|
+ rw[ 3]:='to '; rw[ 4]:='in '; rw[ 5]:='or ';
|
|
|
+ rw[ 6]:='end '; rw[ 7]:='for '; rw[ 8]:='nil ';
|
|
|
+ rw[ 9]:='var '; rw[10]:='div '; rw[11]:='mod ';
|
|
|
+ rw[12]:='set '; rw[13]:='and '; rw[14]:='not ';
|
|
|
+ rw[15]:='then '; rw[16]:='else '; rw[17]:='with ';
|
|
|
+ rw[18]:='case '; rw[19]:='type '; rw[20]:='goto ';
|
|
|
+ rw[21]:='file '; rw[22]:='begin '; rw[23]:='until ';
|
|
|
+ rw[24]:='while '; rw[25]:='array '; rw[26]:='const ';
|
|
|
+ rw[27]:='label '; rw[28]:='repeat '; rw[29]:='record ';
|
|
|
+ rw[30]:='downto '; rw[31]:='packed '; rw[32]:='program ';
|
|
|
+ rw[33]:='function'; rw[34]:='procedur';
|
|
|
+{corresponding symbols}
|
|
|
+ rsy[ 0]:=ifsy; rsy[ 1]:=dosy; rsy[ 2]:=ofsy;
|
|
|
+ rsy[ 3]:=tosy; rsy[ 4]:=insy; rsy[ 5]:=orsy;
|
|
|
+ rsy[ 6]:=endsy; rsy[ 7]:=forsy; rsy[ 8]:=nilcst;
|
|
|
+ rsy[ 9]:=varsy; rsy[10]:=divsy; rsy[11]:=modsy;
|
|
|
+ rsy[12]:=setsy; rsy[13]:=andsy; rsy[14]:=notsy;
|
|
|
+ rsy[15]:=thensy; rsy[16]:=elsesy; rsy[17]:=withsy;
|
|
|
+ rsy[18]:=casesy; rsy[19]:=typesy; rsy[20]:=gotosy;
|
|
|
+ rsy[21]:=filesy; rsy[22]:=beginsy; rsy[23]:=untilsy;
|
|
|
+ rsy[24]:=whilesy; rsy[25]:=arraysy; rsy[26]:=constsy;
|
|
|
+ rsy[27]:=labelsy; rsy[28]:=repeatsy; rsy[29]:=recordsy;
|
|
|
+ rsy[30]:=downtosy; rsy[31]:=packedsy; rsy[32]:=progsy;
|
|
|
+ rsy[33]:=funcsy; rsy[34]:=procsy;
|
|
|
+{indices into rw to find reserved words fast}
|
|
|
+ frw[0]:= 0; frw[1]:= 0; frw[2]:= 6; frw[3]:=15; frw[4]:=22;
|
|
|
+ frw[5]:=28; frw[6]:=32; frw[7]:=33; frw[8]:=35;
|
|
|
+{char types}
|
|
|
+ for c:=chr(0) to chr(maxcharord) do cs[c]:=others;
|
|
|
+ for c:='0' to '9' do cs[c]:=digit;
|
|
|
+ for c:='A' to 'Z' do cs[c]:=upper;
|
|
|
+ for c:='a' to 'z' do cs[c]:=lower;
|
|
|
+ cs[chr(ascnl)]:=layout;
|
|
|
+ cs[chr(ascvt)]:=layout;
|
|
|
+ cs[chr(ascff)]:=layout;
|
|
|
+ cs[chr(asccr)]:=layout;
|
|
|
+{characters with corresponding chartype in ASCII order}
|
|
|
+ cs[chr(ascht)]:=tabch;
|
|
|
+ cs[' ']:=layout; cs['"']:=dquotech; cs['''']:=quotech;
|
|
|
+ cs['(']:=lparentch; cs[')']:=rparentch; cs['*']:=star;
|
|
|
+ cs['+']:=plusch; cs[',']:=commach; cs['-']:=minch;
|
|
|
+ cs['.']:=periodch; cs['/']:=slash; cs[':']:=colonch;
|
|
|
+ cs[';']:=semich; cs['<']:=lessch; cs['=']:=equal;
|
|
|
+ cs['>']:=greaterch; cs['[']:=lbrackch; cs[']']:=rbrackch;
|
|
|
+ cs['^']:=arrowch; cs['{']:=lbracech;
|
|
|
+{single character symbols in chartype order}
|
|
|
+ csy[rparentch]:=rparent; csy[lbrackch]:=lbrack;
|
|
|
+ csy[rbrackch]:=rbrack; csy[commach]:=comma;
|
|
|
+ csy[semich]:=semicolon; csy[arrowch]:=arrow;
|
|
|
+ csy[plusch]:=plussy; csy[minch]:=minsy;
|
|
|
+ csy[slash]:=slashsy; csy[star]:=starsy;
|
|
|
+ csy[equal]:=eqsy;
|
|
|
+{pascal library mnemonics}
|
|
|
+ lmn[ELN ]:='_eln'; lmn[EFL ]:='_efl'; lmn[CLS ]:='_cls';
|
|
|
+ lmn[WDW ]:='_wdw';
|
|
|
+ lmn[OPN ]:='_opn'; lmn[GETX]:='_get'; lmn[RDI ]:='_rdi';
|
|
|
+ lmn[RDC ]:='_rdc'; lmn[RDR ]:='_rdr'; lmn[RDL ]:='_rdl';
|
|
|
+ lmn[RLN ]:='_rln';
|
|
|
+ lmn[CRE ]:='_cre'; lmn[PUTX]:='_put'; lmn[WRI ]:='_wri';
|
|
|
+ lmn[WSI ]:='_wsi'; lmn[WRC ]:='_wrc'; lmn[WSC ]:='_wsc';
|
|
|
+ lmn[WRS ]:='_wrs'; lmn[WSS ]:='_wss'; lmn[WRB ]:='_wrb';
|
|
|
+ lmn[WSB ]:='_wsb'; lmn[WRR ]:='_wrr'; lmn[WSR ]:='_wsr';
|
|
|
+ lmn[WRL ]:='_wrl'; lmn[WSL ]:='_wsl';
|
|
|
+ lmn[WRF ]:='_wrf'; lmn[WRZ ]:='_wrz'; lmn[WSZ ]:='_wsz';
|
|
|
+ lmn[WLN ]:='_wln'; lmn[PAG ]:='_pag';
|
|
|
+ lmn[ABR ]:='_abr'; lmn[RND ]:='_rnd'; lmn[SINX]:='_sin';
|
|
|
+ lmn[COSX]:='_cos'; lmn[EXPX]:='_exp'; lmn[SQT ]:='_sqt';
|
|
|
+ lmn[LOG ]:='_log'; lmn[ATN ]:='_atn'; lmn[ABI ]:='_abi';
|
|
|
+ lmn[ABL ]:='_abl';
|
|
|
+ lmn[BCP ]:='_bcp'; lmn[BTS ]:='_bts'; lmn[NEWX]:='_new';
|
|
|
+ lmn[SAV ]:='_sav'; lmn[RST ]:='_rst'; lmn[INI ]:='_ini';
|
|
|
+ lmn[HLT ]:='_hlt'; lmn[ASS ]:='_ass'; lmn[GTO ]:='_gto';
|
|
|
+ lmn[PAC ]:='_pac'; lmn[UNP ]:='_unp'; lmn[DIS ]:='_dis';
|
|
|
+ lmn[ASZ ]:='_asz'; lmn[MDI ]:='_mdi'; lmn[MDL ]:='_mdl';
|
|
|
+{scalar variables}
|
|
|
+ b.nextbp:=nil;
|
|
|
+ b.reglb:=0;
|
|
|
+ b.minlb:=0;
|
|
|
+ b.ilbno:=0;
|
|
|
+ b.forwcount:=0;
|
|
|
+ b.lchain:=nil;
|
|
|
+ srcchno:=0;
|
|
|
+ srclino:=1;
|
|
|
+ srcorig:=1;
|
|
|
+ lino:=0;
|
|
|
+ dlbno:=0;
|
|
|
+ holeb:=0;
|
|
|
+ argc:=1;
|
|
|
+ lastpfno:=0;
|
|
|
+ giveline:=true;
|
|
|
+ including:=false;
|
|
|
+ eofexpected:=false;
|
|
|
+ intypedec:=false;
|
|
|
+ fltused:=false;
|
|
|
+ seconddot:=false;
|
|
|
+ iop[false]:=nil;
|
|
|
+ iop[true]:=nil;
|
|
|
+ argv[0].ad:=-1;
|
|
|
+ argv[1].ad:=-1;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure init2;
|
|
|
+var p:ip; k:idclass; j:standpf;
|
|
|
+ pfn:array[standpf] of idarr;
|
|
|
+begin
|
|
|
+{initialize the first name space}
|
|
|
+ new(top,blck); top^.occur:=blck; top^.nlink:=nil; top^.fname:=nil;
|
|
|
+ level:=0;
|
|
|
+{undefined identifier pointers used by searchid}
|
|
|
+ for k:=types to func do
|
|
|
+ undefip[k]:=newip(k,spaces,nil,nil);
|
|
|
+{names of standard procedures/functions}
|
|
|
+ pfn[pread ]:='read '; pfn[preadln ]:='readln ';
|
|
|
+ pfn[pwrite ]:='write '; pfn[pwriteln ]:='writeln ';
|
|
|
+ pfn[pput ]:='put '; pfn[pget ]:='get ';
|
|
|
+ pfn[ppage ]:='page '; pfn[preset ]:='reset ';
|
|
|
+ pfn[prewrite ]:='rewrite '; pfn[pnew ]:='new ';
|
|
|
+ pfn[pdispose ]:='dispose '; pfn[ppack ]:='pack ';
|
|
|
+ pfn[punpack ]:='unpack '; pfn[pmark ]:='mark ';
|
|
|
+ pfn[prelease ]:='release '; pfn[phalt ]:='halt ';
|
|
|
+ pfn[feof ]:='eof '; pfn[feoln ]:='eoln ';
|
|
|
+ pfn[fabs ]:='abs '; pfn[fsqr ]:='sqr ';
|
|
|
+ pfn[ford ]:='ord '; pfn[fchr ]:='chr ';
|
|
|
+ pfn[fpred ]:='pred '; pfn[fsucc ]:='succ ';
|
|
|
+ pfn[fodd ]:='odd '; pfn[ftrunc ]:='trunc ';
|
|
|
+ pfn[fround ]:='round '; pfn[fsin ]:='sin ';
|
|
|
+ pfn[fcos ]:='cos '; pfn[fexp ]:='exp ';
|
|
|
+ pfn[fsqt ]:='sqrt '; pfn[flog ]:='ln ';
|
|
|
+ pfn[fatn ]:='arctan ';
|
|
|
+{standard procedure/function identifiers}
|
|
|
+ for j:=pread to phalt do
|
|
|
+ begin new(p,proc,standard); p^.klass:=proc;
|
|
|
+ p^.name:=pfn[j]; p^.pfkind:=standard; p^.key:=j; enterid(p);
|
|
|
+ end;
|
|
|
+ for j:=feof to fatn do
|
|
|
+ begin new(p,func,standard); p^.klass:=func; p^.idtype:=nil;
|
|
|
+ p^.name:=pfn[j]; p^.pfkind:=standard; p^.key:=j; enterid(p);
|
|
|
+ end;
|
|
|
+{program identifier}
|
|
|
+ progp:=newip(proc,'m_a_i_n ',nil,nil);
|
|
|
+end;
|
|
|
+
|
|
|
+procedure init3;
|
|
|
+var n:np; p,q:ip; i:integer; c:char;
|
|
|
+begin
|
|
|
+ for i:=0 to sz_last do readln(errors,sizes[i]);
|
|
|
+ gencst(ps_mes,ms_emx); argcst(sz_word); argcst(sz_addr); argend;
|
|
|
+ ix:=1;
|
|
|
+ while not eoln(errors) do
|
|
|
+ begin read(errors,c);
|
|
|
+ if ix<smax then begin strbuf[ix]:=c; ix:=ix+1 end
|
|
|
+ end;
|
|
|
+ readln(errors); strbuf[ix]:=chr(0);
|
|
|
+ for i:=1 to fnmax do
|
|
|
+ if i<ix then source[i]:=strbuf[i] else source[i]:=' ';
|
|
|
+ fildlb:=romstr(sp_scon,0);
|
|
|
+{standard type pointers}
|
|
|
+ intptr :=newsp(scalar,sz_int);
|
|
|
+ realptr:=newsp(scalar,sz_real);
|
|
|
+ longptr:=newsp(scalar,sz_long);
|
|
|
+ charptr:=newsp(scalar,sz_char);
|
|
|
+ boolptr:=newsp(scalar,sz_bool);
|
|
|
+ nilptr :=newsp(pointer,sz_addr);
|
|
|
+ zeroptr:=newsp(pointer,sz_addr);
|
|
|
+ procptr:=newsp(records,sz_proc);
|
|
|
+ nullset:=newsp(power,sz_word); nullset^.elset:=nil;
|
|
|
+ textptr:=newsp(files,sz_head+sz_buff); textptr^.filtype:=charptr;
|
|
|
+{standard type names}
|
|
|
+ enterid(newip(types,'integer ',intptr,nil));
|
|
|
+ enterid(newip(types,'real ',realptr,nil));
|
|
|
+ enterid(newip(types,'char ',charptr,nil));
|
|
|
+ enterid(newip(types,'boolean ',boolptr,nil));
|
|
|
+ enterid(newip(types,'text ',textptr,nil));
|
|
|
+{standard constant names}
|
|
|
+ q:=nil; p:=newip(konst,'false ',boolptr,q); enterid(p);
|
|
|
+ q:=p; p:=newip(konst,'true ',boolptr,q); p^.value:=1; enterid(p);
|
|
|
+ boolptr^.fconst:=p;
|
|
|
+ p:=newip(konst,'maxint ',intptr,nil); p^.value:=MI2; enterid(p);
|
|
|
+ p:=newip(konst,spaces,charptr,nil); p^.value:=maxcharord;
|
|
|
+ charptr^.fconst:=p;
|
|
|
+{new name space for user externals}
|
|
|
+ new(n,blck); n^.occur:=blck; n^.nlink:=top; n^.fname:=nil; top:=n;
|
|
|
+{options}
|
|
|
+ for c:='a' to 'z' do begin opt[c]:=0; forceopt[c]:=false end;
|
|
|
+ opt['a']:=on;
|
|
|
+ opt['i']:=NB1*sz_iset;
|
|
|
+ opt['l']:=on;
|
|
|
+ opt['o']:=on;
|
|
|
+ opt['r']:=on;
|
|
|
+ sopt:=off;
|
|
|
+end;
|
|
|
+
|
|
|
+procedure init4;
|
|
|
+begin
|
|
|
+ copt:=opt['c'];
|
|
|
+ dopt:=opt['d'];
|
|
|
+ iopt:=opt['i'];
|
|
|
+ sopt:=opt['s'];
|
|
|
+ if sopt<>off then begin copt:=off; dopt:=off end
|
|
|
+ else if opt['u']<>off then cs['_']:=lower;
|
|
|
+ if copt<>off then enterid(newip(types,'string ',zeroptr,nil));
|
|
|
+ if dopt<>off then enterid(newip(types,'long ',longptr,nil));
|
|
|
+ if opt['o']=off then begin gencst(ps_mes,ms_opt); argend end;
|
|
|
+ if dopt<>off then fltused:=true; {temporary kludge}
|
|
|
+end;
|
|
|
+
|
|
|
+begin {main body of pcompiler}
|
|
|
+ init1; {initialize tables and scalars}
|
|
|
+ init2; {initialize heap objects}
|
|
|
+ rewrite(em); put2(sp_magic); reset(errors);
|
|
|
+ init3; {size dependent initialization}
|
|
|
+ while not eof(errors) do
|
|
|
+ begin options(false); readln(errors) end;
|
|
|
+ rewrite(errors);
|
|
|
+ if not eof(input) then
|
|
|
+ begin nextch; insym;
|
|
|
+ init4; {option dependent initialization}
|
|
|
+ compile
|
|
|
+ end;
|
|
|
+#ifdef STANDARD
|
|
|
+9999: ;
|
|
|
+#endif
|
|
|
+end. {pcompiler}
|