DataMuseum.dk

begin
comment fastlæggelse af standardgrænser for stakkene;
integer maxtexttop,fri,num,antalseg,vægttext,vægtfor,frifor,fritext,maxstaktop,m
axparamtop;
real array dummy(1:2);
write(out,<:<12>JVJ71 ⨯ JVJ71 ⨯ JVJ71 ⨯ JVJ71 ⨯ JVJ71<10><10>:>);
system(2,fri,dummy);
readchar(in,num);
if num=95
then begin
     read(in,antalseg,vægttext,vægtfor);
     comment brugeren specificerer antal segmenter til
     transport og vægte;
     end
else begin
     repeatchar(in);
     antalseg:=4;
     vægttext:=6; vægtfor:=10;
     end;
fri:=fri-(antalseg-1)⨯1024-1350;
comment det frie antal bytes er indeholdt i fri;
frifor:=fri⨯vægtfor/(vægtfor+vægttext);
fritext:=fri-frifor;
if frifor<700
then begin
     comment  ingen plads til oversætterstakkene;
     write(out,<:<10> PROCES FOR LILLE <10>:>);
     goto STOP
     end;
maxtexttop:=fritext/6;
maxstaktop:=maxparamtop:=frifor/10;
begin
comment erklæringer af stakke og variable til oversætter;
boolean array op(1:12,1:4);
integer start, katalogtop, texttop,i,j,index;
real værdi;
boolean def,test, ok;
real array text(1:maxtexttop),katalog(1:50);
integer array tilstandstabel,aktionstabel(1:13,1:15),
              klassearray(0:255), type(1:maxtexttop),
              katalogref(1:50);
real procedure fortolker;
begin
comment fortolkeren fortolker et udtryk som oversætteren
har anbragt i de to arrays type og text på omvendt polsk.
Variablen start angiver hvor udtrykket starter;
boolean array stakmærke(1:maxstaktop),parammærke(1:maxparamtop);
array stak(1:maxstaktop),paramstak(1:maxparamtop);
real element1,element2,kald;
integer staktop,paramtop,ordretæller,neveau,paramnr,
paramsted,operator,lexref,antalparam,konstanttal,i,mærke,element;
procedure overløb(staknr);
integer staknr;
begin
comment denne procedure kaldes hvis der er overløb i en stak.
        staknr angiver hvilken stak det er;
write(out,case staknr of(
<:<10>> overløb i stak <<10>>:>,
<:<10>>overløb i paramstak<<10>:>));
goto FORTOLKER_SLUT;
end overløb;
procedure test1(staknr,nedre,øvre);
integer staknr,nedre,øvre;
begin
integer i,mærke;
real element;
for i:=nedre step 1 until øvre do
begin
mærke:=if staknr=1
       then stakmærke(i) extract 12
       else parammærke(i) extract 12;
element:=if staknr=1 then stak(i) else paramstak(i);
write(out, if staknr=1
           then <:<10>stak<10>:>
           else <:<10>paramstak<10>:>,<<ddd>,i,<:,:>,mærke);
if mærke=3
then write(out,<:,:>,<<ddd_ddd>,element shift (-24)
 extract 24,<:,:>,element extract 24)
else write(out,<:,:>,<<ddd_ddd>,element);
end;
end test1;
paramtop:=1;
staktop:=2;stak(1):=0;
comment returaddressen 0 stakkes,så fortolkeren ved hvornår kørslen
        skal afbrydes;
ordretæller:=start;
comment her startes fortolkeren;
NY_ORDRE:
if test then write(out,<:<10>ordretæller::>,ordretæller);
case type(ordretæller) of
begin
begin
comment konstant skal stakkes;
if staktop>maxstaktop then overløb(1);
stak(staktop):=text(ordretæller);
stakmærke(staktop):= false add 1;;
comment referencen til konstanten stakkes;
staktop:=staktop+1;
ordretæller:=ordretæller+1;
if test
then begin
     test1(1,staktop-1,staktop-1);
     end;
end;
begin
comment funktion skal stakkes;
if staktop>maxstaktop then overløb(1);
stak(staktop):=text(ordretæller);
stakmærke(staktop):= false add 2;
staktop:=staktop+1;ordretæller:=ordretæller+1;
if test
then test1(1,staktop-1,staktop-1);
end;
begin
comment formel parameter skal stakkes;
neveau:=text(ordretæller) shift(-24) extract 24;
paramnr:=text(ordretæller) extract 24;
paramsted:=paramtop-2;
comment vi løber nu ned langs lexrefkæden;
for i:=1 step 1 until neveau do
paramsted:=paramstak(paramsted)-1;
comment paramsted peger nu på det rigtige neveau;
if staktop>maxstaktop then overløb(1);
stak(staktop):=paramstak(paramsted-paramnr);
stakmærke(staktop):=parammærke(paramsted-paramnr);
staktop:=staktop+1;
ordretæller:=ordretæller+1;
if test
then test1(1,staktop-1,staktop-1);
end;
begin
comment operator;
element1:=stak(staktop-1);
element2:=stak(staktop-2);
comment de to operander ligger nu i element1 og element2;
operator:=text(ordretæller);
element1:=case operator of(
element1⨯element2,element2/element1,
element2-element1,element1+element2,
if element1>element2 then 1 else 0,
if element1=element2 then 1 else 0);
comment resultatet ligger i element1;
staktop:=staktop-1;
stak(staktop-1):=element1;
comment de 2 operander afstakkes, og resultatet stakkes;
ordretæller:=ordretæller+1;
if test
then test1(1,staktop-1,staktop-1);
end;
begin
comment anv,funktion skal kaldes;
antal_param:=text(ordretæller);kald:=stak(staktop-antalparam-1);
mærke:=stakmærke(staktop-antalparam-1) extract 12;
if mærke=1
then begin
     comment funktionen der kaldes er  en konstant,der
             ligger i konstantstakken;
     if antal_param>0 then goto PARAMFEJL;
     ordretæller:=ordretæller+1
     end
