d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/lang/pc/pem/pem.p
sater 0dc5d2c310 Added output of mes ms_gto 
Fixed bug:
  The frontend generated a mes ms_reg for the local temp where
  the stackpointer was kept in destination procedures for
  a non local goto. This was wrong.
1984-05-21 11:29:48 +00:00

3139 lines
95 KiB
OpenEdge ABL
Raw Blame History

#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));
if r>=0 then 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;
gencst(ps_mes,ms_gto); argend;
temporary(nilptr,-1); 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}
Reference in a new issue View git blame Copy permalink