Continuation Semantics Expressed in Algol-68

LA home
Computing
Semantics
 Examples

See L. Allison, A Practical Introduction to Denotational Semantics, CUP, Cambridge Computer Science Texts V23, 1986.

Note   proc eee,   proc ddd   and   proc ccc   in particular.


( print((newline," progch7.a68:Continuation Semantics 19/4/85 L.A.", newline));

#-----------------------------------------------------------------------------#
                                                              #lexical domains#
MODE ALFA = [1:10]CHAR;
INT  plussy = 0, minussy = 1, timessy = 2, oversy = 3,
     eqsy = 4, nesy = 5, ltsy = 6, lesy = 7, gtsy = 8, gesy = 9,
     ident = 10, numeral = 11,
     ifsy = 12, thensy = 13, elsesy = 14,
     whilesy = 15, dosy = 16,
     beginsy = 17, endsy = 18,
     skipsy = 19,
     semisy = 20, becomessy = 21, open = 22, close = 23,
     varsy = 24, constsy = 25, procsy = 26,
     gotosy = 27,
     valofsy = 28, resultissy = 29,
     stopsy = 30,
     colon = 31,
     writesy = 32;

#-----------------------------------------------------------------------------#
                                                             #syntactic domains#
INT  plus = 0, minus = 1, times = 2, over = 3,
     eq = 4, ne = 5, lt = 6, le = 7, gt = 8, ge = 9,
     neg = 10;
MODE OPR = INT;  # = {plus..neg} #

MODE BEXP = STRUCT(OPR opr, EXP left,right),                 # $e $W $e #
     UEXP = STRUCT(OPR opr, EXP son),                        # $W $e   #
     VAR  = ALFA,                                            # $c     #
     IFEXP= STRUCT(EXP e1, e2, e3);             # if $e then $e else $e #
MODE EXPNODE  = UNION(BEXP, UEXP, VAR, INT, IFEXP, #valof#CMD);
MODE EXP = REF EXPNODE;

MODE LABEL  = INT;

MODE ASSIGN = STRUCT(EXP lhs, rhs),                    # $e:=$e       #
     SEMI   = STRUCT(CMD left, right),                 # $g;$g        #
     IFSTAT = STRUCT(EXP b, CMD gtrue, gfalse),# if $e then $g else $g #
     WHILES = STRUCT(EXP b, CMD g),                  # while $e do $g #
     BLOCK  = STRUCT(DEC d, CMD g),                 # begin $d;$g end #
     LABCMD = STRUCT(LABEL l, CMD g),                  # $n:$g        #
     G0T0   = LABEL,                                   # goto $n     #
     ONEEXP = STRUCT(INT tag, EXP e);      # resultis $e  or write $e #
MODE CMDNODE    = UNION(ASSIGN, SEMI, IFSTAT, WHILES, BLOCK,
                    #call# ALFA, LABCMD, G0T0, ONEEXP);
MODE CMD = REF CMDNODE;

MODE VARDEC  = ALFA,                                   # var   $c   #
     CONSTDEC= STRUCT(ALFA id, EXP e),                 # const $c=$e #
     PROCDEC = STRUCT(ALFA id, CMD g),                 # proc  $c=$g #
     DECLIST = STRUCT(DEC left, right);                # $d;$d       #
MODE DECNODE = UNION(VARDEC, CONSTDEC,  PROCDEC, DECLIST);
MODE DEC = REF DECNODE;

#-------------------------------------------------------------------------#
                                                                    # I/O #
LOC INT line no := 1;
LOC BOOL end of input := FALSE;
print((newline, line no, "->"));

OP =       =(ALFA a, b)BOOL:
   (LOC BOOL eq:=TRUE;
    FOR i TO UPB a WHILE eq DO eq:=a[i]=b[i] OD;
    eq
   );

PROC getch = CHAR:
  (LOC CHAR ch; LOC FILE si:=stand in;
   PROC gc = CHAR:
     (LOC FILE si2 := si;
      PROC eof = (REF FILE f)BOOL:
        (print((" [EOF]", newline)); ch:=".";
         end of input := TRUE; GOTO eoflab
        );
      on logical file end(si2, eof);
      get(si2, ch); print(ch);
      eoflab: ch
     );
   PROC eol = (REF FILE f)BOOL:
     (ch:=" "; newline(f); line no +:=1;
      print((newline, line no, "->")); GOTO eolnlab
     );
   on line end(si, eol);
   ch:=gc;
   eolnlab: ch
  ) # getch #;
#-----------------------------------------------------------------------------#

LOC CHAR ch:=getch; #current character#
LOC INT  sy; # current symbol code #
LOC ALFA word; # holds characters of a var or ident #
LOC INT  n; # value if sy=numeral #

PROC error = (STRING m)VOID:
  (print((newline, " error:", m, " lineno=", whole(line no,0),
          "  ch=", ch, " sy=", sy, " n=", n));
   IF end of input THEN print(" end of input file") FI;
   GOTO stop
  );

PROC check = (INT sym, STRING message)VOID:
   IF sy=sym THEN insymbol ELSE error(message) FI;

PROC insymbol = VOID:
  (PROC letter = (CHAR ch)BOOL:
      (ch >= "a" AND ch <= "z") OR (ch >= "A" AND ch <= "Z");
   PROC digit = (CHAR ch)BOOL:
      ch >= "0" AND ch <= "9";
   LOC BOOL looked ahead := FALSE;

   WHILE ch=" " DO ch:=getch OD; # ch~=" " #
   FOR i FROM LWB word TO UPB word DO word[i]:=" " OD;
   IF letter(ch) THEN
      looked ahead := TRUE; word[1]:=ch; ch:=getch; LOC INT l:=1;
      WHILE letter(ch) OR digit(ch) DO
         l+:=1;
         IF l <= UPB word THEN word[l]:=ch FI;
         ch:=getch
      OD;
      IF   word=ALFA("i","f"," "," "," "," "," "," "," "," ") THEN sy:=ifsy
      ELIF word=ALFA("t","h","e","n"," "," "," "," "," "," ") THEN sy:=thensy
      ELIF word=ALFA("e","l","s","e"," "," "," "," "," "," ") THEN sy:=elsesy
      ELIF word=ALFA("w","h","i","l","e"," "," "," "," "," ") THEN sy:=whilesy
      ELIF word=ALFA("d","o"," "," "," "," "," "," "," "," ") THEN sy:=dosy
      ELIF word=ALFA("b","e","g","i","n"," "," "," "," "," ") THEN sy:=beginsy
      ELIF word=ALFA("e","n","d"," "," "," "," "," "," "," ") THEN sy:=endsy
      ELIF word=ALFA("s","k","i","p"," "," "," "," "," "," ") THEN sy:=skipsy
      ELIF word=ALFA("v","a","r"," "," "," "," "," "," "," ") THEN sy:=varsy
      ELIF word=ALFA("c","o","n","s","t"," "," "," "," "," ") THEN sy:=constsy
      ELIF word=ALFA("p","r","o","c"," "," "," "," "," "," ") THEN sy:=procsy
      ELIF word=ALFA("w","r","i","t","e"," "," "," "," "," ") THEN sy:=writesy
      ELIF word=ALFA("g","o","t","o"," "," "," "," "," "," ") THEN sy:=gotosy
      ELIF word=ALFA("r","e","s","u","l","t","i","s"," "," ") THEN sy:=resultissy
      ELIF word=ALFA("v","a","l","o","f"," "," "," "," "," ") THEN sy:=valofsy
      ELSE sy:=ident
      FI
   ELIF digit(ch) THEN
      looked ahead := TRUE; n:=0;
      WHILE digit(ch) DO
         n:=n*10+ ABS ch - ABS "0"; ch:=getch
      OD;
      sy:=numeral

   ELIF ch=":" THEN
      ch:=getch;
      IF ch="=" THEN sy:=becomessy
      ELSE sy:=colon; looked ahead := TRUE
      FI
   ELIF ch=";" THEN sy:=semisy
   ELIF ch="." THEN sy:=stopsy
   ELIF ch="(" THEN sy:=open
   ELIF ch=")" THEN sy:=close

   ELIF ch="+" THEN sy:=plussy
   ELIF ch="-" THEN sy:=minussy
   ELIF ch="*" THEN sy:=timessy
   ELIF ch="/" THEN sy:=oversy

   ELIF ch="=" THEN sy:=eqsy
   ELIF ch="<" THEN  # < #
      ch:=getch;
      IF ch=">" THEN # ...> # sy:=nesy
      ELIF ch="=" THEN sy:=lesy
      ELSE sy:=ltsy; looked ahead:=TRUE
      FI
   ELIF ch=">" THEN # > #
      ch:=getch;
      IF ch="=" THEN sy:=gesy
      ELSE sy:=gtsy; looked ahead:=TRUE
      FI
   ELSE error("in insymbol")
   FI;
   IF NOT looked ahead THEN ch:=getch FI
  ) # insymbol #;
#-----------------------------------------------------------------------------#
                                                                       #syntax#
PROC parser = CMD:
BEGIN
   PROC pexp = EXP:
    ( PROC pexp3 = EXP:
         IF sy=open THEN insymbol; EXP e:=pexp;
                         check(close, ") "); e
         ELIF sy=minussy THEN insymbol; HEAP EXPNODE:=UEXP(neg,pexp3)
         ELIF sy=ident THEN
            EXP e = HEAP EXPNODE:=word;
            insymbol;
            e
         ELIF sy=numeral THEN
            EXP e = HEAP EXPNODE:=n;
            insymbol;
            e
         ELIF sy=valofsy THEN
            insymbol;
            HEAP EXPNODE := pcmd
         ELIF sy=ifsy THEN
            insymbol; EXP e1:=pexp;
            check(thensy, "then in Conditional expn"); EXP e2:=pexp;
            check(elsesy, "else in Conditional expn"); EXP e3:=pexp;
            HEAP EXPNODE := IFEXP(e1, e2, e3)
         ELSE error("in pexp3"); SKIP
         FI;

      PROC pexp2 = EXP:
       ( LOC EXP e:=pexp3;
         WHILE sy=timessy OR sy=oversy DO
            OPR o = IF sy=timessy THEN times ELSE over FI;
            insymbol;
            e:= HEAP EXPNODE := BEXP(o, e, pexp3)
         OD;
         e
       );

      PROC pexp1 = EXP:
       ( LOC EXP e := pexp2;
         WHILE sy=plussy OR sy=minussy DO
            OPR o = IF sy=plussy THEN plus ELSE minus FI;
            insymbol;
            e:=HEAP EXPNODE:=BEXP(o, e, pexp2)
         OD;
         e
       );

      IF EXP e=pexp1;
            sy=eqsy OR sy=nesy OR sy=lesy
         OR sy=ltsy OR sy=gesy OR sy=gtsy
      THEN  OPR o = IF sy=eqsy THEN eq ELIF sy=nesy THEN ne
                    ELIF sy=lesy THEN le ELIF sy=ltsy THEN lt
                    ELIF sy=gesy THEN ge ELSE gtsy FI;
            insymbol;
            HEAP EXPNODE := BEXP(o, e, pexp1)
      ELSE  e
      FI
    ) # pexp #;

   PROC pdec = DEC:
    ( PROC pdec1 = DEC:
         IF sy=varsy THEN
            insymbol;
            IF sy=ident THEN DEC d=HEAP DECNODE:=word;
                             insymbol; d
            ELSE error("no ident after var"); SKIP
            FI
         ELIF sy=constsy THEN
            insymbol;
            IF sy=ident THEN
               ALFA id=word;
               insymbol;
               check(eqsy, "no = after const ident");
               HEAP DECNODE := CONSTDEC(id,pexp)
            ELSE error("no ident after const"); SKIP
            FI
         ELIF sy=procsy THEN
            insymbol;
            IF sy=ident THEN
               ALFA id=word;
               insymbol;
               check(eqsy,"no = after proc ident");
               HEAP DECNODE := PROCDEC(id,pcmd)
            ELSE error("no id after proc"); SKIP
            FI
         ELSE NIL
         FI;

      IF sy=varsy OR sy=constsy OR sy=procsy THEN
         DEC d=pdec1;
         check(semisy, "no ; after declaration");
         HEAP DECNODE := DECLIST(d,pdec)
      ELSE NIL
      FI
    ) # pdec #;

   PROC pcmd = CMD:
      IF sy=numeral THEN  #labelled#
         LABEL label=n;
         insymbol;
         check(colon, "no : after label");
         HEAP CMDNODE := LABCMD(label, pcmd)
      ELIF sy=ifsy THEN
         insymbol; EXP b=pexp;
         check(thensy,"then in parse cmd"); CMD g1=pcmd;
         check(elsesy,"else in parse cmd"); CMD g2=pcmd;
         HEAP CMDNODE := IFSTAT(b, g1, g2)
      ELIF sy=whilesy THEN
         insymbol; EXP b=pexp;
         check(dosy,"no do after while");
         HEAP CMDNODE := WHILES(b,pcmd)
      ELIF sy=beginsy THEN
         PROC pcmd list = CMD:
               (LOC CMD g:=HEAP CMDNODE := SEMI(NIL,pcmd);
                WHILE sy=semisy DO
                   insymbol;
                   g:=HEAP CMDNODE := SEMI(g,pcmd)
                OD;
                g
               );

         insymbol;
         DEC d=pdec;
         CMD blk = HEAP CMDNODE := BLOCK(d, pcmd list);
         check(endsy, "no end to block");
         blk
      ELIF sy=skipsy THEN insymbol; NIL
      ELIF sy=resultissy THEN
         insymbol;
         HEAP CMDNODE := ONEEXP(resultissy,pexp)
      ELIF sy=writesy THEN
         insymbol;
         HEAP CMDNODE := ONEEXP(writesy,pexp)
      ELIF sy=gotosy THEN
         insymbol;
         CMD g = HEAP CMDNODE := n;
         insymbol;
         g
      ELIF sy=open THEN
         EXP lhs=pexp;
         check(becomessy, "no := after expn in pcmd");
         HEAP CMDNODE := ASSIGN(lhs, pexp)
      ELIF sy=ident THEN
         ALFA id=word;
         insymbol;
         IF sy=becomessy THEN
            insymbol;
            HEAP CMDNODE := ASSIGN( HEAP EXPNODE := id, pexp)
         ELSE #a call #
            HEAP CMDNODE := id
         FI
      FI # pcmd #;

   insymbol;
   CMD c = pcmd;
   check(stopsy, "no . at end of program");
   c
END #parser#;
#-----------------------------------------------------------------------------#
                                                           # semantic domains #
MODE EV    = UNION( INT, LOCN ),               # = Int + Locn              #
     SV    = INT,
     CONT  = PROC(     INT,STORE)ANS,          # = IntxStore -> Ans        #
     KONT  = PROC(EV,  INT,STORE)ANS,          # = Ev -> IntxStore -> Ans  #
     DCONT = PROC(ENV, INT,STORE)ANS;          # = Env -> IntxStore -> Ans #
MODE DV    = EV,  # it so happens #
     LOCN  = STRUCT(INT l, dont care);

OP =       = (LOCN m,n)BOOL: l OF m = l OF n;

MODE ANS   = UNION( ALFA, REF ANSCELL);   # Ans = Int x Ans  +  {wrong,finish}#
MODE ANSCELL=STRUCT(INT v, ANS next);

MODE STORE = PROC(LOCN)SV;                     # = Locn -> Sv              #

MODE VNV   = PROC(ALFA)DV;                   # Ide -> Dv #
MODE PNV   = PROC(ALFA,CONT,  INT,STORE)ANS; # Ide -> Cont -> IntxStore ->Ans #
MODE LNV   = PROC(LABEL, INT,STORE)ANS;      # Numeral -> IntxStore -> Ans #
MODE ENV   = STRUCT( VNV vnv, PNV pnv, LNV lnv, KONT kont );
#-----------------------------------------------------------------------------#
                                                                  # semantics #
PROC show = (ANS a)VOID:
   CASE a IN
   (ALFA w):FOR i TO UPB w DO print(w[i]) OD,
   (REF ANSCELL r): IF r ISNT NIL THEN
                       print((" ",whole(v OF r,0),",")); show(next OF r) FI
   ESAC;

PROC wrong = (STRING m)ANS:
   ( print((newline, m, newline));
     ALFA("w", "r", "o", "n", "g", " ", " ", " ", " ", " ")
   );
PROC undefined = VOID:
   error(" undefined");

PROC eee = (EXP ex, KONT k, ENV e, INT f,STORE s)ANS:
 ( #     :  EXP -> KONT -> ENV -> INT x STORE -> ANS #
   #debug # print(" E[");
   CASE ex IN
   (BEXP   b):(KONT rhs = (EV v1, INT f,STORE s)ANS:
                (KONT opr = (EV v2, INT f,STORE s)ANS:
                   k( CASE v1 IN
                      (INT i1):CASE v2 IN
                               (INT i2):IF opr OF b = plus THEN i1+i2
                                        ELIF opr OF b = minus THEN i1-i2
                                        ELIF opr OF b = times THEN i1*i2
                                        ELIF opr OF b = over  THEN i1%i2
                                        ELIF opr OF b = ne THEN
                                           IF i1=i2 THEN 0 ELSE 1 FI
                                        ELIF opr OF b = eq THEN
                                           IF i1=i2 THEN 1 ELSE 0 FI
                                        ELIF opr OF b = lt THEN
                                           IF i1 < i2 THEN 1 ELSE 0 FI
                                        ELIF opr OF b = le THEN
                                           IF i1 <= i2 THEN 1 ELSE 0 FI
                                        ELIF opr OF b = gt THEN
                                           IF i1 > i2 THEN 1 ELSE 0 FI
                                        ELIF opr OF b = ge THEN
                                           IF i1 >= i2 THEN 1 ELSE 0 FI
                                        ELSE error(" bad operator");SKIP
                                        FI
                               OUT wrong(" int OPR non-int"); SKIP
                               ESAC
                      OUT wrong(" non-int OPR ???"); SKIP
                      ESAC,
                      f,s
                     )# opr #;

                   rrr(right OF b, opr, e, f,s)
                  )# rhs #;

               #debug# print((" bopr",whole(opr OF b,0)  ));
               rrr(left OF b, rhs, e, f,s)
              ),
   (UEXP   u):(KONT opr = (EV v, INT f, STORE s)ANS:
                  CASE v IN
                  (INT i): k(-i, f, s)
                  OUT wrong(" - nonInt")
                  ESAC;

               #debug# print(" -");
               rrr(son OF u, opr, e, f,s)
              ),
   (VAR    v):k( (vnv OF e)(v), f, s),
   (INT    n):k( n, f, s),
   (IFEXP if):(KONT cond = (EV v, INT f, STORE s)ANS:
                  CASE v IN
                  (INT i): IF i=1 THEN eee(e2 OF if, k, e, f, s)
                           ELSE        eee(e3 OF if, k, e, f, s)
                           FI
                  OUT wrong(" CondExp non-int")
                  ESAC;

               #debug#print(" CondExp");
               rrr(e1 OF if, cond, e, f, s)
              ),
   (CMD    g):(KONT new rnv = (EV v, INT f, STORE s)ANS:
   # valof $g #    k(v, f, s);

               CONT fail = (INT f, STORE s)ANS:
                  wrong(" fail: fell out of valof");

               #debug#print(" valof");
               ENV new e=(vnv OF e, pnv OF e, lnv OF e, new rnv);

               ccc(g, fail, new e, f, s)
              )
   ESAC
 ) # eee #;

PROC lll = (EXP ex, KONT k, ENV e, INT f, STORE s)ANS:
 ( #        EXP ->  KONT -> ENV -> INT x STORE -> ANS  #
   #debug# print(" L[");
   KONT check = (EV v, INT f, STORE s)ANS:
      CASE v IN
      (LOCN l): k(l, f, s)
      OUT wrong(" not left-value")
      ESAC;

   eee( ex, check, e, f, s)
 ) # lll #;

PROC rrr = (EXP ex, KONT k, ENV e, INT f, STORE s)ANS:
 ( #        EXP  -> KONT -> ENV -> INT x STORE -> ANS #
   #debug# print(" R[");
   KONT deref = (EV v, INT f, STORE s)ANS:
      CASE v IN
      (INT i): k(i, f, s),
      (LOCN l): k( s(l), f, s)
      ESAC;

   eee( ex, deref, e, f, s)
 )# rrr #;

PROC ddd = (DEC d, DCONT dc, ENV e, INT f, STORE s)ANS:
 ( #        DEC -> DCONT ->  ENV -> INT x STORE -> ANS #
   #debug# print(" D[");
   IF d IS NIL THEN dc(e, f, s)
   ELSE CASE d IN
        (VARDEC vd):(VNV new vnv = (ALFA id)DV:
                        IF id = vd THEN LOCN(f,0) ELSE (vnv OF e)(id) FI;
                     ENV new e = (new vnv, pnv OF e, lnv OF e, kont OF e);

                     #debug# print(( " VAR ", vd[1]));
                     dc( new e, f+1, s)
                    ),
        (CONSTDEC cd):(KONT update env = (EV v, INT f, STORE s)ANS:
                        ( CASE v IN
                          (INT i):(VNV new vnv = (ALFA id)DV:
                                      IF id = id OF cd THEN i
                                      ELSE (vnv OF e)(id) FI;
                                   ENV new e = (new vnv, pnv OF e, lnv OF e,
                                                kont OF e);
                                   dc( new e, f, s)
                                  )
                          OUT wrong(" const id=non-int")
                          ESAC
                        ) # update env # ;

                       # debug # print(" CONST");
                       rrr(e OF cd, update env, e, f, s)
                      ),
        (PROCDEC pd):(PNV new pnv = (ALFA id, CONT ra, INT f, STORE s)ANS:
                         IF id = id OF pd THEN
                            ccc(g OF pd, ra, new e #recursion#, f, s)
                         ELSE (pnv OF e)(id, ra, f, s)
                         FI;
                      ENV new e = (vnv OF e, new pnv, lnv OF e, kont OF e);

                      #debug#print(" PROC");
                      dc( new e, f, s)
                     ),
        (DECLIST l):(DCONT d2 = (ENV e, INT f, STORE s)ANS:
                        ddd(right OF l, dc, e, f, s);

                     #debug#print(" ;");
                     ddd(left OF l, d2, e, f, s)
                    )
        ESAC
   FI
 ) # ddd #;

PROC ccc = (CMD g, CONT t, ENV e, INT f, STORE s)ANS:
 ( #     :  CMD -> CONT -> ENV -> INT x STORE -> ANS #
   # debug # print( " C[" );
  IF g IS NIL #SKIP# THEN t(f,s)
  ELSE
   CASE g IN
   (ASSIGN a):(KONT do rhs = (EV v1, INT f,STORE s)ANS:
                ( KONT update = (EV v2, INT f,STORE s)ANS:
                    ( CASE v1 IN
                      (LOCN l):CASE v2 IN
                               (SV v):(STORE new s =(LOCN ll)SV:
                                          IF ll=l THEN v ELSE s(ll) FI;
                                       t(f, new s)
                                      )
                               OUT wrong("try to store bad value")
                               ESAC
                      OUT wrong("try to update non-location")
                      ESAC
                    );
                  rrr(rhs OF a, update, e, f, s)
                );
               # debug # print(":=");
               lll(lhs OF a, do rhs, e, f, s)
              ),
   (SEMI g1g2):(CONT g2 = (INT f, STORE s)ANS:
                      ccc(right OF g1g2, t, e, f, s);
                #debug# print(";");
                ccc(left OF g1g2, g2, e, f, s)
               ),
   (IFSTAT if):(KONT cond = (EV b, INT f,STORE s)ANS:
                      CASE b IN
                      (INT i): ccc(IF i=1 THEN gtrue OF if ELSE gfalse OF if FI,
                                   t, e, f, s)
                      OUT wrong("if-cmd, non-int expn")
                      ESAC;
                #debug#print(" IF");
                rrr(b OF if, cond, e, f,s)
               ),
   (WHILES  w):(KONT cond = (EV b, INT f,STORE s)ANS:
                    ( CONT again = (INT f, STORE s)ANS:
                            ccc(g, t, e, f,s);

                      CASE b IN
                      (INT i): IF i=1 THEN ccc(g OF w, again, e, f,s)
                               ELSE t(f,s)
                               FI
                      OUT wrong("while, non-int expn")
                      ESAC
                    );
                #debug# print(" WHILE");
                rrr(b OF w, cond, e, f,s)
               ),
   (BLOCK   b):(DCONT body = (ENV e, INT f,STORE s)ANS:
   # begin $d;$g end #   ( LNV new lnv = (LABEL n, INT f,STORE s)ANS:
                            ( PROC search=(CMD g, CONT t2)ANS:
                                 IF g IS NIL THEN (lnv OF e)(n,f,s)
                                 ELSE
                                    CASE g IN
                                    (SEMI g):
                                        ( CONT t1=(INT f,STORE s)ANS:
                                               ccc(right OF g,t2,new e,f,s);
                                         CASE right OF g IN
                                         (LABCMD lg):IF n=(l OF lg) THEN
                                                       ccc(g OF lg,t2,new e,f,s)
                                                     ELSE search(left OF g,t1)
                                                     FI
                                         OUT search(left OF g, t1)
                                         ESAC
                                        )
                                    OUT wrong("knotted cmd in block")
                                    ESAC
                                 FI # search #;
                              #debug# print((" lnv(", whole(n,0), ")" ));
                              search(g OF b, t)
                            )# new lnv#;

                           ENV new e=(vnv OF e, pnv OF e, new lnv, kont OF e);

                           ccc(g OF b, t, new e, f, s)
                         )# body #;

                #debug# print(( newline," block"));
                ddd(d OF b, body, e, f,s)
               ),
   (ALFA proc):(pnv OF e)(proc, t, f,s),  # $r\*<2\*>[procid]$t #
   (LABCMD  l):ccc(g OF l, t, e, f,s),
   (G0T0    n):(lnv OF e)(n, f,s),        # $r[$n] #
   (ONEEXP eg): # resultis $e    or    write $e #
      IF tag OF eg = resultissy THEN
         rrr( e OF eg, kont OF e, e, f,s)
      ELIF tag OF eg = writesy THEN
         KONT do output = (EV v, INT f, STORE s)ANS:
               CASE v IN
               (INT i): HEAP ANSCELL := (i, t(f,s))
               OUT      wrong("write a non-int")
               ESAC;
         rrr( e OF eg, do output, e, f,s)
      ELSE error(" bad tag in ccc< tag,exp>"); SKIP
      FI
   ESAC
  FI
 ) # ccc #;

CONT finish = (INT f, STORE s)ANS:
   ALFA("f", "i", "n", "i", "s", "h", " ", " ", " ", " ");

VNV start vnv = (ALFA a)DV:
   (undefined; SKIP);
PNV start pnv = (ALFA a, CONT ra, INT f, STORE s)ANS:
   (undefined; SKIP);
LNV start lnv = (LABEL l, INT f, STORE s)ANS:
   (undefined; SKIP);
KONT start kont = (EV v, INT f, STORE s)ANS:
   (undefined; SKIP);
ENV start env = (start vnv, start pnv, start lnv, start kont);

STORE empty store = (LOCN n)SV:
   (undefined; SKIP);

show( ccc(parser, finish, start env, 0, empty store) )
)


www #ad:

↑ © L. Allison, www.allisons.org/ll/   (or as otherwise indicated).
Created with "vi (Linux)",  charset=iso-8859-1,   fetched Tuesday, 27-Sep-2022 14:12:02 UTC.

Free: Linux, Ubuntu operating-sys, OpenOffice office-suite, The GIMP ~photoshop, Firefox web-browser, FlashBlock flash on/off.