else begin
     if mærke=3
     then begin
          comment funktionen der kaldes er en hjælpefuntion;
          lexref:= kald shift (-24) extract 24;
          kald:= kald extract 24;
          end
     else lexref:=0;
     comment kald indeholder nu addressen på funktionen der
             skal kaldes,og lexref,den reference,der skal an=
             bringes i lexrefkæden i paramstakken;
     if text(kald)<>antal_param then goto PARAMFEJL;
     comment nu anbringes de aktuelle parametre i paramstak i
             omvendt orden(altså så den første ligger øverst;
     for i:=1 step 1 until antal_param do
          begin
          if paramtop+i-1>maxparamtop then overløb(2);
          paramstak(paramtop+i-1):=stak(staktop-i);
          parammærke(paramtop+i-1):=stakmærke(staktop-i);
          end i;
     staktop:=staktop-antal_param;
     stak(staktop-1):=ordretæller+1;
     comment returaddressen stakkes;
     paramtop:=paramtop+antal_param+2;
     paramstak(paramtop-2):=lexref;
     paramstak(paramtop-1):=antal_param;
     ordretæller:=kald+1;
     if test
     then test1(2,
        paramtop-antal_param-2,
        paramtop-1);
     end;
end;
begin
comment betinget hop;
staktop:=staktop-1;
if stak(staktop)=0
then ordretæller:=text(ordretæller)
else ordretæller:=ordretæller+1;
comment Der hoppes hvis den boolean,der ligger øverst i
        stakken (resultatet af anvendelsen af en relations=
        operator) er false;
end;
comment ubetinget hop;
ordretæller:=text(ordretæller);
begin
comment defordre, en hjælpefunktion skal kaldes;
if staktop>maxstaktop then overløb(2);
stak(staktop):=
   0.0 shift 24 add (paramtop-1) shift 24
   add (ordretæller+1);
comment paramtop-1 er den fremtidige hægte i lexrefkæden,
        ordretæller+1 referencen til hjælpefunktionen;
stakmærke(staktop):=false add 3;
staktop:=staktop+1;
ordretæller:=text(ordretæller);
if test
then test1(1,staktop-1,staktop-1);
end;
begin
comment slutmærke.Vi skal returnere til den funktion,der kaldte den
        nuværende;
ordretæller:=stak(staktop-2);
comment returaddressen gemmes i ordretæller;
if ordretæller=0 then
begin
fortolker:=stak(staktop-1);
goto FORTOLKER_SLUT;
end;
comment nu slettes parametrene i paramstakken;
antal_param:=paramstak(paramtop-1);
paramtop:=paramtop-antalparam-2;
staktop:=staktop-1;
stak(staktop-1):=stak(staktop);
stakmærke(staktop-1):=stakmærke(staktop);
comment returaddressen skiftes ud med den allerede beregnede
        værdi;
end
end case;
if test then write(out,<:<10> staktoppe::>,<<_ddd>,
   staktop,paramtop);
goto NY_ORDRE;
PARAMFEJL:write(out,<:<10>forkert antal parametre:>);
FORTOLKERSLUT:
end fortolker;
boolean procedure oversætter;
begin
comment oversættelse af en sætning til omvendt polsk notation.
        Hvis oversættelsen er ok, er notationen lagret i arrayerne
             type og text, og procedureværdien er true.
             Er sætningen en funktionsdefinition, er der endvidere
             oprettet en indgang for funktionen i katalog og katalogref.
        Hvis der er syntaxfejl i sætningen, er procedureværdien false,
             og sætningen bliver da skippet ved hjælp af proceduren fejl;
integer operatortop,anvtop,hoptop,formeltop,næsteop,klasse,klasse1,i,
        antalparam,tilstand;
real ord,ventenavn;
integer array operatorstak(1:100),anvstak(1:25),
              hopstak(1:25);
real array formelstak(1:100);
procedure test1(trykkes,stak,nedre,øvre);
value nedre,øvre;
string trykkes; integer array stak;
integer nedre,øvre;
begin
integer i;
comment proceduren trykker =trykkes=, samt indholdet
        af stak(nedre:øvre);
write(out,<:<10>:>,trykkes,<:<10>:>);
for i:=nedre step 1 until øvre do
write(out,<:index:>,<<ddd>,i,<:indhold:>,<<ddd_ddd>,
      stak(i),<:<10>:>);
end procedure test1;
procedure testtext(trykkes,nedre,øvre);
value nedre,øvre;
string trykkes; integer nedre,øvre;
begin
integer i;
comment proceduren trykker =trykkes=, samt
        text(nedre:øvre) og type(nedre:øvre);
write(out,<:<10>:>,trykkes,<:<10>:>);
for i:=nedre step 1 until øvre do
     begin
     write(out,<:index:>,<<ddd>,i,<:type:>,<<ddd>,type(i));
     if type(i)=1
     then write(out,<:konst:>,<<ddd_ddd.ddd>,text(i))
     else if type(i)=3
     then write(out,<:niveau:>,<<ddd_ddd>,text(i) shift (-24)
                extract 24,<:paramnr:>,text(i) extract 24)
     else write(out,<:text :>,<<ddd_ddd>,text(i));
     write(out,<:<10>:>);
     end;
end procedure testtext;
procedure testkat(trykkes,nedre,øvre);
value nedre,øvre;
string trykkes; integer nedre,øvre;
begin
integer i;
comment procedyren trykker =trykkes=, samt
        katalog(nedre:øvre) og katalogref(nedre:øvre);
write(out,<:<10>:>,trykkes,<:<10>:>);
for i:=nedre step 1 until  øvre do
write(out,<:index:>,<<ddd>,i,<:navn   :>,string katalog(i),
          <:ref:>,<<ddd_ddd>,katalogref(i));
end procedure textkat;
procedure katalogsøgning(navn);
value navn; real navn;
begin
integer index,ref;
comment denne procedure finder =navn= i kataloget og
        indsætter referencen til definitionen i text;
for index:=1 step 1 until katalogtop-1 do
if  navn= katalog(index)
then begin
     comment =navn= er fundet;
     ref:=katalogref(index);
     goto FUNDET;
     end;
comment =navn= findes ikke i kataloget;
fejl(<:<10>(variabel udefineret)<10>:>,1);
FUNDET:
gem(2,ref);
end procedure katalogsøgning;
procedure søgvariabel(navn);
value navn; real navn;
begin
integer pil,niveau,antalparam,nr;
real paramnavn;
comment denne procedure gennemløber formelstak for =navn= og
        hvis den ikke finder =navn= da gennemløbes kataloget,
        i begge tilfælde gemmes oplysningerne om den variable
        i text;
pil:=formeltop-1; niveau:=-1;
comment pil er index til formelstak,
        niveau er det niveau den formelle parameter findes i,
               det yderste er 0, det næstyderste 1 osv;
FORMELSTAK:
if pil<=1 then goto KATALOG else antalparam:=formelstak(pil);
niveau:=niveau+1;
for nr:=antalparam step -1 until 1 do
     begin
     comment nr angiver nummeret paa den formelle parameter i
                det givne niveau,
             paramnavn er navnet paa den formelle parameter givet
                       ved niveau og nr;
     pil:=pil-1;
     paramnavn:=formelstak(pil);
     if  navn= paramnavn
     then begin
          comment =navn= er genkendt som en formel parameter;
          gem(3,0.0 shift 24 add niveau shift 24 add nr);
          goto FUNDET;
          end;
     end;
pil:=pil-1;
goto FORMELSTAK;
KATALOG:
katalogsøgning(navn);
FUNDET:
end procedure søgvariabel;
procedure fejl(trykkes,overspring);
value overspring;
string trykkes; integer overspring;
begin
integer i;
comment denne procedure trykker parametertexten =trykkes=,
        samt laver de forskellige fejlreaktioner, hvis
        overspring=1, saa skippes texten til semikolon ellers ikke;
write(out,trykkes);
if overspring=1
then for i:=læsord(ord) while i<>12 do;
oversætter:=false;
texttop:=start;
if def then katalogtop:=katalogtop-1;
comment hvis det var en katalogdef da blev den smadret;
goto OVSLUT;
end procedure fejl;
procedure gem(klasse,specifikation);
value klasse,specifikation;
integer klasse; real specifikation;
begin
comment denne procedure gemmer de to parametre i text og type,
        samt checker for overløb;
text(texttop):=specifikation;
type(texttop):=klasse;
texttop:=texttop+1;
if test then testtext(<:text og type:>,texttop-1,texttop-1);
if texttop>maxtexttop
then begin
     write(out,<:<10>(datamængde for stor)<10>:>);
     goto STOP;
     end;
end procedure gem;
procedure tæltopop(nr);
value nr; integer nr;
begin
comment denne procedure tæller staktoppen op samt checker
        for overløb i den givne stak, hvilken stak det er
        afhænger af nr paa flg maade:
        nr= 1, 2, 3, 4, 5, giver flg stakke:
        operatorstak, formelstak, hopstak, katalog, anvstak;
case nr of
begin
begin
if test then test1(<:operatorstak:>,operatorstak,operatortop,operatortop);
operatortop:=operatortop+1;
if operatortop>100
then fejl(<:<10>(for mange operatorer)<10>:>,1);
end;
begin
formeltop:=formeltop+1;
if formeltop>100
then fejl(<:<10>(for mange formelle parametre)<10>:>,1);
end;
begin
if test then test1(<:hopstak:>,hopstak,hoptop,hoptop);
hoptop:=hoptop+1;
if hoptop>25
then fejl(<:<10>(for mange rekursive ifsætninger)<10>:>,1);
end;
begin
if test then testkat(<:katalog og katalogref:>,katalogtop,katalogtop);
katalogtop:=katalogtop+1;
if katalogtop>50
then fejl(<:<10>(for mange katalogdefinitioner)<10>:>,1);
end;
begin
if test then test1(<:anvstak:>,anvstak,anvtop,anvtop);
anvtop:=anvtop+1;
if anvtop>25
then fejl(<:<10>(for mange rekursive funktionsanvendelser)<10>:>,1);
end
end case;
end procedure tæltopop;
integer procedure læsord(ord);
real ord;
begin
integer klasse,værdi,i,ord1,ord2;
integer array bogstav(1:6);
real dec;
comment læsord=klasseværdi til oversætter
        ord= specifikation til klasseværdi,
             fx: variabel = repræsenteret som text,
                 konstant = værdien,
                 operator = nummer paa operator,
        klasse= klassen paa det indlæste symbol,
                givet ved intable(klassearray),
        værdi= værdien af det indlæste symbol,
               givet ved intable(klassearray);
intable(klassearray);
NY:
klasse:=readchar(in,værdi);
if klasse<>7 then write(out,false add værdi,1);
case klasse of
begin
begin comment kan ikke forekomme; end;
goto NY; comment tegn der adskiller symboler;
begin
comment et bogstav er indlæst;
bogstav(1):=værdi;
for i:=2 step 1 until 6 do bogstav(i):=0;
for i:=2 step 1 until 5 do
     begin
     klasse:=readchar(in,værdi);
     if klasse=3
     then begin
          bogstav(i):=værdi;
          write(out,false add værdi,1);
          end
     else begin
          if klasse<>2 then repeatchar(in) else write(out,false add værdi,1);
          goto ORDSLUT;
          end;
     end;
comment løkken er slut fordi 5 bogstaver er indlæst;
klasse:=readchar(in,værdi);
if klasse=3 then begin
                  læsord:=15;
                  write(out,false add værdi,1,<:<10>(for mange bogstaver i den v
ariable)<10>:>);
                  goto LÆSORDSLUT;
                  end
            else if klasse<>2 then repeatchar(in) else write(out,false add værdi
,1);
ORDSLUT:
ord1:=bogstav(1) shift 16 + bogstav(2) shift 8 + bogstav(3);
ord2:=bogstav(4) shift 16 + bogstav(5) shift 8 + bogstav(6);
ord:=0.0 shift 24 add ord1 shift 24 add ord2;
comment nu er den variable eller det reserverede ord indlæst;
if ord=real<:if:> then læsord:=3 else
if ord=real<:then:> then læsord:=4 else
if ord=real<:else:> then læsord:=5 else
if ord=real<:fi:> then læsord:=6 else
if ord=real<:slut:> then begin
                         if tilstand<>1 then write(out,
                         <:<10>(syntaxfejl før slut)<10>:>);
                         goto STOP;
                         end else
læsord:=1;
end;
begin
comment et ciffer er indlæst,værdi-48 = cifrets værdi;
ord:=værdi-48;
for klasse:=readchar(in,værdi) while klasse=4 do
     begin
     ord:=ord⨯10 + værdi-48;
     write(out,false add værdi,1);
     end;
comment en række cifre er indlæst, hvis stopsymbolet var et
        decimalpunktum (klasse=5) da indlæses decimaldelen;
if klasse=5
then begin
     write(out,<:.:>);
     goto EFTERPUNKTUM;
     end
else if klasse<>2 then repeatchar(in) else write(out,false add værdi,1);
læsord:=2;
end;
begin
comment decimalpunktum er indlæst;
ord:=0;
EFTERPUNKTUM:
dec:=1;
for klasse:=readchar(in,værdi) while klasse=4 do
     begin
     write(out,false add værdi,1);
     dec:=dec/10;
     ord:=ord + (værdi-48)⨯dec;
     end;
if dec=1 then begin
              comment konstanten er syntaktisk forkert,
                      fx: =12.= eller =.= ;
              læsord:=15;
               write(out,<:<10>(syntaxfejl i konstant)<10>:>);
               goto LÆSORDSLUT;
               end;
if klasse<>2 then repeatchar(in) else write(out,false add værdi,1);
læsord:=2;
end;
læsord:=15; comment fejlklasse, tegnet har grafisk repræsentation;
begin
læsord:=15;
comment fejlklasse, tegnet har ingen grafisk repræsentation;
write(out,<:<10>(illegalt symbol,værdi=:>,værdi,<:)<10>:>);
end;
begin
comment relations operator;
læsord:=7;
ord:=if værdi=60 then 5 else 6;
end;
begin
comment ⨯,/ eller +;
læsord:=8;
ord:=if værdi=42 then 1 else
     if værdi=47 then 2 else 4;
end;
begin
comment -;
klasse:=readchar(in,værdi);
if værdi=62
then begin
     comment -> er indlæst;
     læsord:=13;
     write(out,<:>:>);
     end
else begin
     comment - er indlæst, det næste symbol glemmes;
     ord:=3;
     læsord:=8;
     if klasse<>2 then repeatchar(in) else write(out,false add værdi,1);
     end;
end;
læsord:=9; comment ( ;
læsord:=10; comment ) ;
læsord:=11; comment =komma= ;
læsord:=12; comment =semikolon = ;
begin
comment :;
klasse:=readchar(in,værdi);
if værdi=61
then begin
     comment := er indlæst;
     læsord:=14;
     write(out,<:=:>);
     end
else begin
     comment fejlklasse;
     læsord:=15;
     if klasse<>2 then repeatchar(in) else write(out,false add værdi,1);
     end;
end;
end case;
LÆSORDSLUT:
intable(0);
end procedure læsord;
tilstand:=1;
oversætter:=true;
start:=texttop;
def:=false;
operatortop:=anvtop:=hoptop:=formeltop:=1;
NYTORD:
klasse:=læsord(ord);
if test then write(out,<:<10>klasse,tilstand,aktion::>,<<__ddd>,
klasse,tilstand,aktionstabel(tilstand,klasse),<:<10>:>);
case aktionstabel(tilstand,klasse) of
begin
begin
comment <var> i udtryk;
søgvariabel(ord);
end 01;
begin
comment <kons> i udtryk;
if tilstand=3 then gem(0,0);
gem(1,ord);
end 02;
begin
comment  if er læst;
if tilstand=3 then gem(0,0);
operatorstak(operatortop):=8; comment if-mærke;
tæltopop(1);
end 03;
begin
comment  ( i udtryk;
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
end 04;
begin
comment funktionskald i udtryk;
C5:
operatorstak(operatortop):=11; comment fkt-mærke;
tæltopop(1);
anvstak(anvtop):=1;
tæltopop(5);
end 05;
begin
comment  then er læst;
if tilstand=8 then gem(5,0); comment <var> foran then;
comment tømning af operatorstak til og med relationsoperator;
for operatortop:=operatortop-1 step -1 until 1 do
begin næsteop:=operatorstak(operatortop);
     if næsteop<7
     then begin
          comment tal- eller relationsoperator;
          gem(4,næsteop);
          if næsteop>4 then goto TØMT6;
          end
     else begin
          comment fejlreaktioner for andre elementer i operatorstakken;
          if næsteop=7 or næsteop=11
               then fejl(<:<10>(højreparentes mangler)<10>:>,1);
          if næsteop=8
               then fejl(<:<10>(relationsoperator mangler)<10>:>,1);
          if næsteop<10
               then fejl(<:<10>(gal anvendelse af then)<10>:>,1);
          fejl(<:<10>(ulovlig hjælpedefinition)<10>:>,1);
          end;
end for;
comment operatorstakken er tømt uden at finde relationsoperatoren;
fejl(<:<10>(relationsoperator mangler)<10>:>,1);
comment relationsoperatoren er fundet korrekt;
TØMT6:
gem(6,0); comment betinget hop;
hopstak(hoptop):=texttop-1; comment index til hoppet stakkes;
tæltopop(3);
operatorstak(operatortop):=9; comment then-mærke;
tæltopop(1);
end 06;
begin
comment  else er læst;
if tilstand=8 then gem(5,0); comment <var> foran else;
C7:
operatortop:=operatortop-1;
comment operatorstakken afstakkes stykvis indtil then-mærke
        mødes (repræsenteret ved 9);
if operatortop<0 then fejl(<:<10>(then mangler)<10>:>,1);
næsteop:=operatorstak(operatortop);
if næsteop<5 then gem(4,næsteop) else
if næsteop=9
then begin
     comment then-mærke;
     gem(7,0); comment ubetinget hop;
     text(hopstak(hoptop-1)):=texttop;
hopstak(hoptop-1):=texttop-1;
     comment texttop peger paa det betinegde hops adresse,
             og texttop-1 er det sted hvor der senere indsættes
             et ubetinget hop;
     operatorstak(operatortop):=10; comment else-mærke;
     tæltopop(1);
     goto TØMT7;
     end else
if næsteop=8 or næsteop<7
then begin
     comment relationsoperator eller if-mærke;
     fejl(<:<10>(then mangler)<10>:>,1);
     end else
if næsteop=7 or næsteop=11
then begin
     comment ( eller fkt-mærke;
     fejl(<:<10>(højreparentes mangler)<10>:>,1);
     end else
fejl(<:<10>(else for meget)<10>:>,1);
comment det sidste var else-mærke eller def-mærke;
goto C7;
TØMT7:
end 07;
begin
comment  fi er læst;
if tilstand=8 then gem(5,0); comment <var> foran fi;
comment tømning af operatorstakken til og med else-mærke;
for operatortop:=operatortop-1 step -1 until 1 do
begin næsteop:=operatorstak(operatortop);
     if næsteop<5
     then begin
          comment taloperator;
          gem(4,næsteop);
          end
     else begin
          if næsteop=10 then goto TØMT8;
          comment fejlreaktioner for andre elementer i operatorstakken;
          if næsteop=7 or næsteop=11
               then fejl(<:<10>(højreparentes mangler)<10>:>,1);
          if næsteop<9
               then fejl(<:<10>(gal anvendelse af fi)<10>:>,1);
          fejl(<:<10>(ukorrekt hjælpedefinition)<10>:>,1);
     end;
end for;
comment operatorstakken er tømt uden at finde else-mærket;
fejl(<:<10>(else mangler)<10>:>,1);
comment else-mærket er fundet korrekt;
TØMT8:
text(hopstak(hoptop-1)):=texttop;
comment adresse til det ubetingede hop indsættes;
hoptop:=hoptop-1;
end 08;
begin
comment <relationsoperator> er læst;
if tilstand=8 then gem(5,0); comment <var> foran <relationsoperator>;
comment tømning af operatorstakken til og med if-mærke;
for operatortop:=operatortop-1 step -1 until 1 do
begin næsteop:=operatorstak(operatortop);
     if næsteop<5
     then begin
          comment taloperator;
          gem(4,næsteop);
          end
     else begin
          if næsteop=8 then goto TØMT9;
          comment fejlreaktioner for andre elementer i operatorstakken;
          if næsteop=7 or næsteop=11
               then fejl(<:<10>(højreparentes mangler)<10>:>,1);
          if næsteop<11
               then fejl(<:<10>(ulovlig relationsoperator)<10>:>,1);
          fejl(<:<10>(ulovlig hjælpedefinition)<10>:>,1);
     end;
end for;
comment operatorstakken er tømt uden at finde if-mærket;
fejl(<:<10>(if mangler)<10>:>,1);
comment if-mærket er fundet korrekt;
TØMT9:
operatorstak(operatortop):=ord; comment relationsoperatoren;
tæltopop(1);
end 09;
begin
comment <taloperator> i udtryk;
if tilstand=11 then søgvariabel(ventenavn);
if tilstand<>9 then gem(5,0);
comment <var> foran <taloperator>;
C10:
if operatortop<=1
then begin
     comment operatorstakken er tom, stak taloperatoren;
     operatorstak(operatortop):=ord;
     operatortop:=operatortop+1;
     goto SLUT10;
     end;
comment Dijkstras vigesporsalgoritme;
if op(operatorstak(operatortop-1),ord)
then begin
     comment operatorstakken afstakkes med et element;
     gem(4,operatorstak(operatortop-1));
     operatortop:=operatortop-1;
     goto C10;
     end
else begin
     comment den læste operator stakkes;
     operatorstak(operatortop):=ord;
     tæltopop(1);
     end;
SLUT10:
end 10;
begin
comment  højreparentes er læst;
if tilstand=8 then gem(5,0); comment <var> foran højreparentes;
C11:
operatortop:=operatortop-1;
comment operatorstakken afstakkes stykvis til først mødte
        def- eller fkt-mærke eller (,som har værdierne: 12 og 11 og 7;
if operatortop<=0 then fejl(<:<10>(venstreparentes mangler)<10>:>,1);
næsteop:=operatorstak(operatortop); comment næsteop=næste operator;
if næsteop<5 then gem(4,næsteop) else
if næsteop=11
then begin
     comment fkt-mærke, anvstak indeholder antallet af parametre;
     anvtop:=anvtop-1;
     if anvtop<=0 then fejl(<:<10>(fejl i funktionsanvendelse)<10>:>,1);
     gem(5,anvstak(anvtop));
     goto AFSTAKNINGSLUT;
     end else
if næsteop=12
then begin
     comment def-mærke, slutmærke gemmes og hoppet indsættes;
     gem(9,0);
     hoptop:=hoptop-1;
     text(hopstak(hoptop)):=texttop; comment ubetingede hop;
     comment nu tælles formelstak antalparam+1 ned;
     formeltop:=formeltop-1-formelstak(formeltop-1);
     comment nu afstakkes det fkt-mærke der ligger lige under def-mærket;
     operatortop:=operatortop-1;
     næsteop:=operatorstak(operatortop);
     if næsteop<>11 then fejl(<:<10>(ulovlig hjælpedefinition)<10>:>,1);
     goto AFSTAKNINGSLUT;
     end else
if næsteop=7
then begin
     comment parentesen er en udtryks-parentes og har ikke noget
             med fkt- eller def-parentes at gøre, ( er blevet
             afstakket;
     goto AFSTAKNINGSLUT;
     end else
fejl(<:<10>(venstreparentes mangler)<10>:>,1);
goto C11;
AFSTAKNINGSLUT:
end 11;
begin
comment  komma i aktuel parameterliste er læst;
if tilstand=8 then gem(5,0 ) else
if tilstand=11 then søgvariabel(ventenavn);
comment  <var> foran komma;
anvstak(anvtop-1):=anvstak(anvtop-1)+1;
comment antalparam til den givne funktion blev talt 1 op;
comment nu afstakkes til fkt-mærke eller def-mærke;
for operatortop:=operatortop-1 step -1 until 1 do
     begin
     næsteop:=operatorstak(operatortop);
     if næsteop<5 then gem(4,næsteop) else
     if næsteop=11
     then begin
          comment fkt-mærke er mødt;
     operatortop:=operatortop+1;
          goto SLUT12;
          end else
     if næsteop=12
     then begin
          comment def-mærke;
          gem(9,0); comment slutmærke for hjælpedef;
          hoptop:=hoptop-1;
          text(hopstak(hoptop)):=texttop; comment defhoppet indsættes;
           formeltop:=formeltop-1-formelstak(formeltop-1);
          comment formelstakken afstakkes med parametrene til hjælpedef;
          goto SLUT12;
          end else
     fejl(<:<10>(galt placeret komma)<10>:>,1);
     end;
comment bunden er naaet;
fejl(<:<10>(galt placeret komma)<10>:>,1);
SLUT12:
end 12;
begin
comment semikolon er læst;
if tilstand=8 then gem(5,0); comment <var> foran semikolon;
comment afstak operatorstak;
for operatortop:=operatortop-1 step -1 until 1 do
     begin
     næsteop:=operatorstak(operatortop);
     if næsteop<5
     then gem(4,næsteop)
     else fejl(<:<10>(galt placeret semikolon)<10>:>,0);
     end;
goto SLUT;
end 13;
begin
ventenavn:=ord;
end 14;
begin
comment tom aktion;
;
end 15;
begin
comment <var>(<var>);
søgvariabel(ventenavn);
anvtop:=anvtop-1;
gem(5,anvstak(anvtop));
operatortop:=operatortop-1; comment afstak fkt-mærke;
if operatorstak(operatortop)<>11 then fejl(<:<10>(fejl i funktionsanvendelse)<10
>:>,1);
end 16;
begin
comment hjælpefunktionsdefinition;
gem(8,0); comment def-mærke;
formelstak(formeltop):=ventenavn;
tæltopop(2); comment def-ordre;
hopstak(hoptop):=texttop-1;
formelstak(formeltop):=1;
tæltopop(2); comment index til udhoppet stakkes;
tæltopop(3);
operatorstak(operatortop):=12; comment def-mærke;
tæltopop(1);
gem(0,1); comment antal parametre til hjælpedef;
end 17;
begin
comment <var>((<var> <operator> ;
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
søgvariabel(ventenavn);
operatorstak(operatortop):=ord; comment <operator> ;
tæltopop(1);
gem(5,0); comment anv0;
end 18;
begin
comment <var>((<var>( ;
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
søgvariabel(ventenavn);
anvstak(anvtop):=1; comment der er mindst en parameter i funktionen,
                            senere adderes der til dette element i anvstak, naar
                            komma og ) mødes;
tæltopop(5);
end 19;
begin
comment <var>((<var>);
søgvariabel(ventenavn);
gem(5,0);
end 20;
begin
comment <var>((<var>, ;
gem(8,0); comment def-mærke;
hopstak(hoptop):=texttop-1;
tæltopop(3);
comment slutmærke indsattes og det sted hvor hopadressen senere
         skal indsættes gemtes;
operatorstak(operatortop):=12;
tæltopop(1);
goto C30;
comment denne aktion indlæser resten af parameterlisten;
end 21;
begin
comment  :=(<kons> eller  ((<kons>;
if tilstand=4 then
gem(0,0); comment start paa katalogdefinition;
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
gem(1,ord); comment <kons> ;
end 22;
begin
comment  :=( if  eller  (( if ;
if tilstand=4 then gem(0,0); comment start paa katalogdefinition;
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
operatorstak(operatortop):=8; comment if-mærke;
tæltopop(1);
end 23;
begin
comment  :=((  eller  (((  ;
if tilstand=4 then gem(0,0); comment start paa katalogdefinition;
for i:=1,2 do
     begin
     operatorstak(operatortop):=7; comment ( ;
     tæltopop(1);
     end;
end 24;
begin
comment <var>:=<var>(      ;
gem(0,0); comment gem antalparam ved start paa katalogdefinition;
katalogsøgning(ventenavn);
goto C5;
comment aktion 5 ordner anvstak;
end 25;
begin
comment <var>:=<var> -> ;
gem(0,1); comment gem antalparam (1) ved start paa katalogdefinition;
formelstak(formeltop):=ventenavn;
tæltopop(2);
formelstak(formeltop):=1; comment antalparam;
tæltopop(2);
end 26;
begin
comment <var>:=(<var> <operator> ;
gem(0,0);
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
katalogsøgning(ventenavn);
gem(5,0); comment anv0;
operatorstak(operatortop):=ord; comment <operator>;
tæltopop(1);
end 27;
begin
comment <var>:=(<var>( ;
gem(0,0);
operatorstak(operatortop):=7; comment ( ;
tæltopop(1);
katalogsøgning(ventenavn);
goto C5;
comment aktion 5 ordner anvstak i forbindelse med den
        læste fkt-anvendelse;
end 28;
begin
comment <var>:=(<var>) ;
gem(0,0);
katalogsøgning(ventenavn);
gem(5,0);
write(out,<:   (advarsel: KODESVIN)   :>);
end 29;
begin
comment <var>:=(<var>,     (formel parameterliste)  ;
C30:
antalparam:=1;
comment denne aktion indlæser en parameterliste (første parameter
        er indlæst) samt pilen efter parameterlisten;
formelstak(formeltop):=ventenavn; comment den indlæste parameter;
tæltopop(2);
klasse1:=0;
comment nu indlæses de øvrige formelle parametre, og de stakkes
        i formelstak, der stoppes naar ) mødes (klasse=10);
for i:=i while klasse1<>10 do
     begin
     klasse1:=læsord(ord);
     if klasse1<>1 then fejl(<:<10>(fejl i parameterliste)<10>:>,1);
     formelstak(formeltop):=ord;
     tæltopop(2);
     antalparam:=antalparam+1;
     klasse1:=læsord(ord);
     comment her blev komma (11) eller ) (10) indlæst;
     if klasse1<>10 and klasse1<>11
     then fejl(<:<10>(fejl i parameterliste)<10>:>,1);
     end;
comment de formelle parametre er indlæst nu indlæses pilen;
klasse1:=læsord(ord);
if klasse1<>13 then fejl(<:<10>(fejl efter parameterliste)<10>:>,1);
gem(0,antalparam); comment antalparam gemmes ved defstart;
formelstak(formeltop):=antalparam;
tæltopop(2);
end 30;
begin
comment <var> <operator> ;
if tilstand=5 then gem(0,0); comment start paa en katalogdefinition;
katalogsøgning(ventenavn);
gem(5,0); comment anv0;
operatorstak(operatortop):=ord; comment operator;
tæltopop(1);
end 31;
begin
comment <var> ( ;
katalogsøgning(ventenavn);
goto C5;
comment denne aktion ordner anvstak for den indlæste fkt-anvendelse;
end 32;
begin
comment <var> <semikolon> ;
if tilstand=5 then gem(0,0); comment start paa en katalogdefinition;
write(out,<:   (advarsel: KODESVIN)   :>);
katalogsøgning(ventenavn);
gem(5,0); comment anv0;
goto SLUT;
end 33;
begin
comment <var>:= ;
for i:=1 step 1 until katalogtop-1 do
if ventenavn=katalog(i) then fejl(<:<10>variabel er erklæret<10>:>,1);
comment katalog-definition;
katalog(katalogtop):=ventenavn;
katalogref(katalogtop):=texttop;
tæltopop(4);
def:=true;
end 34;
begin
comment  almindelig fejlaktion i aktionstabellen;
fejl(<:<10>(syntaxfejl)<10>:>,1);
end 35;
begin
comment denne fejlaktion anvendes ved illegale tegn;
fejl(<:<10>(illegalt tegn)<10>:>,1);
end 36;
begin
comment som 35 men der skippes ikke til semikolon da dette
        lige er indlæst;
fejl(<:<10>(syntaxfejl)<10>:>,0);
end 37;
end case;
if test
then write(out,<:<10>text::>,<<_ddd>,texttop,
               <:_operator::>,operatortop,
               <:_formel::>,formeltop,
               <:_hop::>,hoptop,
               <:_katalog::>,katalogtop,
               <:_anv::>,anvtop);
tilstand:=tilstandstabel(tilstand,klasse);
goto NYTORD;
SLUT:
gem(9,0); comment slutmærke paa en sætning;
OVSLUT:
if test
then  testtext(<:text:>,1,texttop-1);
end procedure oversætter;
comment initialisering af klassearray til læsord;
for i:=1 step 1 until 31 do klassearray(i):=7;
for i:=33 step 1 until 39,
       62 step 1 until 96 do klassearray(i):=6;
for i:=48 step 1 until 57 do klassearray(i):=4;
for i:=97 step 1 until 125 do klassearray(i):=3;
for i:=1 step 1 until 17 do
     begin
     index:=case i of(
      0,10,32,40,41,42,43,44,45,46,47,58,59,60,61,126,127);
     klassearray(index):=case i of(
      0, 2, 2,11,12, 9, 9,13,10, 5, 9,15,14, 8, 8,  6,  0);
     end;
for i:=0 step 1 until 127 do klassearray(i):=klassearray(i) shift 12 + i;
for i:=128 step 1 until 255 do klassearray(i):=0;
comment initialisering af tilstands- og aktionstabel;
for i:=1 step 1 until 13 do
for j:=1 step 1 until 15 do
begin
tilstandstabel(i,j):= case i of(
     case j of( 2, 9, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0),
     case j of( 0, 0, 0, 0, 0, 0, 0, 7,10, 0, 0, 0, 0, 3, 0),
     case j of( 5, 9, 7, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0),
     case j of( 6, 9, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0),
     case j of( 0, 0, 0, 0, 0, 0, 0, 7,10, 0, 0, 0, 7, 0, 0),
     case j of( 0, 0, 0, 0, 0, 0, 0, 7,10, 9, 7, 0, 0, 0, 0),
     case j of( 8, 9, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0),
     case j of( 0, 0, 0, 7, 7, 9, 7, 7,10, 9,10, 0, 0, 0, 0),
     case j of( 0, 0, 0, 7, 7, 9, 7, 7, 0, 9,10, 0, 0, 0, 0),
     case j of(11, 9, 7, 0, 0, 0, 0, 0,12, 0, 0, 0, 0, 0, 0),
     case j of( 0, 0, 0, 0, 0, 0, 0, 7,10, 9,10, 0, 7, 0, 0),
     case j of(13, 9, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0),
     case j of( 0, 0, 0, 0, 0, 0, 0, 7,10, 9, 7, 0, 0, 0, 0));
aktionstabel(i,j):= case i of(
     case j of(14, 2, 3,35,35,35,35,35, 4,35,35,37,35,35,36),
     case j of(35,35,35,35,35,35,35,31,32,35,35,33,35,34,36),
     case j of(14, 2, 3,35,35,35,35,35,15,35,35,37,35,35,36),
     case j of(14,22,23,35,35,35,35,35,24,35,35,37,35,35,36),
     case j of(35,35,35,35,35,35,35,31,25,35,35,33,26,35,36),
     case j of(35,35,35,35,35,35,35,27,28,29,30,37,35,35,36),
     case j of( 1, 2, 3,35,35,35,35,35, 4,35,35,37,35,35,36),
     case j of(35,35,35, 6, 7, 8, 9,10, 5,11,12,13,35,35,36),
     case j of(35,35,35, 6, 7, 8, 9,10,35,11,12,13,35,35,36),
     case j of(14, 2, 3,35,35,35,35,35,15,35,35,37,35,35,36),
     case j of(35,35,35,35,35,35,35,10,32,16,12,37,17,35,36),
     case j of(14,22,23,35,35,35,35,35,24,35,35,37,35,35,36),
     case j of(35,35,35,35,35,35,35,18,19,20,21,37,35,35,36));
end;
comment initialisering af præcedenstabel til operatorstak;
for i:=1,2,3,4 do
for j:=3 step 1 until 12 do  op(j,i):=false;
for i:=1,2,3,4 do
for j:=1,2 do op(j,i):=true;
for i:=3,4 do
for j:=3,4 do op(j,i):=true;
comment det administrerende system med den centrale løkke;
test:=false;
texttop:=katalogtop:=1;
REP:
ok:=oversætter;
if ok
then begin
     if -,def
     then begin
          værdi:=fortolker;
          write(out,<:<10><10><33><33><33><33><33>   resultat= :>,<<  +d.ddddddd
dd10-ddd>,værdi,<:<10><10>:>);
          texttop:=start;
          end;
     end
else write(out,<:<10>⨯⨯⨯beklager⨯⨯⨯<10>:>);
goto REP;
end;
STOP:
end
 [end]