%#MASTER(%BLIB0)
GET "GLOBALS"   
////    START OF "LIBB" 


LET PACKSTRING(V,S) BE  
   $( LET N = !V & #377 
         $( LET A,B,C = V!0,0,0 
            UNLESS N < 1 DO B := V!1
            UNLESS N < 2 DO C := V!2
            !S := A << 16 LOGOR B << 8 LOGOR C  
            S,V,N := S+1,V+3,N-3
         $) REPEATUNTIL N < 0   
   $)   

AND UNPACKSTRING(S,V) BE
   $( LET W = !S
      LET N = W >> 16   
      LET J = 16
      FOR I = 0 TO N DO 
         $( V!I := W >> J & #377
            TEST J = 0 THEN $( S,J := S+1,16; W := !S $)
                        OR       J := J - 8 
         $) 
   $)   

AND WRITES(S) BE
   $( LET W = !S
      LET N = W >> 16   
         $( IF N = 0 RETURN 
            WRITECH(OUTPUT, W >> 8) 
            IF N = 1 RETURN 
            WRITECH(OUTPUT, W)  
            IF N = 2 RETURN 
            S,N := S+1,N-3  
            W := !S 
            WRITECH(OUTPUT, W >> 16)
         $) REPEAT  
   $)   

AND WRITEC(CH) BE WRITECH(OUTPUT,CH)

AND WRITEN(N) BE TEST N < 0 THEN $( WRITEC('-');
                                    TEST -N < 0 THEN WRITES("8388608")  
                                                 OR  WRITEPN(-N)
                                 $) 
                             OR                      WRITEPN( N)

AND WRITEPN(N) BE $( IF N > 9 DO WRITEPN( N/10 )
                     WRITECH(OUTPUT, N REM 10 + '0' ) $)

