//\*   /DGIM/NTRN0   11.52  4/12


GET "SY:NTRN.GET"

STATIC $( SECT=0 $)
 
LET NEXTPARAM() = VALOF
    $( PARAMNUMBER := PARAMNUMBER + 1
       RESULTIS PARAMNUMBER  $)

AND TRANSREPORT(N, X) BE
    $( LET A = OUTPUT
       OUTPUT := CONSOLE
       REPORTERROR("******  ERROR, ", MESSAGE(N))
       WRITES("COMMANDS COMPILED ")
       WRITEN(COMCOUNT); NEWLINE()
       PLIST(X, 0, 4); NEWLINE()
       OUTPUT := A  $)

AND MESSAGE(N) = VALOF
        $( SWITCHON N INTO

        $( DEFAULT: RESULTIS "UNKNOWN ERROR"

           CASE 100: RESULTIS "UNKNOWN COMMAND"
           CASE 141: RESULTIS "TOO MANY CASES"
           CASE 101: RESULTIS "DEFAULT USED TWICE"
           CASE 102: RESULTIS "UNKNOWN DECLARATION"
           CASE 103: RESULTIS "BAD NAMELIST"
           CASE 104: RESULTIS "ILLEGAL USE OF BREAK OR RESULTIS"
           CASE 105: RESULTIS "ILLEGAL USE OF CASE OR DEFAULT"
           CASE 106: RESULTIS "TWO CASES WITH SAME CONSTANT"
           CASE 144: RESULTIS "TOO MANY GLOBALS"
           CASE 142: RESULTIS "NAME DECLARED TWICE"
           CASE 143: RESULTIS "TOO MANY NAMES DECLARED"
           CASE 147:
           CASE 148: RESULTIS "UNKNOWN EXPRESSION"
           CASE 115: RESULTIS "NAME NOT DECLARED"
           CASE 116: RESULTIS "DYNAMIC FREE VARIABLE USED"
           CASE 117:CASE 118:CASE 119:
                     RESULTIS "ERROR IN CONSTANT EXPRESSION"
           CASE 110:CASE 112:
                     RESULTIS "LHS AND RHS DO NOT MATCH"
           CASE 109:CASE 113:
                     RESULTIS "LTYPE EXPRESSION EXPECTED"
           CASE 199: RESULTIS "COMPILER BUG"
                       $)   $)



