GET "[1,5]DLIB.HDR" 
 
GLOBAL  $(  MSTORE:101;  MACRO:102;  BUFFER:103;  PTR:104
            CH:106;  LINE:107;  COPYING:108;  T.COPY:109 
            S.FLAG:110;  S.EOL:111;  T.FLAG:112;  T.EOL:113  
            ZERO:115;  LENGTH:116;  MATCH:117;  ARBNO:118
            MACRO.NUMBER:119;  SYMBOL:120    $)  
 
MANIFEST  $(  MACLEN=12000;   LINELEN=150   $)   
 
 
LET  START()  BE        //        MAIN PROGRAM   
 
    $(S   LET V1 = VEC MACLEN
          AND V2 = VEC LINELEN   
          AND V3 = VEC 9 
 
          MSTORE, BUFFER, MATCH := V1, V2, V3
 
	  SELECTOUTPUT(FINDOUTPUT("?OUTPUT"))
	  SELECTINPUT (FINDINPUT ("?INPUT "))
          READFLAGLINE() 
          READMACRODEFINITIONS() 
 
          SYMBOL := 100-10    //    SET SYMBOL GENERATOR 
 
      $(  LENGTH := READSOURCELINE() 
          GENERATE()          $)    REPEAT   $)S 
 
 
 
AND  READFLAGLINE()  BE       //     READ IN SPECIAL CHARACTERS  
 
    $(RF  S.EOL := RCH();   S.FLAG := RCH();   T.EOL := RCH()
          T.FLAG := RCH();   ZERO := RCH();   T.COPY := RCH()
 
          IF  CH=ENDSTREAMCH  DO 
                $(  WRITES("*NEND OF STREAM READING FLAG LINE*N")
                    ABTERM(24)    $) 
 
          COPYING  :=  (CH = '*N') \/ (CH = '*S')         //     COPY OPTION  
          CLEARLINE()      $)RF  
 
 
 