AND WRITEO(N,W) BE  
      IF W > 0 DO   
         $( WRITEO( N >> 3 , W - 1 )
            WRITECH(OUTPUT, ( N & #7 ) + '0' )  
         $) 

AND WRITED(N,W) BE  
   $( LET V = VEC 8 
      LET C = 0 
      LET S = N < 0 
      LET M = S -> -N , N   
      IF M < 0 DO   
         $( FOR I = 9 TO W DO WRITECH(OUTPUT,' ')   
            WRITES("-8388608")  
            RETURN  
         $) 
      $( C := C + 1; V!C := M REM 10 + '0'; M := M/10 $) REPEATUNTIL M = 0  
      IF S DO $( C := C + 1; V!C := '-' $)  
      WHILE W > C DO $( WRITECH(OUTPUT,' '); W := W - 1 $)  
      $( WRITECH(OUTPUT,V!C); C := C - 1 $) REPEATUNTIL C = 0   
   $)   

AND WRITEF(FORMAT,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) BE   
   $( LET V = VEC 255   
      AND Q = @FORMAT   
      UNPACKSTRING(FORMAT,V)
      FOR P = V + 1 TO V + V!0 DO   
         $( LET K = !P  
            TEST K # '%' THEN WRITEC(K) 
                          OR  $( LET F,N = ?,?  
                                 P := P + 1 
                                 SWITCHON !P INTO   
                                    $( DEFAULT : WRITEC(!P);  LOOP  
                                       CASE 'S': F := WRITES; ENDCASE   
                                       CASE 'C': F := WRITEC; ENDCASE   
                                       CASE 'N': F := WRITEN; ENDCASE   
                                       CASE 'O': F := WRITEO; GOTO M
                                       CASE 'I':
                                       CASE 'D': F := WRITED;   
                                    M: P := P + 1; N := !P - '0' $) 
                                       Q := Q + 1; F(!Q,N)  
                              $)
         $) 
   $)   

AND NEWLINE() BE WRITECH(OUTPUT,'*N')   

AND REPORT(N) BE
   $( LET A = OUTPUT
      OUTPUT := MONITOR 
      WRITEF("*NREPORT :- ERROR %N*N",N)
      REPORTCOUNT := REPORTCOUNT + 1
      IF REPORTCOUNT = REPORTMAX DO WRITES("TOO MANY REPORTS*N")
      IF REPORTCOUNT >= REPORTMAX DO
         $( WRITES("REPORT FINISH.*N")  
            FINISH  
         $) 
      OUTPUT := A   
   $)   


////    END OF "LIBB"   


GLOBAL $( STANDARDIO:78 $)  
STATIC $( LAST = -1; NEXT = -1 $)   

LET STANDARDIO() BE $( INITIALIZEIO()   
                        INPUT := VALOF $(   
                                       $( IF ENTRYUSED < 2 RESULTIS 
                                                      FINDINPUT(30*ENTRYUSED)   
                                          UNLESS INIT.X.REGS!0 = 0 RESULTIS 
                                                      FINDFILE(INIT.X.REGS) 
                                          TY.HALT("LD") $) REPEAT   
                                       $)   
                       OUTPUT := CREATEOUTPUT(20)   
                       MONITOR := OUTPUT
                       NEXTCH := 0  
                       CH     := 0  
                    $)  

LET TERMINATE() BE FINISH   

LET RCH() = VALOF   
         $( 
            IF NEXT < 0 DO READCH(INPUT, LV NEXT)   

            IF LAST = '*E' DO $( LET A = OUTPUT 
                                OUTPUT := MONITOR   
                                WRITEF("*N*N**** ATTEMPT TO READ PAST END *<
                                       *>OF INPUT STREAM.*N")   
                                OUTPUT := A 
                                TERMINATE() 
                                FINISH  
                             $) 

            LAST, CH := NEXT, NEXT  
            READCH(INPUT, LV NEXT)  
            NEXTCH := NEXT  
            RESULTIS CH 
         $) 

LET READN() = VALOF $( LET A, SIGN = 0, 1   
                       RCH() REPEATWHILE CH <= '*S' 
                       IF CH = ',' DO $( RCH() REPEATWHILE CH LE ' ' $) 
                       IF CH = '-' \/ CH = '+' DO $( IF CH = '-' DO SIGN := -1  
                                                     RCH() REPEATWHILE CH <= ' '
                                                  $)
                       UNLESS '0' LE CH LE '9' DO   
                                  $( LET A = OUTPUT 
                                     AND C = S(CH)         // RV OF A STRING
                                     AND N = S(NEXTCH)  
                                     OUTPUT := MONITOR  
                                     WRITEF("*N*N**** 'READN' EXPECTS A DIGIT *<
                                          *>ON INPUT STREAM.CURRENT CHARACTER *<
                                          *>('CH') IS '%S', NEXT CHARACTER *<   
                                          *>('NEXTCH') IS '%S'.*N", LV C, LV N) 

                                                     OUTPUT := A
                                                     TERMINATE()
                                                     FINISH 
                                                  $)
                       $( A :=(A << 3)+ A + A + CH - '0'
                          UNLESS '0' LE NEXTCH LE '9' BREAK 
                          RCH() 
                       $) REPEAT
                       WHILE NEXTCH LE ' ' DO RCH() 
                       RESULTIS A * SIGN
                    $)  


AND S(X) = X = '*N' -> RV "**N",
           X = '*T' -> RV "**T",
           X = '*E' -> RV "**E",

                       [ ( X LOGAND #377 )  << 8 ] LOGOR ( 1 LSHIFT 16 )




.   
%#MASTER(%BSTART)   
%#INCLUDE(%BPOINTERS,%BTYROUTINE,%BSYSTEM,%BDEBUG)  
GET "GLOBALS"   
STATIC $( REENTERED = FALSE $)  
STATIC $( PSAVED = 0
       $)   
STATIC $( CHECK = 0 $)  
MANIFEST $( PRIVATESTACKSIZE =  10 $)   
LET START() BE  
    $(  
SWITCHON ENTRYUSED INTO 

$(SWITCH
CASE 0: 
CASE 1: 
CASE 5: 
        STANDARDIO()
        PSAVED := P.POINTER()   
         REPORTMAX := 5 
         REPORTCOUNT := 0   
         RV 10 := #03600033                      // BRN     27 - RE-ENTER AT 7  
         TERMINATE := GIVEUP
         GIVEUPLEVEL := 0              // FULL GIVEUP OPTIONS   
         $( LET PRIVATESTACK = VEC PRIVATESTACKSIZE // SAVE SPACE FOR   
                                                    // POST-MORTEMS.
            PROGRAM()   
         $) 
         OUTPUT := MONITOR  
         WRITES("*N*N*N**** EXECUTION COMPLETED*N") 
         ENDCASE

CASE 2: 
         TY.HALT("22")  
         ENDCASE
CASE 3: 
         TY.HALT("23")  
         ENDCASE
CASE 4: 
         TY.HALT("24")  
         ENDCASE
CASE 6: 
                 $( LET I = INPUT AND O = OUTPUT
                    LET V = VEC 2   
                    LET P = P.POINTER() 
                    AND X = INIT.X.REGS 
                    INPUT := FINDINPUT(1)   
                    OUTPUT := MONITOR   
                    CORE(3, V)                   // GET CORE CONSTANTS  
                    CORE(1, 10)                  // INCREASE CORE BY 10 WORDS   
                    SETP.POINTER(V!2)            // SET PP TO MAXC  
                    ONLINEDEBUG()   
                    SETP.POINTER(P) 
                    WRITES("RESUME AT CORRECT ADDRESS,OR RESUME TO FINISH*N")   
                    INPUT, OUTPUT := I, O   
                    EXECUTE(#07012020, X, X)     // SUSWT 2H

                 $) 
         ENDCASE

CASE 7: 
         DEBUG("TRIED TO EXECUTE LOCATION 10")  
         ENDCASE

CASE 8: 
         DEBUG("TIMED UP")  
         ENDCASE

CASE 9: 
         DEBUG("FAILED")
         ENDCASE


DEFAULT:
         TY.DISPLAY("ENTRYUSED OUT OF RANGE")   
         TY.HALT("EE")  
         ENDCASE
$)SWITCH
    $)  

AND DEBUG(S) BE $(  
                   STATIC $( SS = 0 $)  


                   LET UNKNOWN() BE 
                                    $( REPORTSTACKSTATE(0,GIVEUPLEVEL/1000000=0)
                                       TY.HALT("EE")
                                       ONLINEDEBUG()
                                    $)  

                   IF REENTERED DO TY.HALT("EE")
                   REENTERED := TRUE
                   SS := S  
                                       // SET P-POINTER TO CURK 
                   SETP.POINTER(SYSTEM.DATA.BLOCK!4)

                   WRITEF("THE PROGRAM HAS %S.RE-ENTERED AT %N*N",SS, ENTRYUSED)

                   PRINTREGISTERS() 
                   REPORTTOPSTACK() 
                   IF GIVEUPLEVEL >= 0 DO PROGRAMMAP()  
                   REPORTGLOBALS((GIVEUPLEVEL/1000)REM 1000,GIVEUPLEVEL REM 
                                                                    1000)   
                   IF CHECK = -1 DO              // LINK AND P-POINTER O.K. 
UN:                            $( SETP.POINTER(INIT.X.REGS!2)   
                                  GOTO UNKNOWN  
                               $)   
                   TY.HALT("EE")

          IF CHECK = 1 GOTO UN         // LINK CORRUPTED

               $)   

AND REPORTTOPSTACK() BE 
          $(
             LET PP = INIT.X.REGS!2 
             AND C = CORE(6)       // CURRENT CORE-SIZE 
             WRITES("TOP LEVEL OF STACK.*N*<
                   *>-------------------*N*N")  
             WRITEF("INITIAL STACK POINTER WAS %N.*N*<  
                   *>CURRENT CORE SIZE IS %N.*N", PSAVED, C)

             UNLESS PSAVED LE PP LE C  DO $( WRITES("STACK POINTER CORRUPTED *< 
                                                   *>OR STOPPED IN A SYSTEM *<  
                                                   *>ROUTINE*N")
                                             CHECK := 0 
                                             RETURN 
                                          $)
             WRITEF("STACK POINTER %N SEEMS OK.*N", PP) 
          $( LET LINK = PP!1
             AND D = SYSTEM.DATA.BLOCK  
             LET L = LINK   
             MANIFEST $( LDX3 = #30000000 $)
             GLOBAL $( G0 : 0 $)
// CHECK LINK WITHIN PROGRAM BOUNDS AND "CALL  1  %BSAVE"  IS THERE 
             UNLESS [ D!7  < LINK < D!8!0 ] /\ [ RV(LINK - 2) = 
                                                 (#13400000 \/ D!18)] DO
                             $( WRITEF("LINK = %N CORRUPTED*N", LINK)   
                                CHECK := 1  
                                RETURN  
                             $) 


             UNTIL (!L & #77740000) = LDX3 DO L := L - 1   // FIND LDX 3 INSTR. 

             $( LET M, N = (!L & #30000) >>12, !L & #7777   
                LET S, A, B = "THE RESULT OF AN EXPRESSION", N, FALSE   

                TEST M = 2 THEN S, B := "THE %N TH LOCAL VARIABLE, OR *<
                                       *>AN EXPRESSION", TRUE   

                OR TEST M = 0 & G0 <N <= G0 + !G0   THEN S, A, B := 
                                        "GLOBAL VARIABLE %N", N-@G0 ,TRUE   

                OR IF   M = 0 & N > 7 THEN S, B :="A STATIC VARIABLE*<  
                                                 *>(LOCATION %N)", TRUE 


                WRITES("THE CURRENTLY ACTIVE FUNCTION MAY BE  ")
                WRITEF(S, N)
                NEWLINE()   

                IF B DO $(  
                   WRITEF( "ITS VALUE IS %N.*N",    M = 2 -> PP!0!N, !N)

                           TEST ISFN(RV N + 2) THEN WRITEF("ITS NAME IS '%S'*N",
                                                                    RV N + 3)   

                           OR WRITES("ITS NAME CANNOT BE DETERMINED*N") 
                        $)  

             $) 

                             WRITEF("CURRENT FUNCTION WAS CALLED FROM *<
                                   *>LOCATION %N BY '%S'*N", LINK-2,CFN(PP))
                             WRITES("FIRST 10 LOCAL VARIABLES:*N")  

                               FOR I = 1 TO 10 DO $( WRITEN(PP!(I+1))   
                                                     WRITEC(' ') $) 
                               NEWLINE()
                          $)
             CHECK := -1

          $)

AND PRINTREGISTERS() BE  $( LET X = INIT.X.REGS 
                            WRITES("CONTENTS OF ACCUMULATORS:*N*<   
                                  *>------------------------*N*N")  
                            FOR I = 0 TO 7 DO WRITEF( "       X%N ", I) 
                            NEWLINE()   
                            NEWLINE()   
                            FOR I = 0 TO 7 DO WRITEF("%D9 ", INIT.X.REGS!I) 
                            NEWLINE()   
                            FOR I = 0 TO 7 DO WRITEF("#%O8 ", INIT.X.REGS!I)
                            NEWLINE()   
                            NEWLINE()   
                         $) 


.   
%#SEGMENT(%BTRACE)  
%#INCLUDE(%BTRACESAVE)  
GET "GLOBALS"   
MANIFEST $( TRACEFLAG = -2; FUNCTIONFLAG = -1 $)
STATIC $( TAB = 0 $)

LET REPORTCALL(FUNCTION) BE 
          $( LET A = OUTPUT 
             AND P = RV P.POINTER() 
             AND S = FUNCTION   
             LET NARGS = FUNCTION!1 - 2 
             LET UNSPEC = NARGS < 0 

             IF UNSPEC DO NARGS := 5

             OUTPUT := MONITOR  
             NEWLINE()  
             FOR I = 0 TO TAB DO WRITEC(' ')

             S := S + 1 REPEATUNTIL RV S = FUNCTIONFLAG \/ RV S = TRACEFLAG 
             WRITES("--> ") 
             WRITES(S + 1)  
             WRITEC('(')
             UNLESS NARGS = 0 DO
                   $( FOR I=2 TO NARGS DO $( WRITEN(P!I); WRITEC(',') $)
                      WRITEN(P!(NARGS + 1 ))
                      IF UNSPEC DO WRITES(", . . . ")   
                   $)   
             WRITES(") CALLED BY ") 
             WRITES(CFN(P)) 
             NEWLINE()  

             TAB := TAB + 1 
             OUTPUT := A
          $)

AND REPORTRETURN(X) = VALOF $( LET A = OUTPUT   
                               OUTPUT := MONITOR
                               NEWLINE()
                               TAB := TAB - 1   
                               FOR I = 0  TO TAB DO WRITEC(' ') 
                               WRITES(  "<-- FUNCTION EXIT:RESULTIS ")  
                               WRITEN(X)
                               NEWLINE()
                               OUTPUT := A  
                               RESULTIS X   
                            $)  

AND REPORTMISSINGFUNCTIONS(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z) 
                 = VALOF $(RP LET F = REPORTMISSINGFUNCTIONS
                              REPORTMISSINGFUNCTIONS:=SYSTEM.DATA.BLOCK!16 // GQ
                         $( LET PP = P.POINTER()
                            GLOBAL $( G0:0 $)   

                            LET LINK = PP!1 
                            LET A = OUTPUT  
                            AND GLOC = VALOF $( LET J = LINK - 3
                                                MANIFEST $( LDX3 = #30000000 $) 
                                                WHILE J > 0 DO  
                                                    $( IF (!J & #77740000) =LDX3
                                                             RESULTIS !J & #7777
                                                       J := J - 1   
                                                    $)  
                                                REPORTF("SYSTEM ERROR IN *< 
                                                      *>REPORTMISSINGFUNCTIONS")
                                                TERMINATE() 
                                             $) 


                            OUTPUT := MONITOR   
                           WRITEF("*>   
                                   *>ATTEMPT TO APPLY OR JUMP TO THE VALUE OF *<
                                   *>A VARIABLE WHICH HAS NOT BEEN INITIALISED*<
                                   *>.*NPOSITION IN GLOBAL VECTOR IS %N AND TH*<
                                   *>E CALL WAS MADE FROM '%S'.*NARGUMENTS ARE*<
                                   *> %N,%N,%N,%N,..,..*N", 
                                                           GLOC - LV G0,
                                                           CFN(PP)     ,
                                                           PP!2        ,
                                                           PP!3        ,
                                                           PP!4        ,
                                                           PP!5        )


                            OUTPUT := A 
                            REPORTCOUNT := REPORTCOUNT + 1  
                            IF REPORTCOUNT GE REPORTMAX DO TERMINATE()  
                            REPORTMISSINGFUNCTIONS := F 
                            RESULTIS 0  
                         $)RP   

AND TRACE(F) BE $( UNTIL RV F = FUNCTIONFLAG \/ RV F = TRACEFLAG DO F := F + 1  
                   RV F := TRACEFLAG
                $)  

AND UNTRACE(F) BE $( UNTIL RV F = FUNCTIONFLAG \/ RV F = TRACEFLAG DO F := F + 1
                     RV F := FUNCTIONFLAG   
                  $)
LET REPORTF(FORMAT,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z) 
       BE $( LET AA = OUTPUT
             LET PP = P.POINTER()   
             LET LINK = PP!1
             OUTPUT := MONITOR  
             NEWLINE()  
             WRITEF("**** REPORT FROM %S:*N", CFN(PP))  
             WRITEF(FORMAT,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z) 
             NEWLINE()  
             OUTPUT := AA   
             REPORTCOUNT := REPORTCOUNT + 1 
             IF REPORTCOUNT GE REPORTMAX DO TERMINATE() 
          $)


.   
%#SEGMENT(%BDEBUG)  
%#INCLUDE(%BPOINTERS,%BTYROUTINE)   
GET "GLOBALS"   
MANIFEST $( TRACEFLAG = -2; FUNCTIONFLAG = -1 $)
//    SEGMENTS COMPILED WITH SWITCH 4 OF THE CODE-GENERATOR ON HAVE 
//    A 'HEADER' AT THE START OF EACH FUNCTION. 

//    1. SEGMENT HEADER.
//          BRN      GLOBLAB
//             "%%"                      [ SPECIAL NAME "%%"

//    2. FUNCTIONS COMPILED BY EARLY VERSIONS OF CODE-GENERATOR 

//          BRN      SKIP                [ SKIP ROUND THE BODY  
//          BRN      L1                  [ START OF FUNCTION : SKIP HEADER  
//                   -1                  [ FLAG. SET TO -2 FOR TRACING. 

//             < FUNCTION NAME AS STRING >  

//    L1  ...                            [ START OF CODE.   


//    3. SEGMENTS COMPILED BY LATER VERSIONS.   

//          BRN      SKIP   
//          BRN      L1 
//                   < NUMBER OF ARGUMENTS - 2 >
//                   -1            [ AS ABOVE   
//                   < NAME >   
//    L1    .....   





LET REPORTGLOBALS(M,N) BE   
         $( GLOBAL $( G0:0 $)   
            LET O = OUTPUT  
            AND BLANK = FALSE   
            LET LOWER = SYSTEM.DATA.BLOCK!7 
            LET UPPER = SYSTEM.DATA.BLOCK!8!0   
            LET G = LV G0   
            OUTPUT := MONITOR   
            WRITEF("*N*NSTATE OF GLOBAL VECTOR:LENGTH %N,STARTS AT %N*N*N", G0, 
                                                                     LV G0) 
            UNLESS N=0 DO WRITEF("*NPRINT FROM %N TO %N*N", M, N)   
            FOR I = M TO N=0  \/ N> G0 -> G0, N DO  
                               $( LET C = G!I   
                                 IF C = 0 DO            $( BLANK := TRUE
                                                           LOOP 
                                                        $)  
                                  IF BLANK DO $( NEWLINE()  
                                                 BLANK := FALSE 
                                              $)
                                  WRITEF("%D3*T%D8*T#%O8"  , I, G ! I, C)   
                                  IF LOWER LE C LE UPPER DO 
                                  IF (C!2 = TRACEFLAG \/ C!2 = FUNCTIONFLAG) /\ 
                                                          ISFN(C+2) DO  
                                       WRITEF("*T%S", C+3)  
                                  NEWLINE() 
                               $)   
         $) 
AND REPORTSTACKSTATE(M, B) BE   
   $( LET P = P.POINTER()   
      AND FN = "REPORTSTACKSTATE"   
      LET CF = CFN(P)   
      LET O = OUTPUT
      AND WRSL(PTR,SEP) BE  
              $( LET V,S6 = RV PTR,SEP=0 -> "      ",SEP
                 IF V = 0 RETURN
                 WRITEF("*N%D8  #%O8%S#%O8  %D8  ",PTR,PTR,S6,V,V)  
              $)

      OUTPUT := MONITOR 
         $( LET L = P!1                // LINK  
            AND N = P - ( RV P & #17777777) 
            M := M - 1  
            WRITEF("*N*N%S WAS CALLED FROM %N WITHIN %S", FN, L, CFN(P))
            IF N = 0 THEN BREAK 
            WRITEF(" AT SAVE SPACE PLUS %N*N" , N ) 
            P, FN, CF := P-N, CF, CFN(P)
            IF B DO $( LET Q = P+N-1
                       UNTIL P=Q DO $( WRSL(Q,0); Q := Q - 1 $) 
                       WRSL(Q," ---- ") 
                    $)  
         $) REPEATUNTIL M = 0   
      NEWLINE();  NEWLINE() 
      OUTPUT := O   
   $)   


AND PROGRAMMAP() BE $( LET O = OUTPUT   
                       AND PRINTFNNAMES(LL, UU, T) BE   
                                $( LET L, U = LL, UU
                                WHILE L LE UU DO
                                $(  
                               L := L + 1   
                               UNLESS [ !L=FUNCTIONFLAG \/ !L=TRACEFLAG ] /\
                                                        ISFN(L) LOOP

                               U := LIMIT(L)
                               FOR I = 1 TO T DO WRITEC(' ')
                               WRITEF("%D5  <--> %D5      %C%S*N", L-1, 
                                                                   U-1, 
                                                       !L=TRACEFLAG->'**', '*S',
                                                                   L+1) 
                               PRINTFNNAMES(L+(L!1 >> 16)/3+2, U, T+6)  
                               L := U   
                                $)  
                                $)  

                       OUTPUT := MONITOR
                       WRITES("*NLAYOUT OF FUNCTIONS IN CORE*N*<
                             *>---------------------------*N*N")
                       WRITES("( '**' DENOTES FUNCTION BEING TRACED )*N*N") 
                       PRINTFNNAMES(SYSTEM.DATA.BLOCK!7,
                                    SYSTEM.DATA.BLOCK!8!0, // START OF BUFFERS  
                                    0)  
                       NEWLINE()
                       OUTPUT := O  
                    $)  
AND GIVEUP() = VALOF
                $(    LET A = OUTPUT
                      LET MAP = GIVEUPLEVEL >= 0
                      LET G = GIVEUPLEVEL < 0 -> -GIVEUPLEVEL, GIVEUPLEVEL  
                      LET FULLPRINT = G/1000000 = 0 
                      LET M = [ G REM 1000000 ] / 1000  
                      LET N = G REM 1000
                      OUTPUT := MONITOR 
                      WRITEF("*N**** 'GIVEUP' CALLED BY %S*N*N",
                                                         CFN(P.POINTER()))  
                      REPORTGLOBALS(M, N)   
                      IF MAP DO PROGRAMMAP()
                      REPORTSTACKSTATE(0, FULLPRINT)
                      WRITES("*N*N*N*N**** EXECUTION TERMINATED BY 'GIVEUP'.*N")
                      TY.HALT("EE") 
                      RESULTIS ONLINEDEBUG()
                   $)   

AND DUMP(N, M) BE $( STATIC $( I = 0 $) 
                    STATIC $( END = TRUE $) 
                    STATIC $( U = 0 $)  
                    LET SKIPZEROES() BE $( END := FALSE 
                                           WHILE I LE U DO $( IF RV I NE 0 DO   
                                                              $( NEWLINE()  
                                                                 RETURN 
                                                              $)
                                                              I := I + 1
                                                           $)   
                                           END := TRUE  
                                        $)  

                    AND PRINTLINE() BE $( WRITEF("%D5*T**%O5*T", I, I)  
                                          FOR J=1 TO 4 DO $( IF I>U BREAK   
                                          WRITEF("     %D9  **%O8", RV I, RV I) 
                                          I := I + 1
                                       $)   
                                          IF I > U DO END := TRUE   
                                       NEWLINE()
                                    $)  
                    LET O = OUTPUT  
                    LET C = CORE(6) 
                    I := N  
                    U := M  
                    IF I > U DO I, U := M, N
                    IF U > C DO U := C  
                    OUTPUT := MONITOR   
                    END := FALSE
                    WRITEF("*N*NDUMP FROM %D5 TO %D5*N*<
                              *>------------------------*N*N", I, U)
                    WRITES("   ADDRESS*T*T")
                    FOR I = 0 TO 3 DO WRITEF("            WORD N+%-         ",I)
                    WRITES("*N*N   N*T*T*T")
                    FOR I = 0 TO 3 DO WRITES("       DECIMAL      OCTAL")   
                    WRITES("*N*N")  

                    UNTIL END DO $( IF !I=0 DO $( SKIPZEROES(); IF END BREAK $) 
                                    PRINTLINE() 
                                 $) 
                    NEWLINE()   
                    OUTPUT := O 
                 $) 
.   
%#SEGMENT(%BPOINTERS)   
%#INCLUDE(%BSYSTEM) 
GET "GLOBALS"   
MANIFEST $( TRACEFLAG = -2; FUNCTIONFLAG = -1 $)
MANIFEST $( BRN = #03600000 $)  


////    PSEUDO DYNAMIC VECTORS  


LET DYVEC(N) = VALOF
   $( LET P = LV N - 2  
      LET Q, R = RV P, N + 1
      LET S = R < 16 -> 16 , R  
      LET T = P + S 
      LET V = VEC 2 
      CORE(3,V) 
      CORE(2,V!1 + S)   
      FOR I = 0 TO 16 DO T!I := P!I 
      RV 2 := T 
      $( P := P - 1; R!P := RV P $) REPEATUNTIL P = Q   
      RV T := Q + R 
      RESULTIS Q
   $)   
LET P.POINTER(X) = RV ( LV X - 2 ) & #17777777  
AND SETP.POINTER(P) BE RV(LV P - 2) := P
LET CFN(P) = VALOF  
   $( LET L,N = P!1& #77777,  P - (!P & #17777777)  
      IF N = 0 DO RESULTIS "% SYSTEM %" 
      P := (RV P & #17777777)   
      IF P = (RV P & #17777777) RESULTIS "% MASTER %"   
      FOR I = L TO SYSTEM.DATA.BLOCK!7 BY -1     // START OF PROGRAM AREA   
      DO IF [ RV I = FUNCTIONFLAG \/ RV I = TRACEFLAG ] /\ ISFN(I) /\ LIMIT(I)>L
                                                         RESULTIS I+1   
      REPORTF("CALLING FUNCTION NAME NOT FOUND: WAS PROGRAM COMPILED IN *<  
                        *>TRACE MODE?") 
      RESULTIS "?"  
   $)   
AND LIMIT(I) = VALOF                   // I POINTS TO -1 OR -2 IN FN. HEADER
                                       // RETURNS UPPER LIMIT OF FUNCTION BODY  
   $( LET J = I 
     UNLESS J!1 = RV "%%"              // SEGMENT HEADER
     DO                                // SEARCH FOR SKIP ROUND HEADER : "BRN"  
     $( J := J - 1 REPEATUNTIL ( RV J LOGAND #77700000 ) = BRN $)   
     J := J - 1 
     RESULTIS ( RV J LOGAND #77777)    // ADRESS PART OF SKIP ROUND BODY
   $)   

AND ISFN(I) = [ RV(I-1) /\ #77700000 ] = BRN \/ [ RV(I-2) /\ #77700000 ] = BRN  
****