LET COMPILEAE(X) BE
   $(1 LET A = VEC 1200    
       LET D = VEC 100
       LET K = VEC 150
       LET L = VEC 150
       LET R = REPORT

       DVEC, DVECS, DVECE, DVECP, DVECT := A, 3, 3, 3, 1200
       DVEC%0, DVEC%1, DVEC%2 := 0, 0, 0

       GLOBDECL, GLOBDECLS, GLOBDECLT := D, 0, 100

       CASEK, CASEL, CASEP, CASET, CASEB := K, L, 0, 150, -1

       REPORT := TRANSREPORT

       RESULTLABEL, BREAKLABEL, DEFAULTLABEL, LOOPLABEL := -1, -1, -1, -1

       COMCOUNT, CURRENTBRANCH := 0, X

       PARAMNUMBER := 0
       SAVESPACESIZE := 3
       SSP := SAVESPACESIZE
       WRITES("SECT"); WRITEN(SECT); NEWLINE()
       SECT := SECT+1
       OUT2(S.STACK, SSP)
       DECLLABELS(X)
       TRANS(X)
       OUT2(S.GLOBAL, GLOBDECLS/2)

    $( LET I = 0
       UNTIL I=GLOBDECLS DO
          $( OUTN(GLOBDECL%I)
             OUTL(GLOBDECL%(I+1))
             I := I + 2  $)

        REPORT := R  $)1


.



//\*   /DGIM/NTRN1   12.50  10/4


GET "SY:NTRN.GET"

LET TRANS(X) BE
  $(TR
NEXT:
 $( LET SW = FALSE
    IF X=0 RETURN
    CURRENTBRANCH := X

    SWITCHON H1%X INTO
$(  DEFAULT: REPORT(100, X); RETURN

    CASE S.LET:
      $( LET A, B, S = DVECE, DVECS, SSP
         LET V = VECSSP
         DECLNAMES(H2%X)
         CHECKDISTINCT(B, DVECS)
         DVECE := DVECS
         VECSSP := SSP
         SSP := S
         TRANSDEF(H2%X)
         UNLESS SSP=VECSSP DO $( SSP := VECSSP
                                 OUT2(S.STACK, SSP)  $)
         OUT1(S.STORE)
         DECLLABELS(H3%X)
         TRANS(H3%X)
         VECSSP := V
         DVECE, DVECS, SSP := A, B, S
         OUT2(S.STACK, SSP)
         RETURN   $)

    CASE S.GLOBAL: SW := TRUE
    CASE S.MANIFEST:
     $(1 LET A, B, S = DVECE, DVECS, SSP
         AND P = SW -> S.GLOBAL, S.NUMBER

         LET Y = H2%X
         UNTIL Y=0 DO
              $( ADDNAME(H3%Y, P, EVALCONST(H4%Y))
                 Y := H2%Y   $)

         CHECKDISTINCT(B, DVECS)
         DVECE := DVECS
         DECLLABELS(H3%X)
         TRANS(H3%X)
         DVECE, DVECS, SSP := A, B, S
         RETURN   $)1


    CASE S.STATIC:
     $(1 LET A, B, S = DVECE, DVECS, SSP
         LET Y = H2%X
         UNTIL Y=0 DO
            $( LET M = NEXTPARAM()
               ADDNAME(H3%Y, S.LABEL, M)
               COMPDATALAB(M)
               OUT2(S.ITEMN, EVALCONST(H4%Y))
               Y := H2%Y  $)

         CHECKDISTINCT(B, DVECS)
         DVECE := DVECS

         DECLLABELS(H3%X)
         TRANS(H3%X)
         DVECE, DVECS, SSP := A, B, S
         RETURN   $)1

    CASE S.ASS:
       ASSIGN(H2%X, H3%X)
       RETURN

    CASE S.RTAP:
     $( LET S = SSP
        SSP := SSP+SAVESPACESIZE
        OUT2(S.STACK, SSP)
        LOADLIST(H3%X)
        LOAD(H2%X)
        OUT2(S.RTAP, S)
        SSP := S
        RETURN  $)

    CASE S.GOTO:
        LOAD(H2%X)
        OUT1(S.GOTO)
        SSP := SSP-1
        RETURN

    CASE S.COLON:
        COMPLAB(H4%X)
        OUT2(S.STACK, SSP)
        TRANS(H3%X)
        RETURN

    CASE S.UNLESS: SW := TRUE
    CASE S.IF:
        IF ISCONST(H2%X) & NOLABELS(H3%X) DO
        $( UNLESS CONSTVAL=SW TRANS(H3%X)
           RETURN $)
     $( LET L = NEXTPARAM()
        JUMPCOND(H2%X, SW, L)
        TRANS(H3%X)
        COMPLAB(L)
        RETURN   $)

    CASE S.TEST:
        IF ISCONST(H2%X) & NOLABELS(H3%X) & NOLABELS(H4%X) DO
        $( TRANS(CONSTVAL -> H3%X, H4%X); RETURN $)
     $( LET L, M = NEXTPARAM(), NEXTPARAM()
        JUMPCOND(H2%X, FALSE, L)
        TRANS(H3%X)
        COMPJUMP(M)
        COMPLAB(L)
        TRANS(H4%X)
        COMPLAB(M)
        RETURN   $)

    CASE S.LOOP:
        IF LOOPLABEL<0 REPORT(104, X)
        IF LOOPLABEL=0 LOOPLABEL := NEXTPARAM()
        COMPJUMP(LOOPLABEL)
        RETURN
    CASE S.BREAK:
        IF BREAKLABEL<0 DO REPORT(104, X)
        IF BREAKLABEL=0 DO BREAKLABEL := NEXTPARAM()
        COMPJUMP(BREAKLABEL)
        RETURN

    CASE S.RETURN: OUT1(S.RTRN)
                   RETURN

    CASE S.FINISH: OUT1(S.FINISH)
                   RETURN

    CASE S.RESULTIS:
        IF RESULTLABEL<0 DO REPORT(104, X)
        LOAD(H2%X)
        OUT2P(S.RES, RESULTLABEL)
        SSP := SSP - 1
        RETURN

    CASE S.CODE: 
     $( LET B=H2%X
        UNLESS H1%B=S.STRING REPORT(107,X)
        OUT2(S.CODE, H2%B)
        OUTS(H2+B)
        RETURN   $)
 
    CASE S.WHILE: SW := TRUE
    CASE S.UNTIL:
     $( LET L, M = NEXTPARAM(), NEXTPARAM()
        LET BL, LL = BREAKLABEL, LOOPLABEL
        BREAKLABEL, LOOPLABEL := 0, M
       
        COMPJUMP(M)
        COMPLAB(L)
        TRANS(H3%X)
        COMPLAB(M)
        JUMPCOND(H2%X, SW, L)
        UNLESS BREAKLABEL=0 DO COMPLAB(BREAKLABEL)
        BREAKLABEL, LOOPLABEL := BL, LL
        RETURN   $)

    CASE S.REPEATWHILE: SW := TRUE
    CASE S.REPEATUNTIL:
    CASE S.REPEAT:
     $( LET L, BL, LL = NEXTPARAM(), BREAKLABEL, LOOPLABEL
        BREAKLABEL, LOOPLABEL := 0, 0
        COMPLAB(L)
        TRANS(H2%X)
        UNLESS LOOPLABEL=0 COMPLAB(LOOPLABEL)
        TEST H1%X=S.REPEAT
             THEN COMPJUMP(L)
               OR JUMPCOND(H3%X, SW, L)
        UNLESS BREAKLABEL=0 DO COMPLAB(BREAKLABEL) 
        BREAKLABEL, LOOPLABEL := BL, LL
        RETURN   $)

    CASE S.CASE:
     $( LET L, K = NEXTPARAM(), EVALCONST(H2%X)
        IF CASEP GE CASET DO REPORT(141, X)
        IF CASEB<0 DO REPORT(105, X)
        FOR I = CASEB TO CASEP-1 DO
                    IF CASEK%I=K DO REPORT(106, X)
        CASEK%CASEP := K
        CASEL%CASEP := L
        CASEP := CASEP + 1
        COMPLAB(L)
        TRANS(H3%X)
        RETURN   $)

    CASE S.DEFAULT:
        IF CASEB<0 DO REPORT(105, X)
        UNLESS DEFAULTLABEL=0 DO REPORT(101, X)
        DEFAULTLABEL := NEXTPARAM()
        COMPLAB(DEFAULTLABEL)
        TRANS(H2%X)
        RETURN

    CASE S.ENDCASE: IF CASEB<0 DO REPORT(105, X)
                    COMPJUMP(ENDCASELABEL)
                    RETURN

    CASE S.SWITCHON:
        TRANSSWITCH(X)
        RETURN

    CASE S.FOR: TRANSFOR(X)
                RETURN

    CASE S.SEQ:
        TRANS(H2%X)
        COMCOUNT :=  COMCOUNT + 1
        X := H3%X
        GOTO NEXT        $)TR

.



//\*   /DGIM/NTRN2   12.4  4/12


GET "SY:NTRN.GET"

LET DECLNAMES(X) BE
    $(DN IF X=0 RETURN
         SWITCHON H1%X INTO

     $(  DEFAULT: REPORT(102, CURRENTBRANCH)
                  RETURN

         CASE S.VECDEF: CASE S.VALDEF:
               DECLDYN(H2%X)
               RETURN

         CASE S.RTDEF: CASE S.FNDEF:
               H5%X := NEXTPARAM()
               DECLSTAT(H2%X, H5%X)
               RETURN

         CASE S.AND:
               DECLNAMES(H2%X)
               DECLNAMES(H3%X)
               RETURN
                            $)DN


AND DECLDYN(X) BE
    $( IF X=0 RETURN

       IF H1%X=S.NAME DO
          $( ADDNAME(X, S.LOCAL, SSP)
             SSP := SSP + 1
             RETURN   $)

       IF H1%X=S.COMMA DO
          $( ADDNAME(H2%X, S.LOCAL, SSP)
             SSP := SSP + 1
             DECLDYN(H3%X)
             RETURN  $)

       REPORT(103, X)   $)

AND DECLSTAT(X, L) BE
    $(1 LET T = CELLWITHNAME(X)

       IF DVEC%(T+1)=S.GLOBAL DO
          $( LET N = DVEC%(T+2)
             ADDNAME(X, S.GLOBAL, N)
             IF GLOBDECLS GE GLOBDECLT DO REPORT(144, X)
             GLOBDECL%GLOBDECLS := N
             GLOBDECL%(GLOBDECLS+1) := L
             GLOBDECLS := GLOBDECLS + 2
             RETURN  $)


    $( LET M = NEXTPARAM()
       ADDNAME(X, S.LABEL, M)
       COMPDATALAB(M)
       OUT2P(S.ITEML, L)    $)1


AND DECLLABELS(X) BE
    $( LET B = DVECS
       SCANLABELS(X)
       CHECKDISTINCT(B, DVECS)
       DVECE := DVECS   $)


AND CHECKDISTINCT(E, S) BE
       UNTIL E=S DO
          $( LET P = E + 3
             AND N = DVEC%E
             WHILE P LS S DO
                $( IF DVEC%P=N DO REPORT(142, N)
                   P := P + 3  $)
             E := E + 3  $)


AND ADDNAME(N, P, A) BE
    $( IF DVECS GE DVECT DO REPORT(143, CURRENTBRANCH)
       DVEC%DVECS, DVEC%(DVECS+1), DVEC%(DVECS+2) := N, P, A
       DVECS := DVECS + 3  $)


AND CELLWITHNAME(N) = VALOF
    $( LET X = DVECE

       X := X - 3 REPEATUNTIL X=0 \/ DVEC%X=N

       RESULTIS X  $)


AND SCANLABELS(X) BE
    $( IF X=0 RETURN

       SWITCHON H1%X INTO
    $( DEFAULT: RETURN

       CASE S.COLON:
            H4%X := NEXTPARAM()
            DECLSTAT(H2%X, H4%X)

       CASE S.IF: CASE S.UNLESS: CASE S.WHILE: CASE S.UNTIL:
       CASE S.SWITCHON: CASE S.CASE:
            SCANLABELS(H3%X)
            RETURN

       CASE S.SEQ:
            SCANLABELS(H3%X)

       CASE S.REPEAT: 
       CASE S.REPEATWHILE: CASE S.REPEATUNTIL: CASE S.DEFAULT:
            SCANLABELS(H2%X)
            RETURN

       CASE S.TEST:
            SCANLABELS(H3%X)
            SCANLABELS(H4%X)
            RETURN   $)   $)


AND TRANSDEF(X) BE
    $(1 TRANSDYNDEFS(X)
        IF STATDEFS(X) DO
           $( LET L, S= NEXTPARAM(), SSP
              COMPJUMP(L)
              TRANSSTATDEFS(X)
              SSP := S
              OUT2(S.STACK, SSP)
              COMPLAB(L)  $)1


AND TRANSDYNDEFS(X) BE
        SWITCHON H1%X INTO
     $( CASE S.AND:
            TRANSDYNDEFS(H2%X)
            TRANSDYNDEFS(H3%X)
            RETURN

        CASE S.VECDEF:
            OUT2(S.LLP, VECSSP)
            SSP := SSP + 1
            VECSSP := VECSSP + 1 + EVALCONST(H3%X)
            RETURN

        CASE S.VALDEF: LOADLIST(H3%X)
                       RETURN

        DEFAULT: RETURN  $)

AND TRANSSTATDEFS(X) BE
        SWITCHON H1%X INTO
     $( CASE S.AND:
             TRANSSTATDEFS(H2%X)
             TRANSSTATDEFS(H3%X)
             RETURN

        CASE S.FNDEF: CASE S.RTDEF:
         $(2 LET A, B, C = DVECE, DVECS, DVECP
             AND BL, LL, RL, CB = BREAKLABEL, LOOPLABEL, RESULTLABEL, CASEB
             BREAKLABEL, LOOPLABEL, RESULTLABEL, CASEB := -1, -1, -1, -1

             COMPENTRY(H2%X, H5%X)
             SSP := SAVESPACESIZE

             DVECP := DVECS
             DECLDYN(H3%X)
             CHECKDISTINCT(B, DVECS)
             DVECE := DVECS
             DECLLABELS(H4%X)

             OUT2(S.SAVE, SSP)

             TEST H1%X=S.FNDEF
                THEN $( LOAD(H4%X); OUT1(S.FNRN)  $)
                  OR $( TRANS(H4%X); OUT1(S.RTRN)  $)

             BREAKLABEL, LOOPLABEL, RESULTLABEL, CASEB := BL, LL, RL, CB
             DVECE, DVECS, DVECP := A, B, C   $)2

        DEFAULT: RETURN   $)

AND STATDEFS(X) = H1%X=S.FNDEF \/ H1%X=S.RTDEF -> TRUE,
                  H1%X NE S.AND -> FALSE,
                  STATDEFS(H2%X) -> TRUE,
                  STATDEFS(H3%X)



.



//\*   /DGIM/NTRN3   12.52  10/4


GET "SY:NTRN.GET"

LET JUMPCOND(X, B, L) BE
$(JC LET SW = B
     SWITCHON H1%X INTO
     $( CASE S.FALSE: B := NOT B
        CASE S.TRUE: IF B DO COMPJUMP(L)
                     RETURN

        CASE S.NOT: JUMPCOND(H2%X, NOT B, L)
                    RETURN

        CASE S.LOGAND: SW := NOT SW
        CASE S.LOGOR:
         TEST SW THEN $( JUMPCOND(H2%X, B, L)
                         JUMPCOND(H3%X, B, L)  $)

                   OR $( LET M = NEXTPARAM()
                         JUMPCOND(H2%X, NOT B, M)
                         JUMPCOND(H3%X, B, L)
                         COMPLAB(M)  $)

         RETURN

        DEFAULT: LOAD(X)
                 OUT2P(B -> S.JT, S.JF, L)
                 SSP := SSP - 1
                 RETURN     $)JC

AND TRANSSWITCH(X) BE
    $(1 LET P, B, DL = CASEP, CASEB, DEFAULTLABEL
        AND ECL = ENDCASELABEL
        LET L = NEXTPARAM()
        ENDCASELABEL := NEXTPARAM()
        CASEB := CASEP
       
        COMPJUMP(L)
        DEFAULTLABEL := 0
        TRANS(H3%X)
        COMPJUMP(ENDCASELABEL)
      
        COMPLAB(L)
        LOAD(H2%X)
        IF DEFAULTLABEL=0 DO DEFAULTLABEL := ENDCASELABEL
        OUT3P(S.SWITCHON, CASEP-P, DEFAULTLABEL)

        FOR I = CASEB TO CASEP-1 DO $( OUTN(CASEK%I)
                                   OUTL(CASEL%I)  $)

        SSP := SSP - 1
        COMPLAB(ENDCASELABEL)
        ENDCASELABEL := ECL
        CASEP, CASEB, DEFAULTLABEL := P, B, DL   $)1

AND TRANSFOR(X) BE
     $( LET A, B = DVECE, DVECS
        LET L, M = NEXTPARAM(), NEXTPARAM()
        LET BL, LL = BREAKLABEL, LOOPLABEL
        LET K, N = 0, 0
        LET STEP = 1
        LET S = SSP
        BREAKLABEL, LOOPLABEL := 0, 0

        ADDNAME(H2%X, S.LOCAL, S)
        DVECE := DVECS
        LOAD(H3%X)

        TEST H1%(H4%X)=S.NUMBER
            THEN K, N := S.LN, H2%(H4%X)
              OR $( K, N := S.LP, SSP
                    LOAD(H4%X)  $)

        UNLESS H5%X=0 DO STEP := EVALCONST(H5%X)

        OUT1(S.STORE)
        COMPJUMP(L)
        DECLLABELS(H6%X)
        COMPLAB(M)
        TRANS(H6%X)
        UNLESS LOOPLABEL=0 COMPLAB(LOOPLABEL)
        OUT2(S.LP, S); OUT2(S.LN, STEP); OUT1(S.PLUS); OUT2(S.SP, S)
        COMPLAB(L)
        OUT2(S.LP, S); OUT2(K, N); OUT1(STEP<0 -> S.GE, S.LE)
        OUT2P(S.JT, M)
 
        UNLESS BREAKLABEL=0 DO COMPLAB(BREAKLABEL)
        BREAKLABEL, LOOPLABEL, SSP := BL, LL, S
        OUT2(S.STACK, SSP)
        DVECE, DVECS := A, B  $)


.



//\*   /DGIM/NTRN4   13.20  23/10


GET "SY:NTRN.GET"

LET LOAD(X) BE
    $(1 IF X=0 DO $( REPORT(148, CURRENTBRANCH)
                     LOADZERO()
                     RETURN  $)

     $( LET OP = H1%X

        SWITCHON OP INTO
     $( DEFAULT: REPORT(147, CURRENTBRANCH)
                 LOADZERO()
                 RETURN

        CASE S.DIV: CASE S.REM: CASE S.MINUS:
        CASE S.LS: CASE S.GR: CASE S.LE: CASE S.GE:
        CASE S.LSHIFT: CASE S.RSHIFT:
            LOAD(H2%X)
            LOAD(H3%X)
            OUT1(OP)
            SSP := SSP - 1
            RETURN

        CASE S.VECAP: CASE S.MULT: CASE S.PLUS: CASE S.EQ: CASE S.NE:
        CASE S.LOGAND: CASE S.LOGOR: CASE S.EQV: CASE S.NEQV:
         $( LET A, B = H2%X, H3%X
            IF H1%A=S.NAME \/ H1%A=S.NUMBER DO
                               A, B := H3%X, H2%X
            LOAD(A)
            LOAD(B)
            IF OP=S.VECAP DO $( OUT1(S.PLUS); OP := S.RV  $)
            OUT1(OP)
            SSP := SSP - 1
            RETURN   $)

        CASE S.NEG: CASE S.NOT: CASE S.RV:
            LOAD(H2%X)
            OUT1(OP)
            RETURN

        CASE S.TRUE: CASE S.FALSE:
            OUT1(OP)
            SSP := SSP + 1
            RETURN

        CASE S.LV: LOADLV(H2%X)
                   RETURN

        CASE S.NUMBER: CASE S.CHAR:
            OUT2(S.LN, H2%X)
            SSP := SSP + 1
            RETURN

        CASE S.STRING:
            OUT2(S.LSTR, H2%X)
            OUTS(H2+X)
            SSP := SSP + 1
            RETURN 
 
       CASE S.CODE:
        $(  LET B = H2%X
            UNLESS H1%B=S.STRING REPORT(107, X)
            OUT2(S.CODE, H2%B)
            OUTS(H2+B)
            OUT2(S.RSTACK, SSP)
            SSP := SSP+1
            RETURN $)

        CASE S.NAME:
             TRANSNAME(X, S.LP, S.LG, S.LL, S.LN)
             SSP := SSP + 1
             RETURN

        CASE S.VALOF:
         $( LET RL = RESULTLABEL
            LET A, B = DVECS, DVECE
            DECLLABELS(H2%X)
            RESULTLABEL := NEXTPARAM()
            TRANS(H2%X)
            COMPLAB(RESULTLABEL)
            OUT2(S.RSTACK, SSP)
            SSP := SSP + 1
            DVECS, DVECE := A, B
            RESULTLABEL := RL
            RETURN   $)


        CASE S.FNAP:
         $( LET S = SSP
            SSP := SSP + SAVESPACESIZE
            OUT2(S.STACK, SSP)
            LOADLIST(H3%X)
            LOAD(H2%X)
            OUT2(S.FNAP, S)
            SSP := S + 1
            RETURN   $)

        CASE S.COND:
            IF ISCONST(H2%X) $( LOAD(CONSTVAL -> H3%X, H4%X); RETURN $)
         $( LET L, M = NEXTPARAM(), NEXTPARAM()
            LET S = SSP
            JUMPCOND(H2%X, FALSE, M)
            LOAD(H3%X)
            COMPJUMP(L)
            SSP := S; OUT2(S.STACK, SSP)
            COMPLAB(M)
            LOAD(H4%X)
            COMPLAB(L)
            RETURN   $)

        CASE S.TABLE:
         $( LET M = NEXTPARAM()
            COMPDATALAB(M)
            X := H2%X
            WHILE H1%X=S.COMMA DO
                  $( OUT2(S.ITEMN, EVALCONST(H2%X))
                     X := H3%X   $)
            OUT2(S.ITEMN, EVALCONST(X))
            OUT2P(S.LLL, M)
            SSP := SSP + 1
            RETURN  $)                         $)1


AND LOADLV(X) BE
    $(1 IF X=0 GOTO ERR

        SWITCHON H1%X INTO
     $( DEFAULT: 
        ERR:     REPORT(113, CURRENTBRANCH)
                 LOADZERO()
                 RETURN

        CASE S.NAME:
              TRANSNAME(X, S.LLP, S.LLG, S.LLL, 0)
              SSP := SSP + 1
              RETURN

        CASE S.RV:
            LOAD(H2%X)
            RETURN

        CASE S.VECAP:
         $( LET A, B = H2%X, H3%X
            IF H1%A=S.NAME DO A, B := H3%X, H2%X
            LOAD(A)
            LOAD(B)
            OUT1(S.PLUS)
            SSP := SSP - 1
            RETURN   $)

        CASE S.COND:
            IF ISCONST(H2%X) $( LOADLV(CONSTVAL -> H3%X, H4%X); RETURN $)
           $( LET L, M = NEXTPARAM(), NEXTPARAM()
              LET S = SSP
              JUMPCOND(H2%X, FALSE, M)
              LOADLV(H3%X)
              COMPJUMP(L)
              SSP := S; OUT2(S.STACK, SSP)
              COMPLAB(M)
              LOADLV(H4%X)
              COMPLAB(L)
              RETURN   $)         $)1

AND LOADZERO() BE $( OUT2(S.LN, 0)
                     SSP := SSP + 1  $)

AND LOADLIST(X) BE
    $( IF X=0 RETURN

       UNLESS H1%X=S.COMMA DO $( LOAD(X); RETURN  $)

       LOADLIST(H2%X)
       LOADLIST(H3%X)  $)

.



//\*   /DGIM/NTRN5   13.15  23/10


GET "SY:NTRN.GET"

GLOBAL $( E:235 $)  // SYNONYM
LET EVALCONST(X) = VALOF
    $(1 IF X=0 DO $( REPORT(117, CURRENTBRANCH)
                     RESULTIS 0  $)

        SWITCHON H1%X INTO
     $( DEFAULT: REPORT(118, X)
                 RESULTIS 0

        CASE S.NAME:
         $( LET T = CELLWITHNAME(X)
            IF DVEC%(T+1)=S.NUMBER RESULTIS DVEC%(T+2)
            REPORT(119, X)
            RESULTIS 0  $)

        CASE S.NUMBER: RESULTIS H2%X
        CASE S.TRUE: RESULTIS TRUE
        CASE S.FALSE: RESULTIS FALSE

        CASE S.NEG: RESULTIS -E(H2%X)
        CASE S.NOT: RESULTIS NOT E(H2%X)
 
        CASE S.PLUS: RESULTIS E(H2%X)+E(H3%X)
        CASE S.MINUS: RESULTIS E(H2%X)-E(H3%X)
        CASE S.MULT: RESULTIS E(H2%X)*E(H3%X)
        CASE S.DIV:  RESULTIS E(H2%X)/E(H3%X)
        CASE S.REM:  RESULTIS E(H2%X) REM E(H3%X)
        CASE S.EQV:  RESULTIS E(H2%X) EQV E(H3%X)
        CASE S.NEQV: RESULTIS E(H2%X) NEQV E(H3%X)
        CASE S.LSHIFT: RESULTIS E(H2%X) LSHIFT E(H3%X)
        CASE S.RSHIFT: RESULTIS E(H2%X) RSHIFT E(H3%X)
        CASE S.EQ:   RESULTIS E(H2%X) EQ E(H3%X)
        CASE S.NE:   RESULTIS E(H2%X) NE E(H3%X)
        CASE S.LS:   RESULTIS E(H2%X) LS E(H3%X)
        CASE S.LE:   RESULTIS E(H2%X) LE E(H3%X)
        CASE S.GR:   RESULTIS E(H2%X) GR E(H3%X)
        CASE S.GE:   RESULTIS E(H2%X) GE E(H3%X)
        CASE S.COND: RESULTIS E(E(H2%X) -> H3%X, H4%X)
                    $)1
 
AND ISCONST(X) = VALOF
$(  STATIC $( NOTCONST.P=0; NOTCONST.L=0 $)
    LET DUMMY() BE LONGJUMP(NOTCONST.P, NOTCONST.L)
    LET SAVETR = REPORT
    REPORT := DUMMY
    NOTCONST.P, NOTCONST.L := LEVEL(), NOTCONST
    CONSTVAL := EVALCONST(X)
    REPORT := SAVETR
    RESULTIS TRUE
NOTCONST:
    REPORT := SAVETR
    RESULTIS FALSE  $)
 
AND NOLABELS(X) = VALOF
$(N IF X=0 RESULTIS TRUE
    SWITCHON H1%X INTO $(
 
DEFAULT:     RESULTIS TRUE
CASE S.COLON:CASE S.CASE: RESULTIS FALSE
CASE S.IF: CASE S.UNLESS:
CASE S.WHILE: CASE S.UNTIL:
CASE S.SWITCHON: CASE S.SEQ: RESULTIS NOLABELS(H3%X)
CASE S.REPEAT:CASE S.REPEATWHILE:CASE S.REPEATUNTIL:
CASE S.DEFAULT:  RESULTIS NOLABELS(H2%X)
CASE S.TEST:     RESULTIS NOLABELS(H3%X)->NOLABELS(H4%X), FALSE
$)N
.
 
GET "SY:NTRN.GET"
 


LET ASSIGN(X, Y) BE
    $(1 IF X=0 \/ Y=0 DO
            $( REPORT(110, CURRENTBRANCH)
               RETURN  $)

        SWITCHON H1%X INTO
     $( CASE S.COMMA:
            UNLESS H1%Y=S.COMMA DO
                       $( REPORT(112, CURRENTBRANCH)
                          RETURN   $)
            ASSIGN(H2%X, H2%Y)
            ASSIGN(H3%X, H3%Y)
            RETURN

        CASE S.NAME:
            LOAD(Y)
            TRANSNAME(X, S.SP, S.SG, S.SL, 0)
            SSP := SSP - 1
            RETURN

        CASE S.RV: CASE S.VECAP: CASE S.COND:
            LOAD(Y)
            LOADLV(X)
            OUT1(S.STIND)
            SSP := SSP - 2
            RETURN

        DEFAULT: REPORT(109, CURRENTBRANCH)   $)1


AND TRANSNAME(X, P, G, L, N) BE
    $(1 LET T = CELLWITHNAME(X)
        LET K, A = DVEC%(T+1), DVEC%(T+2)

        IF T=0 DO $( REPORT(115, X)
                     OUT2(P, 2)
                     RETURN  $)

        SWITCHON K INTO
        $( CASE S.LOCAL: IF T<DVECP DO REPORT(116, X)
                         OUT2(P, A); RETURN

           CASE S.GLOBAL: OUT2(G, A); RETURN

           CASE S.LABEL: OUT2P(L, A); RETURN

           CASE S.NUMBER: IF N=0 DO $( REPORT(113, X)
                                       N := P  $)
                          OUT2(N, A)  $)1


.



//\*   /DGIM/NTRN6   13.35  4/12


GET "SY:NTRN.GET"

LET COMPLAB(L) BE
    $( OUT2P(S.LAB, L)  $)

AND COMPENTRY(N, L) BE
    $(  LET S = N+3
        OUT3P(S.ENTRY, S%0, L)
        OUTS(S)  $)

AND COMPDATALAB(L) BE
    $( OUT2P(S.DATALAB, L)  $)

AND COMPJUMP(L) BE
    $( OUT2P(S.JUMP, L)  $)

AND OUT1(X) BE
    $( WRITEOP(X); NEWLINE()  $)

AND OUT2(X, Y) BE
    $( WRITEOP(X); WRITEC('*S')
       WRITEN(Y); NEWLINE()   $)

AND OUT2P(X, Y) BE
    $( WRITEOP(X); WRITES('*SL')
       WRITEN(Y); NEWLINE()   $)

AND OUT3P(X, Y, Z) BE
    $( WRITEOP(X); WRITEC('*S')
       WRITEN(Y); WRITES('*SL')
       WRITEN(Z); NEWLINE()   $) 


AND OUTN(N) BE
    $( WRITEN(N)  $)

AND OUTL(X) BE
    $( WRITES('*SL'); WRITEN(X); NEWLINE()  $)
 
AND OUTS(S) BE
    $( LET V = VEC 256
       UNPACKSTRING(S, V)
       FOR I=1 TO V%0
       $( IF I REM 18 = 0 NEWLINE()
          OUTC(V%I) $)
       NEWLINE() $)

AND OUTC(X) BE
    $( WRITEN(X); WRITEC('*S')   $)  // CHARCODE DELETED

AND WRITEOP(X) BE
    $(1 LET S = VALOF
        $( SWITCHON X INTO
        $( DEFAULT: REPORT(199, CURRENTBRANCH)
                    RESULTIS 'ERROR'

           CASE S.MULT:    RESULTIS 'MULT'
           CASE S.DIV:     RESULTIS 'DIV'
           CASE S.REM:     RESULTIS 'REM'
           CASE S.PLUS:    RESULTIS 'PLUS'
           CASE S.MINUS:   RESULTIS 'MINUS'
           CASE S.EQ:      RESULTIS 'EQ'
           CASE S.NE:      RESULTIS 'NE'
           CASE S.LS:      RESULTIS 'LS'
           CASE S.GR:      RESULTIS 'GR'
           CASE S.LE:      RESULTIS 'LE'
           CASE S.GE:      RESULTIS 'GE'
           CASE S.LSHIFT:  RESULTIS 'LSHIFT'
           CASE S.RSHIFT:  RESULTIS 'RSHIFT'
           CASE S.LOGAND:  RESULTIS 'LOGAND'
           CASE S.LOGOR:   RESULTIS 'LOGOR'
           CASE S.EQV:     RESULTIS 'EQV'
           CASE S.NEQV:    RESULTIS 'NEQV'

           CASE S.NEG:     RESULTIS 'NEG'
           CASE S.NOT:     RESULTIS 'NOT'
           CASE S.RV:      RESULTIS 'RV'

           CASE S.TRUE:    RESULTIS 'TRUE'
           CASE S.FALSE:   RESULTIS 'FALSE'

           CASE S.LP:      RESULTIS 'LP'
           CASE S.LG:      RESULTIS 'LG'
           CASE S.LN:      RESULTIS 'LN'
           CASE S.LSTR:    RESULTIS 'LSTR'
           CASE S.LL:      RESULTIS 'LL'

           CASE S.LLP:     RESULTIS 'LLP'
           CASE S.LLG:     RESULTIS 'LLG'
           CASE S.LLL:     RESULTIS 'LLL'

           CASE S.SP:      RESULTIS 'SP'
           CASE S.SG:      RESULTIS 'SG'
           CASE S.SL:      RESULTIS 'SL'
           CASE S.STIND:   RESULTIS 'STIND'

           CASE S.JUMP:    RESULTIS 'JUMP'
           CASE S.JT:      RESULTIS 'JT'
           CASE S.JF:      RESULTIS 'JF'
           CASE S.GOTO:    RESULTIS 'GOTO'
           CASE S.LAB:     RESULTIS 'LAB'
           CASE S.STACK:   RESULTIS 'STACK'
           CASE S.STORE:   RESULTIS 'STORE'

           CASE S.ENTRY:   RESULTIS 'ENTRY'
           CASE S.SAVE:    RESULTIS 'SAVE'
           CASE S.FNAP:    RESULTIS 'FNAP'
           CASE S.FNRN:    RESULTIS 'FNRN'
           CASE S.RTAP:    RESULTIS 'RTAP'
           CASE S.RTRN:    RESULTIS 'RTRN'
           CASE S.RES:     RESULTIS 'RES'
           CASE S.RSTACK:  RESULTIS 'RSTACK'
           CASE S.FINISH:  RESULTIS 'FINISH'

           CASE S.SWITCHON:RESULTIS 'SWITCHON'
           CASE S.CODE:    RESULTIS 'CODE'
           CASE S.GLOBAL:  RESULTIS 'GLOBAL'
           CASE S.DATALAB: RESULTIS 'DATALAB'
           CASE S.ITEML:   RESULTIS 'ITEML'
           CASE S.ITEMN:   RESULTIS 'ITEMN'   $)   $)

        WRITES(S)   $)1


.