AND  READMACRODEFINITIONS()  BE      //      READ IN THE MACRO-DEFINITIONS   
 
   $(RMD  MACRO, MACRO.NUMBER := MSTORE, 0   
 
     $(1  PTR, LINE := MACRO+1, 0
          MACRO.NUMBER := MACRO.NUMBER + 1   
          SYMBOL := 0       //     SYMBOLS CALLED IN THIS MACRO  
 
      $(  LET N = READMACRO()
          PTR!0 := N;   PTR := PTR+N+1   
          CLEARLINE()        $)  
 
     $(2  LINE := LINE+1 
 
      $(  LET N = READLINE() 
          IF  N=1  BREAK 
          PTR!0 := LINE  
          PTR := PTR+N+1 
          CLEARLINE()       $)2   REPEAT 
 
          PTR!0 := 0                  //   NULL LINE ENDS MACRO  
          PTR!1 := SYMBOL             //   SYMBOL GENERATOR INCREMENT
          IF  RCH()=T.EOL  BREAK      //   LAST MACRO DEFINITION 
 
          MACRO!0 := PTR+2            //   CHAIN MACRO DEFINITIONS   
          MACRO := MACRO!0            //   NEXT MACRO DEFINITION 
          CLEARLINE()        $)1    REPEAT   
 
          CLEARLINE()
          MACRO!0 := 0       $)RMD      //   TERMINATE THE CHAIN 
 
 
 
AND  READMACRO()  =  VALOF          //    READ A SINGLE MACRO-DEFINITION 
 
    $(RM  LET I = 0  
          ARBNO := 0                   //    MAXIMUM PARAMETER   
          RCH()  
 
          UNTIL  CH='*N' \/  CH=ENDSTREAMCH  DO 
                $(  IF  CH=S.EOL   RESULTIS I
                    IF  CH=S.FLAG   DO  ARBNO := ARBNO + 1   
                    I := I+1;    PTR!I := CH;    RCH()    $) 
 
          WRITES("*NUNTERMINATED MACRO DEFINITION LINE*N")   
          ABTERM(8)     $)RM 
 
 
 
AND  READLINE()  =  VALOF         //     READ MACRO BODY LINE
 
    $(RL  LET I, J, K = 1, 1, 1  
          RCH()  
 
          UNTIL  CH='*N' \/ CH=ENDSTREAMCH  DO 
                $(  IF  CH=T.EOL   BREAK 
 
                    IF  CH=T.FLAG   DO   
                      $(  IF  I>J  DO  $(  PTR!J := I-J;  I := I+1  $)   
                          J := RCH()-ZERO
                          K := RCH()-ZERO
                          UNLESS  0<=J<=ARBNO  DO
                                 $(   WRITES("*NBAD PARAMETER VALUE*N")  
                                      ABTERM(12)     $)  
                          UNLESS  (J*K)=0  DO
                                 $(   WRITES("*NINVALID CONVERSION TYPE*N")  
                                      ABTERM(16)     $)  
                          TEST  J>0  THEN   PTR!I := -J  
                                       OR   $(  CHECKSYMBOL(K)   
                                                PTR!I := -(K+10)  $) 
                          I := I+1;   J := I;   RCH();    LOOP    $) 
 
                    I := I+1;    PTR!I := CH;     RCH()       $) 
 
          IF  I>J    DO  $(  PTR!J := I-J;  I := I+1   $)
          PTR!I := 0;          RESULTIS  I         $)RL  
 
 
 
AND  CHECKSYMBOL(K)  BE          //        VALIDATE SYMBOL-GENERATOR CALL
 
    $(CK  UNLESS  0<=K<=9  DO
             $(  WRITES("*NINVALID SYMBOL GENERATOR CALL*N");  ABTERM(32)  $)
          IF  K>=SYMBOL   DO  SYMBOL := K+1        $)CK  
 
 
 
AND  READSOURCELINE()  =  VALOF             //    READ IN SOURCE LINE
 
    $(RS  LET I = 0  
          RCH()  
 
          UNTIL  CH='*N' \/ CH=ENDSTREAMCH  DO 
                $(  IF  CH=S.EOL   DO  $(  BUFFER!0 := I;  CLEARLINE()
                                           RESULTIS  I   $)  
                    I := I+1;    BUFFER!I := CH;    RCH()    $)  
 
          IF  CH=ENDSTREAMCH  DO STOP() 
          BUFFER!0 := I;    COPYLINE()    $)RS     REPEAT
 
 
 
AND  GENERATE()  BE  
 
   $(GEN TEST MATCHLINE() DO OUTPUTTEXT() OR COPYLINE()        $)GEN  
 
 
 
AND  MATCHLINE()  =  VALOF   
 
    $(ML  MACRO := MSTORE
 
      $(  IF  CHECKMACRO()  RESULTIS TRUE
          MACRO := MACRO!0    $)      REPEATUNTIL  MACRO=0   
 
          RESULTIS FALSE      $)ML   
 
 
 
AND  CHECKMACRO()  =  VALOF  
 
    $(CM  UNLESS MACRO!1=LENGTH  RESULTIS FALSE  
 
      $(  LET N = 0  
          PTR := MACRO+1 
 
          FOR I = 1 TO LENGTH  DO
              $(   IF PTR!I=S.FLAG  DO  $( N := N+1  
                                           MATCH!N := BUFFER!I   
                                           LOOP  $)  
                   UNLESS  PTR!I=BUFFER!I  RESULTIS FALSE  $)
 
          RESULTIS TRUE    $)CM  
 
 
 
AND  OUTPUTTEXT()  BE
 
    $(OT  PTR := MACRO + MACRO!1 + 2 
          UNTIL  PTR!0=0   DO PROCESSLINE()  
          SYMBOL := SYMBOL + PTR!1         $)OT  
 
 
 
AND  PROCESSLINE()  BE   
 
    $(PL  PTR := PTR+1   
 
      $(  LET N = PTR!0  
          PTR := PTR+1   
 
          IF  N=0   DO  $(  NEWLINE();   RETURN   $) 
 
          IF  N>0  DO
                 $(  FOR I = 0 TO (N-1)  DO WRCH(PTR!I)  
                     PTR := PTR + N;    LOOP   $)
 
          N := -N
          TEST  N>9  THEN  WRITEN(SYMBOL+N)  
                       OR  WRCH(MATCH!N)       $)   REPEAT    $)PL   
 
 
 
AND  COPYLINE()  BE  
 
    $(CO  UNLESS  COPYING  DO
              $(   CLEARLINE();   RETURN   $)
 
          UNLESS  CH='*N'   DO  WRCH(T.COPY)          //    TERMINATED LINES 
          FOR I = 1 TO BUFFER!0   DO WRCH(BUFFER!I)  
          IF  CH='*N'   DO  NEWLINE()               //    UNTERMINATED LINES 
          UNTIL  CH='*N'  DO     $(  RCH();   WRCH(CH)   $)       $)CO   
 
 
 
AND  RCH()  =  VALOF 
    $(RC  CH := RDCH()   
          RESULTIS  CH    $)RC   
 
 
 
AND  CLEARLINE()  BE 
 
    $(CL  UNTIL  CH='*N' \/ CH = ENDSTREAMCH   DO RCH()      $)CL
 
 
 
AND  ABTERM(N)  BE   
 
    $(AB  WRITEF("STOP CALLED FROM LINE %N OF MACRO %N*N",  LINE,
                                     MACRO.NUMBER)   
          STOP(N)        $)AB