Google
 

Trailing-Edge - PDP-10 Archives - decus_20tap4_198111 - decus/20-0122/xcom.lst
There are 2 other files named xcom.lst in the archive. Click here to see a list.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 1
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
    1   /*                                                                              *
    2                                P D P - 1 0   X P L                                *
    3                                V E R S I O N   1                                  *
    4        A COMPILER-COMPILER FOR PROGRAMMING LANGUAGE 1.                            *
    5                                                 RICHARD L. BISBEY II              *
    6                                                 JULY 1971                         *
    7                                                                                   *
    8  VERSION 4.0        NOVEMBER 1975.                                                *
    9                                                                                   *
   10        VERION 4 OF THE COMPILER PROCESSES THE ENTIRE XPL GRAMMAR.                 *
   11                                                                                   *
   12  VERSION 3.0        NOVEMBER, 1975.                                               *
   13                                                                                   *
   14        VERSION 3.0 CONTAINS THE FOLLOWING DIFFERENCES FROM VERSION 2.0:           *
   15        RELOCATABLE BINARY CODE OUTPUT,                                            *
   16        CALL INLINE FACILITY IMPLEMENTED,                                          *
   17        UUOS USED TO CALL THE RUN-TIME ROUTINES,                                   *
   18        SOME SWITCHES CAN BE SPECIFIED FROM THE TERMINAL,                          *
   19        "COMPACTIFY" IS COMPILED FROM A SOURCE LIBRARY,                            *
   20        REDUNDANT SAVES OF PROCEDURE RESULTS IN OTHER REGISTERS IS                 *
   21           AVOIDED IN MOST INSTANCES.                                              *
   22                                                                                   *
   23        VERSION 2.0                                                                *
   24        HASH-CODED SYMBOL TABLE,                                                   *
   25        LEFT-TO-RIGHT GENERATION OF STRINGS FROM NUMBERS,                          *
   26        SPECIAL CASE CHECKS IN STRING CATENATION ROUTINE,                          *
   27        FASTER, MORE EFFICIENT PROCEDURE CALLS,                                    *
   28        GENERAL INPUT/OUTPUT, FILE, FILENAME PROCEDURES,                           *
   29        BETTER LISTING, SYMBOL DUMP FORMAT, ETC.                                   *
   30                                                                                   *
   31               R. W. HAY,                                                          *
   32               COMPUTER GROUP,                                                     *
   33               DEPT. OF ELECTRICAL ENG.,                                           *
   34               UNIVERSITY OF TORONTO,                                              *
   35               TORONTO, ONTARIO, CANADA.                                           *
   36                                                                                   *
   37                                                                                   *
   38        THE MAIN STRUCTURE OF THE PROGRAM IS AS FOLLOWS:                           *
   39              CONTENTS.                                                            *
   40              RECOGNITION TABLES FOR THE SYNTAX ANALYZER.                          *
   41              DECLARATION OF SCANNER/COMPILER VARIABLES.                           *
   42              STORAGE COMPACTIFICATION PROCEDURE.                                  *
   43              SCANNER PROCEDURES.                                                  *
   44              PARSER PROCEDURES.                                                   *
   45              CODE/DATA EMITTER PROCEDURES.                                        *
   46              SYMBOL TABLE PROCEDURES.                                             *
   47              CODE GENERATION PROCEDURES.                                          *
   48              INITIALIZATION PROCEDURE.                                            *
   49              ANALYSIS ALGORITHM.                                                  *
   50              PRODUCTION RULES.                                                    *
   51     */                                                                            *
   52                                                                                   *
   53     DECLARE VERSION LITERALLY '''4.0''';                                          *
   54                                                                                   *
   55           /*   THESE ARE LALR PARSING TABLES   */                                 *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 2
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
   56                                                                                   *
   57           DECLARE MAXR# LITERALLY '99'; /* MAX READ # */                          *
   58                                                                                   *
   59           DECLARE MAXL# LITERALLY '125'; /* MAX LOOK # */                         *
   60                                                                                   *
   61           DECLARE MAXP# LITERALLY '125'; /* MAX PUSH # */                         *
   62                                                                                   *
   63           DECLARE MAXS# LITERALLY '234'; /* MAX STATE # */                        *
   64                                                                                   *
   65           DECLARE START_STATE LITERALLY '1';                                      *
   66                                                                                   *
   67           DECLARE TERMINAL# LITERALLY '42'; /* # OF TERMINALS */                  *
   68                                                                                   *
   69           DECLARE VOCAB# LITERALLY '91';                                          *
   70                                                                                   *
   71           DECLARE VOCAB(VOCAB#) CHARACTER INITIAL ('','<','(','+','^','&','*',')' *
   72           ,';','\','-','/',',','>',':','=','^^','BY','DO','GO','IF','TO','BIT'    *
   73           ,'END','EOF','MOD','CALL','CASE','ELSE','GOTO','THEN','FIXED','LABEL'   *
   74           ,'WHILE','RETURN','DECLARE','INITIAL','<NUMBER>','<STRING>','CHARACTER' *
   75           ,'LITERALLY','PROCEDURE','<IDENTIFIER>','<TERM>','<TYPE>','<GO TO>'     *
   76           ,'<GROUP>','<ENDING>','<PRIMARY>','<PROGRAM>','<REPLACE>','<BIT HEAD>'  *
   77           ,'<CONSTANT>','<RELATION>','<VARIABLE>','<IF CLAUSE>','<LEFT PART>'     *
   78           ,'<STATEMENT>','<TRUE PART>','<ASSIGNMENT>','<BOUND HEAD>'              *
   79           ,'<EXPRESSION>','<GROUP HEAD>','<IF STATEMENT>','<INITIAL HEAD>'        *
   80           ,'<INITIAL LIST>','<WHILE CLAUSE>','<CASE SELECTOR>','<CALL STATEMENT>' *
   81           ,'<LOGICAL FACTOR>','<PARAMETER HEAD>','<PARAMETER LIST>'               *
   82           ,'<PROCEDURE HEAD>','<PROCEDURE NAME>','<STATEMENT LIST>'               *
   83           ,'<SUBSCRIPT HEAD>','<BASIC STATEMENT>','<GO TO STATEMENT>'             *
   84           ,'<IDENTIFIER LIST>','<LOGICAL PRIMARY>','<STEP DEFINITION>'            *
   85           ,'<LABEL DEFINITION>','<RETURN STATEMENT>','<TYPE DECLARATION>'         *
   86           ,'<ITERATION CONTROL>','<LOGICAL SECONDARY>','<STRING EXPRESSION>'      *
   87           ,'<DECLARATION ELEMENT>','<PROCEDURE DEFINITION>'                       *
   88           ,'<ARITHMETIC EXPRESSION>','<DECLARATION STATEMENT>'                    *
   89           ,'<IDENTIFIER SPECIFICATION>');                                         *
   90                                                                                   *
   91           DECLARE P# LITERALLY '109'; /* # OF PRODUCTIONS */                      *
   92                                                                                   *
   93           DECLARE STATE_NAME(MAXR#) BIT(8) INITIAL (0,0,1,2,3,3,4,5,6,7,9,9,10,10 *
   94           ,11,12,13,16,17,18,19,20,21,22,23,25,26,27,33,34,35,36,37,37,40,42,42   *
   95           ,42,42,42,43,43,43,43,43,44,44,45,46,50,50,51,52,53,54,54,55,56,58,59   *
   96           ,60,61,61,61,61,61,61,61,61,61,61,62,64,66,67,68,69,69,70,71,72,73,74   *
   97           ,74,75,76,77,78,80,81,81,82,83,86,86,88,89,89,90,91);                   *
   98                                                                                   *
   99           DECLARE RSIZE LITERALLY '337'; /*  READ STATES INFO  */                 *
  100                                                                                   *
  101           DECLARE LSIZE LITERALLY '69'; /* LOOK AHEAD STATES INFO */              *
  102                                                                                   *
  103           DECLARE ASIZE LITERALLY '105'; /* APPLY PRODUCTION STATES INFO */       *
  104                                                                                   *
  105           DECLARE READ1(RSIZE) BIT(8) INITIAL (0,8,18,19,20,26,29,34,35,42,15,2,3 *
  106           ,9,10,37,38,42,2,37,38,42,2,37,38,42,2,3,9,10,37,38,42,2,3,9,10,37,38   *
  107           ,42,2,37,38,42,22,31,32,39,2,3,10,37,38,42,1,13,15,2,37,38,42,2,37,38   *
  108           ,42,2,37,38,42,2,42,15,2,3,10,37,38,42,2,3,9,10,37,38,42,8,27,33,42,21  *
  109           ,2,3,9,10,37,38,42,2,3,9,10,37,38,42,2,42,2,37,38,42,42,2,3,9,10,37,38  *
  110           ,42,2,3,9,10,37,38,42,2,3,9,10,37,38,42,2,42,2,7,7,38,2,14,2,40,7,12,7  *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 3
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  111           ,12,6,11,25,6,11,25,6,11,25,6,11,25,6,11,25,8,8,42,8,2,3,9,10,37,38,42  *
  112           ,2,3,9,10,37,38,42,37,7,12,2,3,10,37,38,42,12,15,15,8,18,19,20,26,29,34 *
  113           ,35,42,42,8,18,19,20,26,29,34,35,42,8,37,4,30,4,4,7,12,4,4,4,7,4,4,21,4 *
  114           ,17,4,8,18,19,20,23,26,29,34,35,42,37,38,8,8,8,5,5,42,8,22,31,32,39,8   *
  115           ,18,19,20,26,29,34,35,42,2,8,22,31,32,39,8,18,19,20,24,26,29,34,35,42,8 *
  116           ,18,19,20,23,26,29,34,35,42,2,3,9,10,37,38,42,28,8,42,8,8,18,19,20,26   *
  117           ,29,34,35,41,42,8,18,19,20,23,26,29,34,35,41,42,8,36,1,9,13,15,16,16,8  *
  118           ,3,10,3,10,8,12,2,22,31,32,39);                                         *
  119                                                                                   *
  120           DECLARE LOOK1(LSIZE) BIT(8) INITIAL (0,15,0,15,0,42,0,8,0,2,14,0,2,0,40 *
  121           ,0,6,11,25,0,6,11,25,0,6,11,25,0,6,11,25,0,6,11,25,0,4,0,4,0,4,0,4,0,8  *
  122           ,0,4,0,5,0,5,0,28,0,36,0,1,9,13,15,16,0,16,0,3,10,0,3,10,0);            *
  123                                                                                   *
  124           /*  PUSH STATES ARE BUILT-IN TO THE INDEX TABLES  */                    *
  125                                                                                   *
  126           DECLARE APPLY1(ASIZE) BIT(8) INITIAL (0,0,80,0,56,58,71,82,83,0,56,89   *
  127           ,90,0,89,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,83,90,0,71,83,90,0,0,0,0,0,0,15 *
  128           ,0,0,9,79,99,0,0,0,0,0,0,0,57,0,55,0,0,3,18,22,27,28,29,49,50,84,0,6,0  *
  129           ,7,0,10,0,0,53,0,17,0,4,5,12,13,0,8,14,25,0,1,19,26,56,57,58,71,80,82   *
  130           ,83,89,90,0,0,72,0);                                                    *
  131                                                                                   *
  132           DECLARE READ2(RSIZE) BIT(8) INITIAL (0,138,19,20,21,26,174,103,30,104   *
  133           ,213,3,4,10,12,234,233,105,3,234,233,105,3,234,233,105,3,4,10,12,234    *
  134           ,233,105,3,4,10,12,234,233,105,3,234,233,105,23,182,184,183,3,4,12,234  *
  135           ,233,105,211,212,210,3,234,233,105,3,234,233,105,3,234,233,105,190,106  *
  136           ,214,3,4,12,234,233,105,3,4,10,12,234,233,105,146,27,28,105,173,3,4,10  *
  137           ,12,234,233,105,3,4,10,12,234,233,105,186,166,3,234,233,105,105,3,4,10  *
  138           ,12,234,233,105,3,4,10,12,234,233,105,3,4,10,12,234,233,105,190,106,193 *
  139           ,9,185,178,231,168,231,34,189,191,162,164,8,14,25,8,14,25,8,14,25,8,14  *
  140           ,25,8,14,25,158,160,172,132,3,4,10,12,234,233,105,3,4,10,12,234,233,105 *
  141           ,33,192,194,3,4,12,234,233,105,198,197,197,138,19,20,21,26,174,103,30   *
  142           ,104,105,138,19,20,21,26,174,103,30,104,131,32,6,143,6,6,230,232,6,6,6  *
  143           ,228,6,6,22,6,18,6,138,19,20,21,102,26,174,103,30,104,234,233,148,149   *
  144           ,135,7,7,39,159,23,182,184,183,138,19,20,21,26,174,103,30,104,163,157   *
  145           ,23,182,184,183,138,19,20,21,126,26,174,103,30,104,138,19,20,21,102,26  *
  146           ,174,103,30,104,3,4,10,12,234,233,105,144,136,38,147,138,19,20,21,26    *
  147           ,174,103,30,161,104,138,19,20,21,102,26,174,103,30,161,104,134,31,100   *
  148           ,11,101,207,17,17,133,5,13,5,13,137,15,187,23,182,184,183);             *
  149                                                                                   *
  150           DECLARE LOOK2(LSIZE) BIT(8) INITIAL (0,2,208,16,209,24,165,169,29,35,35 *
  151           ,229,36,229,37,188,40,40,40,217,41,41,41,220,42,42,42,221,43,43,43,218  *
  152           ,44,44,44,219,62,170,64,155,65,154,67,195,152,69,70,153,76,199,77,200   *
  153           ,85,129,92,177,93,93,93,93,93,205,94,206,96,96,215,97,97,216);          *
  154                                                                                   *
  155           DECLARE APPLY2(ASIZE) BIT(8) INITIAL (0,0,83,82,140,141,150,128,128,127 *
  156           ,120,139,139,129,142,142,130,56,58,48,71,88,151,73,74,95,80,81,79,78    *
  157           ,156,167,145,90,90,90,89,91,75,86,47,98,176,175,121,180,46,179,45,51,60 *
  158           ,99,87,181,72,196,59,50,49,57,66,117,116,113,114,112,115,68,63,61,119   *
  159           ,118,202,201,204,203,53,123,122,125,124,108,110,109,111,107,223,224,225 *
  160           ,222,54,55,171,54,54,54,54,54,54,54,54,54,227,84,52,226);               *
  161                                                                                   *
  162           DECLARE INDEX1(MAXS#) BIT(16) INITIAL (0,1,10,11,18,22,26,33,40,44,48   *
  163           ,54,57,61,65,69,71,72,78,85,89,90,97,104,105,106,110,111,118,125,132    *
  164           ,134,135,136,137,138,140,141,142,144,146,149,152,155,158,161,162,163    *
  165           ,164,165,172,179,180,182,188,190,191,200,201,210,211,212,214,215,218    *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 4
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  166           ,219,220,222,223,225,227,228,238,240,241,242,243,244,245,246,251,260    *
  167           ,266,276,286,293,294,295,296,297,307,318,319,320,325,326,327,329,331    *
  168           ,333,1,3,5,7,9,12,14,16,20,24,28,32,36,38,40,42,44,46,48,50,52,54,56,62 *
  169           ,64,67,1,2,2,4,4,10,10,10,10,10,10,10,10,10,14,14,14,17,18,19,20,20,20  *
  170           ,20,20,21,22,22,23,24,25,26,26,26,26,27,28,29,29,30,30,30,33,37,37,38   *
  171           ,39,40,40,41,41,42,42,44,44,44,45,45,45,45,49,50,51,51,52,52,53,54,54   *
  172           ,55,55,57,59,60,60,70,70,72,72,74,74,76,76,76,76,76,76,76,76,77,77,79   *
  173           ,79,79,79,79,81,81,81,81,86,86,86,90,90,103,103,104,104);               *
  174                                                                                   *
  175           DECLARE INDEX2(MAXS#) BIT(8) INITIAL (0,9,1,7,4,4,7,7,4,4,6,3,4,4,4,2,1 *
  176           ,6,7,4,1,7,7,1,1,4,1,7,7,7,2,1,1,1,1,2,1,1,2,2,3,3,3,3,3,1,1,1,1,7,7,1  *
  177           ,2,6,2,1,9,1,9,1,1,2,1,3,1,1,2,1,2,2,1,10,2,1,1,1,1,1,1,5,9,6,10,10,7,1 *
  178           ,1,1,1,10,11,1,1,5,1,1,2,2,2,5,2,2,2,2,3,2,2,4,4,4,4,4,2,2,2,2,2,2,2,2  *
  179           ,2,2,6,2,3,3,1,0,1,0,0,1,1,1,1,1,1,1,0,1,1,2,1,2,1,1,1,2,2,2,1,3,1,3,1  *
  180           ,1,2,1,2,2,3,1,2,0,2,0,1,1,1,0,1,1,1,1,0,1,2,0,2,1,3,1,0,0,0,2,1,1,0,2  *
  181           ,0,2,2,1,2,2,1,0,1,0,2,0,2,0,1,0,2,0,0,0,1,1,1,1,1,0,2,0,2,2,1,1,0,2,2  *
  182           ,2,0,0,2,0,2,1,2,0,0);                                                  *
  183                                                                                   *
  184                                                                                   *
  185     /*  DECLARATIONS FOR THE SCANNER                                        */    *
  186     /* TOKEN IS THE INDEX INTO THE VOCABULARY V() OF THE LAST SYMBOL SCANNED,     *
  187        CP IS THE POINTER TO THE LAST CHARACTER SCANNED IN THE CARDIMAGE,          *
  188        BCD IS THE LAST SYMBOL SCANNED (LITERAL CHARACTER STRING). */              *
  189                                                                                   *
  190     DECLARE TOKEN FIXED, BCD CHARACTER, CH FIXED, CP FIXED;                       *
  191                                                                                   *
  192     /* SET UP SOME CONVENIENT ABBREVIATIONS FOR PRINTER CONTROL */                *
  193                                                                                   *
  194     DECLARE TRUE LITERALLY '"1"', FALSE LITERALLY '"0"',                          *
  195        FOREVER LITERALLY 'WHILE TRUE',                                            *
  196        X70 CHARACTER INITIAL ('                                                   *
  197                                ');                                                *
  198     DECLARE POINTER CHARACTER INITIAL    ('                                       *
  199                                                             ^');                  *
  200     /* LENGTH OF LONGEST SYMBOL IN V */                                           *
  201     DECLARE RESERVED_LIMIT FIXED;                                                 *
  202                                                                                   *
  203     /* CHARTYPE() IS USED TO DISTINGUISH CLASSES OF SYMBOLS IN THE SCANNER.       *
  204        TX() IS A TABLE USED FOR TRANSLATING FROM ONE CHARACTER SET TO ANOTHER.    *
  205        CONTROL() HOLDS THE VALUE OF THE COMPILER CONTROL TOGGLES SET IN $ CARDS.  *
  206        NOT_LETTER_OR_DIGIT() IS SIMILIAR TO CHARTYPE() BUT USED IN SCANNING       *
  207        IDENTIFIERS ONLY.                                                          *
  208                                                                                   *
  209        ALL ARE USED BY THE SCANNER AND CONTROL() IS SET THERE.                    *
  210     */                                                                            *
  211     DECLARE CHARTYPE(255) BIT(8), TX(255) BIT(8), CONTROL(255) BIT(1),            *
  212        NOT_LETTER_OR_DIGIT(255) BIT(1);                                           *
  213     /* BUFFER HOLDS THE LATEST CARDIMAGE,                                         *
  214        TEXT HOLDS THE PRESENT STATE OF THE INPUT TEXT                             *
  215        (NOT INCLUDING THE PORTIONS DELETED BY THE SCANNER),                       *
  216        TEXT_LIMIT IS A CONVENIENT PLACE TO STORE THE POINTER TO THE END OF TEXT,  *
  217        CARD_COUNT IS INCREMENTED BY ONE FOR EVERY SOURCE CARD READ,               *
  218        ERROR_COUNT TABULATES THE ERRORS AS THEY ARE DETECTED,                     *
  219        SEVERE_ERRORS TABULATES THOSE ERRORS OF FATAL SIGNIFICANCE.                *
  220        CURRENT_PROCEDURE CONTAINS THE NAME OF THE PROCEDURE BEING PROCESSED.      *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 5
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  221     */                                                                            *
  222     DECLARE BUFFER CHARACTER, TEXT CHARACTER, TEXT_LIMIT FIXED,                   *
  223         CARD_COUNT FIXED, ERROR_COUNT FIXED,                                      *
  224         SEVERE_ERRORS FIXED, PREVIOUS_ERROR FIXED,                                *
  225         LINE_LENGTH  FIXED,         /* LENGTH OF SOURCE STATEMENT */              *
  226         CURRENT_PROCEDURE CHARACTER;                                              *
  227                                                                                   *
  228     /* NUMBER_VALUE CONTAINS THE NUMERIC VALUE OF THE LAST CONSTANT SCANNED,      *
  229     */                                                                            *
  230     DECLARE NUMBER_VALUE FIXED, JBASE FIXED, BASE FIXED;                          *
  231     /* EACH OF THE FOLLOWING CONTAINS THE INDEX INTO V() OF THE CORRESPONDING     *
  232        SYMBOL.   WE ASK:    IF TOKEN = IDENT    ETC.    */                        *
  233     DECLARE IDENT FIXED, STRING FIXED, NUMBER FIXED, DIVIDE FIXED, EOFILE FIXED,  *
  234        LABELSET FIXED;                                                            *
  235     DECLARE ORSYMBOL FIXED, CONCATENATE FIXED;                                    *
  236     DECLARE BALANCE CHARACTER, LB FIXED ;                                         *
  237     DECLARE MACRO_LIMIT LITERALLY '60', MACRO_NAME (MACRO_LIMIT) CHARACTER,       *
  238        MACRO_TEXT(MACRO_LIMIT) CHARACTER, MACRO_INDEX (255) BIT (8),              *
  239        MACRO_COUNT (MACRO_LIMIT) FIXED, MACRO_DECLARE (MACRO_LIMIT) FIXED,        *
  240        TOP_MACRO FIXED;                                                           *
  241     DECLARE EXPANSION_COUNT FIXED, EXPANSION_LIMIT LITERALLY '300';               *
  242     /* STOPIT() IS A TABLE OF SYMBOLS WHICH ARE ALLOWED TO TERMINATE THE ERROR    *
  243        FLUSH PROCESS.  IN GENERAL THEY ARE SYMBOLS OF SUFFICIENT SYNTACTIC        *
  244        HIERARCHY THAT WE EXPECT TO AVOID ATTEMPTING TO START CHECKING AGAIN       *
  245        RIGHT INTO ANOTHER ERROR PRODUCING SITUATION.  THE TOKEN STACK IS ALSO     *
  246        FLUSHED DOWN TO SOMETHING ACCEPTABLE TO A STOPIT() SYMBOL.                 *
  247        FAILSOFT IS A BIT WHICH ALLOWS THE COMPILER ONE ATTEMPT AT A GENTLE        *
  248        RECOVERY.   THEN IT TAKES A STRONG HAND.   WHEN THERE IS REAL TROUBLE      *
  249        COMPILING IS SET TO FALSE, THEREBY TERMINATING THE COMPILATION.            *
  250     */                                                                            *
  251     DECLARE STOPIT(TERMINAL#) BIT(1), FAILSOFT FIXED, COMPILING FIXED;            *
  252     /*   THE FOLLOWING SWITCH IS USED BY THE LALR PARSER   */                     *
  253                                                                                   *
  254     DECLARE NO_LOOK_AHEAD_DONE BIT(1);                                            *
  255     DECLARE TARGET_REGISTER FIXED;       /* FOR FINDAR */                         *
  256     DECLARE TRUELOC FIXED;               /* LOCATION OF CONSTANT 1 */             *
  257     DECLARE FALSELOC FIXED;              /* LOCATION OF CONSTANT 0 */             *
  258     DECLARE BYTEPTRS FIXED,              /* LOCATION OF 4 PTRS FOR LDB & DPB */   *
  259             PSBITS FIXED;                /* BYTE PTRS FORE MOVE */                *
  260     DECLARE STRING_CHECK FIXED,          /* COMPACTIFY CALLER */                  *
  261             CATENTRY FIXED,              /* CATENATION SUBROUTINE */              *
  262             NMBRENTRY FIXED,             /* NUMBER TO STRING SUBROUTINE */        *
  263             STRCOMP FIXED,               /* STRING COMPARE SUBROUTINE */          *
  264             CALLTYPE FIXED INITIAL (1),  /* DIST BETWEEN SUB & FUNCTION */        *
  265             MOVER FIXED,                 /* STRING MOVE SUBROUTINE */             *
  266             STRING_RECOVER FIXED,        /* SYT LOCATION OF COMPACTIFY */         *
  267             COREBYTELOC FIXED,           /* SYT LOCATION OF COREBYTE */           *
  268             LIMITWORD FIXED,             /* ADDRESS OF FREELIMIT */               *
  269             TSA FIXED;                   /* ADDRESS OF FREEPOINT */               *
  270     DECLARE NDESC FIXED;                 /* ADDRESS OF NDESCRIPT               */ *
  271     DECLARE LIBRARY FIXED,               /* ADDRESS OF RUNTIME LIBRARY */         *
  272             LIBRARY_SAVE FIXED,          /* PLACE TO STORE R11 ON LIB CALLS */    *
  273             STR  FIXED;                  /* DESCRIPTOR OF LAST STRING */          *
  274     DECLARE STEPK FIXED;                 /* USED FOR DO LOOPS */                  *
  275     DECLARE A FIXED, B FIXED, C FIXED;   /* FOR CATENATION & CONVERSION */        *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 6
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  276     DECLARE LENGTHMASK FIXED;            /* ADDR OF DV LENGTH MASK */             *
  277     DECLARE ADDRMASK FIXED;              /* ADDRESS OF "FFFFF" */                 *
  278     DECLARE LABEL_SINK FIXED INITIAL(0); /* FOR LABEL GENERATOR */                *
  279     DECLARE LABEL_GEN CHARACTER;         /* CONTAINS LABEL FOR NEXT INST*/        *
  280     DECLARE ACC(15) FIXED;               /* KEEPS TRACK OF ACCUMULATORS */        *
  281     DECLARE AVAIL LITERALLY '0', BUSY LITERALLY '1';                              *
  282      /* CALL COUNTS OF IMPORTANT PROCEDURES */                                    *
  283     DECLARE COUNT_SCAN FIXED, /* SCAN               */                            *
  284              COUNT_INST FIXED,  /* EMITINST           */                          *
  285              COUNT_FORCE FIXED, /* FORCEACCUMULATOR   */                          *
  286              COUNT_ARITH FIXED, /* ARITHEMIT          */                          *
  287              COUNT_STORE FIXED; /* GENSTORE           */                          *
  288                                                                                   *
  289     DECLARE TITLE        CHARACTER,     /*TITLE LINE FOR LISTING */               *
  290             SUBTITLE     CHARACTER,     /*SUBTITLE FOR LISTING */                 *
  291             PAGE_COUNT   FIXED,         /*CURRENT PAGE NUMBER FOR LISTING*/       *
  292             LINE_COUNT   FIXED,         /*NUMBER OF LINES PRINTED */              *
  293             PAGE_MAX LITERALLY '54',    /*MAX NO OF LINES ON PAGE*/               *
  294             EJECT_PAGE LITERALLY 'LINE_COUNT = PAGE_MAX+1';                       *
  295     DECLARE SOURCE CHARACTER;           /*FILE NAME BEING COMPILED*/              *
  296     DECLARE DATAFILE LITERALLY '2';     /* SCRATCH FILE FOR DATA */               *
  297     DECLARE CODEFILE LITERALLY '3';     /* SCRATCH FILE FOR CODE */               *
  298     DECLARE RELFILE  LITERALLY '4';     /* BINARY OUTPUT FILE */                  *
  299     DECLARE LIBFILE  LITERALLY '5';     /* SOURCE LIBRARY FILE */                 *
  300     DECLARE READING  BIT(1);            /* 0 IFF READING LIBFILE */               *
  301     DECLARE DATACARD CHARACTER;         /* DATA BUFFER */                         *
  302     DECLARE PP      FIXED,              /* CURRENT PROGRAM POINTER */             *
  303             CODE(3) CHARACTER,           /* THE CODE BUFFER */                    *
  304             CODE_FULL(3) BIT(1),         /* FULLNESS FLAG */                      *
  305             CODE_HEAD FIXED,             /* FRONT OF BUFFER */                    *
  306             CODE_TAIL FIXED,             /* END OF BUFFER */                      *
  307             DP      FIXED,              /* CURRENT DATA POINTER */                *
  308             DPOFFSET FIXED;             /* CURRENT DP BYTE OFFSET */              *
  309     DECLARE CODESTRING CHARACTER;     /*FOR COPYING CODE INTO DATA FILE*/         *
  310                                                                                   *
  311     /*   THE FOLLOWING ARE FOR RELOCATABLE BINARY CODE EMISSION */                *
  312                                                                                   *
  313     DECLARE BUFFERSIZE LITERALLY '18';   /* SIZE OF BINARY BUFFERS */             *
  314     DECLARE CODE_BUFFER (BUFFERSIZE) FIXED;   /*CODE (HIGH) BUFFER */             *
  315     DECLARE DATA_BUFFER (BUFFERSIZE) FIXED;   /* DATA (LOW) BUFFER */             *
  316     DECLARE LABEL_BUFFER (BUFFERSIZE) FIXED;  /* LABELS DEFINED BUFFER */         *
  317     DECLARE CODE_REL(3) FIXED,         /* BINARY CODE BUFFER (SEE CODE) */        *
  318             CODE_PP(3) FIXED,                                                     *
  319             CODE_RBITS(3) FIXED;                                                  *
  320                                                                                   *
  321     DECLARE RPTR FIXED,                  /* POINTER TO CODE_BUFFER */             *
  322             RCTR FIXED,                  /* COUNTER FOR CODE_BUFFER */            *
  323             DPTR FIXED,                   /* POINTER TO DATA_BUFFER */            *
  324             DCTR FIXED,                  /* COUNTER FOR DATA_BUFFER */            *
  325             DLOC FIXED;                   /* LOCATION OF NEXT WORD IN DATA BUFFER */*
  326     DECLARE LABEL_COUNT FIXED;            /*NO OF LABELS IN LABEL_BUFFER */       *
  327                                                                                   *
  328     DECLARE FOR_MAX  LITERALLY '50';      /* MAXIMUM FORWARD REFERENCES */        *
  329     DECLARE FOR_REF   (FOR_MAX) FIXED,    /* FORWARD REFERENCED LABELS */         *
  330             FOR_LABEL (FOR_MAX) FIXED,    /* LABEL REFERENCED */                  *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 7
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  331             FOR_COUNT FIXED;              /* COUNT OF CURRENT FORWARD REFS */     *
  332     DECLARE PWORD FIXED;                  /* PART-WORD ACC. FOR BYTES*/           *
  333     DECLARE STARTLOC FIXED;               /* FIRST INSTRUCTION TO BE EXECUTED */  *
  334                                                                                   *
  335                                                                                   *
  336     DECLARE CODE_TYPE LITERALLY '"(3)1000000"';   /* CODE & DATA TYPE BLOCK */    *
  337     DECLARE SYMB_TYPE LITERALLY '"(3)2000000"';   /* SYMBOL DEFN TYPE BLOCK */    *
  338     DECLARE HISEG_TYPE LITERALLY '"(3)3000000"';  /* HIGH SEGMENT TYPE BLOCK */   *
  339     DECLARE END_TYPE LITERALLY '"(3)5000000"';    /* END TYPE BLOCK */            *
  340     DECLARE NAME_TYPE LITERALLY '"(3)6000000"';   /* NAME TYPE BLOCK */           *
  341     DECLARE START_TYPE LITERALLY '"(3)7000000"';  /* START ADDRESS TYPE BLOCK */  *
  342     DECLARE INTREQ_TYPE LITERALLY '"(3)10000000"'; /* INTERNAL REQUEST TYPE BLOCK */*
  343                                                                                   *
  344                                                                                   *
  345     /* END OF DEFINITIONS FOR RELOCATABLE BINARY FILES */                         *
  346                                                                                   *
  347     DECLARE ADR     FIXED;                                                        *
  348     DECLARE ITYPE FIXED;                                                          *
  349     DECLARE NEWDP FIXED, NEWDSP FIXED, NEWDPOFFSET FIXED; /* FOR ALLOCATION */    *
  350     DECLARE OLDDP FIXED, OLDDSP FIXED, OLDDPOFFSET FIXED; /* FOR ALLOCATION */    *
  351     DECLARE DESCLIMIT LITERALLY '1000', /* NUMBER OF STRING DESCRIPTORS */        *
  352             DESCA (DESCLIMIT) FIXED,     /* STRING DESCRIPTOR ADDRESS */          *
  353             DESCL (DESCLIMIT) FIXED,     /* STRING DESCRIPTOR LENGTH */           *
  354             DESCREF (DESCLIMIT) FIXED,    /* LAST REFERENCE TO STRING */          *
  355             DSP     FIXED;              /* DESCRIPTOR POINTER */                  *
  356     DECLARE S CHARACTER;                                                          *
  357     DECLARE OPNAME (15) CHARACTER INITIAL (                                       *
  358  '      .INIT..INPT..OUTP..EXIT.      .FILI..FILO..NAME.',                        *
  359  'CALL  INIT  UUO042UUO043UUO044UUO045UUO046CALLI OPEN  TTCALLUUO052UUO053UUO054  *
  360  RENAMEIN    OUT   SETSTSSTATO GETSTSSTATZ INBUF OUTBUFINPUT OUTPUTCLOSE          *
  361  RELEASMTAPE UGETF USETI USETO LOOKUPENTER ',                                     *
  362  'UUO100UUO101UUO102UUO103UUO104UUO105UUO106UUO107UUO110UUO111UUO112UUO113UUO114U *
  363  UO115UUO116UUO117UUO120UUO121UUO122UUO123UUO124UUO125UUO126UUO127UFA   DFN   FSC *
  364     IBP   ILDB  LDB   IDPB  DPB   ',                                              *
  365  '',                                                                              *
  366  'MOVE  MOVEI MOVEM MOVES MOVS  MOVSI MOVSM MOVSS MOVN  MOVNI MOVNM MOVNS MOVM  M *
  367  OVMI MOVMM MOVMS IMUL  IMULI IMULM IMULB MUL   MULI  MULM  MULB  IDIV  IDIVI IDI *
  368  VM IDIVB DIV   DIVI  DIVM  DIVB  ',                                              *
  369  'ASH   ROT   LSH   JFFO  ASHC  ROTC  LSHC  ......EXCH  BLT   AOBJP AOBJN JRST  J *
  370  FCL  XCT   ......PUSHJ PUSH  POP   POPJ  JSR   JSP   JSA   JRA   ADD   ADDI  ADD *
  371  M  ADDB  SUB   SUBI  SUBM  SUBB  ',                                              *
  372  'CAI   CAIL  CAIE  CAILE CAIA  CAIGE CAIN  CAIG  CAM   CAML  CAME  CAMLE CAMA  C *
  373  AMGE CAMN  CAMG  JUMP  JUMPL JUMPE JUMPLEJUMPA JUMPGEJUMPN JUMPG SKIP  SKIPL SKI *
  374  PE SKIPLESKIPA SKIPGESKIPN SKIPG ',                                              *
  375   'AOJ   AOJL  AOJE  AOJLE AOJA  AOJGE AOJN  AOJG  AOS   AOSL  AOSE  AOSLE AOSA  A*
  376  OSGE AOSN  AOSG  SOJ   SOJL  SOJE  SOJLE SOJA  SOJGE SOJN  SOJG  SOS   SOSL  SOS *
  377  E  SOSLE SOSA  SOSGE SOSN  SOSG  ',                                              *
  378  'SETZ  SETZI SETZM SETZB AND   ANDI  ANMD  ANDB  ANDCA ANDCAIANDCAMANDCABSETM  S *
  379  ETMI SETMM SETMB ANDCM ANDCMIANDCMMANDCMBSETA  SETAI SETAM SETAB XOR   XORI  XOR *
  380  M  XORB  IOR   IORI  IORM  IORB  ',                                              *
  381  'ANDCB ANDCBIANDCBMANDCBBEQV   EQVI  EQVM  EQVB  SETCA SETCAISETCAMSETCABORCA  O *
  382  RCAI ORCAM ORCAB SETCM SETCMISETCMMSETCMBORCM  ORCMI ORCMM ORCMB ORCB  ORCBI ORC *
  383  BM ORCBB SETO  SETOI SETOM SETOB ',                                              *
  384  'HLL   HLLI  HLLM  HLLS  HRL   HRLI  HRLM  HRLS  HLLZ  HLLZI HLLZM HLLZS HRLZ  H *
  385  RLZI HRLZM HRLZS HLLO  HLLOI HLLOM HLLOS HRLO  HRLOI HRLOM HRLOS HLLE  HLLEI HLL *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 8
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  386  EM HLLES HRLE  HRLEI HRLEM HRLES ',                                              *
  387  'HRR   HRRI  HRRM  HRRS  HLR   HLRI  HLRM  HLRS  HRRZ  HRRZI HRRZM HRRZS HLRZ  H *
  388  LRZI HLRZM HLRZS HRRO  HRROI HRROM HRROS HLRO  HLROI HLROM HLROS HRRE  HRREI HRR *
  389  EM HRRES HLRE  HLREI HLREM HLRES ',                                              *
  390  'TRN   TLN   TRNE  TLNE  TRNA  TLNA  TRNN  TLNN  TDN   TSN   TDNE  TSNE  TDNA  T *
  391  SNA  TDNN  TSNN  TRZ   TLZ   TRZE  TLZE  TRZA  TLZA  TRZN  TLZN  TDZ   TSZ   TDZ *
  392  E  TSZE  TDZA  TSZA  TDZN  TSZN  ',                                              *
  393  'TRC   TLC   TRCE  TLCE  TRCA  TLCA  TRCN  TLCN  TDC   TSC   TDCE  TSCE  TDCA  T *
  394  SCA  TDCN  TSCN  TRO   TLO   TROE  TLOE  TROA  TLOA  TRON  TLON  TDO   TSO   TDO *
  395  E  TSOE  TDOA  TSOA  TDON  TSON  ',                                              *
  396  '',                                                                              *
  397  '');                                                                             *
  398     DECLARE INSTRUCT(511) FIXED;         /* COUNT OF THE INSTRUCTIONS ISSUED */   *
  399           /* COMMONLY USED OPCODES */                                             *
  400     DECLARE ADD    FIXED INITIAL ("(3)270"),                                      *
  401             ADDI   FIXED INITIAL ("(3)271"),                                      *
  402             ADDM   FIXED INITIAL ("(3)272"),                                      *
  403             AND    FIXED INITIAL ("(3)404"),                                      *
  404             ANDI   FIXED INITIAL ("(3)405"),                                      *
  405             AOSA   FIXED INITIAL ("(3)354"),                                      *
  406             BLT    FIXED INITIAL ("(3)251"),                                      *
  407             CALLI  FIXED INITIAL ("(3)047"),                                      *
  408             CAM    FIXED INITIAL ("(3)310"),                                      *
  409             CAMGE  FIXED INITIAL ("(3)315"),                                      *
  410             CAML   FIXED INITIAL ("(3)311"),                                      *
  411             CAMLE  FIXED INITIAL ("(3)313"),                                      *
  412             CAMN   FIXED INITIAL ("(3)316"),                                      *
  413             CMPRHI FIXED INITIAL ("(3)317"),                                      *
  414             DPB    FIXED INITIAL ("(3)137"),                                      *
  415             HLL    FIXED INITIAL ("(3)500"),                                      *
  416             HLRZ   FIXED INITIAL ("(3)554"),                                      *
  417             HRLI   FIXED INITIAL ("(3)505"),                                      *
  418             HRLM   FIXED INITIAL ("(3)506"),                                      *
  419             HRREI  FIXED INITIAL ("(3)571"),                                      *
  420             IDIV   FIXED INITIAL ("(3)230"),                                      *
  421             IDIVI  FIXED INITIAL ("(3)231"),                                      *
  422             IDPB   FIXED INITIAL ("(3)136"),                                      *
  423             ILDB   FIXED INITIAL ("(3)134"),                                      *
  424             IMUL   FIXED INITIAL ("(3)220"),                                      *
  425             IOR    FIXED INITIAL ("(3)434"),                                      *
  426             JRST   FIXED INITIAL ("(3)254"),                                      *
  427             JUMP   FIXED INITIAL ("(3)320"),                                      *
  428             JUMPE  FIXED INITIAL ("(3)322"),                                      *
  429             JUMPGE FIXED INITIAL ("(3)325"),                                      *
  430             JUMPN  FIXED INITIAL ("(3)326"),                                      *
  431             LDB    FIXED INITIAL ("(3)135"),                                      *
  432             LSH    FIXED INITIAL ("(3)242"),                                      *
  433             LSHC   FIXED INITIAL ("(3)246"),                                      *
  434             MOVE   FIXED INITIAL ("(3)200"),                                      *
  435             MOVEI  FIXED INITIAL ("(3)201"),                                      *
  436             MOVEM  FIXED INITIAL ("(3)202"),                                      *
  437             MOVM   FIXED INITIAL ("(3)214"),                                      *
  438             MOVN   FIXED INITIAL ("(3)210"),                                      *
  439             POP    FIXED INITIAL ("(3)262"),                                      *
  440             POPJ   FIXED INITIAL ("(3)263"),                                      *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 9
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  441             PUSH   FIXED INITIAL ("(3)261"),                                      *
  442             PUSHJ  FIXED INITIAL ("(3)260"),                                      *
  443             ROT    FIXED INITIAL ("(3)241"),                                      *
  444             SETCA  FIXED INITIAL ("(3)450"),                                      *
  445             SETZM  FIXED INITIAL ("(3)402"),                                      *
  446             SKIP   FIXED INITIAL ("(3)330"),                                      *
  447             SKIPE  FIXED INITIAL ("(3)332"),                                      *
  448             SOJG   FIXED INITIAL ("(3)367"),                                      *
  449             SUB    FIXED INITIAL ("(3)274"),                                      *
  450             SUBI   FIXED INITIAL ("(3)275");                                      *
  451     DECLARE COMPARESWAP (7) FIXED INITIAL (0,7,2,5,0,3,6,1);                      *
  452     DECLARE STILLCOND FIXED,            /* PEEP HOLE FOR BOOL BRANCHING */        *
  453             STILLINZERO FIXED;          /* PEEPHOLE FOR REDUNDANT MOVES */        *
  454     DECLARE STATEMENT_COUNT FIXED;      /* A COUNT OF THE XPL STATEMENTS */       *
  455     DECLARE IDCOMPARES FIXED;                                                     *
  456     DECLARE X1 CHARACTER INITIAL (' ');                                           *
  457     DECLARE X2 CHARACTER INITIAL ('  ');                                          *
  458     DECLARE X3 CHARACTER INITIAL ('   ');                                         *
  459     DECLARE X4 CHARACTER INITIAL ('    ');                                        *
  460     DECLARE X7 CHARACTER INITIAL ('       ');                                     *
  461     DECLARE INFO CHARACTER;         /* FOR LISTING INFORMATION*/                  *
  462     DECLARE CHAR_TEMP CHARACTER;                                                  *
  463     DECLARE I_STRING CHARACTER;      /* FOR I_FORMAT */                           *
  464     DECLARE I FIXED, J FIXED, K FIXED, L FIXED;                                   *
  465     DECLARE PROCMARK FIXED, NDECSY FIXED, MAXNDECSY FIXED, PARCT FIXED;           *
  466     DECLARE RETURNED_TYPE FIXED;                                                  *
  467     DECLARE LABELTYPE     LITERALLY  '1',                                         *
  468             ACCUMULATOR   LITERALLY  '2',                                         *
  469             VARIABLE      LITERALLY  '3',                                         *
  470             CONSTANT      LITERALLY  '4',                                         *
  471             CHRTYPE       LITERALLY  '6',                                         *
  472             FIXEDTYPE     LITERALLY  '7',                                         *
  473             BYTETYPE      LITERALLY  '8',                                         *
  474             FORWARDTYPE   LITERALLY  '9',                                         *
  475             DESCRIPT      LITERALLY '10',                                         *
  476             SPECIAL       LITERALLY '11',                                         *
  477             FORWARDCALL   LITERALLY '12',                                         *
  478             PROCTYPE      LITERALLY '13',                                         *
  479             CHARPROCTYPE  LITERALLY '14';                                         *
  480     DECLARE TYPENAME (14) CHARACTER INITIAL ('', 'LABEL    ', '', '', '', '',     *
  481             'CHARACTER', 'FIXED    ', 'BIT (9)  ' , '', '', '', '',               *
  482             'PROCEDURE','CHARACTER PROCEDURE');                                   *
  483     /*  THE SYMBOL TABLE IS INITIALIZED WITH THE NAMES OF ALL                     *
  484         BUILTIN FUNCTIONS AND PSEUDO VARIABLES.  THE PROCEDURE                    *
  485         INITIALIZE DEPENDS ON THE ORDER AND PLACEMENT OF THESE                    *
  486         NAMES.  CHANGES SHOULD BE MADE OBSERVING DUE CAUTION TO                   *
  487         AVOID MESSING THINGS UP.                                                  *
  488     */                                                                            *
  489     DECLARE SYTSIZE LITERALLY '420';     /* THE SYMBOL TABLE SIZE */              *
  490     DECLARE SYT (SYTSIZE) CHARACTER      /* THE VARIABLE NAME */                  *
  491        INITIAL ('COREWORD', 'COREBYTE', 'FREEPOINT', 'DESCRIPTOR',                *
  492           'NDESCRIPT',   'LENGTH', 'SUBSTR', 'BYTE', 'SHL', 'SHR',                *
  493           'INPUT', 'OUTPUT', 'FILE', 'INLINE', 'TRACE', 'UNTRACE',                *
  494           'EXIT', 'TIME', 'DATE', 'CLOCK_TRAP', 'INTERRUPT_TRAP',                 *
  495           'MONITOR', 'ADDR', 'RUNTIME', 'FILENAME',                               *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 10
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  496           'COMPACTIFY', 'FREELIMIT', 'FREEBASE');                                 *
  497     DECLARE SYTYPE (SYTSIZE) BIT (8)     /* TYPE OF VARIABLE */                   *
  498        INITIAL (FIXEDTYPE, BYTETYPE, FIXEDTYPE, FIXEDTYPE,                        *
  499           FIXEDTYPE, SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                 *
  500           SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                   *
  501            SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                           *
  502           SPECIAL, SPECIAL, SPECIAL, SPECIAL,                                     *
  503           FORWARDCALL, FIXEDTYPE, FIXEDTYPE);                                     *
  504     DECLARE SYTLOC (SYTSIZE) FIXED       /* LOCATION OF VARIABLE */               *
  505        INITIAL (0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,     *
  506            0,0,0);                                                                *
  507     DECLARE SYTSEG (SYTSIZE) BIT(8)      /* SEGMENT OF VARIABLE */                *
  508        INITIAL (0,0,1,3,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,1,1);         *
  509     DECLARE SYTCO (SYTSIZE) FIXED;       /* A COUNT OF REFERENCES */              *
  510     DECLARE SYTCARD (SYTSIZE) FIXED;     /* WHERE SYMBOL IS DEFINED */            *
  511                                                                                   *
  512     DECLARE HASH (255)      FIXED,       /* HASH TABLE INTO SYMBOL TABLE*/        *
  513             PTR  (SYTSIZE)  FIXED,       /* POINTS TO NEXT SYMBOL IN HASH*/       *
  514             IDX             FIXED;       /* INDEX WHILE USING HASH*/              *
  515                                                                                   *
  516     /*  THE COMPILER STACKS DECLARED BELOW ARE USED TO DRIVE THE SYNTACTIC        *
  517        ANALYSIS ALGORITHM AND STORE INFORMATION RELEVANT TO THE INTERPRETATION    *
  518        OF THE TEXT.  THE STACKS ARE ALL POINTED TO BY THE STACK POINTER SP.  */   *
  519     DECLARE STACKSIZE LITERALLY '50';  /* SIZE OF STACK  */                       *
  520     DECLARE STATE_STACK (STACKSIZE)  BIT (8);                                     *
  521     DECLARE TYPE        (STACKSIZE)  FIXED;                                       *
  522     DECLARE REG         (STACKSIZE)  FIXED;                                       *
  523     DECLARE INX         (STACKSIZE)  FIXED;                                       *
  524     DECLARE CNT         (STACKSIZE)  FIXED;                                       *
  525     DECLARE VAR         (STACKSIZE)  CHARACTER;                                   *
  526     DECLARE FIXV        (STACKSIZE)  FIXED;                                       *
  527     DECLARE PPSAVE      (STACKSIZE)  FIXED;                                       *
  528     DECLARE FIXL        (STACKSIZE)  FIXED;                                       *
  529     DECLARE SP FIXED, MP FIXED, MPP1 FIXED;                                       *
  530                                                                                   *
  531     DECLARE CASELIMIT LITERALLY '175',                                            *
  532             CASESTACK (CASELIMIT) FIXED, /* CONTAINS ADDR OF STMTS OF CASE */     *
  533             CASEP  FIXED;                /* POINTS TO CURRENT CASESTACK ENTRY */  *
  534                                                                                   *
  535     DECLARE CODEMSG  CHARACTER INITIAL ('CODE = '),                               *
  536             DATAMSG  CHARACTER INITIAL ('DATA = '),                               *
  537             BACKMSG  CHARACTER INITIAL ('BACK UP CODE EMITTER'),                  *
  538             FILEMSG  CHARACTER INITIAL ('MISSING NUMBER FOR FILE');               *
  539                                                                                   *
  540                                                                                   *
  541  /*                                                                               *
  542            G L O B A L   P R O C E D U R E S                                      *
  543  */                                                                               *
  544                                                                                   *
  545  I_FORMAT:                                                                        *
  546     PROCEDURE (NUMBER, WIDTH);                                                    *
  547     DECLARE NUMBER  FIXED,                                                         I_FORMAT
  548             WIDTH   FIXED;                                                         I_FORMAT
  549     DECLARE L       FIXED;                                                         I_FORMAT
  550     I_STRING = NUMBER;                                                             I_FORMAT
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 11
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  551     L = LENGTH (I_STRING);                                                         I_FORMAT
  552     IF L < WIDTH THEN                                                              I_FORMAT
  553           I_STRING = SUBSTR(X70,0,WIDTH-L) ^^ I_STRING;                            I_FORMAT
  554     END  I_FORMAT;                                                                 I_FORMAT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
L               FIXED      9113     DATA    549       3
NUMBER          FIXED      9111     DATA    546       1
WIDTH           FIXED      9112     DATA    546       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 12
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  555                                                                                   *
  556  PRINTLINE:                                                                       *
  557     PROCEDURE (LINE, IND);                                                        *
  558     DECLARE LINE CHARACTER,             /*LINE TO BE PRINTED */                    PRINTLINE
  559             IND FIXED;                  /*FORMAT INDICATOR*/                       PRINTLINE
  560     DECLARE CTL(5) CHARACTER INITIAL ('0','1','','','','');                        PRINTLINE
  561     DECLARE SKIPS (5) FIXED INITIAL (2,99,0,0,0,0);                                PRINTLINE
  562     IF LINE_COUNT > PAGE_MAX THEN                                                  PRINTLINE
  563        DO;                                                                         PRINTLINE
  564           PAGE_COUNT = PAGE_COUNT + 1;                                             PRINTLINE
  565           OUTPUT(1) = TITLE ^^ PAGE_COUNT;                                         PRINTLINE
  566           OUTPUT = SUBTITLE;                                                       PRINTLINE
  567           OUTPUT = ' ';                                                            PRINTLINE
  568           LINE_COUNT = 0;                                                          PRINTLINE
  569        END;                                                                        PRINTLINE
  570     IF IND < 0 ^ IND > 5 THEN                                                      PRINTLINE
  571        DO;                                                                         PRINTLINE
  572           OUTPUT = LINE;                                                           PRINTLINE
  573           LINE_COUNT = LINE_COUNT + 1;                                             PRINTLINE
  574        END;                                                                        PRINTLINE
  575     ELSE                                                                           PRINTLINE
  576        DO;                                                                         PRINTLINE
  577           OUTPUT(1) = CTL(IND) ^^ LINE;                                            PRINTLINE
  578           LINE_COUNT = LINE_COUNT + SKIPS(IND);                                    PRINTLINE
  579        END;                                                                        PRINTLINE
  580  END PRINTLINE;                                                                    PRINTLINE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CTL             CHARACTER   753   STRING    560       1
IND             FIXED      9114     DATA    557       4
LINE            CHARACTER   752   STRING    557       2
SKIPS           FIXED      9116     DATA    561       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 13
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  581     ERROR:                                                                        *
  582        PROCEDURE (MSG, SEVERITY);                                                 *
  583     /* PRINT THE ERROR MESSAGE WITH A POINTER POINTING TO THE CURRENT TOKEN        ERROR
  584        BEING SCANNED.  IF SOURCE LISTING IS DISABLED, ALSO PRINT THE CURRENT       ERROR
  585        SOURCE IMAGE.                                                               ERROR
  586     */                                                                             ERROR
  587        DECLARE MSG CHARACTER, SEVERITY FIXED;                                      ERROR
  588        DECLARE I FIXED;                                                            ERROR
  589        ERROR_COUNT = ERROR_COUNT + 1;                                              ERROR
  590        IF CONTROL(BYTE('L')) = 0 THEN                                              ERROR
  591           DO;                                                                      ERROR
  592              I = 5 - LENGTH(CARD_COUNT);                                           ERROR
  593              CALL PRINTLINE (SUBSTR (X70, 0, I) ^^ CARD_COUNT ^^ X4 ^^ BUFFER,-1); ERROR
  594           END;                                                                     ERROR
  595        CALL PRINTLINE (SUBSTR(POINTER,LENGTH(POINTER)-7-                           ERROR
  596              (LINE_LENGTH+CP-TEXT_LIMIT-LB-1)),-1);                                ERROR
  597                                                                                    ERROR
  598        OUTPUT(-1) = CARD_COUNT ^^ X4 ^^ BUFFER;                                    ERROR
  599        OUTPUT(-1) = X7 ^^ MSG;                                                     ERROR
  600                                                                                    ERROR
  601        IF PREVIOUS_ERROR > 0 THEN                                                  ERROR
  602           MSG = MSG ^^ '. LAST PREVIOUS ERROR WAS ON LINE ' ^^ PREVIOUS_ERROR;     ERROR
  603        CALL PRINTLINE ('*** ERROR. ' ^^ MSG,-1);                                   ERROR
  604        PREVIOUS_ERROR = CARD_COUNT;                                                ERROR
  605        IF SEVERITY > 0 THEN                                                        ERROR
  606           IF SEVERE_ERRORS > 25 THEN                                               ERROR
  607              DO;                                                                   ERROR
  608                  CALL PRINTLINE ('*** TOO MANY SEVERE ERRORS, COMPILATION ABORTED ***',0); ERROR
  609                  COMPILING = FALSE;                                                ERROR
  610               END;                                                                 ERROR
  611             ELSE SEVERE_ERRORS = SEVERE_ERRORS + 1;                                ERROR
  612     END ERROR;                                                                     ERROR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9124     DATA    588       2
MSG             CHARACTER   760   STRING    582       4
SEVERITY        FIXED      9123     DATA    582       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 14
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  613     /*                THE SCANNER PROCEDURES              */                      *
  614     BUILD_BCD:                                                                    *
  615        PROCEDURE (C);                                                             *
  616        DECLARE C BIT(9);                                                           BUILD_BCD
  617        IF LENGTH(BCD) > 0 THEN BCD = BCD ^^ X1;                                    BUILD_BCD
  618        ELSE BCD = SUBSTR(X1 ^^ X1, 1);                                             BUILD_BCD
  619        COREBYTE(FREEPOINT-1) = C;                                                  BUILD_BCD C5 = 134217727
  620     END BUILD_BCD;                                                                 BUILD_BCD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
C               BIT (9)    9149     DATA    615       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 15
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  621     GET_CARD:                                                                     *
  622        PROCEDURE;                                                                 *
  623        /* DOES ALL CARD READING AND LISTING                                 */     GET_CARD
  624        DECLARE I FIXED, TEMPO CHARACTER, TEMP2 CHARACTER;                          GET_CARD
  625        IF LB \= 0 THEN                                                             GET_CARD
  626           DO;                                                                      GET_CARD
  627              IF CP >= 255 THEN                                                     GET_CARD
  628                 DO;                                                                GET_CARD
  629                    TEXT = SUBSTR(TEXT, LB);                                        GET_CARD
  630                    CP = CP - LB;                                                   GET_CARD
  631                    CALL ERROR ('IDENTIFIER TOO LONG', 0);                          GET_CARD
  632                 END;                                                               GET_CARD
  633                 IF LB > 255 - CP THEN I = 255 - CP;                                GET_CARD
  634                 ELSE I = LB;                                                       GET_CARD
  635                 LB = LB - I;                                                       GET_CARD
  636                 TEXT = TEXT ^^ SUBSTR(BALANCE, 0, I);                              GET_CARD
  637                 BALANCE = SUBSTR(BALANCE, I);                                      GET_CARD
  638                 TEXT_LIMIT = LENGTH(TEXT) - 1;                                     GET_CARD
  639                 RETURN;                                                            GET_CARD
  640           END;                                                                     GET_CARD
  641        EXPANSION_COUNT = 0;    /* CHECKED IN SCANNER  */                           GET_CARD
  642        IF READING THEN   /* READING IS FALSE INITIALLY, TO READ LIBRARY */         GET_CARD
  643           DO;                                                                      GET_CARD
  644              BUFFER = INPUT;                                                       GET_CARD
  645              IF LENGTH(BUFFER) = 0 THEN                                            GET_CARD
  646                 DO;                                                                GET_CARD
  647                    CALL ERROR ('EOF MISSING', 0);                                  GET_CARD
  648                    BUFFER = ' /* '' /* */ EOF; END; EOF; END; EOF';                GET_CARD
  649                 END;                                                               GET_CARD
  650              ELSE CARD_COUNT = CARD_COUNT + 1;                                     GET_CARD
  651           END;                                                                     GET_CARD
  652        ELSE                                                                        GET_CARD
  653           DO;                                                                      GET_CARD
  654              BUFFER = INPUT(LIBFILE);                                              GET_CARD
  655              IF LENGTH(BUFFER) = 0 THEN                                            GET_CARD
  656                 DO;                                                                GET_CARD
  657                    READING = TRUE;                                                 GET_CARD
  658                    BUFFER = INPUT;                                                 GET_CARD
  659                    CARD_COUNT = CARD_COUNT + 1;                                    GET_CARD
  660                    STATEMENT_COUNT = 0;                                            GET_CARD
  661                    CONTROL(BYTE('L')) = TRUE & \ CONTROL(BYTE('K'));               GET_CARD
  662                 END;                                                               GET_CARD
  663           END;                                                                     GET_CARD
  664        LINE_LENGTH = LENGTH (BUFFER);                                              GET_CARD
  665        IF CP + LENGTH(BUFFER) > 255 THEN                                           GET_CARD
  666           DO;                                                                      GET_CARD
  667              I = 255 - CP;                                                         GET_CARD
  668              TEXT = TEXT ^^ SUBSTR(BUFFER, 0, I);                                  GET_CARD
  669              BALANCE = SUBSTR(BUFFER, I);                                          GET_CARD
  670              LB = LENGTH(BALANCE);                                                 GET_CARD
  671           END;                                                                     GET_CARD
  672        ELSE TEXT = TEXT ^^ BUFFER;                                                 GET_CARD
  673        TEXT_LIMIT = LENGTH(TEXT) - 1;                                              GET_CARD
  674        IF CONTROL(BYTE('M')) THEN CALL PRINTLINE(BUFFER,-1);                       GET_CARD
  675        ELSE IF CONTROL(BYTE('L')) THEN                                             GET_CARD
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 16
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  676           DO;                                                                      GET_CARD
  677              TEMPO = CARD_COUNT;                                                   GET_CARD
  678              I = 5 - LENGTH (TEMPO);                                               GET_CARD
  679              TEMPO = SUBSTR(X70, 0, I) ^^ TEMPO ^^ X2 ^^ BUFFER;                   GET_CARD
  680              I = 88 - LENGTH(TEMPO);                                               GET_CARD
  681              IF I >= 70 THEN                                                       GET_CARD
  682                 DO;                                                                GET_CARD
  683                    I = I - 70;                                                     GET_CARD
  684                    TEMPO = TEMPO ^^ X70;                                           GET_CARD
  685                 END;                                                               GET_CARD
  686              IF I > 0 THEN TEMPO = TEMPO ^^ SUBSTR(X70, 0, I);                     GET_CARD
  687              TEMP2 = CURRENT_PROCEDURE ^^ INFO;                                    GET_CARD
  688              IF CONTROL(BYTE('F')) THEN                                            GET_CARD
  689                     TEMP2 = X2 ^^ PP ^^ X1 ^^ DP ^^ X1 ^^ DSP ^^ TEMP2;            GET_CARD
  690              IF LENGTH (TEMP2) > 44 THEN TEMP2 = SUBSTR (TEMP2,0,44);              GET_CARD
  691              CALL PRINTLINE (TEMPO ^^ TEMP2,-1);                                   GET_CARD C6 = 5905580032
  692           END;                                                                     GET_CARD
  693        INFO = '';           /* CLEAR INFORMATION BUFFER */                         GET_CARD
  694     END GET_CARD;                                                                  GET_CARD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9151     DATA    624      16
TEMP2           CHARACTER   765   STRING    624       7
TEMPO           CHARACTER   764   STRING    624      10
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 17
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  695     CHAR:                                                                         *
  696        PROCEDURE;                                                                 *
  697        CP = CP + 1;                                                                CHAR
  698        IF CP <= TEXT_LIMIT THEN RETURN;                                            CHAR
  699        CP = 0;                                                                     CHAR
  700        TEXT = '';                                                                  CHAR
  701        CALL GET_CARD;                                                              CHAR
  702     END CHAR;                                                                      CHAR
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 18
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  703     DEBLANK:                                                                      *
  704        PROCEDURE;                                                                 *
  705        CALL CHAR;                                                                  DEBLANK
  706        DO WHILE BYTE (TEXT, CP) = BYTE (' ');                                      DEBLANK
  707           CALL CHAR;                                                               DEBLANK
  708        END;                                                                        DEBLANK
  709     END DEBLANK;                                                                   DEBLANK
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 19
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  710     BCHAR:                                                                        *
  711        PROCEDURE;                                                                 *
  712        DO FOREVER;                                                                 BCHAR
  713           CALL DEBLANK;                                                            BCHAR
  714           CH = BYTE(TEXT, CP);                                                     BCHAR
  715           IF CH \= BYTE ('(') THEN RETURN;                                         BCHAR
  716           /*  (BASE WIDTH)  */                                                     BCHAR
  717            CALL DEBLANK;                                                           BCHAR
  718           JBASE = BYTE (TEXT, CP) - BYTE ('0');  /* WIDTH */                       BCHAR
  719           IF JBASE < 1 ^ JBASE > 4 THEN                                            BCHAR
  720              DO;                                                                   BCHAR
  721                 CALL ERROR ('ILLEGAL BIT STRING WIDTH: ' ^^ SUBSTR(TEXT,CP,1),0);  BCHAR
  722                 JBASE = 4;  /* DEFAULT WIDTH FOR ERROR */                          BCHAR C7 = 134217728
  723              END;                                                                  BCHAR
  724           BASE = SHL(1, JBASE);                                                    BCHAR
  725           CALL DEBLANK;                                                            BCHAR
  726          IF BYTE(TEXT,CP)\=BYTE(')')THEN CALL ERROR('MISSING ) IN BIT STRING',0);  BCHAR
  727        END;                                                                        BCHAR
  728     END BCHAR;                                                                     BCHAR
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 20
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  729     SCAN:                                                                         *
  730        PROCEDURE;     /* GET THE NEXT TOKEN FROM THE TEXT  */                     *
  731        DECLARE S1 FIXED, S2 FIXED;                                                 SCAN
  732     DECLARE LSTRNGM CHARACTER INITIAL ('STRING TOO LONG');                         SCAN
  733     DECLARE LBITM CHARACTER INITIAL ('BIT STRING TOO LONG');                       SCAN
  734      COUNT_SCAN = COUNT_SCAN + 1;                                                  SCAN
  735        FAILSOFT = TRUE;                                                            SCAN
  736        BCD = '';  NUMBER_VALUE = 0;                                                SCAN
  737     RESCAN:                                                                        SCAN
  738        IF CP > TEXT_LIMIT THEN                                                     SCAN
  739           DO;                                                                      SCAN
  740              TEXT = '';                                                            SCAN
  741              CALL GET_CARD;                                                        SCAN
  742           END;                                                                     SCAN
  743        ELSE                                                                        SCAN
  744           DO;                                                                      SCAN
  745              TEXT_LIMIT = TEXT_LIMIT - CP;                                         SCAN
  746              TEXT = SUBSTR(TEXT, CP);                                              SCAN
  747           END;                                                                     SCAN
  748        CP = 0;                                                                     SCAN
  749     /*  BRANCH ON NEXT CHARACTER IN TEXT                  */                       SCAN
  750        DO CASE CHARTYPE(BYTE(TEXT));                                               SCAN
  751           /*  CASE 0  */                                                           SCAN CASE 0.
  752           /* ILLEGAL CHARACTERS FALL HERE  */                                      SCAN
  753           CALL ERROR ('ILLEGAL CHARACTER: ' ^^ SUBSTR (TEXT, 0, 1), 0);            SCAN
  754           /*  CASE 1  */                                                           SCAN CASE 1.
  755           /*  BLANK  */                                                            SCAN
  756           DO CP = 1 TO TEXT_LIMIT;                                                 SCAN
  757              IF BYTE (TEXT, CP) \= BYTE (' ') THEN GOTO RESCAN;                    SCAN
  758           END;                                                                     SCAN
  759           /*  CASE 2  */                                                           SCAN CASE 2.
  760           DO FOREVER;   /* STRING QUOTE ('):  CHARACTER STRING       */            SCAN
  761              TOKEN = STRING;                                                       SCAN
  762              DO CP = CP + 1 TO TEXT_LIMIT;                                         SCAN
  763                 IF BYTE (TEXT, CP) = BYTE ('''') THEN                              SCAN
  764                    DO;                                                             SCAN
  765                       IF LENGTH(BCD) + CP > 257 THEN                               SCAN
  766                          DO;                                                       SCAN
  767                             CALL ERROR (LSTRNGM, 0);                               SCAN
  768                             RETURN;                                                SCAN
  769                          END;                                                      SCAN
  770                       IF CP > 1 THEN                                               SCAN
  771                       BCD = BCD ^^ SUBSTR(TEXT, 1, CP-1);                          SCAN
  772                       CALL CHAR;                                                   SCAN
  773                        IF BYTE (TEXT, CP) = BYTE ('''') THEN                       SCAN
  774                           IF LENGTH(BCD) = 255 THEN                                SCAN
  775                             DO;                                                    SCAN
  776                               CALL ERROR (LSTRNGM, 0);                             SCAN
  777                               RETURN;                                              SCAN
  778                             END;                                                   SCAN
  779                          ELSE                                                      SCAN
  780                             DO;                                                    SCAN
  781                                BCD = BCD ^^ SUBSTR(TEXT, CP, 1);                   SCAN
  782                                GO TO RESCAN;                                       SCAN
  783                             END;                                                   SCAN
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 21
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  784                       RETURN;                                                      SCAN
  785                    END;                                                            SCAN
  786              END;                                                                  SCAN
  787              /*  WE HAVE RUN OFF A CARD  */                                        SCAN
  788              IF LENGTH(BCD) + CP > 257 THEN                                        SCAN
  789                 DO;                                                                SCAN
  790                   CALL ERROR (LSTRNGM, 0);                                         SCAN
  791                   RETURN;                                                          SCAN
  792                 END;                                                               SCAN
  793              IF CP > 1 THEN BCD = BCD ^^ SUBSTR(TEXT, 1, CP-1);                    SCAN
  794              TEXT = X1;                                                            SCAN
  795              CP = 0;                                                               SCAN
  796              CALL GET_CARD;                                                        SCAN
  797           END;                                                                     SCAN
  798           /*  CASE 3  */                                                           SCAN CASE 3.
  799           DO;      /*  BIT QUOTE("):  BIT STRING  */                               SCAN
  800              JBASE = 4;  BASE = 16;  /* DEFAULT WIDTH */                           SCAN
  801              TOKEN = NUMBER;                                                       SCAN
  802              S1 = 0;                                                               SCAN
  803              CALL BCHAR;                                                           SCAN
  804              DO WHILE CH \= BYTE ('"');                                            SCAN
  805                 S1 = S1 + JBASE;                                                   SCAN
  806                 IF CH >= BYTE ('0') & CH <= BYTE ('9') THEN S2 = CH - BYTE ('0');  SCAN
  807                 ELSE S2 = CH + 10 - BYTE ('A');                                    SCAN
  808                 IF S2 >= BASE ^ S2 < 0 THEN                                        SCAN
  809                    CALL ERROR ('ILLEGAL CHARACTER IN BIT STRING: '                 SCAN
  810                    ^^ SUBSTR(TEXT, CP, 1), 0);                                     SCAN
  811                 IF S1 > 36 THEN TOKEN = STRING;                                    SCAN
  812                 IF TOKEN = STRING THEN                                             SCAN
  813                    DO WHILE S1 - JBASE >= 9;                                       SCAN
  814                       IF LENGTH(BCD) >= 255 THEN                                   SCAN
  815                          DO;                                                       SCAN
  816                             CALL ERROR ( LBITM, 0);                                SCAN
  817                             RETURN;                                                SCAN
  818                          END;                                                      SCAN
  819                       S1 = S1 - 9;                                                 SCAN
  820                       CALL BUILD_BCD (SHR(NUMBER_VALUE, S1-JBASE));                SCAN
  821                    END;                                                            SCAN
  822                 NUMBER_VALUE = SHL(NUMBER_VALUE, JBASE) + S2;                      SCAN
  823                 CALL BCHAR;                                                        SCAN
  824              END;     /* OF DO WHILE CH...  */                                     SCAN
  825              CP = CP + 1;                                                          SCAN
  826              IF TOKEN = STRING THEN                                                SCAN
  827                 IF LENGTH(BCD) >= 255 THEN CALL ERROR (LBITM,0);                   SCAN
  828                 ELSE CALL BUILD_BCD (SHL(NUMBER_VALUE, 9 - S1));                   SCAN
  829               RETURN;                                                              SCAN
  830           END;                                                                     SCAN
  831           /*  CASE 4  */                                                           SCAN CASE 4.
  832           DO FOREVER;   /*  A LETTER:  IDENTIFIERS AND RESERVED WORDS  */          SCAN
  833              DO CP = CP + 1 TO TEXT_LIMIT;                                         SCAN
  834                 IF NOT_LETTER_OR_DIGIT(BYTE(TEXT, CP)) THEN                        SCAN
  835                    DO;  /* END OF IDENTIFIER  */                                   SCAN
  836                       BCD = SUBSTR(TEXT, 0, CP);                                   SCAN
  837                       IF CP > 1 THEN IF CP <= RESERVED_LIMIT THEN                  SCAN
  838                          /* CHECK FOR RESERVED WORDS */                            SCAN
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 22
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  839                          DO I = 1 TO TERMINAL#;                                    SCAN
  840                             IF BCD = VOCAB(I) THEN                                 SCAN C8 = 42
  841                                DO;                                                 SCAN
  842                                   TOKEN = I;                                       SCAN
  843                                   RETURN;                                          SCAN
  844                                END;                                                SCAN
  845                          END;                                                      SCAN
  846                       DO I = MACRO_INDEX(CP-1) TO MACRO_INDEX(CP) - 1;             SCAN
  847                          IF BCD = MACRO_NAME(I) THEN                               SCAN
  848                             DO;                                                    SCAN
  849                              MACRO_COUNT(I) = MACRO_COUNT(I) + 1;                  SCAN
  850                                BCD = MACRO_TEXT(I);                                SCAN
  851                                IF EXPANSION_COUNT < EXPANSION_LIMIT THEN           SCAN
  852                                   EXPANSION_COUNT = EXPANSION_COUNT + 1;           SCAN
  853                                ELSE CALL PRINTLINE ('** WARNING, TOO MANY EXPANSIONS FOR SCAN
  854   THE MACRO: ' ^^ BCD,-1);                                                         SCAN
  855                                TEXT = SUBSTR(TEXT, CP);                            SCAN
  856                                TEXT_LIMIT = TEXT_LIMIT - CP;                       SCAN
  857                                IF LENGTH(BCD) + TEXT_LIMIT > 255 THEN              SCAN
  858                                   DO;                                              SCAN
  859                                      IF LB + TEXT_LIMIT > 255 THEN                 SCAN
  860                                         CALL ERROR('MACRO EXPANSION TOO LONG',0);  SCAN
  861                                      ELSE                                          SCAN
  862                                         DO;                                        SCAN
  863                                            BALANCE = TEXT ^^ BALANCE;              SCAN
  864                                            LB = LENGTH(BALANCE);                   SCAN
  865                                            TEXT = BCD;                             SCAN
  866                                         END;                                       SCAN
  867                                   END;                                             SCAN
  868                                ELSE TEXT = BCD ^^ TEXT;                            SCAN
  869                                BCD = '';                                           SCAN
  870                                TEXT_LIMIT = LENGTH(TEXT) - 1;                      SCAN
  871                                CP = 0;                                             SCAN
  872                                GO TO RESCAN;                                       SCAN
  873                             END;                                                   SCAN
  874                       END;                                                         SCAN
  875                       /*  RESERVED WORDS EXIT HIGHER:  THEREFORE <IDENTIFIER> */   SCAN
  876                       TOKEN = IDENT;                                               SCAN
  877                       RETURN;                                                      SCAN
  878                    END;                                                            SCAN
  879              END;                                                                  SCAN
  880              /*  END OF CARD  */                                                   SCAN
  881              CALL GET_CARD;                                                        SCAN
  882              CP = CP - 1;                                                          SCAN
  883           END;                                                                     SCAN
  884           /*  CASE 5  */                                                           SCAN CASE 5.
  885            DO FOREVER;   /*  DIGIT:  A NUMBER  */                                  SCAN
  886              TOKEN = NUMBER;                                                       SCAN
  887              DO CP = CP TO TEXT_LIMIT;                                             SCAN
  888                 S1 = BYTE(TEXT, CP);                                               SCAN
  889                 IF S1 < BYTE ('0') ^ S1 > BYTE ('9') THEN RETURN;                  SCAN
  890                 NUMBER_VALUE = 10 * NUMBER_VALUE + S1 - BYTE ('0');                SCAN
  891              END;                                                                  SCAN
  892              CALL GET_CARD;                                                        SCAN
  893           END;                                                                     SCAN
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 23
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  894           /*  CASE 6  */                                                           SCAN CASE 6.
  895           DO;      /*  A /:  MAY BE DIVIDE OR START OF COMMENT  */                 SCAN
  896              CALL CHAR;                                                            SCAN
  897              IF BYTE (TEXT, CP) \= BYTE ('*') THEN                                 SCAN
  898                 DO;                                                                SCAN
  899                    TOKEN = DIVIDE;                                                 SCAN
  900                    RETURN;                                                         SCAN
  901                 END;                                                               SCAN
  902              /* WE HAVE A COMMENT  */                                              SCAN
  903              S1, S2 = BYTE (' ');                                                  SCAN
  904              DO WHILE S1 \= BYTE ('*') ^ S2 \= BYTE ('/');                         SCAN
  905                 IF S1 = BYTE ('$') THEN /* A CONTROL CHAR */                       SCAN
  906                      CONTROL(S2) = \CONTROL(S2) & 1;                               SCAN
  907                 S1 = S2;                                                           SCAN
  908                 CALL CHAR;                                                         SCAN
  909                 S2 = BYTE(TEXT, CP);                                               SCAN
  910              END;                                                                  SCAN
  911           END;                                                                     SCAN
  912           /*  CASE 7  */                                                           SCAN CASE 7.
  913           DO;      /*  SPECIAL CHARACTERS  */                                      SCAN
  914              TOKEN = TX(BYTE(TEXT));                                               SCAN
  915              CP = 1;                                                               SCAN
  916              RETURN;                                                               SCAN
  917           END;                                                                     SCAN
  918           /*  CASE 8  */                                                           SCAN CASE 8.
  919           DO;   /* A ^:  MAY BE  ^  OR  ^^  */                                     SCAN
  920              CALL CHAR;                                                            SCAN
  921              IF BYTE(TEXT, CP) = BYTE('^') THEN                                    SCAN
  922                 DO;                                                                SCAN
  923                    CALL CHAR;                                                      SCAN
  924                    TOKEN = CONCATENATE;                                            SCAN
  925                 END;                                                               SCAN
  926              ELSE TOKEN = ORSYMBOL;                                                SCAN
  927              RETURN;                                                               SCAN
  928           END;                                                                     SCAN
  929        END;     /* OF CASE ON CHARTYPE  */                                         SCAN CASE 9.
  930        CP = CP + 1;  /* ADVANCE SCANNER AND RESUME SEARCH FOR TOKEN  */            SCAN
  931        GO TO RESCAN;                                                               SCAN
  932     END SCAN;                                                                      SCAN

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LBITM           CHARACTER   772   STRING    733       2
LSTRNGM         CHARACTER   771   STRING    732       3
RESCAN          LABEL       996  PROGRAM    737       4
S1              FIXED      9184     DATA    731      17
S2              FIXED      9185     DATA    731      11
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 24
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  933     /*                                                                            *
  934              C O D E   E M I S S I O N   P R O C E D U R E S                      *
  935   */                                                                              *
  936  FLUSH_DATA_BUFFER:                                                               *
  937     PROCEDURE;                                                                    *
  938        /* CLEAN OUT THE DATA BUFFER AND STICK ALL CURRENT CONTENTS                 FLUSH_DATA_BUFFER
  939           INTO THE REL FILE */                                                     FLUSH_DATA_BUFFER
  940        DECLARE I FIXED, J FIXED;                                                   FLUSH_DATA_BUFFER
  941        IF (DPTR+DCTR) > 1 THEN                                                     FLUSH_DATA_BUFFER
  942           DO;                                                                      FLUSH_DATA_BUFFER
  943              J = (DPTR/19)*18 + DCTR -1;                                           FLUSH_DATA_BUFFER
  944              FILE(RELFILE) = CODE_TYPE + J;                                        FLUSH_DATA_BUFFER
  945              I = DPTR+DCTR-1;                                                      FLUSH_DATA_BUFFER C9 = 262144
  946              DO J = 0 TO I;                                                        FLUSH_DATA_BUFFER
  947                 FILE(RELFILE) = DATA_BUFFER(J);                                    FLUSH_DATA_BUFFER
  948                 END;                                                               FLUSH_DATA_BUFFER
  949           END;                                                                     FLUSH_DATA_BUFFER
  950        DPTR = 0;                                                                   FLUSH_DATA_BUFFER
  951        DCTR = 1;                                                                   FLUSH_DATA_BUFFER
  952     END FLUSH_DATA_BUFFER;                                                         FLUSH_DATA_BUFFER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9233     DATA    940       2
J               FIXED      9234     DATA    940       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 25
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  953  FLUSH_CODE_BUFFER:                                                               *
  954     PROCEDURE;                                                                    *
  955        /* CLEAN OUT THE CODE BUFFER AND STICK ALL CURRENT CONTENTS                 FLUSH_CODE_BUFFER
  956           INTO THE REL FILE */                                                     FLUSH_CODE_BUFFER
  957        DECLARE I FIXED, J FIXED;                                                   FLUSH_CODE_BUFFER
  958        IF (RPTR+RCTR) > 1 THEN                                                     FLUSH_CODE_BUFFER
  959           DO;                                                                      FLUSH_CODE_BUFFER
  960              I = (RPTR/19)*18 + RCTR -1;                                           FLUSH_CODE_BUFFER
  961              J = RPTR+RCTR-1;                                                      FLUSH_CODE_BUFFER
  962              FILE (RELFILE) = CODE_TYPE+I;                                         FLUSH_CODE_BUFFER
  963              DO I = 0 TO J;                                                        FLUSH_CODE_BUFFER
  964                 FILE(RELFILE) = CODE_BUFFER(I);                                    FLUSH_CODE_BUFFER
  965                 END;                                                               FLUSH_CODE_BUFFER
  966           END;                                                                     FLUSH_CODE_BUFFER
  967        RPTR = 0;                                                                   FLUSH_CODE_BUFFER
  968        RCTR = 1;                                                                   FLUSH_CODE_BUFFER
  969     END FLUSH_CODE_BUFFER;                                                         FLUSH_CODE_BUFFER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9237     DATA    957       4
J               FIXED      9238     DATA    957       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 26
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  970  RADIX50:                                                                         *
  971     PROCEDURE (SYMBOL);                                                           *
  972     /* PROCEDURE TO RETURN THE RADIX-50 REPRESENTATION OF A SYMBOL.                RADIX50
  973        ONLY THE FIRST 6 CHARACTERS ARE USED. */                                    RADIX50
  974     DECLARE SYMBOL CHARACTER;                                                      RADIX50
  975     DECLARE (I,J,K,L) FIXED;                                                       RADIX50
  976                                                                                    RADIX50
  977     J = 0;                                                                         RADIX50
  978     IF LENGTH(SYMBOL) < 6 THEN SYMBOL = SYMBOL ^^ X7;                              RADIX50
  979     DO L = 0 TO 5;                                                                 RADIX50
  980        I = BYTE(SYMBOL,L);                                                         RADIX50 C10 = 5
  981        IF I = BYTE(' ') THEN K = 0;                                                RADIX50
  982           ELSE IF I = BYTE ('.') THEN K = "(3)45";                                 RADIX50
  983           ELSE IF I = BYTE ('$') THEN K = "(3)46";                                 RADIX50
  984           ELSE IF I = BYTE ('%') THEN K = "(3)47";                                 RADIX50
  985           ELSE IF I >= BYTE ('0') & I <= BYTE ('9') THEN                           RADIX50
  986                      K = I-BYTE('0') + "(3)1";                                     RADIX50
  987           ELSE IF I >= BYTE ('A') & I <= BYTE ('Z') THEN                           RADIX50
  988                      K = I - BYTE ('A') + "(3)13";                                 RADIX50
  989           ELSE RETURN J;                                                           RADIX50
  990        J = J * "(3)50" + K;                                                        RADIX50
  991        END;                                                                        RADIX50
  992     RETURN J;                                                                      RADIX50
  993     END RADIX50;                                                                   RADIX50

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9240     DATA    975      11
J               FIXED      9241     DATA    975       5
K               FIXED      9242     DATA    975       7
L               FIXED      9243     DATA    975       2
SYMBOL          CHARACTER   777   STRING    971       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 27
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  994  OUTPUT_CODEWORD:                                                                 *
  995     PROCEDURE;                                                                    *
  996     /* SPIT OUT THE INSTRUCTION AT CODEXXX(CODE_TAIL) */                           OUTPUT_CODEWORD
  997     IF CODE_FULL(CODE_TAIL) THEN                                                   OUTPUT_CODEWORD
  998        DO;                                                                         OUTPUT_CODEWORD
  999           IF CONTROL(BYTE('A')) THEN OUTPUT (CODEFILE) = CODE (CODE_TAIL);         OUTPUT_CODEWORD
 1000           IF RCTR+RPTR = 1 THEN                                                    OUTPUT_CODEWORD
 1001              DO;                                                                   OUTPUT_CODEWORD
 1002                 CODE_BUFFER(0) =SHL(1,34);                                         OUTPUT_CODEWORD
 1003                 CODE_BUFFER(1) = CODE_PP(CODE_TAIL) + "(3)400000";                 OUTPUT_CODEWORD
 1004                 RCTR = RCTR +1;                                                    OUTPUT_CODEWORD
 1005              END;                                                                  OUTPUT_CODEWORD
 1006           CODE_BUFFER(RPTR) = SHL(CODE_RBITS(CODE_TAIL),36-RCTR*2)^CODE_BUFFER(RPTR); OUTPUT_CODEWORD
 1007           CODE_BUFFER(RPTR+RCTR) = CODE_REL(CODE_TAIL);                            OUTPUT_CODEWORD
 1008           RCTR = RCTR +1;                                                          OUTPUT_CODEWORD
 1009           IF RPTR+RCTR > BUFFERSIZE THEN CALL FLUSH_CODE_BUFFER;                   OUTPUT_CODEWORD
 1010           IF RCTR > 18 THEN                                                        OUTPUT_CODEWORD
 1011              DO;                                                                   OUTPUT_CODEWORD
 1012                 RPTR = RPTR +19;                                                   OUTPUT_CODEWORD
 1013                 RCTR = 1;                                                          OUTPUT_CODEWORD
 1014                 CODE_BUFFER(RPTR) = 0;                                             OUTPUT_CODEWORD
 1015              END;                                                                  OUTPUT_CODEWORD
 1016        END;                                                                        OUTPUT_CODEWORD
 1017     CODE_FULL(CODE_TAIL) = FALSE;                                                  OUTPUT_CODEWORD
 1018     CODE_TAIL = (CODE_TAIL+1) & 3;                                                 OUTPUT_CODEWORD
 1019     END OUTPUT_CODEWORD;                                                           OUTPUT_CODEWORD
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 28
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1020  FLUSH_LABELS:                                                                    *
 1021     PROCEDURE;                                                                    *
 1022        /* CLEAN OUT LABEL BUFFER BY GENERATING INTERNAL REQUEST                    FLUSH_LABELS
 1023           TYPE BLOCK AND DEFINING ALL LABELS NOW KNOWN */                          FLUSH_LABELS
 1024        DECLARE I FIXED;                                                            FLUSH_LABELS
 1025        IF LABEL_COUNT = 0 THEN RETURN;                                             FLUSH_LABELS
 1026        DO WHILE CODE_TAIL \= CODE_HEAD;                                            FLUSH_LABELS
 1027           CALL OUTPUT_CODEWORD;                                                    FLUSH_LABELS
 1028           END;                                                                     FLUSH_LABELS
 1029        CALL OUTPUT_CODEWORD;                                                       FLUSH_LABELS
 1030        CODE_TAIL = CODE_HEAD;      /* RESET POINTERS, SINCE BUFFERS NOW EMPTY */   FLUSH_LABELS
 1031        STILLCOND, STILLINZERO = 0; /* MAKE SURE PEEPHOLE WORKS */                  FLUSH_LABELS
 1032        CALL FLUSH_CODE_BUFFER;                                                     FLUSH_LABELS
 1033        FILE (RELFILE) = INTREQ_TYPE+LABEL_COUNT;                                   FLUSH_LABELS
 1034        DO I = 0 TO LABEL_COUNT;                                                    FLUSH_LABELS C11 = 2097152
 1035           FILE (RELFILE) = LABEL_BUFFER(I);                                        FLUSH_LABELS
 1036           END;                                                                     FLUSH_LABELS
 1037        LABEL_COUNT = 0;                                                            FLUSH_LABELS
 1038        LABEL_BUFFER(0) = 0;                                                        FLUSH_LABELS
 1039     END FLUSH_LABELS;                                                              FLUSH_LABELS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9245     DATA   1024       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 29
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1040  OUTPUT_DATAWORD:                                                                 *
 1041     PROCEDURE (W,LOC);                                                            *
 1042        /* OUTPUT A WORD TO THE LOW SEGMENT */                                      OUTPUT_DATAWORD
 1043        DECLARE W  FIXED, LOC FIXED;                                                OUTPUT_DATAWORD
 1044        IF (DPTR+DCTR)>BUFFERSIZE ^ DLOC \= LOC THEN CALL FLUSH_DATA_BUFFER;        OUTPUT_DATAWORD
 1045        IF DPTR+DCTR = 1 THEN                                                       OUTPUT_DATAWORD
 1046           DO;                                                                      OUTPUT_DATAWORD
 1047              DATA_BUFFER(0) = "(3)200000000000";                                   OUTPUT_DATAWORD
 1048              DATA_BUFFER(1) = LOC;                                                 OUTPUT_DATAWORD C12 = 17179869184
 1049              DATA_BUFFER(2) = W;                                                   OUTPUT_DATAWORD
 1050              DLOC = LOC + 1;                                                       OUTPUT_DATAWORD
 1051              DCTR = DCTR + 2;                                                      OUTPUT_DATAWORD
 1052              RETURN;                                                               OUTPUT_DATAWORD
 1053           END;                                                                     OUTPUT_DATAWORD
 1054        DATA_BUFFER (DPTR+DCTR) = W;                                                OUTPUT_DATAWORD
 1055        DCTR = DCTR +1;                                                             OUTPUT_DATAWORD
 1056        DLOC = DLOC + 1;                                                            OUTPUT_DATAWORD
 1057        IF DPTR+DCTR > BUFFERSIZE THEN CALL FLUSH_DATA_BUFFER;                      OUTPUT_DATAWORD
 1058        IF DCTR > 18 THEN                                                           OUTPUT_DATAWORD
 1059          DO;                                                                       OUTPUT_DATAWORD
 1060              DCTR = 1;                                                             OUTPUT_DATAWORD
 1061              DPTR = DPTR + 19;                                                     OUTPUT_DATAWORD
 1062              DATA_BUFFER(DPTR) = 0;                                                OUTPUT_DATAWORD
 1063           END;                                                                     OUTPUT_DATAWORD
 1064     END OUTPUT_DATAWORD;                                                           OUTPUT_DATAWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LOC             FIXED      9249     DATA   1041       3
W               FIXED      9248     DATA   1041       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 30
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1065  FLUSH_DATACARD:PROCEDURE;                                                        *
 1066        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             FLUSH_DATACARD
 1067           DO;                                                                      FLUSH_DATACARD
 1068              DATACARD = DATACARD ^^ '; D' ^^ DP;                                   FLUSH_DATACARD
 1069              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              FLUSH_DATACARD
 1070              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   FLUSH_DATACARD
 1071           END;                                                                     FLUSH_DATACARD
 1072        CALL OUTPUT_DATAWORD (PWORD,DP);                                            FLUSH_DATACARD
 1073        PWORD = 0;                                                                  FLUSH_DATACARD
 1074        DPOFFSET = 0;                                                               FLUSH_DATACARD
 1075        DP = DP + 1;                                                                FLUSH_DATACARD
 1076  END FLUSH_DATACARD;                                                               FLUSH_DATACARD
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 31
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1077  EMITBLOCK:                                                                       *
 1078     PROCEDURE (I);                                                                *
 1079        /* RESERVE A BLOCK OF I WORDS */                                            EMITBLOCK
 1080        DECLARE I FIXED;                                                            EMITBLOCK
 1081        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITBLOCK
 1082           DO;                                                                      EMITBLOCK
 1083              DATACARD = '       REPEAT ' ^^ I ^^ ',<0>; D' ^^ DP;                  EMITBLOCK
 1084              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              EMITBLOCK
 1085              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   EMITBLOCK
 1086           END;                                                                     EMITBLOCK
 1087        DP = DP + I;                                                                EMITBLOCK
 1088  END EMITBLOCK;                                                                    EMITBLOCK

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9252     DATA   1078       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 32
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1089  EMITDATAWORD:                                                                    *
 1090     PROCEDURE (W);                                                                *
 1091        DECLARE W FIXED;                                                            EMITDATAWORD
 1092        /* SEND AN 80 CHARACTER CARD TO THE DATA FILE */                            EMITDATAWORD
 1093        IF DPOFFSET > 0 THEN CALL FLUSH_DATACARD;                                   EMITDATAWORD
 1094        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITDATAWORD
 1095           DO;                                                                      EMITDATAWORD
 1096              DATACARD = X7 ^^ W ^^ '; D' ^^ DP;                                    EMITDATAWORD
 1097              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              EMITDATAWORD
 1098              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   EMITDATAWORD
 1099           END;                                                                     EMITDATAWORD
 1100        CALL OUTPUT_DATAWORD(W,DP);                                                 EMITDATAWORD
 1101        DP = DP + 1;                                                                EMITDATAWORD
 1102  END EMITDATAWORD;                                                                 EMITDATAWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
W               FIXED      9259     DATA   1090       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 33
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1103  EMITBYTE:                                                                        *
 1104     PROCEDURE (C);                                                                *
 1105        DECLARE C FIXED;                                                            EMITBYTE
 1106        /* SEND ONE 9-BIT BYTE TO THE DATA AREA */                                  EMITBYTE
 1107        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITBYTE
 1108           IF DPOFFSET = 0 THEN DATACARD = '       BYTE (9)'^^ C;                   EMITBYTE
 1109           ELSE DATACARD = DATACARD ^^ ',' ^^ C;                                    EMITBYTE
 1110        PWORD = PWORD + SHL(C&"(3)777",9*(3-DPOFFSET));                             EMITBYTE
 1111        DPOFFSET = DPOFFSET + 1;                                                    EMITBYTE
 1112        IF DPOFFSET = 4 THEN CALL FLUSH_DATACARD;                                   EMITBYTE
 1113  END EMITBYTE;                                                                     EMITBYTE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
C               FIXED      9261     DATA   1104       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 34
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1114  EMITCONSTANT:                                                                    *
 1115     PROCEDURE (C);                                                                *
 1116        DECLARE C FIXED;                                                            EMITCONSTANT
 1117        DECLARE CTAB (100) FIXED, CADD (100) FIXED, NC FIXED, I FIXED;              EMITCONSTANT
 1118        /* SEE IF C HAS ALREADY BEEN EMITED, AND IF NOT, EMIT IT.  SET UP ADR.  */  EMITCONSTANT
 1119        DO I = 1 TO NC;                  /* STEP THRU THE CONSTANTS */              EMITCONSTANT
 1120           IF CTAB (I) = C THEN                                                     EMITCONSTANT
 1121              DO;                                                                   EMITCONSTANT
 1122                 ADR = CADD (I);                                                    EMITCONSTANT
 1123                 RETURN;                                                            EMITCONSTANT
 1124              END;                                                                  EMITCONSTANT
 1125        END;                                                                        EMITCONSTANT
 1126        CTAB (I) = C;                                                               EMITCONSTANT
 1127        CALL EMITDATAWORD (C);                                                      EMITCONSTANT
 1128        ADR, CADD (I) = DP - 1;                                                     EMITCONSTANT
 1129        IF I < 100 THEN NC = I;                                                     EMITCONSTANT
 1130        IF CONTROL(BYTE('C')) THEN CALL PRINTLINE ('* CONSTANT ' ^^ NC ^^ ' = ' ^^ C,-1); EMITCONSTANT
 1131           ELSE IF CONTROL(BYTE('L')) THEN INFO=INFO^^ ' C'^^ NC ^^' = ' ^^ C;      EMITCONSTANT
 1132  END EMITCONSTANT;                                                                 EMITCONSTANT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
C               FIXED      9266     DATA   1115       5
CADD            FIXED      9368     DATA   1117       2
CTAB            FIXED      9267     DATA   1117       2
I               FIXED      9470     DATA   1117       7
NC              FIXED      9469     DATA   1117       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 35
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1133  EMITCODEWORD:PROCEDURE (W,WORD,RBITS);                                           *
 1134         DECLARE W CHARACTER;                                                       EMITCODEWORD
 1135        DECLARE WORD FIXED;                                                         EMITCODEWORD
 1136        DECLARE RBITS FIXED;                                                        EMITCODEWORD
 1137        /* SEND AN 80 CHARACTER CODE CARD TO THE BUFFER AREA */                     EMITCODEWORD
 1138        CODE_HEAD = (CODE_HEAD+1) & 3;                                              EMITCODEWORD
 1139        IF CODE_HEAD = CODE_TAIL THEN CALL OUTPUT_CODEWORD;                         EMITCODEWORD
 1140        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('E')) THEN                             EMITCODEWORD
 1141              CODE(CODE_HEAD) = LABEL_GEN ^^ W;                                     EMITCODEWORD
 1142        IF CONTROL(BYTE('E')) THEN                                                  EMITCODEWORD
 1143              CALL PRINTLINE (CODEMSG ^^ CODE(CODE_HEAD),-1);                       EMITCODEWORD
 1144        CODE_REL(CODE_HEAD) = WORD;                                                 EMITCODEWORD
 1145        CODE_PP(CODE_HEAD) = PP;                                                    EMITCODEWORD
 1146        CODE_RBITS(CODE_HEAD) = RBITS;                                              EMITCODEWORD
 1147        CODE_FULL(CODE_HEAD) = TRUE;                                                EMITCODEWORD
 1148        LABEL_GEN = '';                                                             EMITCODEWORD
 1149        STILLCOND, STILLINZERO = 0;                                                 EMITCODEWORD
 1150        PP = PP + 1;                                                                EMITCODEWORD
 1151  END EMITCODEWORD;                                                                 EMITCODEWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
RBITS           FIXED      9478     DATA   1133       1
W               CHARACTER   788   STRING   1133       1
WORD            FIXED      9477     DATA   1133       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 36
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1152  OUTPUTLABEL:                                                                     *
 1153     PROCEDURE (J);                                                                *
 1154     DECLARE J FIXED;                                                               OUTPUTLABEL
 1155     LABEL_COUNT = LABEL_COUNT+1;                                                   OUTPUTLABEL
 1156     LABEL_BUFFER(0) = SHL(3,36-LABEL_COUNT*2)^LABEL_BUFFER(0);                     OUTPUTLABEL
 1157     LABEL_BUFFER(LABEL_COUNT) = J;                                                 OUTPUTLABEL
 1158     IF(LABEL_COUNT >= BUFFERSIZE) THEN CALL FLUSH_LABELS;                          OUTPUTLABEL
 1159     END OUTPUTLABEL;                                                               OUTPUTLABEL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
J               FIXED      9479     DATA   1153       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 37
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1160  EMITLABEL:PROCEDURE(L,R);                                                        *
 1161        DECLARE L FIXED;                                                            EMITLABEL
 1162        DECLARE R FIXED;                                                            EMITLABEL
 1163        DECLARE I FIXED;                                                            EMITLABEL
 1164        DECLARE J FIXED;                                                            EMITLABEL
 1165        IF R = 3 THEN                                                               EMITLABEL
 1166           DO;                                                                      EMITLABEL
 1167              IF DESCREF(L) = 0 THEN RETURN;                                        EMITLABEL
 1168              J = SHL(DESCREF(L),18) + DP;                                          EMITLABEL
 1169              CALL OUTPUTLABEL(J);                                                  EMITLABEL
 1170              DESCREF(L) = 0;                                                       EMITLABEL
 1171              RETURN;                                                               EMITLABEL
 1172           END;                                                                     EMITLABEL
 1173        STILLINZERO = 0;    /* DON'T TRY OPTIMIZING OVER LABEL */                   EMITLABEL
 1174        J = SHL(R,18) + L;                                                          EMITLABEL
 1175        DO I = 1 TO FOR_COUNT;                                                      EMITLABEL
 1176           IF J = FOR_LABEL(I) THEN                                                 EMITLABEL
 1177              DO;                                                                   EMITLABEL
 1178                 J = SHL(FOR_REF(I)+"(3)400000",18);                                EMITLABEL
 1179                 IF R = 4 THEN J = J + PP + "(3)400000";                            EMITLABEL
 1180                          ELSE J = J + DP;                                          EMITLABEL
 1181                 CALL OUTPUTLABEL(J);                                               EMITLABEL
 1182                 J = I;                                                             EMITLABEL
 1183                 DO WHILE J < FOR_COUNT;                                            EMITLABEL
 1184                    FOR_LABEL(J) = FOR_LABEL(J+1);                                  EMITLABEL
 1185                    FOR_REF(J) = FOR_REF(J+1);                                      EMITLABEL
 1186                    J = J + 1;                                                      EMITLABEL
 1187                 END;                                                               EMITLABEL
 1188                 FOR_LABEL(FOR_COUNT) = 0;                                          EMITLABEL
 1189                 FOR_REF(FOR_COUNT) = 0;                                            EMITLABEL
 1190                 FOR_COUNT = FOR_COUNT -1;                                          EMITLABEL
 1191                 /* PUT A LABEL ON THE NEXT INSTRUCTION GENERATED */                EMITLABEL
 1192                 IF R = 4 & (CONTROL(BYTE('A')) ^ CONTROL(BYTE('E'))) THEN          EMITLABEL
 1193                              LABEL_GEN = LABEL_GEN ^^ '$' ^^ L ^^ ':';             EMITLABEL
 1194                 RETURN;                                                            EMITLABEL
 1195              END;                                                                  EMITLABEL
 1196        END;                                                                        EMITLABEL
 1197        IF R = 4 & (CONTROL(BYTE('A')) ^ CONTROL(BYTE('E'))) THEN                   EMITLABEL
 1198            LABEL_GEN = LABEL_GEN ^^ '$' ^^ L ^^ ':';                               EMITLABEL
 1199        RETURN;                                                                     EMITLABEL
 1200  END EMITLABEL;                                                                    EMITLABEL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9482     DATA   1163       4
J               FIXED      9483     DATA   1164      18
L               FIXED      9480     DATA   1160       6
R               FIXED      9481     DATA   1160       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 38
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1201  REFCHECK:                                                                        *
 1202     PROCEDURE (I);                                                                *
 1203        /* CHECK TO SEE IF THIS SATISFIES ANY FORWARD REFERENCES.                   REFCHECK
 1204           IF SO, SET UP LABEL BUFFER.  IF NOT, CHECK IF THIS                       REFCHECK
 1205           SHOULD BE CHAINED. */                                                    REFCHECK
 1206        DECLARE I FIXED;                                                            REFCHECK
 1207        DECLARE J FIXED;                                                            REFCHECK
 1208        IF SHR(I,18) = 3 THEN                                                       REFCHECK
 1209           DO;                                                                      REFCHECK
 1210              I = I & "(3)777777";                                                  REFCHECK
 1211              J = DESCREF(I);                                                       REFCHECK
 1212              DESCREF(I) = PP + "(3)400000";                                        REFCHECK
 1213              RETURN J;                                                             REFCHECK
 1214           END;                                                                     REFCHECK
 1215        J = 1;                                                                      REFCHECK
 1216        DO WHILE J <= FOR_COUNT;                                                    REFCHECK
 1217           IF FOR_LABEL(J) = I THEN                                                 REFCHECK
 1218              DO;                                                                   REFCHECK
 1219                 I = FOR_REF(J) + "(3)400000";                                      REFCHECK
 1220                 FOR_REF(J) = PP;                                                   REFCHECK
 1221                 RETURN I;                                                          REFCHECK
 1222              END;                                                                  REFCHECK
 1223           J=J+1;                                                                   REFCHECK
 1224        END;                                                                        REFCHECK
 1225        FOR_COUNT = FOR_COUNT +1;                                                   REFCHECK
 1226        IF FOR_COUNT > FOR_MAX THEN CALL ERROR ('TOO MANY FORWARD REFERENCES',3);   REFCHECK
 1227        FOR_REF(FOR_COUNT) = PP;                                                    REFCHECK
 1228        FOR_LABEL(FOR_COUNT) = I;                                                   REFCHECK
 1229        RETURN 0;                                                                   REFCHECK
 1230     END REFCHECK;                                                                  REFCHECK

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9486     DATA   1202       9
J               FIXED      9487     DATA   1207       9
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 39
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1231  EMITINST:PROCEDURE (OPCODE,TREG,INDIRECT,OPERAND,IREG,RELOCATION);               *
 1232        DECLARE OPCODE FIXED,                                                       EMITINST
 1233                TREG FIXED,                                                         EMITINST
 1234                INDIRECT FIXED,                                                     EMITINST
 1235                OPERAND FIXED,                                                      EMITINST
 1236                IREG FIXED,                                                         EMITINST
 1237                RELOCATION FIXED;                                                   EMITINST
 1238        DECLARE RBITS FIXED,                                                        EMITINST
 1239                WORD FIXED;                                                         EMITINST
 1240        /* EMIT A 80 CHARACTER INSTRUCTION IMAGE */                                 EMITINST
 1241        DECLARE RELOC (5) CHARACTER                                                 EMITINST
 1242                INITIAL ('', 'D+', 'P+', 'S+', '$', '$');                           EMITINST
 1243        DECLARE I FIXED,                                                            EMITINST
 1244                J FIXED,                                                            EMITINST
 1245                CARD CHARACTER,                                                     EMITINST
 1246                INDIR (1) CHARACTER INITIAL ('', '@');                              EMITINST
 1247        COUNT_INST = COUNT_INST + 1;                                                EMITINST
 1248                                                                                    EMITINST
 1249        WORD = SHL(OPCODE,27) + SHL(TREG&"F",23) + SHL(INDIRECT&1,22)               EMITINST
 1250               + SHL(IREG&"F",18);                                                  EMITINST
 1251        DO CASE RELOCATION;                                                         EMITINST
 1252           /* CASE 0 : ABSOLUTE ADDRESS - NO RELOCATION */                          EMITINST CASE 0.
 1253           DO;                                                                      EMITINST
 1254              WORD = WORD + (OPERAND&"(3)777777");                                  EMITINST
 1255              RBITS = 0;                                                            EMITINST
 1256           END;                                                                     EMITINST
 1257                                                                                    EMITINST CASE 1.
 1258           /* CASE 1 : RELATIVE TO THE BEGINNING OF DATA SEGMENT */                 EMITINST
 1259           DO;                                                                      EMITINST
 1260              WORD = WORD + (OPERAND&"(3)777777");                                  EMITINST
 1261              RBITS = 1;                                                            EMITINST
 1262           END;                                                                     EMITINST
 1263                                                                                    EMITINST CASE 2.
 1264           /* CASE 2 : RELATIVE TO BEGINNING OF CODE SEGMENT */                     EMITINST
 1265           DO;                                                                      EMITINST
 1266              WORD = WORD + (OPERAND&"(3)777777") + "(3)400000";                    EMITINST
 1267              RBITS = 1;                                                            EMITINST
 1268           END;                                                                     EMITINST
 1269                                                                                    EMITINST CASE 3.
 1270           /* CASE 3 : RELATIVE TO BEGINNING OF STRINGS */                          EMITINST
 1271           DO;                                                                      EMITINST
 1272              I = SHL(RELOCATION,18) + (OPERAND&"(3)777777");                       EMITINST
 1273              J = REFCHECK(I);                                                      EMITINST
 1274              WORD = WORD + J;                                                      EMITINST
 1275              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1276                       ELSE RBITS = 1;                                              EMITINST
 1277           END;                                                                     EMITINST
 1278                                                                                    EMITINST CASE 4.
 1279           /* CASE 4 : FORWARD LABEL REFERENCE IN CODE AREA */                      EMITINST
 1280           DO;                                                                      EMITINST
 1281              J = REFCHECK("(3)4000000" + (OPERAND&"(3)777777"));                   EMITINST
 1282              WORD = WORD + J;                                                      EMITINST C13 = 1048576
 1283              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1284                       ELSE RBITS = 1;                                              EMITINST
 1285           END;                                                                     EMITINST
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 40
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1286                                                                                    EMITINST CASE 5.
 1287           /* CASE 5 : FORWARD LABEL REFERENCE IN DATA AREA */                      EMITINST
 1288           DO;                                                                      EMITINST
 1289              J = REFCHECK("(3)5000000" + (OPERAND&"(3)777777"));                   EMITINST
 1290              WORD = WORD + J;                                                      EMITINST C14 = 1310720
 1291              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1292                       ELSE RBITS = 1;                                              EMITINST
 1293           END;                                                                     EMITINST
 1294        END;  /* END OF DO CASE RELOCATION */                                       EMITINST CASE 6.
 1295                                                                                    EMITINST
 1296        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('E')) THEN                             EMITINST
 1297           DO;                                                                      EMITINST
 1298              I = SHR(OPCODE,5);                                                    EMITINST
 1299              CARD = X7 ^^ SUBSTR(OPNAME(I),(OPCODE-I*32)*6,6) ^^ X1 ^^TREG ^^ ','  EMITINST
 1300                     ^^ INDIR(INDIRECT) ^^ RELOC(RELOCATION) ^^ OPERAND;            EMITINST C15 = 805306368
 1301              IF IREG > 0 THEN CARD = CARD ^^ '(' ^^ IREG ^^ ')';                   EMITINST
 1302              CARD = CARD ^^ '; P' ^^ PP;                                           EMITINST
 1303           END;                                                                     EMITINST
 1304        INSTRUCT(OPCODE) = INSTRUCT(OPCODE) + 1;                                    EMITINST
 1305        CALL EMITCODEWORD (CARD,WORD,RBITS);                                        EMITINST
 1306  END EMITINST;                                                                     EMITINST

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CARD            CHARACTER   800   STRING   1245       6
I               FIXED      9505     DATA   1243       5
INDIR           CHARACTER   801   STRING   1246       1
INDIRECT        FIXED      9497     DATA   1231       2
IREG            FIXED      9499     DATA   1231       3
J               FIXED      9506     DATA   1244       9
OPCODE          FIXED      9495     DATA   1231       5
OPERAND         FIXED      9498     DATA   1231       7
RBITS           FIXED      9501     DATA   1238      10
RELOC           CHARACTER   794   STRING   1241       1
RELOCATION      FIXED      9500     DATA   1231       3
TREG            FIXED      9496     DATA   1231       2
WORD            FIXED      9502     DATA   1239      14
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 41
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1307  EMITDESC:PROCEDURE (L,A);                                                        *
 1308        DECLARE L FIXED,                                                            EMITDESC
 1309                A FIXED;                                                            EMITDESC
 1310        /* SEND A LENGTH AND STRING ADDRESS TO THE DESCRIPTOR AREA */               EMITDESC
 1311        IF DSP > DESCLIMIT THEN                                                     EMITDESC
 1312           DO;                                                                      EMITDESC
 1313              CALL ERROR ('TOO MANY STRINGS',1);                                    EMITDESC
 1314              DSP = 0;                                                              EMITDESC
 1315           END;                                                                     EMITDESC
 1316         IF CONTROL(BYTE('B')) THEN                                                 EMITDESC
 1317           CALL PRINTLINE (X70 ^^ 'DESC =        ' ^^ L ^^ ',' ^^ A ^^ '; S' ^^ DSP,-1); EMITDESC
 1318        DESCL(DSP) = L;                                                             EMITDESC
 1319        DESCA(DSP) = A;                                                             EMITDESC
 1320        DSP = DSP + 1;                                                              EMITDESC
 1321  END EMITDESC;                                                                     EMITDESC

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
A               FIXED      9514     DATA   1307       2
L               FIXED      9513     DATA   1307       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 42
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1322  FINDLABEL:PROCEDURE;                                                             *
 1323        LABEL_SINK = LABEL_SINK + 1;                                                FINDLABEL
 1324        RETURN (LABEL_SINK);                                                        FINDLABEL
 1325  END FINDLABEL;                                                                    FINDLABEL
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 43
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1326   /*                                                                              *
 1327             S Y M B O L   T A B L E   P R O C E D U R E S                         *
 1328   */                                                                              *
 1329                                                                                   *
 1330  HASHER:                                                                          *
 1331     PROCEDURE (ID);          /* CALCULATE HASH INDEX INTO HASH TABLE*/            *
 1332     DECLARE ID   CHARACTER;                                                        HASHER
 1333     DECLARE L    FIXED;                                                            HASHER
 1334     L = LENGTH (ID);                                                               HASHER
 1335     RETURN (BYTE (ID) + BYTE (ID, L-1) + SHL (L,4)) & "FF";                        HASHER
 1336     END HASHER;                                                                    HASHER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
ID              CHARACTER   811   STRING   1331       3
L               FIXED      9524     DATA   1333       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 44
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1337                                                                                   *
 1338  ENTER:PROCEDURE (N, T, L, S);                                                    *
 1339        DECLARE T FIXED, L FIXED, S FIXED;                                          ENTER
 1340        DECLARE N CHARACTER;                                                        ENTER
 1341   /* ENTER THE NAME N IN THE SYMBOL TABLE WITH TYPE T AT LOCATION L SEGMENT S */   ENTER
 1342        DECLARE I FIXED, K FIXED;                                                   ENTER
 1343        IDX = HASHER (N);                                                           ENTER
 1344        I = HASH (IDX);                                                             ENTER
 1345        DO WHILE I >= PROCMARK;                                                     ENTER
 1346           IDCOMPARES = IDCOMPARES + 1;                                             ENTER
 1347           IF N = SYT (I) THEN                                                      ENTER
 1348              DO;                                                                   ENTER
 1349                 K = SYTYPE (I);                                                    ENTER
 1350                 IF T = LABELTYPE & (K = FORWARDTYPE ^ K = FORWARDCALL) THEN        ENTER
 1351                    DO;                                                             ENTER
 1352                       IF CONTROL (BYTE ('E')) THEN                                 ENTER
 1353                          CALL PRINTLINE (X70 ^^ 'FIXED REFERENCES TO: ' ^^ N,-1);  ENTER
 1354                       IF K = FORWARDTYPE THEN                                      ENTER
 1355                          DO;                                                       ENTER
 1356                             CALL EMITLABEL(SYTLOC(I),4);                           ENTER
 1357                             SYTLOC(I) = L;                                         ENTER
 1358                             SYTSEG(I) = S;                                         ENTER
 1359                          END;                                                      ENTER
 1360                       SYTYPE (I) = T;                                              ENTER
 1361                    END;                                                            ENTER
 1362                 ELSE IF PROCMARK + PARCT < I THEN                                  ENTER
 1363                    CALL ERROR ('DUPLICATE DECLARATION FOR: ' ^^ N, 0);             ENTER
 1364                 RETURN I;                                                          ENTER
 1365              END;                                                                  ENTER
 1366           I = PTR (I);                                                             ENTER
 1367        END;                                                                        ENTER
 1368        NDECSY = NDECSY + 1;                                                        ENTER
 1369        IF NDECSY > MAXNDECSY THEN                                                  ENTER
 1370           IF NDECSY > SYTSIZE THEN                                                 ENTER
 1371              DO;                                                                   ENTER
 1372                 CALL ERROR ('SYMBOL TABLE OVERFLOW', 1);                           ENTER
 1373                 NDECSY = NDECSY - 1;                                               ENTER
 1374              END;                                                                  ENTER
 1375           ELSE MAXNDECSY = NDECSY;                                                 ENTER
 1376        SYT (NDECSY) = N;                                                           ENTER
 1377        SYTYPE (NDECSY) = T;                                                        ENTER
 1378        SYTLOC (NDECSY) = L;                                                        ENTER
 1379        SYTSEG (NDECSY) = S;                                                        ENTER
 1380        SYTCO (NDECSY) = 0;                                                         ENTER
 1381        SYTCARD (NDECSY) = CARD_COUNT;                                              ENTER
 1382        PTR (NDECSY) = HASH (IDX);                                                  ENTER
 1383        HASH (IDX) = NDECSY;                                                        ENTER
 1384        RETURN (NDECSY);                                                            ENTER
 1385  END ENTER;                                                                        ENTER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9528     DATA   1342      12
K               FIXED      9529     DATA   1342       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 45
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 
L               FIXED      9526     DATA   1338       2
N               CHARACTER   812   STRING   1338       5
S               FIXED      9527     DATA   1338       2
T               FIXED      9525     DATA   1338       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 46
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1386   ID_LOOKUP:                                                                      *
 1387     PROCEDURE (P);                                                                *
 1388        /* LOOKS UP THE IDENTIFIER AT P IN THE ANALYSIS STACK IN THE                ID_LOOKUP
 1389           SYMBOL TABLE AND INITIALIZES FIXL, CNT, TYPE, AND INX                    ID_LOOKUP
 1390           APPROPRIATELY.  IF THE IDENTIFIER IS NOT FOUND, FIXL IS                  ID_LOOKUP
 1391           SET TO -1                                                                ID_LOOKUP
 1392        */                                                                          ID_LOOKUP
 1393        DECLARE P FIXED, I FIXED;                                                   ID_LOOKUP
 1394        CHAR_TEMP = VAR (P);                                                        ID_LOOKUP
 1395        I = HASH (HASHER (CHAR_TEMP));                                              ID_LOOKUP
 1396        DO WHILE I \= -1;                                                           ID_LOOKUP
 1397           IDCOMPARES = IDCOMPARES + 1;                                             ID_LOOKUP C16 = -1
 1398           IF SYT(I) = CHAR_TEMP THEN                                               ID_LOOKUP
 1399              DO;                                                                   ID_LOOKUP
 1400                 FIXL (P) = I;                                                      ID_LOOKUP
 1401                 CNT (P) = 0;        /* INITIALIZE SUBSCRIPT COUNT */               ID_LOOKUP
 1402                 TYPE (P) = VARIABLE;                                               ID_LOOKUP
 1403                 IF SYTYPE (I) = SPECIAL THEN                                       ID_LOOKUP
 1404                    FIXV (P) = SYTLOC (I);    /* BUILTIN FUNCTION */                ID_LOOKUP
 1405                 ELSE                                                               ID_LOOKUP
 1406                    FIXV (P) = 0;                                                   ID_LOOKUP
 1407                 INX (P) = 0;       /* LOCATION OF INDEX */                         ID_LOOKUP
 1408                 REG(P) = 0;                                                        ID_LOOKUP
 1409                 SYTCO (I) = SYTCO (I) + 1;                                         ID_LOOKUP
 1410                 RETURN;                                                            ID_LOOKUP
 1411              END;                                                                  ID_LOOKUP
 1412           I = PTR (I);                                                             ID_LOOKUP
 1413        END;                                                                        ID_LOOKUP
 1414        FIXL (P) = -1;              /* IDENTIFIER NOT FOUND */                      ID_LOOKUP
 1415  END ID_LOOKUP;                                                                    ID_LOOKUP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9549     DATA   1393      10
P               FIXED      9548     DATA   1387       9
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 47
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1416  UNDECLARED_ID:                                                                   *
 1417     PROCEDURE (P);                                                                *
 1418        /* ISSUES AN ERROR MESSAGE FOR UNDECLARED IDENTIFIERS AND                   UNDECLARED_ID
 1419           ENTERS THEM WITH DEFAULT TYPE IN THE SYMBOL TABLE                        UNDECLARED_ID
 1420       */                                                                           UNDECLARED_ID
 1421        DECLARE P FIXED;                                                            UNDECLARED_ID
 1422        CALL ERROR ('UNDECLARED IDENTIFIER: ' ^^ VAR (P), 0);                       UNDECLARED_ID
 1423        CALL EMITDATAWORD (0);                                                      UNDECLARED_ID
 1424        FIXL (P) = ENTER (VAR (P), FIXEDTYPE, DP-1, 1);                             UNDECLARED_ID
 1425        CNT (P) = 0;                                                                UNDECLARED_ID
 1426        FIXV (P) = 0;                                                               UNDECLARED_ID
 1427        INX (P) = 0;                                                                UNDECLARED_ID
 1428        SYTCO (NDECSY) = 1;            /* COUNT FIRST REFERENCE */                  UNDECLARED_ID
 1429        SYTCARD (NDECSY) = -1;         /* FLAG UNDECLARED IDENTIFIER */             UNDECLARED_ID
 1430        TYPE (P) = VARIABLE;                                                        UNDECLARED_ID
 1431  END UNDECLARED_ID;                                                                UNDECLARED_ID

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9551     DATA   1417       7
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 48
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1432   /*                                                                              *
 1433          A R I T H E M E T I C   P R O C E D U R E S                              *
 1434   */                                                                              *
 1435  CLEARARS:                                                                        *
 1436     PROCEDURE;                                                                    *
 1437        /* FREE ALL THE TEMPROARY ARITHEMETIC REGISTERS */                          CLEARARS
 1438        DO I = 0 TO 11;                                                             CLEARARS
 1439           ACC(I) = AVAIL;                                                          CLEARARS C17 = 11
 1440        END;                                                                        CLEARARS
 1441  END CLEARARS;                                                                     CLEARARS
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 49
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1442  FINDAR:                                                                          *
 1443     PROCEDURE;                                                                    *
 1444         DECLARE I FIXED;                                                           FINDAR
 1445        /* GET A TEMPORARY ARITHEMETIC REGISTER */                                  FINDAR
 1446        IF TARGET_REGISTER > -1 THEN                                                FINDAR
 1447           IF ACC (TARGET_REGISTER) = AVAIL THEN                                    FINDAR
 1448              DO;                                                                   FINDAR
 1449                 ACC (TARGET_REGISTER) = BUSY;                                      FINDAR
 1450                 RETURN TARGET_REGISTER;                                            FINDAR
 1451              END;                                                                  FINDAR
 1452        DO I = 1 TO 11;                                                             FINDAR
 1453           IF ACC(I) = AVAIL THEN                                                   FINDAR
 1454              DO;                                                                   FINDAR
 1455                 ACC(I) = BUSY;                                                     FINDAR
 1456                 RETURN (I);                                                        FINDAR
 1457              END;                                                                  FINDAR
 1458        END;                                                                        FINDAR
 1459        CALL ERROR ('USED ALL ACCUMULATORS', 0);                                    FINDAR
 1460        RETURN (0);                                                                 FINDAR
 1461  END FINDAR;                                                                       FINDAR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9559     DATA   1444       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 50
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1462  MOVESTACKS:                                                                      *
 1463     PROCEDURE (F, T);                                                             *
 1464        DECLARE F FIXED, T FIXED;                                                   MOVESTACKS
 1465        /* MOVE ALL COMPILER STACKS DOWN FROM F TO T */                             MOVESTACKS
 1466        TYPE (T) = TYPE (F);                                                        MOVESTACKS
 1467        REG (T) = REG (F);                                                          MOVESTACKS
 1468        CNT (T) = CNT (F);                                                          MOVESTACKS
 1469        VAR (T) = VAR (F);                                                          MOVESTACKS
 1470        FIXL (T) = FIXL (F);                                                        MOVESTACKS
 1471        FIXV (T) = FIXV (F);                                                        MOVESTACKS
 1472        INX (T) = INX (F);                                                          MOVESTACKS
 1473        PPSAVE (T) = PPSAVE (F);                                                    MOVESTACKS
 1474  END MOVESTACKS;                                                                   MOVESTACKS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
F               FIXED      9566     DATA   1463       8
T               FIXED      9567     DATA   1463       8
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 51
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1475  FORCEADDRESS:                                                                    *
 1476     PROCEDURE(SP);                                                                *
 1477        /* GENERATES THE ADDRESS OF <VARIABLE> IN THE ANALYSIS STACK                FORCEADDRESS
 1478           AT SP.                                                                   FORCEADDRESS
 1479        */                                                                          FORCEADDRESS
 1480        DECLARE SP FIXED, J FIXED, R FIXED;                                         FORCEADDRESS
 1481        R = FINDAR;                                                                 FORCEADDRESS
 1482        J = FIXL(SP);                                                               FORCEADDRESS
 1483        CALL EMITINST (MOVEI,R,0,SYTLOC(J),0,SYTSEG(J));                            FORCEADDRESS
 1484        REG(J) = R;                                                                 FORCEADDRESS
 1485  END FORCEADDRESS;                                                                 FORCEADDRESS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
J               FIXED      9569     DATA   1480       4
R               FIXED      9570     DATA   1480       3
SP              FIXED      9568     DATA   1476       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 52
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1486  SETINIT:                                                                         *
 1487     PROCEDURE;                                                                    *
 1488        /* PLACES INITIAL VALUES INTO DATA AREA */                                  SETINIT
 1489        DECLARE TMIIIL CHARACTER INITIAL ('TOO MANY ITEMS IN INITIAL LIST');        SETINIT
 1490        IF ITYPE = CHRTYPE THEN                                                     SETINIT
 1491           DO;                                                                      SETINIT
 1492              IF DSP < NEWDSP THEN                                                  SETINIT
 1493                 DO;                                                                SETINIT
 1494                    IF TYPE (MPP1) \= CHRTYPE THEN S = FIXV (MPP1);                 SETINIT
 1495                    ELSE S = VAR (MPP1);     /* THE STRING */                       SETINIT
 1496                    I = LENGTH (S);                                                 SETINIT
 1497                    IF I = 0 THEN                                                   SETINIT
 1498                       CALL EMITDESC (0,0);                                         SETINIT
 1499                    ELSE                                                            SETINIT
 1500                       DO;                                                          SETINIT
 1501                          CALL EMITDESC (I, DPOFFSET+SHL(DP,2));                    SETINIT
 1502                          DO J = 0 TO I - 1;                                        SETINIT
 1503                             CALL EMITBYTE (BYTE (S, J));                           SETINIT
 1504                          END;                                                      SETINIT
 1505                        END;                                                        SETINIT
 1506                 END;                                                               SETINIT
 1507              ELSE CALL ERROR (TMIIIL,0);                                           SETINIT
 1508           END;                                                                     SETINIT
 1509        ELSE                                                                        SETINIT
 1510           IF TYPE (MPP1) \= CONSTANT THEN                                          SETINIT
 1511              CALL ERROR ('ILLEGAL CONSTANT IN INITIAL LIST',0);                    SETINIT
 1512           ELSE                                                                     SETINIT
 1513              IF ITYPE = FIXEDTYPE THEN                                             SETINIT
 1514                 DO;                                                                SETINIT
 1515                 IF DP < NEWDP THEN CALL EMITDATAWORD (FIXV(MPP1));                 SETINIT
 1516                 ELSE CALL ERROR (TMIIIL,0);                                        SETINIT
 1517                 END;                                                               SETINIT
 1518              ELSE   /* MUST BE BYTETYPE */                                         SETINIT
 1519                 IF DP < NEWDP ^ (DP = NEWDP & DPOFFSET < NEWDPOFFSET) THEN         SETINIT
 1520                    CALL EMITBYTE(FIXV(MPP1));                                      SETINIT
 1521                 ELSE CALL ERROR (TMIIIL,0);                                        SETINIT
 1522  END SETINIT;                                                                      SETINIT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
TMIIIL          CHARACTER   818   STRING   1489       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 53
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1523  SAVE_ACS:                                                                        *
 1524     PROCEDURE (N);                                                                *
 1525        /* GENERATE CODE TO SAVE BUSY ACS, UP TO AC-N */                            SAVE_ACS
 1526        DECLARE N FIXED;                                                            SAVE_ACS
 1527        DECLARE I FIXED;                                                            SAVE_ACS
 1528        DO I = 1 TO N;                                                              SAVE_ACS
 1529           IF (ACC(I) = BUSY) THEN CALL EMITINST (PUSH,15,0,I,0,0);                 SAVE_ACS
 1530        END;                                                                        SAVE_ACS
 1531  END SAVE_ACS;                                                                     SAVE_ACS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9589     DATA   1527       3
N               FIXED      9588     DATA   1524       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 54
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1532  RESTORE_ACS:                                                                     *
 1533     PROCEDURE (N);                                                                *
 1534        /* GENERATE CODE TO RESTORE BUSY ACS, UP TO AC-N  */                        RESTORE_ACS
 1535        DECLARE N FIXED;                                                            RESTORE_ACS
 1536        DECLARE I FIXED, J FIXED;                                                   RESTORE_ACS
 1537        DO I = 1 TO N;                                                              RESTORE_ACS
 1538           J = N - I + 1;                                                           RESTORE_ACS
 1539           IF (ACC(J) = BUSY) THEN CALL EMITINST (POP,15,0,J,0,0);                  RESTORE_ACS
 1540        END;                                                                        RESTORE_ACS
 1541  END RESTORE_ACS;                                                                  RESTORE_ACS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9592     DATA   1536       2
J               FIXED      9593     DATA   1536       3
N               FIXED      9591     DATA   1533       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 55
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1542  PROC_START:                                                                      *
 1543     PROCEDURE;                                                                    *
 1544        /* GENERATES CODE FOR THE HEAD OF A PROCEDURE */                            PROC_START
 1545        PPSAVE(MP) = FINDLABEL;           /* SOMETHING TO GOTO */                   PROC_START
 1546        CALL EMITINST (JRST,0,0,PPSAVE(MP),0,4); /* GO AROUND PROC */               PROC_START
 1547        IF SYTSEG(FIXL(MP)) = 4 THEN CALL EMITLABEL(SYTLOC(FIXL(MP)),4);            PROC_START
 1548        SYTSEG(FIXL(MP)) = 2;                                                       PROC_START
 1549        SYTLOC(FIXL(MP)) = PP;            /* ADDR OF PROC */                        PROC_START
 1550  END PROC_START;                                                                   PROC_START
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 56
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1551  TDECLARE:                                                                        *
 1552     PROCEDURE (DIM);                                                              *
 1553     /* ALLOCATES STORAGE FOR IDENTIFIERS IN DECLARATION */                         TDECLARE
 1554        DECLARE DIM FIXED;                                                          TDECLARE
 1555        DECLARE I   FIXED;                                                          TDECLARE
 1556     ALLOCATE:                                                                      TDECLARE
 1557        PROCEDURE (P, DIM);                                                         TDECLARE
 1558           /* ALLOCATES STORAGE FOR THE IDENTIFIER AT P IN THE ANALYSIS             ALLOCATE
 1559              STACK WITH DIMENSION DIM                                              ALLOCATE
 1560           */                                                                       ALLOCATE
 1561           DECLARE P FIXED, DIM FIXED, J FIXED, K FIXED;                            ALLOCATE
 1562           DIM = DIM + 1;                    /* ACTUAL NUMBER OF ITEMS */           ALLOCATE
 1563           DO CASE TYPE (P);                                                        ALLOCATE
 1564              ;    /*  CASE 0 -- DUMMY */                                           ALLOCATE CASE 0.
 1565              ;    /*  CASE 1 -- LABEL TYPE */                                      ALLOCATE CASE 1.
 1566              ;    /*  CASE 2 -- ACCUMULATOR */                                     ALLOCATE CASE 2.
 1567              ;    /*  CASE 3 -- VARIABLE */                                        ALLOCATE CASE 3.
 1568              ;    /*  CASE 4 -- CONSTANT */                                        ALLOCATE CASE 4.
 1569              ;    /*  CASE 5 -- CONDITION */                                       ALLOCATE CASE 5.
 1570              DO;   /* CASE 6 -- CHRTYPE */                                         ALLOCATE CASE 6.
 1571                 J = DSP; K = 3;                                                    ALLOCATE
 1572                 NEWDSP = DSP + DIM;                                                ALLOCATE
 1573              END;                                                                  ALLOCATE
 1574              DO;  /*  CASE 7 -- FIXEDTYPE */                                       ALLOCATE CASE 7.
 1575                 IF DPOFFSET > 0 THEN                                               ALLOCATE
 1576                    DO;                                                             ALLOCATE
 1577                       CALL FLUSH_DATACARD;                                         ALLOCATE
 1578                       OLDDP = DP;                                                  ALLOCATE
 1579                       OLDDPOFFSET = 0;                                             ALLOCATE
 1580                    END;                                                            ALLOCATE
 1581                 J = DP; K = 1;                                                     ALLOCATE
 1582                 NEWDP = DP + DIM; NEWDPOFFSET = 0;                                 ALLOCATE
 1583              END;                                                                  ALLOCATE
 1584              DO;  /*  CASE 8 -- BYTETYPE */                                        ALLOCATE CASE 8.
 1585                 IF DPOFFSET > 0 THEN                                               ALLOCATE
 1586                    IF I = 1 THEN                                                   ALLOCATE
 1587                       DO;                                                          ALLOCATE
 1588                          CALL FLUSH_DATACARD;                                      ALLOCATE
 1589                          OLDDP = DP; OLDDPOFFSET = 0;                              ALLOCATE
 1590                       END;                                                         ALLOCATE
 1591                    ELSE                                                            ALLOCATE
 1592                       DO;                                                          ALLOCATE
 1593                          DP = DP + 1; DPOFFSET = 0;                                ALLOCATE
 1594                       END;                                                         ALLOCATE
 1595                 NEWDPOFFSET = DIM MOD 4;                                           ALLOCATE
 1596                 NEWDP = DP + DIM/4;                                                ALLOCATE
 1597                 J = DP; K = 1;                                                     ALLOCATE
 1598              END;                                                                  ALLOCATE
 1599              DO;  /*  CASE 9 -- FORWARDTYPE */                                     ALLOCATE CASE 9.
 1600                 J = FINDLABEL; K = 4;                                              ALLOCATE
 1601                 NEWDP = DP; NEWDPOFFSET = DPOFFSET; /* COPY OLD POINTERS  */       ALLOCATE
 1602              END;                                                                  ALLOCATE
 1603              ;    /*  CASE 10 -- DESCRIPT */                                       ALLOCATE CASE 10.
 1604              ;    /*  CASE 11 -- SPECIAL */                                        ALLOCATE CASE 11.
 1605              ;    /*  CASE 12 -- FORWARDCALL */                                    ALLOCATE CASE 12.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 57
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1606              ;    /*  CASE 13 -- PROCTYPE */                                       ALLOCATE CASE 13.
 1607              ;    /*  CASE 14 -- CHARPROCTYPE */                                   ALLOCATE CASE 14.
 1608           END; /* CASE ON TYPE (P) */                                              ALLOCATE CASE 15.
 1609           SYTYPE (FIXL(P)) = TYPE (P);                                             ALLOCATE
 1610           SYTLOC (FIXL (P)) = J;                                                   ALLOCATE
 1611           SYTSEG (FIXL (P)) = K;                                                   ALLOCATE
 1612     END ALLOCATE;                                                                  ALLOCATE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
DIM             FIXED      9598     DATA   1557       6
J               FIXED      9599     DATA   1561       5
K               FIXED      9600     DATA   1561       5
P               FIXED      9597     DATA   1557       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 58
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1613                                                                                    TDECLARE
 1614        OLDDP = DP;                                                                 TDECLARE
 1615        OLDDSP = DSP;                                                               TDECLARE
 1616        OLDDPOFFSET = DPOFFSET;                                                     TDECLARE
 1617        TYPE(MP) = TYPE(SP);                                                        TDECLARE
 1618        CASEP = FIXL(MP);                                                           TDECLARE
 1619        DO I = 1 TO INX(MP);                                                        TDECLARE
 1620           FIXL(MP) = CASESTACK(CASEP+I); /* SYMBOL TABLE POINTER */                TDECLARE
 1621           CALL ALLOCATE (MP,DIM);                                                  TDECLARE
 1622           DP = NEWDP;                                                              TDECLARE
 1623           DSP = NEWDSP;                                                            TDECLARE
 1624           DPOFFSET = NEWDPOFFSET;                                                  TDECLARE
 1625           END;                                                                     TDECLARE
 1626        DP = OLDDP;                                                                 TDECLARE
 1627        DSP = OLDDSP;                                                               TDECLARE
 1628        DPOFFSET = OLDDPOFFSET;                                                     TDECLARE
 1629  END TDECLARE;                                                                     TDECLARE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
ALLOCATE        PROCEDURE  3520  PROGRAM   1556       1
  PARAMETER  1  FIXED      9597     DATA   1557       6
  PARAMETER  2  FIXED      9598     DATA   1557       7
DIM             FIXED      9595     DATA   1552       1
I               FIXED      9596     DATA   1555       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 59
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1630  CHECK_STRING_OVERFLOW:                                                           *
 1631     PROCEDURE;                                                                    *
 1632        /* GENERATE A CHECK TO SEE IF COMPACTIFY NEEDS TO BE CALLED */              CHECK_STRING_OVERFLOW
 1633        CALL EMITINST (PUSHJ,15,0,STRING_CHECK,0,2);                                CHECK_STRING_OVERFLOW
 1634  END CHECK_STRING_OVERFLOW;                                                        CHECK_STRING_OVERFLOW
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 60
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1635  CALLSUB:PROCEDURE (SL,F,P);                                                      *
 1636        /* GENERATES CODE TO CALL A FUNCTION OR PROCEDURE AT SL                     CALLSUB
 1637           ALSO DOES HOUSEKEEPING FOR RETURN VALUES                                 CALLSUB
 1638        */                                                                          CALLSUB
 1639        DECLARE SL FIXED, F FIXED, P FIXED;                                         CALLSUB
 1640        CALL SAVE_ACS (11);                                                         CALLSUB
 1641        CALL EMITINST (PUSHJ,15,0,SL,0,SYTSEG(FIXL(P)));                            CALLSUB
 1642        CALL RESTORE_ACS (11);                                                      CALLSUB
 1643        IF F = 1 THEN                                                               CALLSUB
 1644           DO;  /* MOVE RETURNED VALUE FROM REGISTER ZERO */                        CALLSUB
 1645              I = FINDAR;                                                           CALLSUB
 1646              IF I \= 0 THEN CALL EMITINST (MOVE,I,0,0,0,0);                        CALLSUB
 1647              TYPE(P) = ACCUMULATOR;                                                CALLSUB
 1648              REG(P) = I;                                                           CALLSUB
 1649              ACC(I) = BUSY;                                                        CALLSUB
 1650              STILLINZERO = I;                                                      CALLSUB
 1651           END;                                                                     CALLSUB
 1652  END CALLSUB;                                                                      CALLSUB

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
F               FIXED      9603     DATA   1635       1
P               FIXED      9604     DATA   1635       3
SL              FIXED      9602     DATA   1635       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 61
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1653  BACKUP:                                                                          *
 1654     PROCEDURE;                                                                    *
 1655           CODE_FULL(CODE_HEAD) = FALSE;                                            BACKUP
 1656           CODE_HEAD = (CODE_HEAD-1) & 3;                                           BACKUP
 1657           INSTRUCT(MOVE) = INSTRUCT(MOVE) -1;                                      BACKUP
 1658           PP = PP - 1;                                                             BACKUP
 1659           STILLINZERO = 0;                                                         BACKUP
 1660           IF CONTROL(BYTE('E')) THEN                                               BACKUP
 1661              CALL PRINTLINE (BACKMSG,-1);                                          BACKUP
 1662     END BACKUP;                                                                    BACKUP
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 62
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1663  DELETE_MOVE:                                                                     *
 1664     PROCEDURE (P,OP,AC,IND,OPERAND,INDEX,RELOC);                                  *
 1665     /*  CHECK STILLINZERO FLAG TO SEE IF THE DATUM ABOUT TO                        DELETE_MOVE
 1666          BE MOVED IS STILL IN REGISTER ZERO.  IF SO, THEN DELETE                   DELETE_MOVE
 1667          THE LAST INSTRUCTION GENERATED (IF A "MOVE"),                             DELETE_MOVE
 1668          AND MOVE IT DIRECTLY FROM 0 TO THE DESRIED DEST.                          DELETE_MOVE
 1669          THIS IS DESIGNED TO ELIMINATE MOST EXTRA MOVES                            DELETE_MOVE
 1670          OF FUNCTION RESULTS. */                                                   DELETE_MOVE
 1671        DECLARE P FIXED;                                                            DELETE_MOVE
 1672        DECLARE OP FIXED, AC FIXED, IND FIXED, OPERAND FIXED,                       DELETE_MOVE
 1673             INDEX FIXED, RELOC FIXED;                                              DELETE_MOVE
 1674        IF STILLINZERO \= 0 THEN                                                    DELETE_MOVE
 1675           DO;                                                                      DELETE_MOVE
 1676              IF OP = MOVEM & STILLINZERO = AC THEN                                 DELETE_MOVE
 1677                 DO;                                                                DELETE_MOVE
 1678                    CALL BACKUP;                                                    DELETE_MOVE
 1679                    ACC(REG(P)) = AVAIL;                                            DELETE_MOVE
 1680                    REG(P) = 0;                                                     DELETE_MOVE
 1681                    AC = 0;                                                         DELETE_MOVE
 1682                 END;                                                               DELETE_MOVE
 1683              ELSE IF OP = MOVE  & STILLINZERO = OPERAND                            DELETE_MOVE
 1684                                 & (IND + INDEX + RELOC) = 0 THEN                   DELETE_MOVE
 1685                 DO;                                                                DELETE_MOVE
 1686                    CALL BACKUP;                                                    DELETE_MOVE
 1687                    ACC(REG(P)) = AVAIL;                                            DELETE_MOVE
 1688                    REG(P) = 0;                                                     DELETE_MOVE
 1689                    OPERAND = 0;                                                    DELETE_MOVE
 1690                 END;                                                               DELETE_MOVE
 1691           END;                                                                     DELETE_MOVE
 1692        CALL EMITINST (OP,AC,IND,OPERAND,INDEX,RELOC);                              DELETE_MOVE
 1693     END DELETE_MOVE;                                                               DELETE_MOVE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
AC              FIXED      9607     DATA   1664       3
IND             FIXED      9608     DATA   1664       2
INDEX           FIXED      9610     DATA   1664       2
OP              FIXED      9606     DATA   1664       3
OPERAND         FIXED      9609     DATA   1664       3
P               FIXED      9605     DATA   1664       4
RELOC           FIXED      9611     DATA   1664       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 63
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1694  EMIT_INLINE:                                                                     *
 1695     PROCEDURE (FLAG);                                                             *
 1696     /* GENERATE AN ARBITRARY INSTRUCTION SPECIFIED BY PROGRAMMER */                EMIT_INLINE
 1697        DECLARE FLAG BIT(1);                                                        EMIT_INLINE
 1698        DECLARE FL FIXED;                                                           EMIT_INLINE
 1699        DECLARE INST(5) FIXED;                                                      EMIT_INLINE
 1700        DECLARE BINLM CHARACTER INITIAL ('IMPROPER ARGUMENT TO INLINE');            EMIT_INLINE
 1701        IF CNT(MP) < 5 THEN                                                         EMIT_INLINE
 1702           DO;                                                                      EMIT_INLINE
 1703              IF TYPE(MPP1) = CONSTANT THEN INST(CNT(MP)-1) = FIXV(MPP1);           EMIT_INLINE
 1704              ELSE CALL ERROR (BINLM,1);                                            EMIT_INLINE
 1705              IF FLAG THEN CALL ERROR (BINLM,1);                                    EMIT_INLINE
 1706           END;                                                                     EMIT_INLINE
 1707        ELSE IF CNT(MP) = 5 THEN                                                    EMIT_INLINE
 1708           DO;                                                                      EMIT_INLINE
 1709              IF TYPE(MPP1) = CONSTANT THEN                                         EMIT_INLINE
 1710                 DO;                                                                EMIT_INLINE
 1711                    INST(4) = FIXV(MPP1);                                           EMIT_INLINE
 1712                    INST(5) = 0;                                                    EMIT_INLINE
 1713                 END;                                                               EMIT_INLINE
 1714              ELSE IF TYPE(MPP1) = VARIABLE THEN                                    EMIT_INLINE
 1715                 DO;                                                                EMIT_INLINE
 1716                    FL = FIXL(MPP1);                                                EMIT_INLINE
 1717                    INST(4) = SYTLOC(FL);                                           EMIT_INLINE
 1718                    INST(5) = SYTSEG(FL);                                           EMIT_INLINE
 1719                 END;                                                               EMIT_INLINE
 1720              ELSE CALL ERROR (BINLM,1);                                            EMIT_INLINE
 1721              CALL EMITINST (INST(0),INST(1),INST(2),INST(4),INST(3),INST(5));      EMIT_INLINE
 1722              REG(MP) = INST(1);                                                    EMIT_INLINE
 1723              TYPE(MP) = ACCUMULATOR;                                               EMIT_INLINE
 1724           END;                                                                     EMIT_INLINE
 1725        ELSE CALL ERROR (BINLM,1);  /* TOO MANY ARGS TO INLINE */                   EMIT_INLINE
 1726     END EMIT_INLINE;                                                               EMIT_INLINE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
BINLM           CHARACTER   820   STRING   1700       4
FL              FIXED      9613     DATA   1698       3
FLAG            BIT (9)    9612     DATA   1695       1
INST            FIXED      9614     DATA   1699      12
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 64
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1727  LIBRARY_CALL:   PROCEDURE (RESULT, CODE, MP, SP);                                *
 1728     /*                                                                             LIBRARY_CALL
 1729     GENERATE THE CODE FOR A CALL TO THE RUN-TIME ROUTINES.                         LIBRARY_CALL
 1730     */                                                                             LIBRARY_CALL
 1731     DECLARE RESULT FIXED,   /* 0 = L.H.S. OF = */                                  LIBRARY_CALL
 1732             CODE FIXED,     /* CODE FOR RUN-TIME ROUTINE*/                         LIBRARY_CALL
 1733             MP   FIXED,     /* STACK POINTER */                                    LIBRARY_CALL
 1734             SP   FIXED;     /* TOP OF STACK POINTER */                             LIBRARY_CALL
 1735     DECLARE R    FIXED;                                                            LIBRARY_CALL
 1736                                                                                    LIBRARY_CALL
 1737     IF RESULT = 0 THEN                                                             LIBRARY_CALL
 1738        DO;                                                                         LIBRARY_CALL
 1739           IF STILLINZERO = REG(SP) THEN                                            LIBRARY_CALL
 1740              DO;                                                                   LIBRARY_CALL
 1741                 CALL BACKUP;                                                       LIBRARY_CALL
 1742                 ACC(REG(SP)) = AVAIL;                                              LIBRARY_CALL
 1743                 REG(SP) = 0;                                                       LIBRARY_CALL
 1744              END;                                                                  LIBRARY_CALL
 1745           R = REG(SP);                                                             LIBRARY_CALL
 1746        END;                                                                        LIBRARY_CALL
 1747     ELSE                                                                           LIBRARY_CALL
 1748        R = FINDAR;                                                                 LIBRARY_CALL
 1749     IF CNT(MP) > 0 THEN CALL EMITINST (CODE+1,R,0,0,REG(MP),0);                    LIBRARY_CALL
 1750                    ELSE CALL EMITINST (CODE+1,R,0,0,0,0);                          LIBRARY_CALL
 1751     IF RESULT \= 0 THEN                                                            LIBRARY_CALL
 1752        DO;                                                                         LIBRARY_CALL
 1753           REG(MP) = R;                                                             LIBRARY_CALL
 1754           TYPE(MP) = RESULT;                                                       LIBRARY_CALL
 1755        END;                                                                        LIBRARY_CALL
 1756     END LIBRARY_CALL;                                                              LIBRARY_CALL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CODE            FIXED      9628     DATA   1727       2
MP              FIXED      9629     DATA   1727       4
R               FIXED      9631     DATA   1735       5
RESULT          FIXED      9627     DATA   1727       3
SP              FIXED      9630     DATA   1727       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 65
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1757  MONITOR_CALL:   PROCEDURE (CODE, P, JOBFLG);                                     *
 1758     /*                                                                             MONITOR_CALL
 1759     ROUTINE TO GENERATE CODE FOR PDP-10 CALLI UUO.                                 MONITOR_CALL
 1760     */                                                                             MONITOR_CALL
 1761     DECLARE CODE  FIXED,    /* CALLI NUMBER */                                     MONITOR_CALL
 1762            JOBFLG FIXED,  /* CLEAR AC FLAG */                                      MONITOR_CALL
 1763             P     FIXED;    /* STACK POINTER*/                                     MONITOR_CALL
 1764     DECLARE R     FIXED;    /* CONTAINS REGISTER TO USE */                         MONITOR_CALL
 1765                                                                                    MONITOR_CALL
 1766     R = FINDAR;                                                                    MONITOR_CALL
 1767     IF JOBFLG THEN CALL EMITINST (MOVEI,R,0,0,0,0);                                MONITOR_CALL
 1768     CALL EMITINST (CALLI,R,0,CODE,0,0);                                            MONITOR_CALL
 1769     REG(P) = R;                                                                    MONITOR_CALL
 1770     TYPE(P) = ACCUMULATOR;                                                         MONITOR_CALL
 1771  END MONITOR_CALL;                                                                 MONITOR_CALL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CODE            FIXED      9632     DATA   1757       1
JOBFLG          FIXED      9633     DATA   1757       1
P               FIXED      9634     DATA   1757       2
R               FIXED      9635     DATA   1764       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 66
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1772  FORCEACCUMULATOR:PROCEDURE (P);                                                  *
 1773        DECLARE P FIXED;                                                            FORCEACCUMULATOR
 1774        /* FORCE THE OPERAND AT P INTO AN ACCUMULATOR */                            FORCEACCUMULATOR
 1775        DECLARE SL FIXED, TP FIXED, SFP FIXED, SS FIXED;                            FORCEACCUMULATOR
 1776        DECLARE T1 CHARACTER;                                                       FORCEACCUMULATOR
 1777        DECLARE R FIXED;                                                            FORCEACCUMULATOR
 1778        COUNT_FORCE = COUNT_FORCE + 1;                                              FORCEACCUMULATOR
 1779        TP = TYPE(P);                                                               FORCEACCUMULATOR
 1780        IF TP = VARIABLE THEN                                                       FORCEACCUMULATOR
 1781            DO;                                                                     FORCEACCUMULATOR
 1782              SL = SYTLOC(FIXL(P));                                                 FORCEACCUMULATOR
 1783              SS = SYTSEG(FIXL(P));                                                 FORCEACCUMULATOR
 1784              SFP = SYTYPE(FIXL(P));                                                FORCEACCUMULATOR
 1785              IF SFP = PROCTYPE ^ SFP = FORWARDCALL ^ SFP = CHARPROCTYPE THEN       FORCEACCUMULATOR
 1786                 DO;                                                                FORCEACCUMULATOR
 1787                    CALL CALLSUB (SL,CALLTYPE,P);                                   FORCEACCUMULATOR
 1788                    R = FIXL(P)+CNT(P)+1;                                           FORCEACCUMULATOR
 1789                    IF LENGTH(SYT(R)) = 0 THEN                                      FORCEACCUMULATOR
 1790                       IF R <= NDECSY THEN                                          FORCEACCUMULATOR
 1791                          CALL PRINTLINE ('** WARNING--NOT ALL PARAMETERS SUPPLIED.',-1); FORCEACCUMULATOR
 1792                    IF SFP = CHARPROCTYPE THEN TYPE(P) = DESCRIPT;                  FORCEACCUMULATOR
 1793                 END;                                                               FORCEACCUMULATOR
 1794              ELSE IF SFP = SPECIAL THEN                                            FORCEACCUMULATOR
 1795                 DO;                                                                FORCEACCUMULATOR
 1796                    IF SL = 6 THEN                                                  FORCEACCUMULATOR
 1797                       DO;  /* BUILTIN FUNCTION INPUT */                            FORCEACCUMULATOR
 1798                          CALL CHECK_STRING_OVERFLOW;                               FORCEACCUMULATOR
 1799                          CALL EMITINST (MOVE,13,0,TSA,0,1);                        FORCEACCUMULATOR
 1800                          CALL LIBRARY_CALL (DESCRIPT,1,P,0);                       FORCEACCUMULATOR
 1801                          CALL EMITINST (MOVEM,13,0,TSA,0,1);                       FORCEACCUMULATOR
 1802                          CALL EMITINST (MOVEM,12,0,STR,0,3);                       FORCEACCUMULATOR
 1803                       END;                                                         FORCEACCUMULATOR
 1804                    ELSE IF SL = 8 THEN                                             FORCEACCUMULATOR
 1805                       DO;  /* BUILT-IN FUNCTION FILE */                            FORCEACCUMULATOR
 1806                        IF CNT(P) \= 1 THEN CALL ERROR (FILEMSG,0);                 FORCEACCUMULATOR
 1807                           ELSE CALL LIBRARY_CALL (ACCUMULATOR,5,P,0);              FORCEACCUMULATOR
 1808                       END;                                                         FORCEACCUMULATOR
 1809                    ELSE IF SL = 12 THEN                                            FORCEACCUMULATOR
 1810                       DO;  /* EXIT */                                              FORCEACCUMULATOR
 1811                          CALL EMITINST (4,0,0,0,0,0);                              FORCEACCUMULATOR
 1812                       END;                                                         FORCEACCUMULATOR
 1813                    ELSE IF SL = 13 THEN CALL MONITOR_CALL (19,P,0);                FORCEACCUMULATOR
 1814                    ELSE IF SL = 14 THEN CALL MONITOR_CALL (12,P,0);                FORCEACCUMULATOR
 1815                    ELSE IF SL = 19 THEN CALL MONITOR_CALL (23,P,1);                FORCEACCUMULATOR
 1816                    ELSE CALL ERROR ('ILLEGAL USE OF ' ^^ SYT(FIXL(P)),0);          FORCEACCUMULATOR
 1817                 END;                                                               FORCEACCUMULATOR
 1818              ELSE                                                                  FORCEACCUMULATOR
 1819                 DO;  /* FETCH THE VARIABLE (ALL ELSE HAS FAILED) */                FORCEACCUMULATOR
 1820                    IF SFP \= BYTETYPE THEN                                         FORCEACCUMULATOR
 1821                       DO;   /* WE DON'T HAVE TO DO CRAZY ADDRESSING */             FORCEACCUMULATOR
 1822                          R = FINDAR;     /* GET REG FOR RESULT */                  FORCEACCUMULATOR
 1823                          CALL EMITINST (MOVE,R,0,SL,INX(P),SS);                    FORCEACCUMULATOR
 1824                       END;                                                         FORCEACCUMULATOR
 1825                    ELSE                                                            FORCEACCUMULATOR
 1826                       DO;  /* BYTE ADDRESSING */                                   FORCEACCUMULATOR
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 67
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1827                          IF INX(P) \= 0 THEN                                       FORCEACCUMULATOR
 1828                             DO; /* GOOD GRIEF, SUBSCRIPTING OF BYTES */            FORCEACCUMULATOR
 1829                                R = FINDAR;                                         FORCEACCUMULATOR
 1830                                CALL EMITINST (MOVE,12,0,INX(P),0,0);               FORCEACCUMULATOR
 1831                                CALL EMITINST (LSH,12,0,    -2,0,0);                FORCEACCUMULATOR
 1832                                CALL EMITINST (ANDI,INX(P),0,3,0,0);                FORCEACCUMULATOR
 1833                                IF (SL ^ SS) \= 0 THEN CALL EMITINST (ADDI,12,0,SL,0,SS); FORCEACCUMULATOR
 1834                                CALL EMITINST (LDB,R,0,BYTEPTRS,INX(P),1);          FORCEACCUMULATOR
 1835                             END;                                                   FORCEACCUMULATOR
 1836                           ELSE                                                     FORCEACCUMULATOR
 1837                             DO; /* NON-SUBSCRIPTED BYTE */                         FORCEACCUMULATOR
 1838                                R = FINDAR;                                         FORCEACCUMULATOR
 1839                                CALL EMITINST (MOVEI,12,0,SL,0,SS);                 FORCEACCUMULATOR
 1840                                CALL EMITINST (LDB,R,0,BYTEPTRS,0,1);               FORCEACCUMULATOR
 1841                             END;                                                   FORCEACCUMULATOR
 1842                       END;                                                         FORCEACCUMULATOR
 1843                    IF SFP = CHRTYPE THEN TYPE(P) = DESCRIPT;                       FORCEACCUMULATOR
 1844                    ELSE TYPE(P) = ACCUMULATOR;                                     FORCEACCUMULATOR
 1845                    REG(P) = R;                                                     FORCEACCUMULATOR
 1846                    IF INX(P) \= 0 THEN ACC(INX(P)) = AVAIL;                        FORCEACCUMULATOR
 1847                 END;                                                               FORCEACCUMULATOR
 1848           END;                                                                     FORCEACCUMULATOR
 1849        ELSE IF TP = CONSTANT THEN                                                  FORCEACCUMULATOR
 1850           DO;  /* FETCH A CONSTANT INTO AN ACCUMULATOR */                          FORCEACCUMULATOR
 1851              R = FINDAR;                                                           FORCEACCUMULATOR
 1852              IF FIXV(P) < "20000" & FIXV(P) > - "20000" THEN                       FORCEACCUMULATOR
 1853                 CALL EMITINST (HRREI,R,0,FIXV(P),0,0);                             FORCEACCUMULATOR
 1854              ELSE                                                                  FORCEACCUMULATOR C18 = -131072
 1855                 DO;  /* PUT DOWN A CONSTANT AND PICK IT UP */                      FORCEACCUMULATOR
 1856                    CALL EMITCONSTANT (FIXV(P));                                    FORCEACCUMULATOR
 1857                    CALL EMITINST (MOVE,R,0,ADR,0,1);                               FORCEACCUMULATOR
 1858                 END;                                                               FORCEACCUMULATOR
 1859              REG(P) = R;                                                           FORCEACCUMULATOR
 1860              TYPE(P) = ACCUMULATOR;                                                FORCEACCUMULATOR
 1861           END;                                                                     FORCEACCUMULATOR
 1862        ELSE IF TP = CHRTYPE THEN                                                   FORCEACCUMULATOR
 1863           DO;  /* FETCH A DESCRIPTOR INTO AN ACCUMULATOR */                        FORCEACCUMULATOR
 1864              R = FINDAR;                                                           FORCEACCUMULATOR
 1865              TYPE(P) = DESCRIPT;                                                   FORCEACCUMULATOR
 1866              REG(P) = R;                                                           FORCEACCUMULATOR
 1867              T1 = VAR(P);                                                          FORCEACCUMULATOR
 1868              SL = LENGTH(T1);                                                      FORCEACCUMULATOR
 1869              IF SL = 0 THEN CALL EMITINST (MOVEI,R,0,0,0,0);                       FORCEACCUMULATOR
 1870              ELSE                                                                  FORCEACCUMULATOR
 1871                 DO;  /* GENERATE DESCRIPTOR AND STRING, THEN PICK IT UP */         FORCEACCUMULATOR
 1872                    CALL EMITINST (MOVE,R,0,DSP,0,3);                               FORCEACCUMULATOR
 1873                    CALL EMITDESC (SL,SHL(DP,2)+DPOFFSET);                          FORCEACCUMULATOR
 1874                    DO SL = 0 TO SL-1;                                              FORCEACCUMULATOR
 1875                       CALL EMITBYTE (BYTE(T1,SL));                                 FORCEACCUMULATOR
 1876                    END;                                                            FORCEACCUMULATOR
 1877                 END;                                                               FORCEACCUMULATOR
 1878           END;                                                                     FORCEACCUMULATOR
 1879        ELSE IF TP \= ACCUMULATOR THEN IF TP \= DESCRIPT THEN                       FORCEACCUMULATOR
 1880                 CALL ERROR ('FORCEACCUMULATOR FAILED ***',1);                      FORCEACCUMULATOR
 1881  END FORCEACCUMULATOR;                                                             FORCEACCUMULATOR
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 68
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9636     DATA   1772      34
R               FIXED      9641     DATA   1777      18
SFP             FIXED      9639     DATA   1775       8
SL              FIXED      9637     DATA   1775      18
SS              FIXED      9640     DATA   1775       5
T1              CHARACTER   821   STRING   1776       3
TP              FIXED      9638     DATA   1775       6
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 69
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1882  FORCEDESCRIPTOR:                                                                 *
 1883     PROCEDURE (P);                                                                *
 1884        /* GET A DESCRIPTOR FOR THE OPERAND P */                                    FORCEDESCRIPTOR
 1885        DECLARE P FIXED;                                                            FORCEDESCRIPTOR
 1886        CALL FORCEACCUMULATOR (P);                                                  FORCEDESCRIPTOR
 1887        IF TYPE (P) \= DESCRIPT THEN                                                FORCEDESCRIPTOR
 1888           DO; /* USE THE NUMBER TO DECIMAL STRING CONVERSION ROUTINE */            FORCEDESCRIPTOR
 1889              CALL DELETE_MOVE (P,MOVEM,REG(P),0,C,0,1);  /* SAVE AS C */           FORCEDESCRIPTOR
 1890              ACC(REG(P)) = AVAIL;                                                  FORCEDESCRIPTOR
 1891              CALL SAVE_ACS (1);                                                    FORCEDESCRIPTOR
 1892              CALL EMITINST (PUSHJ,15,0,NMBRENTRY,0,2);                             FORCEDESCRIPTOR
 1893              CALL RESTORE_ACS (1);                                                 FORCEDESCRIPTOR
 1894              ACC(REG(P)) = BUSY;                                                   FORCEDESCRIPTOR
 1895              IF REG(P) \= 0 THEN CALL EMITINST (MOVE,REG(P),0,0,0,0);              FORCEDESCRIPTOR
 1896              TYPE (P) = DESCRIPT;             /* IT IS NOW A STRING */             FORCEDESCRIPTOR
 1897              STILLINZERO = REG(P);                                                 FORCEDESCRIPTOR
 1898           END;                                                                     FORCEDESCRIPTOR
 1899  END FORCEDESCRIPTOR;                                                              FORCEDESCRIPTOR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9665     DATA   1883      10
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 70
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1900  GENSTORE:PROCEDURE (MP, SP);                                                     *
 1901        DECLARE MP FIXED, SP FIXED;                                                 GENSTORE
 1902        /* GENERATE TYPE CONVERSION (IF NECESSARY) & STORAGE CODE --                GENSTORE
 1903           ALSO HANDLES OUTPUT ON THE LEFT OF THE REPLACEMENT OPERATOR              GENSTORE
 1904        */                                                                          GENSTORE
 1905        DECLARE SL FIXED, SFP FIXED, SS FIXED;                                      GENSTORE
 1906        COUNT_STORE = COUNT_STORE + 1;                                              GENSTORE
 1907        SL = SYTLOC(FIXL(MP));                                                      GENSTORE
 1908        SS = SYTSEG(FIXL(MP));                                                      GENSTORE
 1909        SFP = SYTYPE(FIXL(MP));                                                     GENSTORE
 1910        IF SFP = SPECIAL THEN                                                       GENSTORE
 1911           DO;                                                                      GENSTORE
 1912              IF SL = 7 THEN                                                        GENSTORE
 1913                 DO;  /* BUILTIN FUNCTION OUTPUT */                                 GENSTORE
 1914                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1915                    CALL LIBRARY_CALL (0,2,MP,SP);                                  GENSTORE
 1916                 END;                                                               GENSTORE
 1917              ELSE IF SL = 8 THEN                                                   GENSTORE
 1918                 DO;   /* BUILTIN FUNCTION FILE */                                  GENSTORE
 1919                    IF CNT(MP) \= 1 THEN                                            GENSTORE
 1920                       CALL ERROR (FILEMSG,0);                                      GENSTORE
 1921                    CALL FORCEACCUMULATOR (SP);                                     GENSTORE
 1922                    CALL LIBRARY_CALL (0,6,MP,SP);                                  GENSTORE
 1923                 END;                                                               GENSTORE
 1924              ELSE IF SL = 20 THEN                                                  GENSTORE
 1925                 DO;    /* BUILT-IN FUNCTION  FILENAME */                           GENSTORE
 1926                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1927                    CALL LIBRARY_CALL (0,7,MP,SP);                                  GENSTORE
 1928                 END;                                                               GENSTORE
 1929              ELSE CALL ERROR ('ILLEGAL USE OF ' ^^ SYT(FIXL(MP)),0);               GENSTORE
 1930           END;                                                                     GENSTORE
 1931        ELSE                                                                        GENSTORE
 1932           DO;                                                                      GENSTORE
 1933              IF SFP = CHRTYPE THEN                                                 GENSTORE
 1934                 DO;                                                                GENSTORE
 1935                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1936                    CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,SL,INX(MP),SS);            GENSTORE
 1937                 END;                                                               GENSTORE
 1938              ELSE IF TYPE(SP) = DESCRIPT ^ TYPE(SP) = CHRTYPE THEN                 GENSTORE
 1939                   CALL ERROR ('ASSIGNMENT REQUIRES ILLEGAL TYPE CONVERSION.',0);   GENSTORE
 1940              ELSE                                                                  GENSTORE
 1941                 DO;     /* FIXEDTYPE OR BYTETYPE */                                GENSTORE
 1942                    IF SFP = FIXEDTYPE THEN                                         GENSTORE
 1943                       DO;                                                          GENSTORE
 1944                       IF TYPE(SP) = CONSTANT & FIXV(SP) = 0 THEN                   GENSTORE
 1945                          CALL EMITINST(SETZM,0,0,SL,INX(MP),SS);                   GENSTORE
 1946                          ELSE                                                      GENSTORE
 1947                             DO;                                                    GENSTORE
 1948                                CALL FORCEACCUMULATOR(SP);                          GENSTORE
 1949                                CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,SL,INX(MP),SS); GENSTORE
 1950                             END;                                                   GENSTORE
 1951                       END;                                                         GENSTORE
 1952                    ELSE                                                            GENSTORE
 1953                       DO;      /* MUST BE BYTETYPE */                              GENSTORE
 1954                          CALL FORCEACCUMULATOR(SP);                                GENSTORE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 71
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1955                          IF INX(MP) \= 0 THEN                                      GENSTORE
 1956                             DO;  /* GOOD GRIEF, SUBSCRIPTING */                    GENSTORE
 1957                                 CALL EMITINST (MOVE,12,0,INX(MP),0,0);             GENSTORE
 1958                                 CALL EMITINST (LSH,12,0,    -2,0,0);               GENSTORE
 1959                                 CALL EMITINST (ANDI,INX(MP),0,3,0,0);              GENSTORE
 1960                                 IF (SL ^ SS) \= 0 THEN CALL EMITINST (ADDI,12,0,SL,0,SS); GENSTORE
 1961                                 CALL EMITINST (DPB,REG(SP),0,BYTEPTRS,INX(MP),1);  GENSTORE
 1962                             END;                                                   GENSTORE
 1963                          ELSE                                                      GENSTORE
 1964                             DO;                                                    GENSTORE
 1965                                 CALL EMITINST (MOVEI,12,0,SL,0,SS);                GENSTORE
 1966                                 CALL EMITINST (DPB,REG(SP),0,BYTEPTRS,0,1);        GENSTORE
 1967                             END;                                                   GENSTORE
 1968                       END;                                                         GENSTORE
 1969                 END;                                                               GENSTORE
 1970           END;                                                                     GENSTORE
 1971        ACC(INX(MP)) = AVAIL;                                                       GENSTORE
 1972        CALL MOVESTACKS (SP,MP);                                                    GENSTORE
 1973  END GENSTORE;                                                                     GENSTORE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MP              FIXED      9666     DATA   1900      17
SFP             FIXED      9669     DATA   1905       4
SL              FIXED      9668     DATA   1905      10
SP              FIXED      9667     DATA   1900      20
SS              FIXED      9670     DATA   1905       7
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 72
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1974  SHOULDCOMMUTE:PROCEDURE;                                                         *
 1975        IF TYPE(SP) = CONSTANT THEN RETURN (FALSE);                                 SHOULDCOMMUTE
 1976        IF TYPE(MP) = CONSTANT THEN RETURN (TRUE);                                  SHOULDCOMMUTE
 1977        IF TYPE(SP) = VARIABLE & SYTYPE(FIXL(SP)) = FIXEDTYPE THEN RETURN (FALSE);  SHOULDCOMMUTE
 1978        IF TYPE(MP) = VARIABLE & SYTYPE(FIXL(MP)) = FIXEDTYPE THEN RETURN (TRUE);   SHOULDCOMMUTE
 1979        RETURN FALSE;                                                               SHOULDCOMMUTE
 1980  END SHOULDCOMMUTE;                                                                SHOULDCOMMUTE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 73
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1981  ARITHEMIT:PROCEDURE(OP,COMMUTATIVE);                                             *
 1982     DECLARE OP FIXED, COMMUTATIVE FIXED, TP FIXED;                                 ARITHEMIT
 1983     DECLARE AWASD CHARACTER INITIAL ('ARITHMETIC WITH A STRING DESCRIPTOR');       ARITHEMIT
 1984     /* EMIT AN INSTRUCTION FOR AN INFIX OPERATOR -- CONNECT MP & SP */             ARITHEMIT
 1985     COUNT_ARITH = COUNT_ARITH + 1;                                                 ARITHEMIT
 1986     TP = 0;                                                                        ARITHEMIT
 1987     IF COMMUTATIVE THEN                                                            ARITHEMIT
 1988        IF SHOULDCOMMUTE THEN                                                       ARITHEMIT
 1989           DO;                                                                      ARITHEMIT
 1990              TP = MP; MP = SP; SP = TP;                                            ARITHEMIT
 1991              IF OP >= CAM & OP <= CMPRHI THEN OP = COMPARESWAP(OP-CAM)+CAM;        ARITHEMIT
 1992           END;                                                                     ARITHEMIT
 1993     CALL FORCEACCUMULATOR(MP);  /* GET THE LEFT ONE INTO AN ACCUMULATOR */         ARITHEMIT
 1994     IF TYPE(MP) = DESCRIPT THEN CALL ERROR (AWASD,0);                              ARITHEMIT
 1995     ELSE IF TYPE(SP) = VARIABLE & SYTYPE(FIXL(SP)) = FIXEDTYPE THEN                ARITHEMIT
 1996        DO;  /* OPERATE FROM STORAGE */                                             ARITHEMIT
 1997           CALL EMITINST (OP,REG(MP),0,SYTLOC(FIXL(SP)),INX(SP),SYTSEG(FIXL(SP)));  ARITHEMIT
 1998           ACC(INX(SP)) = AVAIL;                                                    ARITHEMIT
 1999        END;                                                                        ARITHEMIT
 2000     ELSE IF TYPE(SP) = CONSTANT THEN                                               ARITHEMIT
 2001        DO;                                                                         ARITHEMIT
 2002           IF FIXV(SP) < "40000" & FIXV(SP) >= 0 THEN /* USE IMMEDIATE */           ARITHEMIT
 2003              DO;                                                                   ARITHEMIT
 2004                 IF OP >= CAM & OP <= CMPRHI THEN OP=OP-9; /* SOB CODE ORDER */     ARITHEMIT
 2005                    CALL EMITINST(OP+1,REG(MP),0,FIXV(SP),0,0);                     ARITHEMIT
 2006              END;                                                                  ARITHEMIT
 2007           ELSE                                                                     ARITHEMIT
 2008              DO;                                                                   ARITHEMIT
 2009                 CALL EMITCONSTANT (FIXV(SP));                                      ARITHEMIT
 2010                 CALL EMITINST (OP,REG(MP),0,ADR,0,1);                              ARITHEMIT
 2011              END;                                                                  ARITHEMIT
 2012        END;                                                                        ARITHEMIT
 2013     ELSE                                                                           ARITHEMIT
 2014         DO;                                                                        ARITHEMIT
 2015           CALL FORCEACCUMULATOR(SP);                                               ARITHEMIT
 2016           IF TYPE(SP) \= ACCUMULATOR THEN CALL ERROR (AWASD,0);                    ARITHEMIT
 2017           ELSE CALL EMITINST (OP,REG(MP),0,REG(SP),0,0);                           ARITHEMIT
 2018           ACC(REG(SP)) = AVAIL;                                                    ARITHEMIT
 2019        END;                                                                        ARITHEMIT
 2020     IF TP \= 0 THEN                                                                ARITHEMIT
 2021        DO;                                                                         ARITHEMIT
 2022           SP = MP; MP = TP;                                                        ARITHEMIT
 2023           CALL MOVESTACKS (SP,MP);                                                 ARITHEMIT
 2024        END;                                                                        ARITHEMIT
 2025  END ARITHEMIT;                                                                    ARITHEMIT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
AWASD           CHARACTER   827   STRING   1983       2
COMMUTATIVE     FIXED      9687     DATA   1981       1
OP              FIXED      9686     DATA   1981      12
TP              FIXED      9688     DATA   1982       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 74
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2026  BOOLBRANCH:PROCEDURE (SP,MP);                                                    *
 2027     DECLARE SP FIXED, MP FIXED, R FIXED;                                           BOOLBRANCH
 2028     /* GENERATE A CONDITIONAL BRANCH FOR DO WHILE OR AN IF STATEMENT               BOOLBRANCH
 2029        PLACE THE ADDRESS OF THIS BRANCH IN FIXL(MP)                                BOOLBRANCH
 2030     */                                                                             BOOLBRANCH
 2031     IF STILLCOND \= 0 THEN                                                         BOOLBRANCH
 2032        DO;  /* WE HAVE NOT GENERATED CODE SINCE SETTING THE CONDITION */           BOOLBRANCH
 2033           /* REMOVE THE MOVEI =1 AND MOVEI =0 AROUND THE CAM? */                   BOOLBRANCH
 2034           CODE_HEAD = (CODE_HEAD-2) &3; /* BACK UP PTR */                          BOOLBRANCH
 2035           R = (CODE_HEAD + 1) & 3;                                                 BOOLBRANCH
 2036           CODE(CODE_HEAD) = CODE(R);                                               BOOLBRANCH
 2037           CODE_REL(CODE_HEAD) = CODE_REL(R);                                       BOOLBRANCH
 2038           CODE_PP(CODE_HEAD) = CODE_PP(R) -1;                                      BOOLBRANCH
 2039           CODE_RBITS(CODE_HEAD) = CODE_RBITS(R);                                   BOOLBRANCH
 2040           CODE_FULL(R) = FALSE;                                                    BOOLBRANCH
 2041           CODE_FULL(R+1&3) = FALSE;                                                BOOLBRANCH
 2042           PP = PP - 2;                                                             BOOLBRANCH
 2043           CODE(CODE_HEAD) = CODE(CODE_HEAD) ^^ ' P' ^^ PP-1;                       BOOLBRANCH
 2044           IF CONTROL(BYTE('E')) THEN                                               BOOLBRANCH
 2045              DO;                                                                   BOOLBRANCH
 2046                 CALL PRINTLINE (BACKMSG,-1);                                       BOOLBRANCH
 2047                 CALL PRINTLINE (CODEMSG ^^ CODE(CODE_HEAD),-1);                    BOOLBRANCH
 2048              END;                                                                  BOOLBRANCH
 2049           INSTRUCT(MOVEI) = INSTRUCT(MOVEI) - 2;                                   BOOLBRANCH
 2050           ACC(REG(SP)) = AVAIL;          /* FREE CONDITION REGISTER */             BOOLBRANCH
 2051           R = 4;                         /* JUMP ALWAYS */                         BOOLBRANCH
 2052        END;                                                                        BOOLBRANCH
 2053     ELSE                                                                           BOOLBRANCH
 2054        DO;                                                                         BOOLBRANCH
 2055           CALL FORCEACCUMULATOR(SP);                                               BOOLBRANCH
 2056           CALL EMITINST (ANDI,REG(SP),0,1,0,0);  /* TEST ONLY LOW ORDER BIT */     BOOLBRANCH
 2057           ACC(REG(SP)) = AVAIL;          /* FREE UP VARIABLE REGISTER */           BOOLBRANCH
 2058           R = 2;                         /* JUMP IF REGISTER ZERO */               BOOLBRANCH
 2059        END;                                                                        BOOLBRANCH
 2060     FIXL(MP) = FINDLABEL;                /* GET A NEW LABEL */                     BOOLBRANCH
 2061     CALL EMITINST (JUMP+R,REG(SP),0,FIXL(MP),0,4);                                 BOOLBRANCH
 2062  END BOOLBRANCH;                                                                   BOOLBRANCH

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MP              FIXED      9699     DATA   2026       2
R               FIXED      9700     DATA   2027      10
SP              FIXED      9698     DATA   2026       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 75
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2063  SETLIMIT:                                                                        *
 2064     PROCEDURE;                                                                    *
 2065        /* SETS DO LOOP LIMIT FOR <ITERATION CONTROL> */                            SETLIMIT
 2066        IF TYPE (MPP1) = CONSTANT THEN                                              SETLIMIT
 2067           CALL EMITCONSTANT (FIXV(MPP1));                                          SETLIMIT
 2068        ELSE                                                                        SETLIMIT
 2069           DO;                                                                      SETLIMIT
 2070              CALL FORCEACCUMULATOR (MPP1);  /* GET LOOP LIMIT */                   SETLIMIT
 2071              CALL EMITDATAWORD (0);                                                SETLIMIT
 2072              ADR = DP - 1;                                                         SETLIMIT
 2073              CALL EMITINST(MOVEM,REG(MPP1),0,ADR,0,1); /* SAVE IT */               SETLIMIT
 2074              ACC(REG(MPP1)) = AVAIL;                                               SETLIMIT
 2075           END;                                                                     SETLIMIT
 2076        FIXV (MP) = ADR;                                                            SETLIMIT
 2077   END SETLIMIT;                                                                    SETLIMIT
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 76
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2078  STUFF_PARAMETER:                                                                 *
 2079     PROCEDURE;                                                                    *
 2080        /* GENERATE CODE TO SEND AN ACTUAL PARAMETER TO A PROCEDURE */              STUFF_PARAMETER
 2081        DECLARE (I,J) FIXED;                                                        STUFF_PARAMETER
 2082        I = FIXL (MP) + CNT (MP);  J = SYTLOC (I);                                  STUFF_PARAMETER
 2083        IF LENGTH (SYT(I)) = 0 THEN                                                 STUFF_PARAMETER
 2084           DO;                                                                      STUFF_PARAMETER
 2085              SYTCO (I) = SYTCO (I) + 1;  /* COUNT THE REFERENCE                */  STUFF_PARAMETER
 2086                 DO;                                                                STUFF_PARAMETER
 2087                    IF SYTYPE(I) = BYTETYPE THEN                                    STUFF_PARAMETER
 2088                      DO;                                                           STUFF_PARAMETER
 2089                         CALL FORCEACCUMULATOR(MPP1);                               STUFF_PARAMETER
 2090                         CALL EMITINST (MOVEI,12,0,J,0,SYTSEG(I));                  STUFF_PARAMETER
 2091                         CALL EMITINST (DPB,REG(MPP1),0,BYTEPTRS,0,1);              STUFF_PARAMETER
 2092                      END;                                                          STUFF_PARAMETER
 2093                    ELSE                                                            STUFF_PARAMETER
 2094                      DO;                                                           STUFF_PARAMETER
 2095                         IF TYPE(MPP1) = CONSTANT & FIXV(MPP1) = 0 THEN             STUFF_PARAMETER
 2096                            DO;                                                     STUFF_PARAMETER
 2097                               CALL EMITINST (SETZM,0,0,J,0,SYTSEG(I));             STUFF_PARAMETER
 2098                               RETURN;                                              STUFF_PARAMETER
 2099                            END;                                                    STUFF_PARAMETER
 2100                         CALL FORCEACCUMULATOR (MPP1);                              STUFF_PARAMETER
 2101                         CALL DELETE_MOVE (MPP1,MOVEM,REG(MPP1),0,J,0,SYTSEG(I));   STUFF_PARAMETER
 2102                      END;                                                          STUFF_PARAMETER
 2103                    ACC(REG(MPP1)) = AVAIL;                                         STUFF_PARAMETER
 2104                 END;                                                               STUFF_PARAMETER
 2105           END;                                                                     STUFF_PARAMETER
 2106        ELSE                                                                        STUFF_PARAMETER
 2107           CALL ERROR ('TOO MANY ACTUAL PARAMETERS', 1);                            STUFF_PARAMETER
 2108  END STUFF_PARAMETER;                                                              STUFF_PARAMETER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9702     DATA   2081       9
J               FIXED      9703     DATA   2081       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 77
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2109  DIVIDE_CODE:PROCEDURE(T);                                                        *
 2110     DECLARE T FIXED, I FIXED;                                                      DIVIDE_CODE
 2111     /* EMIT CODE TO PERFORM A DIVIDE (T=1) OR MOD (T=0) */                         DIVIDE_CODE
 2112     /* FIND A FREE REGISTER PAIR FOR THE DIVIDEND */                               DIVIDE_CODE
 2113     IF TYPE(MP) = ACCUMULATOR THEN                                                 DIVIDE_CODE
 2114        DO;   /* WE MAY BE ABLE TO USE THE REGISTER TO THE RIGHT */                 DIVIDE_CODE
 2115           I = REG(MP);                                                             DIVIDE_CODE
 2116           IF ACC(I+1) = AVAIL THEN GOTO FITS;                                      DIVIDE_CODE
 2117        END;                                                                        DIVIDE_CODE
 2118     DO I = T TO 11;                                                                DIVIDE_CODE
 2119        IF ACC(I) = AVAIL THEN IF ACC(I+1) = AVAIL THEN GOTO FIT;                   DIVIDE_CODE
 2120     END;                                                                           DIVIDE_CODE
 2121     CALL ERROR ('NO FREE REGISTERS FOR DIVISION OR MOD.',0);                       DIVIDE_CODE
 2122     RETURN;                                                                        DIVIDE_CODE
 2123  FIT:                                                                              DIVIDE_CODE
 2124     TARGET_REGISTER = I;                                                           DIVIDE_CODE
 2125     CALL FORCEACCUMULATOR(MP);                                                     DIVIDE_CODE
 2126     TARGET_REGISTER = -1;                                                          DIVIDE_CODE
 2127     IF REG(MP) \= I THEN                                                           DIVIDE_CODE
 2128        DO;                                                                         DIVIDE_CODE
 2129           CALL EMITINST (MOVE,I,0,REG(MP),0,0);                                    DIVIDE_CODE
 2130           ACC(REG(MP)) = AVAIL;                                                    DIVIDE_CODE
 2131           REG(MP) = I;                                                             DIVIDE_CODE
 2132        END;                                                                        DIVIDE_CODE
 2133        ACC(I) = BUSY;                                                              DIVIDE_CODE
 2134   FITS:                                                                            DIVIDE_CODE
 2135     ACC(I+1) = BUSY;                                                               DIVIDE_CODE
 2136     CALL ARITHEMIT (IDIV,0);                                                       DIVIDE_CODE
 2137     IF T = 0 THEN                                                                  DIVIDE_CODE
 2138        DO;  /* MOD, SWITCH REGISTER TO POINT TO REMAINDER */                       DIVIDE_CODE
 2139           ACC(I) = AVAIL;                /* FREE QUOTIENT */                       DIVIDE_CODE
 2140           REG(MP) = I+1;                 /* POINT TO REMAINDER */                  DIVIDE_CODE
 2141        END;                                                                        DIVIDE_CODE
 2142     ELSE ACC(I+1) = AVAIL;               /* FREE REMAINDER */                      DIVIDE_CODE
 2143     IF REG(MP) =12 THEN                                                            DIVIDE_CODE
 2144        DO;  /* TRANSFER THE MOD REMAINDER FROM A SCRATCH REGISTER */               DIVIDE_CODE
 2145           I = FINDAR;                                                              DIVIDE_CODE
 2146           CALL EMITINST (MOVE,I,0,REG(MP),0,0);                                    DIVIDE_CODE
 2147           ACC(REG(MP)) = AVAIL;                                                    DIVIDE_CODE
 2148           REG(MP) = I;                                                             DIVIDE_CODE
 2149        END;                                                                        DIVIDE_CODE
 2150  END DIVIDE_CODE;                                                                  DIVIDE_CODE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
FIT             LABEL      5434  PROGRAM   2119       1
FITS            LABEL      5465  PROGRAM   2116       1
I               FIXED      9712     DATA   2110      17
T               FIXED      9711     DATA   2109       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 78
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2151  SHIFT_CODE:                                                                      *
 2152     PROCEDURE (OP);                                                               *
 2153        DECLARE OP FIXED;                                                           SHIFT_CODE
 2154        /* GENERATE CODE FOR THE BUILTIN FUNCTIONS SHL AND SHR */                   SHIFT_CODE
 2155        /* OP: LEFT = 0, RIGHT = 1 */                                               SHIFT_CODE
 2156        SP = MPP1;                                                                  SHIFT_CODE
 2157        IF CNT (MP) \= 2 THEN                                                       SHIFT_CODE
 2158           CALL ERROR ('SHIFT REQUIRES TWO ARGUMENTS', 0);                          SHIFT_CODE
 2159        ELSE                                                                        SHIFT_CODE
 2160           IF TYPE (MPP1) = CONSTANT THEN                                           SHIFT_CODE
 2161              DO;                                                                   SHIFT_CODE
 2162                 IF OP = 1 THEN FIXV(MPP1) = -FIXV(MPP1);                           SHIFT_CODE
 2163                 CALL EMITINST(LSH,REG(MP),0,FIXV(MPP1),0,0);                       SHIFT_CODE
 2164              END;                                                                  SHIFT_CODE
 2165        ELSE                                                                        SHIFT_CODE
 2166           DO;                                                                      SHIFT_CODE
 2167              /* DO SHIFT WITH VARIABLE */                                          SHIFT_CODE
 2168              CALL FORCEACCUMULATOR(MPP1);                                          SHIFT_CODE
 2169              IF OP = 1 THEN                                                        SHIFT_CODE
 2170                    CALL EMITINST (MOVN,REG(MPP1),0,REG(MPP1),0,0);                 SHIFT_CODE
 2171              CALL EMITINST (LSH,REG(MP),0,0,REG(MPP1),0);                          SHIFT_CODE
 2172              ACC(REG(MPP1)) = AVAIL;                                               SHIFT_CODE
 2173           END;                                                                     SHIFT_CODE
 2174        TYPE(MP) = ACCUMULATOR;                                                     SHIFT_CODE
 2175  END SHIFT_CODE;                                                                   SHIFT_CODE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
OP              FIXED      9723     DATA   2152       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 79
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2176  STRINGCOMPARE:                                                                   *
 2177     PROCEDURE;                                                                    *
 2178        /* GENERATES CODE TO COMPARE THE STRINGS AT SP AND MP.                      STRINGCOMPARE
 2179           COMPARISONS ARE DONE FIRST ON LENGTH, AND SECOND ON A                    STRINGCOMPARE
 2180           CHARACTER BY CHARACTER COMPARISON USING THE PDP-10 COLLATING             STRINGCOMPARE
 2181           SEQUENCE.                                                                STRINGCOMPARE
 2182        */                                                                          STRINGCOMPARE
 2183        CALL FORCEDESCRIPTOR (SP);                                                  STRINGCOMPARE
 2184        CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,B,0,3);                                STRINGCOMPARE
 2185        ACC(REG(SP)) = AVAIL;                                                       STRINGCOMPARE
 2186        CALL FORCEDESCRIPTOR (MP);                                                  STRINGCOMPARE
 2187        CALL DELETE_MOVE (MP,MOVEM,REG(MP),0,A,0,3);                                STRINGCOMPARE
 2188        CALL SAVE_ACS (5);                                                          STRINGCOMPARE
 2189        CALL EMITINST (PUSHJ,15,0,STRCOMP,0,2); /* CALL STRING COMPARE */           STRINGCOMPARE
 2190        CALL RESTORE_ACS (5);                                                       STRINGCOMPARE
 2191        CALL EMITINST (MOVEI,REG(MP),0,1,0,0);                                      STRINGCOMPARE
 2192         CALL EMITINST (SKIP+INX(MPP1),0,0,0,0,0);                                  STRINGCOMPARE
 2193        CALL EMITINST (MOVEI,REG(MP),0,0,0,0);                                      STRINGCOMPARE
 2194        TYPE(MP) = ACCUMULATOR;                                                     STRINGCOMPARE
 2195        STILLCOND = INX(MPP1);                                                      STRINGCOMPARE
 2196  END STRINGCOMPARE;                                                                STRINGCOMPARE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 80
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2197  SYMBOLDUMP:                                                                      *
 2198     PROCEDURE;                                                                    *
 2199        /* LIST THE SYMBOLS IN THE PROCEDURE THAT HAS JUST BEEN                     SYMBOLDUMP
 2200           COMPILED IF TOGGLE S IS ENABLED AND L IS ENABLED.                        SYMBOLDUMP
 2201        */                                                                          SYMBOLDUMP
 2202        DECLARE SUBTITLE_SAVE CHARACTER;                                            SYMBOLDUMP
 2203        DECLARE HEADING CHARACTER INITIAL ('TYPE       LOC   SEGMENT DEFINED REF COUNT'); SYMBOLDUMP
 2204        DECLARE SEG(4) CHARACTER INITIAL ('ABSOLUTE','    DATA',' PROGRAM',         SYMBOLDUMP
 2205                 '  STRING','   LABEL');                                            SYMBOLDUMP
 2206        DECLARE EXCHANGES FIXED, I FIXED, LMAX FIXED,                               SYMBOLDUMP
 2207           J FIXED, K FIXED, L FIXED, M FIXED, SYTSORT (SYTSIZE) FIXED;             SYMBOLDUMP
 2208        DECLARE BLANKS CHARACTER,                                                   SYMBOLDUMP
 2209                TAG    CHARACTER;                                                   SYMBOLDUMP
 2210                                                                                    SYMBOLDUMP
 2211     STRING_GT:                                                                     SYMBOLDUMP
 2212        PROCEDURE (A,B);                                                            SYMBOLDUMP
 2213           /* DO AN HONEST STRING COMPARISON:                                       STRING_GT
 2214              XPL CAN BE TRUSTED ONLY IF STRINGS ARE OF THE SAME LENGTH.            STRING_GT
 2215              IF LENGTHS DIFFER, LET XPL SEE ONLY THE SHORTER, AND THE              STRING_GT
 2216              MATCHING PART OF THE LONGER, AND ARRANGE COMPARISONS SO               STRING_GT
 2217              THAT RESULT IS RIGHT.   */                                            STRING_GT
 2218           DECLARE A CHARACTER,                                                     STRING_GT
 2219                   B CHARACTER;                                                     STRING_GT
 2220           DECLARE LA FIXED,  LB FIXED;                                             STRING_GT
 2221                                                                                    STRING_GT
 2222           LA = LENGTH (A);                                                         STRING_GT
 2223           LB = LENGTH (B);                                                         STRING_GT
 2224           IF LA = LB THEN RETURN (A > B);                                          STRING_GT
 2225           ELSE IF LA > LB THEN RETURN (SUBSTR (A,0,LB) >= B);                      STRING_GT
 2226                ELSE RETURN (A > SUBSTR(B,0,LA));                                   STRING_GT
 2227        END STRING_GT;                                                              STRING_GT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
A               CHARACTER   841   STRING   2212       4
B               CHARACTER   842   STRING   2212       4
LA              FIXED     10180     DATA   2220       4
LB              FIXED     10181     DATA   2220       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 81
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2228                                                                                    SYMBOLDUMP
 2229        IF CONTROL(BYTE('L'))  = 0 THEN RETURN; /* DON'T DUMP IF NOT LISTING */     SYMBOLDUMP
 2230        IF PROCMARK <= NDECSY THEN                                                  SYMBOLDUMP
 2231           DO;                                                                      SYMBOLDUMP
 2232              CALL PRINTLINE ('SYMBOL TABLE DUMP',0);                               SYMBOLDUMP
 2233              LMAX = 15;                                                            SYMBOLDUMP
 2234              DO I = PROCMARK TO NDECSY;  /* PAD ALL NAMES TO THE SAME LENGTH */    SYMBOLDUMP
 2235                 IF LENGTH (SYT (I)) > LMAX THEN                                    SYMBOLDUMP
 2236                    LMAX = LENGTH (SYT (I));                                        SYMBOLDUMP
 2237                 SYTSORT (I) = I;                                                   SYMBOLDUMP
 2238              END;                                                                  SYMBOLDUMP
 2239              IF LMAX > 70 THEN LMAX = 70;                                          SYMBOLDUMP
 2240              BLANKS = SUBSTR (X70,0,LMAX);                                         SYMBOLDUMP
 2241              EXCHANGES = TRUE;                                                     SYMBOLDUMP
 2242              K = NDECSY - PROCMARK;                                                SYMBOLDUMP
 2243              DO WHILE EXCHANGES;                                                   SYMBOLDUMP
 2244                 EXCHANGES = FALSE;                                                 SYMBOLDUMP
 2245                 DO J = 0 TO K - 1;                                                 SYMBOLDUMP
 2246                    I = NDECSY - J;                                                 SYMBOLDUMP
 2247                    L = I - 1;                                                      SYMBOLDUMP
 2248                    IF STRING_GT(SYT (SYTSORT(L)),SYT(SYTSORT(I))) THEN             SYMBOLDUMP
 2249                       DO;                                                          SYMBOLDUMP
 2250                          M = SYTSORT (I);                                          SYMBOLDUMP
 2251                          SYTSORT (I) = SYTSORT (L);                                SYMBOLDUMP
 2252                          SYTSORT (L) = M;                                          SYMBOLDUMP
 2253                          EXCHANGES = TRUE;                                         SYMBOLDUMP
 2254                          K = J;          /* RECORD THE LAST SWAP */                SYMBOLDUMP
 2255                       END;                                                         SYMBOLDUMP
 2256                  END;                                                              SYMBOLDUMP
 2257              END;                                                                  SYMBOLDUMP
 2258              I = PROCMARK;                                                         SYMBOLDUMP
 2259              DO WHILE LENGTH (SYT (SYTSORT (I))) = 0;                              SYMBOLDUMP
 2260                 I = I + 1;               /* IGNORE NULL NAMES */                   SYMBOLDUMP
 2261              END;                                                                  SYMBOLDUMP
 2262              SUBTITLE_SAVE = SUBTITLE;                                             SYMBOLDUMP
 2263              SUBTITLE = 'SYMBOL' ^^ SUBSTR(BLANKS,0,LMAX-5) ^^ HEADING;            SYMBOLDUMP
 2264              CALL PRINTLINE (SUBTITLE,0);                                          SYMBOLDUMP
 2265              DO I = I TO NDECSY;                                                   SYMBOLDUMP
 2266                 K = SYTSORT (I);                                                   SYMBOLDUMP
 2267                 TAG = SYT(K) ^^ SUBSTR(X70,0,LMAX-LENGTH(SYT(K)));                 SYMBOLDUMP
 2268                 CALL I_FORMAT (SYTLOC(K),5);                                       SYMBOLDUMP
 2269                 TAG = TAG ^^ X1 ^^ TYPENAME(SYTYPE(K)) ^^ X1 ^^ I_STRING;          SYMBOLDUMP
 2270                 CALL I_FORMAT (SYTCARD(K),5);                                      SYMBOLDUMP
 2271                 TAG = TAG ^^ X1 ^^ SEG(SYTSEG(K)) ^^ X2 ^^ I_STRING;               SYMBOLDUMP
 2272                 CALL I_FORMAT (SYTCO(K),5);                                        SYMBOLDUMP
 2273                 IF SYTCO(K) = 0 THEN I_STRING = I_STRING ^^ ' *';                  SYMBOLDUMP
 2274                 CALL PRINTLINE (TAG ^^ X3 ^^ I_STRING,-1);                         SYMBOLDUMP
 2275                                                                                    SYMBOLDUMP
 2276                 K = K + 1;                                                         SYMBOLDUMP
 2277                 DO WHILE (LENGTH (SYT (K)) = 0) & (K <= NDECSY);                   SYMBOLDUMP
 2278                    J = K - SYTSORT (I);                                            SYMBOLDUMP
 2279                    TAG = '  PARAMETER  ' ^^ J ^^ SUBSTR(BLANKS,13) ^^              SYMBOLDUMP
 2280                          TYPENAME(SYTYPE(K));                                      SYMBOLDUMP C19 = 1744830451
 2281                    CALL I_FORMAT (SYTLOC(K),5);                                    SYMBOLDUMP
 2282                    TAG = TAG ^^ X1 ^^ I_STRING;                                    SYMBOLDUMP
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 82
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2283                    CALL I_FORMAT (SYTCARD(K),5);                                   SYMBOLDUMP
 2284                    TAG = TAG ^^ X1 ^^ SEG(SYTSEG(K)) ^^ X2 ^^ I_STRING;            SYMBOLDUMP
 2285                    CALL I_FORMAT (SYTCO(K),5);                                     SYMBOLDUMP
 2286                    CALL PRINTLINE (TAG ^^ X3 ^^ I_STRING,-1);                      SYMBOLDUMP
 2287                    K = K + 1;                                                      SYMBOLDUMP
 2288                 END;                                                               SYMBOLDUMP
 2289              END;                                                                  SYMBOLDUMP
 2290              SUBTITLE = SUBTITLE_SAVE;                                             SYMBOLDUMP
 2291           END;                                                                     SYMBOLDUMP
 2292           EJECT_PAGE;                                                              SYMBOLDUMP
 2293  END SYMBOLDUMP;                                                                   SYMBOLDUMP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
BLANKS          CHARACTER   839   STRING   2208       3
EXCHANGES       FIXED      9752     DATA   2206       4
HEADING         CHARACTER   833   STRING   2203       1
I               FIXED      9753     DATA   2206      18
J               FIXED      9755     DATA   2207       5
K               FIXED      9756     DATA   2207      24
L               FIXED      9757     DATA   2207       4
LMAX            FIXED      9754     DATA   2206       8
M               FIXED      9758     DATA   2207       2
SEG             CHARACTER   834   STRING   2204       2
STRING_GT       PROCEDURE  5679  PROGRAM   2211       1
  PARAMETER  1  CHARACTER   841   STRING   2212       5
  PARAMETER  2  CHARACTER   842   STRING   2212       5
SUBTITLE_SAVE   CHARACTER   832   STRING   2202       2
SYTSORT         FIXED      9759     DATA   2207      10
TAG             CHARACTER   840   STRING   2209      12
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 83
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2294  DUMPIT:                                                                          *
 2295     PROCEDURE;                                                                    *
 2296        DECLARE CHAR360 CHARACTER;                                                  DUMPIT
 2297        DECLARE T1 CHARACTER, T2 CHARACTER, L FIXED, LL FIXED;                      DUMPIT
 2298        /* PUT OUT STATISTICS KEPT WITHIN THE COMPILER */                           DUMPIT
 2299       IF TOP_MACRO >= 0 THEN                                                       DUMPIT
 2300            DO; /* DUMP MACRO DICTIONARY */                                         DUMPIT
 2301               CALL PRINTLINE ( 'MACRO DEFINITIONS:',0);                            DUMPIT
 2302               CALL PRINTLINE (X1,-1);                                              DUMPIT
 2303               L = LENGTH (MACRO_NAME(TOP_MACRO));                                  DUMPIT
 2304               IF L > 70 THEN L = 70;                                               DUMPIT
 2305               SUBTITLE = 'NAME' ^^ SUBSTR (X70,0,L-2) ^^                           DUMPIT
 2306                          'AT LINE REF COUNT LITERAL VALUE';                        DUMPIT
 2307               CALL PRINTLINE (SUBTITLE,-1);                                        DUMPIT
 2308               DO I = 0 TO TOP_MACRO;                                               DUMPIT
 2309                  K = LENGTH (MACRO_NAME(I));                                       DUMPIT
 2310                  IF K < L THEN                                                     DUMPIT
 2311                     DO;                                                            DUMPIT
 2312                         CHAR360 = SUBSTR (X70,0,L-K);                              DUMPIT
 2313                         MACRO_NAME (I) = MACRO_NAME (I) ^^ CHAR360;                DUMPIT
 2314                     END;                                                           DUMPIT
 2315                  ELSE                                                              DUMPIT
 2316                     MACRO_NAME(I) = SUBSTR(MACRO_NAME(I),0,L);                     DUMPIT
 2317                  T1 = MACRO_DECLARE(I);                                            DUMPIT
 2318                  T2 = MACRO_COUNT(I);                                              DUMPIT
 2319                  LL = LENGTH (T1);                                                 DUMPIT
 2320                  IF LL < 8 THEN T1 = SUBSTR(X70,0,8-LL) ^^ T1;                     DUMPIT
 2321                  LL = LENGTH (T2);                                                 DUMPIT
 2322                  IF LL < 9 THEN T2 = SUBSTR(X70,0,9-LL) ^^ T2;                     DUMPIT
 2323                  CALL PRINTLINE (MACRO_NAME(I) ^^ T1 ^^ T2 ^^ X4 ^^ MACRO_TEXT(I),-1); DUMPIT
 2324               END;                                                                 DUMPIT
 2325            END;                                                                    DUMPIT
 2326        SUBTITLE = '';                                                              DUMPIT
 2327        CALL PRINTLINE (X1,-1);                                                     DUMPIT
 2328        CALL PRINTLINE ('ID COMPARES       = ' ^^ IDCOMPARES,-1);                   DUMPIT
 2329        CALL PRINTLINE ('SYMBOL TABLE SIZE = ' ^^ MAXNDECSY,-1);                    DUMPIT
 2330        CALL PRINTLINE ('MACRO DEFINITIONS = ' ^^ TOP_MACRO + 1,-1);                DUMPIT
 2331        CALL PRINTLINE ('SCAN              = ' ^^ COUNT_SCAN,-1);                   DUMPIT
 2332        CALL PRINTLINE ('EMITINST          = ' ^^ COUNT_INST,-1);                   DUMPIT
 2333        CALL PRINTLINE ('FORCE ACCUMULATOR = ' ^^ COUNT_FORCE,-1);                  DUMPIT
 2334        CALL PRINTLINE ('ARITHEMIT         = ' ^^ COUNT_ARITH,-1);                  DUMPIT
 2335        CALL PRINTLINE ('GENERATE STORE    = ' ^^ COUNT_STORE,-1);                  DUMPIT
 2336        CALL PRINTLINE ('FREE STRING AREA  = ' ^^ FREELIMIT - FREEBASE,-1);         DUMPIT
 2337        CALL PRINTLINE ('COMPACTIFICATIONS = ' ^^ COUNT_COMPACT,-1);                DUMPIT
 2338        SUBTITLE = 'INSTRUCTION FREQUENCIES';                                       DUMPIT
 2339        EJECT_PAGE;                                                                 DUMPIT
 2340        DO I = 0 TO 15;                                                             DUMPIT
 2341           J = I * 32;                                                              DUMPIT C20 = 15
 2342           DO K = 0 TO 31;                                                          DUMPIT
 2343              IF INSTRUCT(J+K) > 0 THEN                                             DUMPIT C21 = 31
 2344                  CALL PRINTLINE (SUBSTR(OPNAME(I),K*6,6) ^^ X4 ^^ INSTRUCT(J+K),-1); DUMPIT
 2345           END;                                                                     DUMPIT
 2346        END;                                                                        DUMPIT
 2347  END DUMPIT;                                                                       DUMPIT

SYMBOL TABLE DUMP
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 84
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CHAR360         CHARACTER   847   STRING   2296       2
L               FIXED     10197     DATA   2297       7
LL              FIXED     10198     DATA   2297       6
T1              CHARACTER   848   STRING   2297       5
T2              CHARACTER   849   STRING   2297       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 85
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2348     INITIALIZE:                                                                   *
 2349        PROCEDURE;                                                                 *
 2350        DECLARE CH CHARACTER;                                                       INITIALIZE
 2351        DECLARE TIME1 FIXED, HOURS FIXED, MINUTES FIXED, SECS FIXED;                INITIALIZE
 2352        DECLARE DATE1 FIXED, DAY FIXED, YEAR FIXED, L FIXED;                        INITIALIZE
 2353        DECLARE MONTH CHARACTER;                                                    INITIALIZE
 2354        DECLARE MONTHS (11)CHARACTER INITIAL ('-JAN-',                              INITIALIZE
 2355              '-FEB-','-MAR-','-APR-','-MAY-','-JUN-','-JUL-','-AUG-',              INITIALIZE
 2356              '-SEP-','-OCT-','-NOV-','-DEC-');                                     INITIALIZE
 2357        OUTPUT(-2) = 'FILENAME TO BE COMPILED: ';                                   INITIALIZE
 2358        CHAR_TEMP = INPUT(-1);                                                      INITIALIZE
 2359        SOURCE = '';                                                                INITIALIZE
 2360        CONTROL(BYTE('A')) = FALSE;                                                 INITIALIZE
 2361        CONTROL(BYTE('D')) = TRUE;                                                  INITIALIZE
 2362        CONTROL(BYTE('S')) = TRUE;                                                  INITIALIZE
 2363        DO I = 0 TO LENGTH(CHAR_TEMP)-1;                                            INITIALIZE
 2364           CH =  SUBSTR(CHAR_TEMP,I,1);                                             INITIALIZE
 2365           IF BYTE(CH) = BYTE('/') THEN                                             INITIALIZE
 2366              DO;                                                                   INITIALIZE
 2367                 CH = SUBSTR(CHAR_TEMP,I+1,1);                                      INITIALIZE
 2368                 CONTROL(BYTE(CH)) = \ CONTROL(BYTE(CH));                           INITIALIZE
 2369                 I = I + 1;                                                         INITIALIZE
 2370              END;                                                                  INITIALIZE
 2371           ELSE                                                                     INITIALIZE
 2372              SOURCE = SOURCE ^^ CH;                                                INITIALIZE
 2373           END;                                                                     INITIALIZE
 2374        FILENAME (0) = 'SYSIN:' ^^ SOURCE ^^ '.XPL';                                INITIALIZE
 2375        FILENAME (1) = 'SYSOUT:' ^^ SOURCE ^^ '.LST';                               INITIALIZE
 2376        IF CONTROL(BYTE('A')) THEN                                                  INITIALIZE
 2377           DO;                                                                      INITIALIZE
 2378              FILENAME (DATAFILE) = SOURCE ^^ '.MAC';                               INITIALIZE
 2379              FILENAME(CODEFILE) = SOURCE ^^ '.TMP';                                INITIALIZE
 2380           END;                                                                     INITIALIZE
 2381        FILENAME(RELFILE) = SOURCE ^^ '.REL';                                       INITIALIZE
 2382        TIME1 = (TIME+500)/ 1000;                                                   INITIALIZE
 2383        HOURS = TIME1 /3600;                                                        INITIALIZE
 2384        MINUTES = (TIME1 MOD 3600) / 60;                                            INITIALIZE
 2385        SECS = TIME1 MOD 60;                                                        INITIALIZE
 2386        DATE1 = DATE;                                                               INITIALIZE
 2387        DAY = DATE1 MOD 31 + 1;                                                     INITIALIZE
 2388        DATE1 = DATE1 / 31;                                                         INITIALIZE
 2389        MONTH = MONTHS(DATE1 MOD 12);                                               INITIALIZE
 2390        YEAR = DATE1 / 12 + 1964;                                                   INITIALIZE
 2391        TITLE = '1' ^^ SOURCE ^^ '.XPL  COMPILED ' ^^ DAY ^^ MONTH ^^               INITIALIZE
 2392               YEAR ^^ '  AT ' ^^HOURS ^^ ':' ^^ MINUTES ^^ ':' ^^ SECS             INITIALIZE
 2393               ^^ ' BY VERSION ' ^^ VERSION;                                        INITIALIZE
 2394        L = LENGTH (TITLE);                                                         INITIALIZE
 2395        TITLE = TITLE ^^ SUBSTR(X70,0,90-L) ^^ 'PAGE ';                             INITIALIZE
 2396        SUBTITLE = ' LINE    SOURCE STATEMENT' ^^ SUBSTR(X70,7)                     INITIALIZE
 2397              ^^ 'PROCEDURE AND COMPILER INFORMATION';                              INITIALIZE C22 = 939524089
 2398        PAGE_COUNT = 0;                                                             INITIALIZE
 2399        LINE_COUNT = 99;                                                            INITIALIZE
 2400        DO I = 1 TO TERMINAL#;                                                      INITIALIZE
 2401           S = VOCAB(I);                                                            INITIALIZE
 2402           IF S = '<NUMBER>' THEN NUMBER = I;  ELSE                                 INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 86
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2403           IF S = '<IDENTIFIER>' THEN IDENT = I;  ELSE                              INITIALIZE
 2404           IF S = '<STRING>' THEN STRING = I;  ELSE                                 INITIALIZE
 2405           IF S = '/' THEN DIVIDE = I;  ELSE                                        INITIALIZE
 2406           IF S = 'EOF' THEN EOFILE = I;  ELSE                                      INITIALIZE
 2407           IF S = 'DECLARE' THEN STOPIT(I) = TRUE;  ELSE                            INITIALIZE
 2408           IF S = 'PROCEDURE' THEN STOPIT(I) = TRUE;  ELSE                          INITIALIZE
 2409           IF S = 'END' THEN STOPIT(I) = TRUE;  ELSE                                INITIALIZE
 2410           IF S = 'DO' THEN STOPIT(I) = TRUE;  ELSE                                 INITIALIZE
 2411           IF S = ';' THEN STOPIT(I) = TRUE;  ELSE                                  INITIALIZE
 2412           IF S = '^' THEN ORSYMBOL = I; ELSE                                       INITIALIZE
 2413           IF S = '^^' THEN CONCATENATE = I;                                        INITIALIZE
 2414        END;                                                                        INITIALIZE
 2415        IF IDENT = TERMINAL# THEN RESERVED_LIMIT = LENGTH(VOCAB(TERMINAL#-1));      INITIALIZE
 2416        ELSE RESERVED_LIMIT = LENGTH(VOCAB(TERMINAL#));                             INITIALIZE
 2417        STOPIT(EOFILE) = TRUE;                                                      INITIALIZE
 2418     DO I = TERMINAL# TO  VOCAB#;                                                   INITIALIZE
 2419        S = VOCAB(I);                                                               INITIALIZE C23 = 91
 2420        IF S = '<LABEL DEFINITION>' THEN LABELSET = I;                              INITIALIZE
 2421     END;                                                                           INITIALIZE
 2422        CHARTYPE (BYTE(' ')) = 1;                                                   INITIALIZE
 2423        CHARTYPE (BYTE('''')) = 2;                                                  INITIALIZE
 2424        CHARTYPE (BYTE('"')) = 3;                                                   INITIALIZE
 2425        DO I = 0 TO 255;                                                            INITIALIZE
 2426           NOT_LETTER_OR_DIGIT(I) = TRUE;                                           INITIALIZE C24 = 255
 2427        END;                                                                        INITIALIZE
 2428        DO I = 0 TO 29;                                                             INITIALIZE
 2429           J = BYTE('ABCDEFGHIJKLMNOPQRSTUVWXYZ_$@#', I);                           INITIALIZE C25 = 29
 2430           NOT_LETTER_OR_DIGIT(J) = FALSE;                                          INITIALIZE
 2431           CHARTYPE(J) = 4;                                                         INITIALIZE
 2432        END;                                                                        INITIALIZE
 2433        DO I = 0 TO 9;                                                              INITIALIZE
 2434           J = BYTE('0123456789', I);                                               INITIALIZE C26 = 9
 2435           NOT_LETTER_OR_DIGIT(J) = FALSE;                                          INITIALIZE
 2436           CHARTYPE(J) = 5;                                                         INITIALIZE
 2437         END;                                                                       INITIALIZE
 2438        I = 1;                                                                      INITIALIZE
 2439        DO WHILE (LENGTH(VOCAB(I))= 1);                                             INITIALIZE
 2440           J = BYTE(VOCAB(I));                                                      INITIALIZE
 2441           TX(J) = I;                                                               INITIALIZE
 2442           CHARTYPE(J) = 7;                                                         INITIALIZE
 2443           I = I + 1;                                                               INITIALIZE
 2444        END;                                                                        INITIALIZE
 2445        CHARTYPE(BYTE('^')) = 8;                                                    INITIALIZE
 2446        CHARTYPE (BYTE('/')) = 6;                                                   INITIALIZE
 2447        PP = 0;            /* PROGRAM ORIGIN */                                     INITIALIZE
 2448        DP = 0;            /* DATA ORIGIN */                                        INITIALIZE
 2449        DPOFFSET = 0;                                                               INITIALIZE
 2450        DSP = 0;           /* DESCRIPTOR ORIGIN */                                  INITIALIZE
 2451        RETURNED_TYPE = FIXEDTYPE;     /* INITIAL DEFAULT TYPE */                   INITIALIZE
 2452        TOP_MACRO = -1;                                                             INITIALIZE
 2453        TARGET_REGISTER = -1;                                                       INITIALIZE
 2454                                                                                    INITIALIZE
 2455        CODEMSG = X70 ^^ CODEMSG;                                                   INITIALIZE
 2456        DATAMSG = X70 ^^ DATAMSG;                                                   INITIALIZE
 2457        BACKMSG = X70 ^^ BACKMSG;                                                   INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 87
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2458                                                                                    INITIALIZE
 2459  /*    INITIALIZE THE SYMBOL TABLE AND ITS HASH TABLE */                           INITIALIZE
 2460        PROCMARK = 25; NDECSY = 27; PARCT = 0;                                      INITIALIZE
 2461        DO I = 0 TO SYTSIZE;                                                        INITIALIZE
 2462           PTR (I) = -1;                                                            INITIALIZE C27 = 420
 2463        END;                                                                        INITIALIZE
 2464        DO I = 0 TO "FF";                                                           INITIALIZE
 2465           HASH (I) = -1;                                                           INITIALIZE
 2466        END;                                                                        INITIALIZE
 2467        DO I = 0 TO NDECSY;                                                         INITIALIZE
 2468           IDX = HASHER (SYT(I));                                                   INITIALIZE
 2469           PTR (I) = HASH (IDX);                                                    INITIALIZE
 2470           HASH (IDX) = I;                                                          INITIALIZE
 2471        END;                                                                        INITIALIZE
 2472        RPTR, DPTR, DLOC,FOR_COUNT, LABEL_COUNT = 0;                                INITIALIZE
 2473        RCTR, DCTR = 1;                                                             INITIALIZE
 2474                                                                                    INITIALIZE
 2475        FILE(RELFILE) = NAME_TYPE + 2;                                              INITIALIZE
 2476        FILE(RELFILE) = 0;                                                          INITIALIZE C28 = 1572864
 2477        FILE(RELFILE) = RADIX50(SOURCE);                                            INITIALIZE
 2478        FILE(RELFILE) = "(3)17000000" + 0;                                          INITIALIZE
 2479        FILE(RELFILE) = HISEG_TYPE + 1;                                             INITIALIZE C29 = 3932160
 2480        FILE(RELFILE) = "(3)200000000000" ;                                         INITIALIZE C30 = 786432
 2481        FILE(RELFILE) = "(3)400000400000";                                          INITIALIZE
 2482                                                                                    INITIALIZE C31 = -34359607296
 2483        CODE_HEAD, CODE_TAIL = 0;                                                   INITIALIZE
 2484        CODE_FULL(0) = FALSE;                                                       INITIALIZE
 2485        IF CONTROL(BYTE('A')) THEN                                                  INITIALIZE
 2486           DO;                                                                      INITIALIZE
 2487              LABEL_GEN = 'P:';                /* ORG THE CODE SEGMENT */           INITIALIZE
 2488              OUTPUT (DATAFILE) = '       TITLE ' ^^ SOURCE ;                       INITIALIZE
 2489              OUTPUT (DATAFILE) = '       TWOSEG 400000;';                          INITIALIZE
 2490              OUTPUT (DATAFILE) = '       RELOC 0;';                                INITIALIZE
 2491              OUTPUT (DATAFILE) = '       RADIX 10;';                               INITIALIZE
 2492              OUTPUT (CODEFILE) = '       RELOC ^O400000;';                         INITIALIZE
 2493              OUTPUT (DATAFILE) = '       OPDEF   .INIT. [1B8];';                   INITIALIZE
 2494              OUTPUT (DATAFILE) = '       OPDEF   .INPT. [2B8];';                   INITIALIZE
 2495              OUTPUT (DATAFILE) = '       OPDEF   .OUTP. [3B8];';                   INITIALIZE
 2496              OUTPUT (DATAFILE) = '       OPDEF   .EXIT. [4B8];';                   INITIALIZE
 2497              OUTPUT (DATAFILE) = '       OPDEF   .FILI. [6B8];';                   INITIALIZE
 2498              OUTPUT (DATAFILE) = '       OPDEF   .FILO. [7B8];';                   INITIALIZE
 2499              OUTPUT (DATAFILE) = '       OPDEF   .NAME. [8B8];';                   INITIALIZE
 2500              OUTPUT (DATAFILE) = 'D:';                                             INITIALIZE
 2501           END;                                                                     INITIALIZE
 2502        BYTEPTRS = DP;                                                              INITIALIZE
 2503        CALL EMITDATAWORD ("(3)331114000000"); /*   POINT 9,0(12),8 */              INITIALIZE
 2504        CALL EMITDATAWORD ("(3)221114000000"); /*   POINT 9,0(12),17 */             INITIALIZE C32 = 29145169920
 2505        CALL EMITDATAWORD ("(3)111114000000"); /*   POINT 9,0(12),26 */             INITIALIZE C33 = 19481493504
 2506        CALL EMITDATAWORD ("(3)001114000000"); /*   POINT 9,0(12),35 */             INITIALIZE C34 = 9817817088
 2507        PSBITS = DP;                                                                INITIALIZE C35 = 154140672
 2508        CALL EMITDATAWORD ("(3)331100000000"); /*   POINT 9,0,8  */                 INITIALIZE
 2509        CALL EMITDATAWORD ("(3)221100000000"); /*   POINT 9,0,17 */                 INITIALIZE C36 = 29142024192
 2510        CALL EMITDATAWORD ("(3)111100000000"); /*   POINT 9,0,26 */                 INITIALIZE C37 = 19478347776
 2511        CALL EMITDATAWORD ("(3)001100000000"); /*   POINT 9,0,35 */                 INITIALIZE C38 = 9814671360
 2512        CALL EMITCONSTANT (1);            /* ENTER A 1 */                           INITIALIZE C39 = 150994944
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 88
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2513        TRUELOC = ADR;                    /* SAVE ITS ADDRESS */                    INITIALIZE
 2514        CALL EMITCONSTANT (0);            /* ENTER A 0 */                           INITIALIZE
 2515        FALSELOC = ADR;                   /* SAVE ITS ADDRESS */                    INITIALIZE
 2516        TSA = DP; SYTLOC(2) = DP;         /* FREEPOINT */                           INITIALIZE
 2517        CALL EMITDATAWORD (0);                                                      INITIALIZE
 2518        NDESC, SYTLOC(4) = FINDLABEL;     /* NDESCRIPT */                           INITIALIZE
 2519        COREBYTELOC = 1;                  /* SYT LOCATION OF COREBYTE */            INITIALIZE
 2520        STRING_RECOVER = 25;              /* SYT LOCATION OF COMPACTIFY */          INITIALIZE
 2521        SYTLOC(25) = FINDLABEL;           /* LABEL FOR COMPACTIFY */                INITIALIZE
 2522        LIMITWORD = DP; SYTLOC(26) = DP;  /* FREELIMIT */                           INITIALIZE
 2523        CALL EMITDATAWORD (0);                                                      INITIALIZE
 2524        STR = DSP;                        /* PLACE TO SAVE LAST STRING GENERATED */ INITIALIZE
 2525        CALL EMITDESC (0,0);                                                        INITIALIZE
 2526        LIBRARY_SAVE = DP;                /* PLACE TO SAVE R11 ON LIB CALLS */      INITIALIZE
 2527        CALL EMITDATAWORD (0);                                                      INITIALIZE
 2528        LIBRARY = DP;                     /* ADDRESS OF LIBRARY GOES HERE */        INITIALIZE
 2529        IF CONTROL(BYTE('A')) THEN                                                  INITIALIZE
 2530           DO;                                                                      INITIALIZE
 2531              OUTPUT (DATAFILE) = '       XPLLIB;';                                 INITIALIZE
 2532              OUTPUT (DATAFILE) = '       EXTERN XPLLIB;';                          INITIALIZE
 2533           END;                                                                     INITIALIZE
 2534        DP = DP + 1;                                                                INITIALIZE
 2535        CALL EMITCONSTANT ("FFFFF");      /* MASK FOR ADDRESSES ONLY  */            INITIALIZE
 2536        ADDRMASK = ADR;                   /* SAVE IT                  */            INITIALIZE
 2537        CALL EMITCONSTANT(-134217728);  /* DV LENGTH FIELD */                       INITIALIZE
 2538        LENGTHMASK = ADR;                                                           INITIALIZE
 2539                                                                                    INITIALIZE
 2540  /* CHECK-STRING-OVERFLOW  SEE IF COMPACTIFY NEEDS TO BE CALLED */                 INITIALIZE
 2541                                                                                    INITIALIZE
 2542        CALL EMITBLOCK (15);                                                        INITIALIZE
 2543        I = DP - 15;                                                                INITIALIZE
 2544        STRING_CHECK = PP;                                                          INITIALIZE
 2545        CALL EMITINST (MOVE,0,0,TSA,0,1); /* PICK UP TOP OF STRINGS */              INITIALIZE
 2546        CALL EMITINST (CAMGE,0,0,LIMITWORD,0,1); /* COMPARE WITH LIMIT WORD */      INITIALIZE
 2547        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2548        CALL EMITINST (MOVEI,0,0,I,0,1);                                            INITIALIZE
 2549        CALL EMITINST (HRLI,0,0,1,0,0);                                             INITIALIZE
 2550        CALL EMITINST (BLT,0,0,I+14,0,1);                                           INITIALIZE
 2551        CALL EMITINST (PUSHJ,15,0,SYTLOC(STRING_RECOVER),0,SYTSEG(STRING_RECOVER)); INITIALIZE
 2552        CALL EMITINST (MOVEI,0,0,1,0,0);                                            INITIALIZE
 2553        CALL EMITINST (HRLI,0,0,I,0,1);                                             INITIALIZE
 2554        CALL EMITINST (BLT,0,0,14,0,0);                                             INITIALIZE
 2555        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2556        SYTCO (STRING_RECOVER) = SYTCO (STRING_RECOVER) + 1;                        INITIALIZE
 2557                                                                                    INITIALIZE
 2558   /* STRING COMPARISON */                                                          INITIALIZE
 2559                                                                                    INITIALIZE
 2560        A = DSP;                                                                    INITIALIZE
 2561        CALL EMITDESC (0,0);                                                        INITIALIZE
 2562        B = DSP;                                                                    INITIALIZE
 2563        CALL EMITDESC (0,0);                                                        INITIALIZE
 2564        STRCOMP = PP;                                                               INITIALIZE
 2565        CALL EMITINST (MOVE,0,0,A,0,3);   /* FETCH LEFT DESCRIPTOR */               INITIALIZE
 2566        CALL EMITINST (LSH,0,0,    -27,0,0);                                        INITIALIZE
 2567        CALL EMITINST (MOVE,1,0,B,0,3);    /* FETCH RIGHT DESCRIPTOR */             INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 89
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2568        CALL EMITINST (LSH,1,0,    -27,0,0);                                        INITIALIZE
 2569        CALL EMITINST (SUB,0,0,1,0,0);    /* SUBTRACT THE LENGTHS */                INITIALIZE
 2570        CALL EMITINST (JUMPE,0,0,PP+2,0,2);                                         INITIALIZE
 2571        CALL EMITINST (POPJ,15,0,0,0,0);   /* RETURN W/ -, 0, OR + IF LENGTH \= */  INITIALIZE
 2572        CALL EMITINST (MOVEI,2,0,0,0,0);  /* CLEAR A LENGTH REGISTER */             INITIALIZE
 2573        CALL EMITINST (MOVE,3,0,A,0,3);                                             INITIALIZE
 2574        CALL EMITINST (SUBI,3,0,1,0,0);                                             INITIALIZE
 2575        CALL EMITINST (LSHC,2,0,  9,0,0); /* ISOLATE THE LENGTH */                  INITIALIZE
 2576        CALL EMITINST (LSHC,3,0,-11,0,0); /* ISOLATE BYTE INDEX IN R4 */            INITIALIZE
 2577        CALL EMITINST (LSH,4,0,    -34,0,0);                                        INITIALIZE
 2578        CALL EMITINST (HLL,3,0,PSBITS,4,1); /* BUILD BYTE PTR IN R3 */              INITIALIZE
 2579        CALL EMITINST (MOVE,4,0,B,0,3);                                             INITIALIZE
 2580        CALL EMITINST (SUBI,4,0,1,0,0);                                             INITIALIZE
 2581        CALL EMITINST (LSHC,4,0,    -2,0,0);                                        INITIALIZE
 2582        CALL EMITINST (LSH,5,0,    -34,0,0);                                        INITIALIZE
 2583        CALL EMITINST (HLL,4,0,PSBITS,5,1); /* BUILD BYTE PTR IN R4 */              INITIALIZE
 2584                                                                                    INITIALIZE
 2585        /* ONE CHARACTER GOES INTO R0 WHILE THE OTHER GOES INTO R1.  LENGTH IS      INITIALIZE
 2586           CONTROLLED IN R2 AND THE BYTE PTRS ARE IN R3 & R4 FOR SPEED.             INITIALIZE
 2587        */                                                                          INITIALIZE
 2588        CALL EMITINST (ILDB,0,0,3,0,0);   /* FETCH 1ST BYTE */                      INITIALIZE
 2589        CALL EMITINST (ILDB,1,0,4,0,0);   /* FETCH 2ND BYTE */                      INITIALIZE
 2590        CALL EMITINST (CAMN,0,0,1,0,0);   /* SKIP IF \= */                          INITIALIZE
 2591        CALL EMITINST (SOJG,2,0,PP-3,0,2);/* LOOP FOR ALL BYTES */                  INITIALIZE
 2592        CALL EMITINST (SUB,0,0,1,0,0);    /* SUB DIFF BYTES OR LAST TWO EQUAL */    INITIALIZE
 2593        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2594                                                                                    INITIALIZE
 2595   /* MOVE CHARACTER SUBROUTINE */                                                  INITIALIZE
 2596                                                                                    INITIALIZE
 2597        MOVER = PP;                                                                 INITIALIZE
 2598        /* USES REGISTERS 1, 2, 11, 12, & 13 */                                     INITIALIZE
 2599        CALL EMITINST (SUBI,12,0,1,0,0);  /* DECR ADDR OF SOURCE */                 INITIALIZE
 2600        CALL EMITINST (MOVEI,11,0,0,0,0); /* CLEAR LENGTH REG */                    INITIALIZE
 2601        CALL EMITINST (LSHC,11,0,  9,0,0);/* ISOLATE LENGTH */                      INITIALIZE
 2602        CALL EMITINST (LSHC,12,0,-11,0,0);/* ISOLATE BYTE INDEX */                  INITIALIZE
 2603        CALL EMITINST (LSH,13,0,    -34,0,0);                                       INITIALIZE
 2604        CALL EMITINST (HLL,12,0,PSBITS,13,1); /* MAKE FROM BYTEPTR */               INITIALIZE
 2605        CALL EMITINST (MOVE,13,0,11,0,0); /* COPY LENGTH */                         INITIALIZE
 2606        CALL EMITINST (ADD,13,0,1,0,0);   /* CREATE NEW TSA */                      INITIALIZE
 2607        CALL EMITINST (SUBI,1,0,1,0,0);   /* DECR TO ADDR */                        INITIALIZE
 2608        CALL EMITINST (LSHC,1,0,    -2,0,0); /* ISOLATE BYTE INDEX */               INITIALIZE
 2609        CALL EMITINST (LSH,2,0,    -34,0,0);                                        INITIALIZE
 2610        CALL EMITINST (HLL,1,0,PSBITS,2,1);  /* TO BYTEPTR */                       INITIALIZE
 2611                                                                                    INITIALIZE
 2612        /* CHARACTER GOES INTO R2, LENGTH IS IN R11, AND THE NEW TSA IS IN R13.     INITIALIZE
 2613           BYTEPTRS ARE IN R1 & R12 FOR SPEED.                                      INITIALIZE
 2614        */                                                                          INITIALIZE
 2615        CALL EMITINST (ILDB,2,0,12,0,0);  /* FETCH A BYTE */                        INITIALIZE
 2616        CALL EMITINST (IDPB,2,0,1,0,0);   /* STORE A BYTE */                        INITIALIZE
 2617        CALL EMITINST (SOJG,11,0,PP-2,0,2);  /* LOOP FOR ALL BYTES */               INITIALIZE
 2618        CALL EMITINST (MOVE,1,0,13,0,0);  /* RETURN WITH NEW TSA */                 INITIALIZE
 2619        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2620                                                                                    INITIALIZE
 2621   /* CATENATION SUBROUTINE */                                                      INITIALIZE
 2622                                                                                    INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 90
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2623        CATENTRY = PP;                                                              INITIALIZE
 2624        CALL CHECK_STRING_OVERFLOW;       /* SQUEEZE CORE IF NECESSARY */           INITIALIZE
 2625        CALL EMITINST (MOVE,0,0,B,0,3);   /* SEE IF LENGTH (B) = 0 */               INITIALIZE
 2626        CALL EMITINST (AND,0,0,LENGTHMASK,0,1);                                     INITIALIZE
 2627        CALL EMITINST (JUMPN,0,0,PP+3,0,2);                                         INITIALIZE
 2628        CALL EMITINST (MOVE,0,0,A,0,3);   /* YES, RETURN WITH A */                  INITIALIZE
 2629        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2630        CALL EMITINST (MOVE,1,0,A,0,3);   /* SEE IF LENGTH(A) = 0 */                INITIALIZE
 2631        CALL EMITINST (AND,1,0,LENGTHMASK,0,1);                                     INITIALIZE
 2632        CALL EMITINST (JUMPN,1,0,PP+3,0,2);                                         INITIALIZE
 2633        CALL EMITINST (MOVE,0,0,B,0,3);   /* YES, RETURN WITH B */                  INITIALIZE
 2634        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2635                                                                                    INITIALIZE
 2636        /*  WE HAVE TO CONSTRUCT A NEW STRING.  CHECK TO SEE IF STRING 'A'          INITIALIZE
 2637          IS ADJACENT TO THE FIRST AVAILABLE BYTE.  IF IT IS, WE NEED               INITIALIZE
 2638          ONLY ACTUALLY MOVE STRING 'B' AND DUMMY UP A NEW DESCRIPTOR.  */          INITIALIZE
 2639                                                                                    INITIALIZE
 2640        CALL EMITINST (ROT,1,0,9,0,0);     /* PUT L(A) IN LOW END */                INITIALIZE
 2641        CALL EMITINST (ADD,1,0,A,0,3);     /* ADD A DESC. */                        INITIALIZE
 2642        CALL EMITINST (AND,1,0,ADDRMASK,0,1); /* KEEP ONLY BYTE ADDRESS */          INITIALIZE
 2643        CALL EMITINST (ADD,0,0,A,0,3);     /* ADD L(B) TO DESC. A */                INITIALIZE
 2644        CALL EMITINST (MOVE,12,0,B,0,3);     /* GE DESC. B */                       INITIALIZE
 2645        CALL EMITINST (AND,12,0,ADDRMASK,0,1);/* KEEP BYTE ADDRESS */               INITIALIZE
 2646        CALL EMITINST (CAMN,12,0,1,0,0);    /* IS THIS SAME AS END(A)+1? */         INITIALIZE
 2647        CALL EMITINST (JRST,0,0,PP+11,0,2);  /*YES. THEN DONE */                    INITIALIZE
 2648        CALL EMITINST (CAML,1,0,TSA,0,1);  /* IS 'A' LAST STRING ? */               INITIALIZE
 2649        CALL EMITINST (JRST,0,0,PP+6,0,2); /* YES. JUMP TO JUST MOVE B */           INITIALIZE
 2650        CALL EMITINST (AND,0,0,LENGTHMASK,0,1); /* NO. MAKE NEW DESC. */            INITIALIZE
 2651        CALL EMITINST (IOR,0,0,TSA,0,1);  /* NEW DOPE VECTOR */                     INITIALIZE
 2652        CALL EMITINST (MOVE,1,0,TSA,0,1); /* TARGET OF MOVE */                      INITIALIZE
 2653        CALL EMITINST (MOVE,12,0,A,0,3);  /* SOURCE OF MOVE & LENGTH */             INITIALIZE
 2654        CALL EMITINST (PUSHJ,15,0,MOVER,0,2);   /* CALL MOVE SUBROUTINE */          INITIALIZE
 2655        CALL EMITINST (MOVE,12,0,B,0,3);  /* SOURCE OF MOVE */                      INITIALIZE
 2656        CALL EMITINST (PUSHJ,15,0,MOVER,0,2);   /* CALL MOVE SUBROUTINE*/           INITIALIZE
 2657        CALL EMITINST (MOVEM,1,0,TSA,0,1);/* SAVE NEW TSA */                        INITIALIZE
 2658        CALL EMITINST (MOVEM,0,0,STR,0,3);  /* SAVE LAST STRING DESCRIPTOR */       INITIALIZE
 2659        CALL EMITINST (POPJ,15,0,0,0,0);                                            INITIALIZE
 2660                                                                                    INITIALIZE
 2661   /* NUMBER TO STRING CONVERSION */                                                INITIALIZE
 2662                                                                                    INITIALIZE
 2663        NMBRENTRY = PP;                                                             INITIALIZE
 2664        /* USES REGISTERS 0,1,12,13 */                                              INITIALIZE
 2665                                                                                    INITIALIZE
 2666        CALL EMITBLOCK (1);                                                         INITIALIZE
 2667        C = DP - 1;                                                                 INITIALIZE
 2668        CALL CHECK_STRING_OVERFLOW;                                                 INITIALIZE
 2669        CALL EMITINST (MOVE,12,0,TSA,0,1);   /* GET LOC'N FIRST FREE BYTE*/         INITIALIZE
 2670        CALL EMITINST (SUBI,12,0,1,0,0);    /* ADJUST FOR IDBP */                   INITIALIZE
 2671        CALL EMITINST (MOVEI,13,0,0,0,0);    /* CLEAR 13 FOR SHIFT */               INITIALIZE
 2672        CALL EMITINST (LSHC,12,0,-2,0,0);    /* WORD ADDRESS TO 12 */               INITIALIZE
 2673        CALL EMITINST (ROT,13,0,2,0,0);      /* DISPL. TO 13 */                     INITIALIZE
 2674        CALL EMITINST (HLL,12,0,PSBITS,13,1);/* MAKE BYTE POINTER IN 12 */          INITIALIZE
 2675        CALL EMITINST (MOVE,0,0,C,0,1);      /* LOAD NUMBER TO BE CONVERTED */      INITIALIZE
 2676        CALL EMITINST (MOVEI,13,0,0,0,0);    /* CLEAR COUNT OF BYTES */             INITIALIZE
 2677        CALL EMITINST (JUMPGE,0,0,PP+5,0,2); /* JUMP AROUND SIGN IF >= 0 */         INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 91
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2678        CALL EMITINST (MOVEI,1,0,BYTE('-'),0,0);/* PUT - INTO REG. */               INITIALIZE
 2679        CALL EMITINST (IDPB,1,0,12,0,0);     /* PUT BYTE AWAY */                    INITIALIZE
 2680        CALL EMITINST (MOVEI,13,0,1,0,0);    /* SET BYTE COUNT TO 1 */              INITIALIZE
 2681        CALL EMITINST (MOVM,0,0,0,0,0);      /* MAKE NUMBER POSITIVE */             INITIALIZE
 2682        CALL EMITINST (PUSHJ,15,0,PP+8,0,2); /* GENERATE BYTE STRING */             INITIALIZE
 2683        CALL EMITINST (ROT,13,0,-9,0,0);     /* PUT BYTE COUNT IN LENGTH */         INITIALIZE
 2684        CALL EMITINST (MOVE,0,0,TSA,0,1);    /* PICK STARTING ADDRESS OF STRING */  INITIALIZE
 2685        CALL EMITINST (ADD,0,0,13,0,0);      /* ADD LENGTH TO MAKE DESC. */         INITIALIZE
 2686        CALL EMITINST (ROT,13,0,9,0,0);      /* PUT COUNT BACK */                   INITIALIZE
 2687        CALL EMITINST (ADDM,13,0,TSA,0,1);   /* ADJUST TSA FOR NEXT TIME */         INITIALIZE
 2688        CALL EMITINST (MOVEM,0,0,STR,0,3);   /* SAVE NEW DESCRIPTOR */              INITIALIZE
 2689        CALL EMITINST (POPJ,15,0,0,0,0);     /* RETURN */                           INITIALIZE
 2690                                                                                    INITIALIZE
 2691        /* SUBROUTINE TO CONVERT NUMBER TO CHAR STRING BY REPETITIVE                INITIALIZE
 2692           DIVISION.  PUTS OUT DIGITS FROM HIGH-TO-LOW ORDER. */                    INITIALIZE
 2693                                                                                    INITIALIZE
 2694        CALL EMITINST (IDIVI,0,0,10,0,0);    /* QUOTIENT TO 0, REMAINDER TO 1 */    INITIALIZE
 2695        CALL EMITINST (HRLM,1,0,0,15,0);     /* SAVE REMAINDER ON STACK */          INITIALIZE
 2696        CALL EMITINST (JUMPE,0,0,PP+2,0,2);  /* IF QUOTIENT = 0, ALL DIGITS */      INITIALIZE
 2697        CALL EMITINST (PUSHJ,15,0,PP-3,0,2); /* LOOP BACK FOR NEXT DIGIT */         INITIALIZE
 2698        CALL EMITINST (HLRZ,1,0,0,15,0);     /* RETRIEVE DIGIT FROM STACK */        INITIALIZE
 2699        CALL EMITINST (ADDI,1,0,BYTE('0'),0,0); /* CONVERT TO ASCII CHARACTER */    INITIALIZE
 2700        CALL EMITINST (IDPB,1,0,12,0,0);     /* STUFF BYTE OUT */                   INITIALIZE
 2701        CALL EMITINST (ADDI,13,0,1,0,0);     /* INCREMENT BYTE COUNTER */           INITIALIZE
 2702        CALL EMITINST (POPJ,15,0,0,0,0);     /* RETURN (FOR MORE OR TO CALLER */    INITIALIZE
 2703                                                                                    INITIALIZE
 2704     /* THE COMPILED PROGRAM WILL BEGIN EXECUTION HERE.  MAKE THE FIRST JUMP        INITIALIZE
 2705        POINT HERE, INITIALIZE THE LIBRARY, AND FALL INTO COMPILE CODE.             INITIALIZE
 2706     */                                                                             INITIALIZE
 2707                                                                                    INITIALIZE
 2708        STARTLOC = PP;                      /* START LOCATION */                    INITIALIZE
 2709        CALL EMITLABEL (0,4);               /* ORG PROGRAM HERE */                  INITIALIZE
 2710        /* INITIALIZE LIBRARY ROUTINE, FREEBASE, FREELIMIT, & FREEPOINT */          INITIALIZE
 2711        CALL EMITINST (JUMP,0,0,0,0,0);   /* PATCH NOP */                           INITIALIZE
 2712        CALL EMITINST (1,0,0,0,0,0);      /* INIT LIB CODE */                       INITIALIZE
 2713        CALL EMITINST (MOVEM,12,0,TSA,0,1); /* SAVE AS FREEPOINT */                 INITIALIZE
 2714        CALL EMITINST (MOVEM,12,0,DP,0,1); /* SAVE AS FREEBASE */                   INITIALIZE
 2715        SYTLOC (27) = DP;                                                           INITIALIZE
 2716        CALL EMITDATAWORD (0);                                                      INITIALIZE
 2717        CALL EMITINST (SUBI,13,0,256,0,0);                                          INITIALIZE
 2718        CALL EMITINST (MOVEM,13,0,LIMITWORD,0,1); /* SAVE AS FREELIMIT */           INITIALIZE
 2719        /* ROUTINE TO RELOCATE STRING DESCRIPTORS */                                INITIALIZE
 2720        CALL EMITINST (MOVEI,12,0,0,0,1); /* GET ADDRESS OF DATA SEGMENT */         INITIALIZE
 2721        CALL EMITINST (LSH,12,0,  2,0,0);    /* MULTIPLY BY 4 FOR BYTE ADDRESS*/    INITIALIZE
 2722        CALL EMITINST (MOVE,13,0,NDESC,0,5);   /* GET # DESCRIPTORS AS INDEX */     INITIALIZE
 2723        CALL EMITINST (SKIPE,0,0,0,13,3); /* DON'T CHANGE NULL DESC.S */            INITIALIZE
 2724        CALL EMITINST (ADDM,12,0,0,13,3); /* ADD RELOC TO A DESCRIPTOR */           INITIALIZE
 2725        CALL EMITINST (SOJG,13,0,PP-2,0,2);    /* LOOP THRU ALL DESCRIPTORS */      INITIALIZE
 2726        CP = 0;  TEXT = '';  TEXT_LIMIT = -1;                                       INITIALIZE
 2727        COMPILING = TRUE;                                                           INITIALIZE
 2728        READING = CONTROL(BYTE('X'));                                               INITIALIZE
 2729        IF READING THEN                                                             INITIALIZE
 2730            CONTROL(BYTE('L')) = \ (CONTROL(BYTE('K')) ^ CONTROL(BYTE('M'))) & 1;   INITIALIZE
 2731        FILENAME(LIBFILE) = 'LIB:XPL.LIB';                                          INITIALIZE
 2732        CURRENT_PROCEDURE = '*';                                                    INITIALIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 92
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2733        CALL SCAN;                                                                  INITIALIZE
 2734        NO_LOOK_AHEAD_DONE = FALSE;                                                 INITIALIZE
 2735     END INITIALIZE;                                                                INITIALIZE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CH              CHARACTER   864   STRING   2350       6
DATE1           FIXED     10276     DATA   2352       6
DAY             FIXED     10277     DATA   2352       2
HOURS           FIXED     10273     DATA   2351       2
L               FIXED     10279     DATA   2352       2
MINUTES         FIXED     10274     DATA   2351       2
MONTH           CHARACTER   865   STRING   2353       2
MONTHS          CHARACTER   866   STRING   2354       1
SECS            FIXED     10275     DATA   2351       2
TIME1           FIXED     10272     DATA   2351       4
YEAR            FIXED     10278     DATA   2352       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 93
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2736  STACK_DUMP:                                                                      *
 2737     PROCEDURE;                                                                    *
 2738        DECLARE LINE CHARACTER;                                                     STACK_DUMP
 2739        IF \ CONTROL(BYTE('R')) THEN RETURN;  /* 'R' IS BARF SWITCH */              STACK_DUMP
 2740        LINE = 'PARTIAL PARSE TO THIS POINT IS: ';                                  STACK_DUMP
 2741        DO I = 0 TO SP;                                                             STACK_DUMP
 2742           IF LENGTH(LINE) > 105 THEN                                               STACK_DUMP
 2743              DO;                                                                   STACK_DUMP
 2744                 CALL PRINTLINE (LINE,-1);                                          STACK_DUMP
 2745                 LINE = X4;                                                         STACK_DUMP
 2746              END;                                                                  STACK_DUMP
 2747           LINE = LINE ^^ X1 ^^ VOCAB(STATE_NAME(STATE_STACK(I)));                  STACK_DUMP
 2748        END;                                                                        STACK_DUMP
 2749        CALL PRINTLINE (LINE,-1);                                                   STACK_DUMP
 2750     END STACK_DUMP;                                                                STACK_DUMP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LINE            CHARACTER   929   STRING   2738       7
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 94
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2751                                                                                   *
 2752    /*                  THE SYNTHESIS ALGORITHM FOR XPL                      */    *
 2753                                                                                   *
 2754                                                                                   *
 2755  SYNTHESIZE:                                                                      *
 2756  PROCEDURE(PRODUCTION_NUMBER);                                                    *
 2757     DECLARE PRODUCTION_NUMBER FIXED;                                               SYNTHESIZE
 2758     DECLARE TOOMSG CHARACTER INITIAL ('TOO MANY ARGUMENTS FOR ');                  SYNTHESIZE
 2759                                                                                    SYNTHESIZE
 2760     STACK_CASE:                                                                    SYNTHESIZE
 2761        PROCEDURE (DATUM);                                                          SYNTHESIZE
 2762           DECLARE DATUM FIXED;                                                     STACK_CASE
 2763           DECLARE DCLRM CHARACTER                                                  STACK_CASE
 2764                 INITIAL ('TOO MANY CASES OR FACTORED DECLARATIONS');               STACK_CASE
 2765           IF CASEP >= CASELIMIT THEN CALL ERROR (DCLRM,1);                         STACK_CASE
 2766                                 ELSE CASEP = CASEP + 1;                            STACK_CASE
 2767           CASESTACK(CASEP) = DATUM;                                                STACK_CASE
 2768     END STACK_CASE;                                                                STACK_CASE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
DATUM           FIXED     10486     DATA   2761       1
DCLRM           CHARACTER   932   STRING   2764       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 95
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2769                                                                                    SYNTHESIZE
 2770        DO CASE (PRODUCTION_NUMBER);                                                SYNTHESIZE
 2771     /*  ONE STATEMENT FOR EACH PRODUCTION OF THE GRAMMAR*/                         SYNTHESIZE CASE 0.
 2772     ;      /*  CASE 0 IS A DUMMY, BECAUSE WE NUMBER PRODUCTIONS FROM 1  */         SYNTHESIZE
 2773                                                                                    SYNTHESIZE CASE 1.
 2774  /*      1   <PROGRAM> ::= <STATEMENT LIST> EOF                       */           SYNTHESIZE
 2775  DO;  /* END OF COMPILING */                                                       SYNTHESIZE
 2776     COMPILING = FALSE;                                                             SYNTHESIZE
 2777     IF MP \= 0  THEN                                                               SYNTHESIZE
 2778        DO;                                                                         SYNTHESIZE
 2779           CALL ERROR ('INPUT DID NOT PARSE TO <PROGRAM>.', 1);                     SYNTHESIZE
 2780           CALL STACK_DUMP;                                                         SYNTHESIZE
 2781        END;                                                                        SYNTHESIZE
 2782     DO I = PROCMARK TO NDECSY;                                                     SYNTHESIZE
 2783        IF SYTYPE (I) = FORWARDTYPE ^ SYTYPE (I) = FORWARDCALL THEN                 SYNTHESIZE
 2784           IF SYTCO (I) > 0 THEN                                                    SYNTHESIZE
 2785               CALL ERROR ('UNDEFINED LABEL OR PROCEDURE: ' ^^ SYT(I),1);           SYNTHESIZE
 2786     END;                                                                           SYNTHESIZE
 2787        IF DPOFFSET > 0 THEN CALL FLUSH_DATACARD;                                   SYNTHESIZE
 2788  END;                                                                              SYNTHESIZE
 2789                                                                                    SYNTHESIZE CASE 2.
 2790  /*      2   <STATEMENT LIST> ::= <STATEMENT>                         */           SYNTHESIZE
 2791     ;                                                                              SYNTHESIZE
 2792  /*      3                      ^ <STATEMENT LIST> <STATEMENT>        */           SYNTHESIZE CASE 3.
 2793     ;                                                                              SYNTHESIZE
 2794  /*      4   <STATEMENT> ::= <BASIC STATEMENT>                        */           SYNTHESIZE CASE 4.
 2795     DO;                                                                            SYNTHESIZE
 2796        STATEMENT_COUNT = STATEMENT_COUNT + 1;                                      SYNTHESIZE
 2797        CALL CLEARARS;                                                              SYNTHESIZE
 2798     END;                                                                           SYNTHESIZE
 2799                                                                                    SYNTHESIZE CASE 5.
 2800  /*      5                 ^ <IF STATEMENT>                           */           SYNTHESIZE
 2801     CALL CLEARARS;                                                                 SYNTHESIZE
 2802  /*      6   <BASIC STATEMENT> ::= <ASSIGNMENT> ;                     */           SYNTHESIZE CASE 6.
 2803     ;                                                                              SYNTHESIZE
 2804  /*      7                       ^ <GROUP> ;                          */           SYNTHESIZE CASE 7.
 2805     ;                                                                              SYNTHESIZE
 2806  /*      8                       ^ <PROCEDURE DEFINITION> ;           */           SYNTHESIZE CASE 8.
 2807     ;                                                                              SYNTHESIZE
 2808  /*      9                       ^ <RETURN STATEMENT> ;               */           SYNTHESIZE CASE 9.
 2809     ;                                                                              SYNTHESIZE
 2810  /*     10                       ^ <CALL STATEMENT> ;                 */           SYNTHESIZE CASE 10.
 2811     ;                                                                              SYNTHESIZE
 2812  /*     11                       ^ <GO TO STATEMENT> ;                */           SYNTHESIZE CASE 11.
 2813     ;                                                                              SYNTHESIZE
 2814  /*     12                       ^ <DECLARATION STATEMENT> ;          */           SYNTHESIZE CASE 12.
 2815     ;                                                                              SYNTHESIZE
 2816  /*     13                       ^ ;                                  */           SYNTHESIZE CASE 13.
 2817     ;                                                                              SYNTHESIZE
 2818  /*     14                       ^ <LABEL DEFINITION>                 */           SYNTHESIZE CASE 14.
 2819  /*     14                         <BASIC STATEMENT>                  */           SYNTHESIZE
 2820     ;                                                                              SYNTHESIZE
 2821  /*     15   <IF STATEMENT> ::= <IF CLAUSE> <STATEMENT>               */           SYNTHESIZE CASE 15.
 2822     CALL EMITLABEL(FIXL(MP),4);            /* FIX ESCAPE BRANCH */                 SYNTHESIZE
 2823  /*     16                    ^ <IF CLAUSE> <TRUE PART> <STATEMENT>   */           SYNTHESIZE CASE 16.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 96
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2824     CALL EMITLABEL (FIXL(MPP1),4);         /* FIX ESCAPE BRANCH */                 SYNTHESIZE
 2825  /*     17                    ^ <LABEL DEFINITION> <IF STATEMENT>     */           SYNTHESIZE CASE 17.
 2826     ;                                                                              SYNTHESIZE
 2827  /*     18   <IF CLAUSE> ::= IF <EXPRESSION> THEN                     */           SYNTHESIZE CASE 18.
 2828        CALL BOOLBRANCH(MPP1,MP);  /* BRANCH ON FALSE OVER TRUE PART */             SYNTHESIZE
 2829                                                                                    SYNTHESIZE CASE 19.
 2830  /*     19   <TRUE PART> ::= <BASIC STATEMENT> ELSE                   */           SYNTHESIZE
 2831     DO; /* SAVE THE PROGRAM POINTER AND EMIT THE CONDITIONAL BRANCH */             SYNTHESIZE
 2832        FIXL(MP) = FINDLABEL;                                                       SYNTHESIZE
 2833        CALL EMITINST(JRST ,0,0,FIXL(MP),0,4);                                      SYNTHESIZE
 2834        CALL EMITLABEL (FIXL(MP-1),4);      /* COMPLETE HOP AROUND TRUE */          SYNTHESIZE
 2835        CALL CLEARARS;                                                              SYNTHESIZE
 2836     END;                                                                           SYNTHESIZE
 2837                                                                                    SYNTHESIZE CASE 20.
 2838  /*     20   <GROUP> ::= <GROUP HEAD> <ENDING>                        */           SYNTHESIZE
 2839          /* BRANCH BACK TO LOOP AND FIX ESCAPE BRANCH */                           SYNTHESIZE
 2840        IF INX (MP) = 1 ^ INX (MP) = 2 THEN                                         SYNTHESIZE
 2841           DO;  /* STEP OR WHILE LOOP FIXUP */                                      SYNTHESIZE
 2842              CALL EMITINST (JRST ,0,0,PPSAVE(MP),0,2);                             SYNTHESIZE
 2843              CALL EMITLABEL(FIXL(MP),4);                                           SYNTHESIZE
 2844           END;                                                                     SYNTHESIZE
 2845         ELSE IF INX (MP) = 3 THEN                                                  SYNTHESIZE
 2846           DO;  /* CASE GROUP */                                                    SYNTHESIZE
 2847              CALL EMITLABEL(FIXL(MP),4);   /* FIX BRANCH INTO JUMP LIST */         SYNTHESIZE
 2848              DO I = PPSAVE (MP) TO CASEP - 1;                                      SYNTHESIZE
 2849                 CALL EMITINST (JRST ,0,0,CASESTACK(I),0,2); /* JUMP LIST */        SYNTHESIZE
 2850                 END;                                                               SYNTHESIZE
 2851              CASEP = PPSAVE (MP) - 1;                                              SYNTHESIZE
 2852              CALL EMITLABEL(FIXV(MP),4);   /* FIX ESCAPE BRANCH */                 SYNTHESIZE
 2853           END;                                                                     SYNTHESIZE
 2854                                                                                    SYNTHESIZE
 2855  /*     21   <GROUP HEAD> ::= DO ;                                    */           SYNTHESIZE
 2856     INX (MP) = 0;                       /* ZERO DENOTES ORDINARY GROUP */          SYNTHESIZE
 2857                                                                                    SYNTHESIZE CASE 21. CASE 22.
 2858  /*     22                  ^ DO <STEP DEFINITION> ;                  */           SYNTHESIZE
 2859     DO;                                                                            SYNTHESIZE
 2860        CALL MOVESTACKS (MPP1, MP);                                                 SYNTHESIZE
 2861        INX (MP) = 1;                    /* ONE DENOTES STEP */                     SYNTHESIZE
 2862        CALL CLEARARS;                                                              SYNTHESIZE
 2863     END;                                                                           SYNTHESIZE
 2864                                                                                    SYNTHESIZE CASE 23.
 2865  /*     23                  ^ DO <WHILE CLAUSE> ;                     */           SYNTHESIZE
 2866     DO;                                                                            SYNTHESIZE
 2867        CALL MOVESTACKS (MPP1,MP);                                                  SYNTHESIZE
 2868        INX (MP) = 2;                    /* TWO DENOTES WHILE */                    SYNTHESIZE
 2869        CALL CLEARARS;                                                              SYNTHESIZE
 2870     END;                                                                           SYNTHESIZE
 2871                                                                                    SYNTHESIZE CASE 24.
 2872  /*     24                  ^ DO <CASE SELECTOR> ;                    */           SYNTHESIZE
 2873     DO;                                                                            SYNTHESIZE
 2874        CALL MOVESTACKS (MPP1, MP);                                                 SYNTHESIZE
 2875        INX (MP) = 3;                    /* THREE DENOTES CASE */                   SYNTHESIZE
 2876        CALL CLEARARS;                                                              SYNTHESIZE
 2877        INFO = INFO ^^ ' CASE 0.';                                                  SYNTHESIZE
 2878     END;                                                                           SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 97
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2879                                                                                    SYNTHESIZE CASE 25.
 2880  /*     25                  ^ <GROUP HEAD> <STATEMENT>                */           SYNTHESIZE
 2881     IF INX (MP) = 3 THEN                                                           SYNTHESIZE
 2882        DO; /* CASE GROUP, MUST RECORD STATEMENT ADDRESSES */                       SYNTHESIZE
 2883           CALL EMITINST (JRST ,0,0,FIXV(MP),0,4);                                  SYNTHESIZE
 2884           CALL STACK_CASE (PP);                                                    SYNTHESIZE
 2885           INFO = INFO ^^ ' CASE ' ^^ CASEP - PPSAVE(MP) ^^ '.';                    SYNTHESIZE
 2886        END;                                                                        SYNTHESIZE
 2887                                                                                    SYNTHESIZE
 2888  /*     26   <STEP DEFINITION> ::= <VARIABLE> <REPLACE>               */           SYNTHESIZE
 2889  /*     26                         <EXPRESSION> <ITERATION CONTROL>   */           SYNTHESIZE
 2890     DO; /* EMIT CODE FOR STEPPING DO LOOPS */                                      SYNTHESIZE
 2891        CALL FORCEACCUMULATOR (MP+2);     /* GET INITIAL VALUE */                   SYNTHESIZE CASE 26.
 2892        STEPK = FINDLABEL;                                                          SYNTHESIZE
 2893        CALL EMITINST (JRST ,0,0,STEPK,0,4);/* BRANCH AROUND INCR CODE */           SYNTHESIZE
 2894        PPSAVE(MP) = PP;                  /* SAVE ADDRESS FOR LATER FIX */          SYNTHESIZE
 2895        IF CNT (MP) > 0 THEN CALL ERROR ('DO INDEX MAY NOT BE SUBSCRIPTED',0);      SYNTHESIZE
 2896                                                                                    SYNTHESIZE
 2897                         /*  INCREMENT INDUCTION VARIABLE */                        SYNTHESIZE
 2898        IF SYTYPE(FIXL(MP)) = FIXEDTYPE & FIXL(SP) = TRUELOC THEN                   SYNTHESIZE
 2899           DO;           /* USE AOS IF INCREMENTING BY 1 */                         SYNTHESIZE
 2900              REG(MP) = REG(MP+2);                                                  SYNTHESIZE
 2901              CALL EMITINST (AOSA,REG(MP),0,SYTLOC(FIXL(MP)),0,1);                  SYNTHESIZE
 2902              TYPE(MP) = ACCUMULATOR;                                               SYNTHESIZE
 2903           END;                                                                     SYNTHESIZE
 2904        ELSE                                                                        SYNTHESIZE
 2905           DO;           /* CAN'T USE AOS INST. */                                  SYNTHESIZE
 2906              ACC(REG(MP+2)) = AVAIL;     /* MAKE SURE SAME REGISTER IS USED */     SYNTHESIZE
 2907              TARGET_REGISTER = REG(MP+2);                                          SYNTHESIZE
 2908              CALL FORCEACCUMULATOR (MP); /* FETCH THE INDEX     */                 SYNTHESIZE
 2909              TARGET_REGISTER = -1;                                                 SYNTHESIZE
 2910              CALL EMITINST(ADD,REG(MP),0,FIXL(MP+3),0,1);                          SYNTHESIZE
 2911           END;                                                                     SYNTHESIZE
 2912                         /* UPDATE INDUCTION VARIABLE AND TEST FOR END */           SYNTHESIZE
 2913        CALL EMITLABEL(STEPK,4);                                                    SYNTHESIZE
 2914        CALL GENSTORE (MP,MP);                                                      SYNTHESIZE
 2915        CALL EMITINST (CAMLE,REG(MP),0,FIXV(SP),0,1);                               SYNTHESIZE
 2916        FIXL (MP) = FINDLABEL;                                                      SYNTHESIZE
 2917        CALL EMITINST (JRST ,0,0,FIXL(MP),0,4);                                     SYNTHESIZE
 2918        ACC(REG(MP)) = AVAIL;                                                       SYNTHESIZE
 2919     END;                                                                           SYNTHESIZE
 2920                                                                                    SYNTHESIZE CASE 27.
 2921  /*     27   <ITERATION CONTROL> ::= TO <EXPRESSION>                  */           SYNTHESIZE
 2922     DO;                                                                            SYNTHESIZE
 2923        FIXL(MP) = TRUELOC;   /* POINT AT THE CONSTANT ONE FOR STEP */              SYNTHESIZE
 2924        CALL SETLIMIT;                                                              SYNTHESIZE
 2925     END;                                                                           SYNTHESIZE
 2926                                                                                    SYNTHESIZE CASE 28.
 2927  /*     28                         ^ TO <EXPRESSION> BY               */           SYNTHESIZE
 2928  /*     28                           <EXPRESSION>                     */           SYNTHESIZE
 2929     DO;                                                                            SYNTHESIZE
 2930        IF TYPE (SP) = CONSTANT THEN CALL EMITCONSTANT (FIXV(SP));                  SYNTHESIZE
 2931        ELSE                                                                        SYNTHESIZE
 2932           DO;                                                                      SYNTHESIZE
 2933              CALL FORCEACCUMULATOR (SP);                                           SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 98
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2934              CALL EMITDATAWORD (0);                                                SYNTHESIZE
 2935              ADR = DP - 1;                                                         SYNTHESIZE
 2936              CALL EMITINST (MOVEM,REG(SP),0,ADR,0,1);                              SYNTHESIZE
 2937              ACC(REG(SP)) = AVAIL;                                                 SYNTHESIZE
 2938           END;                                                                     SYNTHESIZE
 2939        FIXL (MP) =ADR;                                                             SYNTHESIZE
 2940        CALL SETLIMIT;                                                              SYNTHESIZE
 2941     END;                                                                           SYNTHESIZE
 2942                                                                                    SYNTHESIZE CASE 29.
 2943  /*     29   <WHILE CLAUSE> ::= WHILE <EXPRESSION>                    */           SYNTHESIZE
 2944     CALL BOOLBRANCH (SP,MP);                                                       SYNTHESIZE
 2945                                                                                    SYNTHESIZE CASE 30.
 2946  /*     30   <CASE SELECTOR> ::= CASE <EXPRESSION>                    */           SYNTHESIZE
 2947     /* THE FOLLOWING USE IS MADE OF THE PARALLEL STACKS BELOW <CASE SELECTOR>      SYNTHESIZE
 2948           PPSAVE     PREVIOUS MAXIMUM CASE STACK POINTER                           SYNTHESIZE
 2949           FIXL       ADDRESS OF INDEXED GOTO INTO LIST                             SYNTHESIZE
 2950           FIXV       ADDRESS OF ESCAPE GOTO FOR CASES                              SYNTHESIZE
 2951     */                                                                             SYNTHESIZE
 2952     DO;                                                                            SYNTHESIZE
 2953        CALL FORCEACCUMULATOR (SP);       /* GET THE INDEX IN TO AR */              SYNTHESIZE
 2954        ACC(REG(SP)) = AVAIL;                                                       SYNTHESIZE
 2955        FIXL(MP) = FINDLABEL;                                                       SYNTHESIZE
 2956        CALL EMITINST (JRST ,0,1,FIXL(MP),REG(SP),4);/* INDIRECT INDEXED BRANCH */  SYNTHESIZE
 2957        FIXV(MP) = FINDLABEL;             /* ADDRESS OF ESCAPE BRANCH */            SYNTHESIZE
 2958        CALL STACK_CASE (PP);                                                       SYNTHESIZE
 2959        PPSAVE (MP) = CASEP;                                                        SYNTHESIZE
 2960     END;                                                                           SYNTHESIZE
 2961                                                                                    SYNTHESIZE CASE 31.
 2962  /*     31   <PROCEDURE DEFINITION> ::= <PROCEDURE HEAD>              */           SYNTHESIZE
 2963  /*     31                              <STATEMENT LIST> <ENDING>     */           SYNTHESIZE
 2964     /* THE FOLLOWING USE IS MADE OF THE PARALLEL STACKS BELOW                      SYNTHESIZE
 2965        <PROCEDURE HEAD>                                                            SYNTHESIZE
 2966        PPSAVE           ADDRESS OF PREVIOUS PROC RETURN                            SYNTHESIZE
 2967        FIXL             ADDRESS OF PREVIOUS PROC ACCUMULATOR AREA                  SYNTHESIZE
 2968        FIXV             POINTER TO SYMBOL TABLE FOR THIS BLOCK                     SYNTHESIZE
 2969        CNT              COUNT OF THE PARAMETERS OF PREVIOUS PROC                   SYNTHESIZE
 2970     */                                                                             SYNTHESIZE
 2971     DO;   /* PROCEDURE IS DEFINED, RESTORE SYMBOL TABLE */                         SYNTHESIZE
 2972        IF LENGTH (VAR(SP)) > 0 THEN                                                SYNTHESIZE
 2973           IF SUBSTR (CURRENT_PROCEDURE,1) \= VAR(SP) THEN                          SYNTHESIZE
 2974              CALL ERROR ('PROCEDURE' ^^ CURRENT_PROCEDURE ^^ ' CLOSED BY END '     SYNTHESIZE
 2975                          ^^ VAR(SP), 0);                                           SYNTHESIZE
 2976        IF CONTROL(BYTE('S')) THEN CALL SYMBOLDUMP;                                 SYNTHESIZE
 2977        DO I = PROCMARK TO NDECSY;                                                  SYNTHESIZE
 2978           IF SYTYPE (I) = FORWARDTYPE ^ SYTYPE (I) = FORWARDCALL THEN              SYNTHESIZE
 2979              IF SYTCO (I) > 0 THEN                                                 SYNTHESIZE
 2980                 CALL ERROR ('UNDEFINED LABEL OR PROCEDURE: ' ^^ SYT (I), 1);       SYNTHESIZE
 2981        END;                                                                        SYNTHESIZE
 2982        DO I = 0 TO (NDECSY + 1) - (PROCMARK + PARCT);                              SYNTHESIZE
 2983           J = NDECSY - I;                                                          SYNTHESIZE
 2984           IF (J >= (PROCMARK + PARCT)) & (LENGTH(SYT(J)) > 0) THEN                 SYNTHESIZE
 2985              DO;                                                                   SYNTHESIZE
 2986                 HASH (HASHER(SYT(J))) = PTR (J);                                   SYNTHESIZE
 2987                 PTR (J) = -1;                                                      SYNTHESIZE
 2988              END;                                                                  SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 99
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2989        END;                                                                        SYNTHESIZE
 2990        DO I = PROCMARK + PARCT TO NDECSY;                                          SYNTHESIZE
 2991            SYT (I) = X1;                                                           SYNTHESIZE
 2992        END;                                                                        SYNTHESIZE
 2993        NDECSY = PROCMARK + PARCT - 1;                                              SYNTHESIZE
 2994        /* PARAMETER ADDRESSES MUST BE SAVED BUT NAMES DISCARDED */                 SYNTHESIZE
 2995        IF PARCT > 0 THEN                                                           SYNTHESIZE
 2996           DO J = 0 TO NDECSY - PROCMARK;                                           SYNTHESIZE
 2997              I = NDECSY - J;                                                       SYNTHESIZE
 2998              IF SYTYPE (I) = 0 THEN                                                SYNTHESIZE
 2999                 DO;                                                                SYNTHESIZE
 3000                    CALL ERROR ('UNDECLARED PARAMETER: ' ^^ SYT (I), 0);            SYNTHESIZE
 3001                    SYTYPE (I) = FIXEDTYPE;                                         SYNTHESIZE
 3002                    CALL EMITDATAWORD (0);                                          SYNTHESIZE
 3003                    SYTLOC(I) = DP -1;                                              SYNTHESIZE
 3004                 END;                                                               SYNTHESIZE
 3005              HASH (HASHER(SYT(I))) = PTR (I);                                      SYNTHESIZE
 3006              PTR (I) = -1;                                                         SYNTHESIZE
 3007              SYT (I) = '';                                                         SYNTHESIZE
 3008           END;                                                                     SYNTHESIZE
 3009        PROCMARK = FIXV (MP);                                                       SYNTHESIZE
 3010        PARCT = CNT (MP);                                                           SYNTHESIZE
 3011        CURRENT_PROCEDURE = VAR (MP);                                               SYNTHESIZE
 3012        /* EMIT A GRATUITOUS RETURN */                                              SYNTHESIZE
 3013        CALL EMITINST (POPJ,15,0,0,0,0);                                            SYNTHESIZE
 3014        /* COMPLETE JUMP AROUND THE PROCEDURE DEFINITION */                         SYNTHESIZE
 3015        CALL EMITLABEL(PPSAVE(MP),4);                                               SYNTHESIZE
 3016        RETURNED_TYPE = TYPE(MP);                                                   SYNTHESIZE
 3017     END;                                                                           SYNTHESIZE
 3018                                                                                    SYNTHESIZE CASE 32.
 3019  /*     32   <PROCEDURE HEAD> ::= <PROCEDURE NAME> ;                  */           SYNTHESIZE
 3020     DO;      /* MUST POINT AT FIRST PARAMETER EVEN IF NON EXISTANT */              SYNTHESIZE
 3021        /* SAVE OLD PARAMETER COUNT */                                              SYNTHESIZE
 3022        CNT (MP) = PARCT;                                                           SYNTHESIZE
 3023        PARCT = 0;                                                                  SYNTHESIZE
 3024        /* SAVE OLD PROCEDURE MARK IN SYMBOL TABLE */                               SYNTHESIZE
 3025        FIXV(MP) = PROCMARK;                                                        SYNTHESIZE
 3026        PROCMARK = NDECSY + 1;                                                      SYNTHESIZE
 3027        TYPE(MP) = RETURNED_TYPE;                                                   SYNTHESIZE
 3028        RETURNED_TYPE = 0;                                                          SYNTHESIZE
 3029        CALL PROC_START;                                                            SYNTHESIZE
 3030     END;                                                                           SYNTHESIZE
 3031                                                                                    SYNTHESIZE CASE 33.
 3032  /*     33                      ^ <PROCEDURE NAME> <TYPE> ;           */           SYNTHESIZE
 3033     DO;                                                                            SYNTHESIZE
 3034        CNT (MP) = PARCT;           /* SAVE OLD PARAMETER COUNT */                  SYNTHESIZE
 3035        PARCT = 0;                                                                  SYNTHESIZE
 3036        FIXV(MP) = PROCMARK;        /* SAVE OLD PROCEDURE MARK IN SYMBOL TABLE */   SYNTHESIZE
 3037        PROCMARK = NDECSY + 1;                                                      SYNTHESIZE
 3038        TYPE(MP) = RETURNED_TYPE;                                                   SYNTHESIZE
 3039        RETURNED_TYPE = TYPE(SP-1);                                                 SYNTHESIZE
 3040        IF RETURNED_TYPE = CHRTYPE THEN SYTYPE(FIXL(MP)) = CHARPROCTYPE;            SYNTHESIZE
 3041        CALL PROC_START;                                                            SYNTHESIZE
 3042     END;                                                                           SYNTHESIZE
 3043                                                                                    SYNTHESIZE CASE 34.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 100
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3044  /*     34                      ^ <PROCEDURE NAME> <PARAMETER LIST>   */           SYNTHESIZE
 3045  /*     34                        ;                                   */           SYNTHESIZE
 3046     DO;                                                                            SYNTHESIZE
 3047        CNT(MP) = CNT(MPP1);  /* SAVE PARAMETER COUNT */                            SYNTHESIZE
 3048        FIXV(MP) = FIXV (MPP1);                                                     SYNTHESIZE
 3049        TYPE(MP) = RETURNED_TYPE;                                                   SYNTHESIZE
 3050        RETURNED_TYPE = 0;                                                          SYNTHESIZE
 3051        CALL PROC_START;                                                            SYNTHESIZE
 3052     END;                                                                           SYNTHESIZE
 3053                                                                                    SYNTHESIZE CASE 35.
 3054  /*     35                      ^ <PROCEDURE NAME> <PARAMETER LIST>   */           SYNTHESIZE
 3055  /*     35                        <TYPE> ;                            */           SYNTHESIZE
 3056     DO;                                                                            SYNTHESIZE
 3057        CNT(MP) = CNT(MPP1);  /* SAVE PARAMETER COUNT */                            SYNTHESIZE
 3058        FIXV(MP) = FIXV (MPP1);                                                     SYNTHESIZE
 3059        TYPE(MP) = RETURNED_TYPE;                                                   SYNTHESIZE
 3060        RETURNED_TYPE = TYPE(SP-1);                                                 SYNTHESIZE
 3061        IF RETURNED_TYPE = CHRTYPE THEN SYTYPE(FIXL(MP)) = CHARPROCTYPE;            SYNTHESIZE
 3062        CALL PROC_START;                                                            SYNTHESIZE
 3063     END;                                                                           SYNTHESIZE
 3064                                                                                    SYNTHESIZE CASE 36.
 3065  /*     36   <PROCEDURE NAME> ::= <LABEL DEFINITION> PROCEDURE        */           SYNTHESIZE
 3066     DO;                                                                            SYNTHESIZE
 3067        SYTYPE (FIXL (MP)) = PROCTYPE;                                              SYNTHESIZE
 3068        S = CURRENT_PROCEDURE;                                                      SYNTHESIZE
 3069        CURRENT_PROCEDURE = X1 ^^ VAR (MP);                                         SYNTHESIZE
 3070        VAR (MP) = S;                                                               SYNTHESIZE
 3071     END;                                                                           SYNTHESIZE
 3072                                                                                    SYNTHESIZE CASE 37.
 3073                                                                                    SYNTHESIZE
 3074  /*     37   <PARAMETER LIST> ::= <PARAMETER HEAD> <IDENTIFIER> )     */           SYNTHESIZE
 3075     DO;                                                                            SYNTHESIZE
 3076        PARCT = PARCT + 1;   /* BUMP THE PARAMETER COUNT */                         SYNTHESIZE
 3077        CALL ENTER (VAR(MPP1), 0, 0, 0);                                            SYNTHESIZE
 3078     END;                                                                           SYNTHESIZE
 3079                                                                                    SYNTHESIZE CASE 38.
 3080  /*     38   <PARAMETER HEAD> ::= (                                   */           SYNTHESIZE
 3081     DO;  /* POINT AT THE FIRST PARAMETER FOR SYMBOL TABLE */                       SYNTHESIZE
 3082        FIXV(MP) = PROCMARK;                                                        SYNTHESIZE
 3083        PROCMARK = NDECSY + 1;                                                      SYNTHESIZE
 3084        CNT (MP) = PARCT;        /* SAVE OLD PARAMETER COUNT */                     SYNTHESIZE
 3085        PARCT = 0;                                                                  SYNTHESIZE
 3086     END;                                                                           SYNTHESIZE
 3087                                                                                    SYNTHESIZE CASE 39.
 3088  /*     39                      ^ <PARAMETER HEAD> <IDENTIFIER> ,     */           SYNTHESIZE
 3089     DO;                                                                            SYNTHESIZE
 3090         PARCT = PARCT + 1;          /* BUMP THE PARAMETER COUNT */                 SYNTHESIZE
 3091        CALL ENTER (VAR(MPP1), 0, 0, 0);                                            SYNTHESIZE
 3092     END;                                                                           SYNTHESIZE
 3093                                                                                    SYNTHESIZE CASE 40.
 3094  /*     40   <ENDING> ::= END                                         */           SYNTHESIZE
 3095     ;                                                                              SYNTHESIZE
 3096  /*     41              ^ END <IDENTIFIER>                            */           SYNTHESIZE CASE 41.
 3097     VAR (MP) = VAR (SP);                                                           SYNTHESIZE
 3098                                                                                    SYNTHESIZE CASE 42.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 101
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3099  /*     42              ^ <LABEL DEFINITION> <ENDING>                 */           SYNTHESIZE
 3100     ;                                                                              SYNTHESIZE
 3101  /*     43   <LABEL DEFINITION> ::= <IDENTIFIER> :                    */           SYNTHESIZE CASE 43.
 3102     FIXL(MP) = ENTER (VAR(MP), LABELTYPE, PP, 2);                                  SYNTHESIZE
 3103                                                                                    SYNTHESIZE CASE 44.
 3104  /*     44   <RETURN STATEMENT> ::= RETURN                            */           SYNTHESIZE
 3105     DO;                                                                            SYNTHESIZE
 3106        CALL EMITINST (POPJ,15,0,0,0,0);                                            SYNTHESIZE
 3107     END;                                                                           SYNTHESIZE
 3108                                                                                    SYNTHESIZE CASE 45.
 3109  /*     45                        ^ RETURN <EXPRESSION>               */           SYNTHESIZE
 3110     DO;  /* EMIT A RETURN AND PASS A VALUE */                                      SYNTHESIZE
 3111        TARGET_REGISTER = 0;                                                        SYNTHESIZE
 3112        IF RETURNED_TYPE = CHRTYPE THEN                                             SYNTHESIZE
 3113           CALL FORCEDESCRIPTOR(SP);                                                SYNTHESIZE
 3114        ELSE                                                                        SYNTHESIZE
 3115           CALL FORCEACCUMULATOR (SP);                                              SYNTHESIZE
 3116        TARGET_REGISTER = -1;                                                       SYNTHESIZE
 3117        IF REG(SP) \= 0 THEN CALL EMITINST(MOVE,0,0,REG(SP),0,0);                   SYNTHESIZE
 3118        CALL EMITINST (POPJ,15,0,0,0,0);                                            SYNTHESIZE
 3119     END;                                                                           SYNTHESIZE
 3120                                                                                    SYNTHESIZE CASE 46.
 3121  /*     46   <CALL STATEMENT> ::= CALL <VARIABLE>                     */           SYNTHESIZE
 3122     DO;                                                                            SYNTHESIZE
 3123        I = SYTYPE(FIXL(SP));                                                       SYNTHESIZE
 3124        IF I=PROCTYPE ^ I=FORWARDCALL ^ I = CHARPROCTYPE                            SYNTHESIZE
 3125                      ^ (I=SPECIAL & SYTLOC(FIXL(SP))=12)                           SYNTHESIZE
 3126                      ^ (I=SPECIAL & SYTLOC(FIXL(SP))=9)  THEN                      SYNTHESIZE
 3127           DO;                                                                      SYNTHESIZE
 3128              CALLTYPE = 0;               /* NO RETURN VALUE */                     SYNTHESIZE
 3129              CALL FORCEACCUMULATOR(SP);                                            SYNTHESIZE
 3130              CALLTYPE = 1;                                                         SYNTHESIZE
 3131           END;                                                                     SYNTHESIZE
 3132        ELSE CALL ERROR ('UNDEFINED PROCEDURE: ' ^^ SYT(FIXL(SP)),0);               SYNTHESIZE
 3133     END;                                                                           SYNTHESIZE
 3134                                                                                    SYNTHESIZE CASE 47.
 3135  /*     47   <GO TO STATEMENT> ::= <GO TO> <IDENTIFIER>               */           SYNTHESIZE
 3136     DO;                                                                            SYNTHESIZE
 3137        CALL ID_LOOKUP(SP);                                                         SYNTHESIZE
 3138        J = FIXL (SP);                                                              SYNTHESIZE
 3139        IF J < 0 THEN                                                               SYNTHESIZE
 3140           DO;  /* FIRST OCURRANCE OF THE LABEL */                                  SYNTHESIZE
 3141              I = FINDLABEL;                                                        SYNTHESIZE
 3142              CALL EMITINST (JRST ,0,0,I,0,4);                                      SYNTHESIZE
 3143              J = ENTER (VAR(SP),FORWARDTYPE,I,4);                                  SYNTHESIZE
 3144              SYTCO (J) = 1;                                                        SYNTHESIZE
 3145           END;                                                                     SYNTHESIZE
 3146        ELSE IF SYTYPE(J) = LABELTYPE ^ SYTYPE(J) = FORWARDTYPE THEN                SYNTHESIZE
 3147            CALL EMITINST (JRST ,0,0,SYTLOC(J),0,SYTSEG(J));                        SYNTHESIZE
 3148        ELSE                                                                        SYNTHESIZE
 3149          CALL ERROR ('TARGET OF GOTO IS NOT A LABEL', 0);                          SYNTHESIZE
 3150     END;                                                                           SYNTHESIZE
 3151                                                                                    SYNTHESIZE CASE 48.
 3152  /*     48   <GO TO> ::= GO TO                                        */           SYNTHESIZE
 3153     ;                                                                              SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 102
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3154  /*     49             ^ GOTO                                         */           SYNTHESIZE CASE 49.
 3155     ;                                                                              SYNTHESIZE
 3156  /*     50   <DECLARATION STATEMENT> ::= DECLARE                      */           SYNTHESIZE CASE 50.
 3157  /*     50                               <DECLARATION ELEMENT>        */           SYNTHESIZE
 3158     ;                                                                              SYNTHESIZE
 3159  /*     51                             ^ <DECLARATION STATEMENT> ,    */           SYNTHESIZE CASE 51.
 3160  /*     51                               <DECLARATION ELEMENT>        */           SYNTHESIZE
 3161     ;                                                                              SYNTHESIZE
 3162  /*     52   <DECLARATION ELEMENT> ::= <TYPE DECLARATION>             */           SYNTHESIZE CASE 52.
 3163        IF TYPE (MP) = CHRTYPE THEN                                                 SYNTHESIZE
 3164           DO WHILE (DSP < NEWDSP);                                                 SYNTHESIZE
 3165              CALL EMITDESC (0,0);                                                  SYNTHESIZE
 3166           END;                                                                     SYNTHESIZE
 3167        ELSE                                                                        SYNTHESIZE
 3168           DO;                                                                      SYNTHESIZE
 3169              IF DP < NEWDP THEN                                                    SYNTHESIZE
 3170                 DO;                                                                SYNTHESIZE
 3171                    IF DPOFFSET > 0 THEN CALL FLUSH_DATACARD;                       SYNTHESIZE
 3172                    IF DP < NEWDP THEN CALL EMITBLOCK (NEWDP-DP);                   SYNTHESIZE
 3173                 END;                                                               SYNTHESIZE
 3174              DO WHILE (DPOFFSET < NEWDPOFFSET);                                    SYNTHESIZE
 3175                 CALL EMITBYTE(0);                                                  SYNTHESIZE
 3176              END;                                                                  SYNTHESIZE
 3177           END;                                                                     SYNTHESIZE
 3178                                                                                    SYNTHESIZE CASE 53.
 3179  /*     53                           ^ <IDENTIFIER> LITERALLY         */           SYNTHESIZE
 3180  /*     53                             <STRING>                       */           SYNTHESIZE
 3181     IF TOP_MACRO >= MACRO_LIMIT THEN                                               SYNTHESIZE
 3182        CALL ERROR ('MACRO TABLE OVERFLOW', 1);                                     SYNTHESIZE
 3183     ELSE DO;                                                                       SYNTHESIZE
 3184        TOP_MACRO = TOP_MACRO + 1;                                                  SYNTHESIZE
 3185        I = LENGTH(VAR(MP));                                                        SYNTHESIZE
 3186        J = MACRO_INDEX(I);                                                         SYNTHESIZE
 3187        DO L = 1 TO TOP_MACRO - J;                                                  SYNTHESIZE
 3188           K = TOP_MACRO - L;                                                       SYNTHESIZE
 3189           MACRO_NAME(K+1) = MACRO_NAME(K);                                         SYNTHESIZE
 3190           MACRO_TEXT(K+1) = MACRO_TEXT(K);                                         SYNTHESIZE
 3191           MACRO_COUNT(K+1) = MACRO_COUNT(K);                                       SYNTHESIZE
 3192           MACRO_DECLARE(K+1) = MACRO_DECLARE(K);                                   SYNTHESIZE
 3193        END;                                                                        SYNTHESIZE
 3194        MACRO_NAME(J) = VAR(MP);                                                    SYNTHESIZE
 3195        MACRO_TEXT(J) = VAR(SP);                                                    SYNTHESIZE
 3196        MACRO_COUNT(J) = 0;                                                         SYNTHESIZE
 3197        MACRO_DECLARE(J) = CARD_COUNT;                                              SYNTHESIZE
 3198        DO J = I TO 255;                                                            SYNTHESIZE
 3199           MACRO_INDEX(J) = MACRO_INDEX(J) + 1;                                     SYNTHESIZE
 3200        END;                                                                        SYNTHESIZE
 3201     END;                                                                           SYNTHESIZE
 3202                                                                                    SYNTHESIZE CASE 54.
 3203  /*     54   <TYPE DECLARATION> ::= <IDENTIFIER SPECIFICATION>        */           SYNTHESIZE
 3204  /*     54                          <TYPE>                            */           SYNTHESIZE
 3205     CALL TDECLARE (0);                                                             SYNTHESIZE
 3206                                                                                    SYNTHESIZE CASE 55.
 3207  /*     55                        ^ <BOUND HEAD> <NUMBER> ) <TYPE>    */           SYNTHESIZE
 3208     CALL TDECLARE (FIXV(MPP1));                                                    SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 103
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3209                                                                                    SYNTHESIZE CASE 56.
 3210  /*     56                        ^ <TYPE DECLARATION>                */           SYNTHESIZE
 3211  /*     56                          <INITIAL LIST>                    */           SYNTHESIZE
 3212     ;                                                                              SYNTHESIZE
 3213  /*     57   <TYPE> ::= FIXED                                         */           SYNTHESIZE CASE 57.
 3214     TYPE (MP) = FIXEDTYPE;                                                         SYNTHESIZE
 3215  /*     58            ^ CHARACTER                                     */           SYNTHESIZE CASE 58.
 3216     TYPE (MP) = CHRTYPE;                                                           SYNTHESIZE
 3217  /*     59            ^ LABEL                                         */           SYNTHESIZE CASE 59.
 3218     TYPE (MP) = FORWARDTYPE;                                                       SYNTHESIZE
 3219                                                                                    SYNTHESIZE CASE 60.
 3220  /*     60            ^ <BIT HEAD> <NUMBER> )                         */           SYNTHESIZE
 3221     IF FIXV(MPP1) <= 9 THEN TYPE (MP) = BYTETYPE; ELSE                             SYNTHESIZE
 3222        IF FIXV (MPP1) <= 36 THEN TYPE (MP) = FIXEDTYPE; ELSE                       SYNTHESIZE
 3223           TYPE (MP) = CHRTYPE;                                                     SYNTHESIZE
 3224                                                                                    SYNTHESIZE CASE 61.
 3225  /*     61   <BIT HEAD> ::= BIT (                                     */           SYNTHESIZE
 3226     ;                                                                              SYNTHESIZE
 3227  /*     62   <BOUND HEAD> ::= <IDENTIFIER SPECIFICATION> (            */           SYNTHESIZE CASE 62.
 3228     ;                                                                              SYNTHESIZE
 3229  /*     63   <IDENTIFIER SPECIFICATION> ::= <IDENTIFIER>              */           SYNTHESIZE CASE 63.
 3230     DO;                                                                            SYNTHESIZE
 3231        INX(MP) = 1;                                                                SYNTHESIZE
 3232        FIXL(MP) = CASEP;                                                           SYNTHESIZE
 3233        CALL STACK_CASE (ENTER(VAR(MP),0,0,0));                                     SYNTHESIZE
 3234     END;                                                                           SYNTHESIZE
 3235  /*     64                                ^ <IDENTIFIER LIST>         */           SYNTHESIZE CASE 64.
 3236  /*     64                                  <IDENTIFIER> )            */           SYNTHESIZE
 3237     DO;                                                                            SYNTHESIZE
 3238        INX(MP) = INX(MP) + 1;                                                      SYNTHESIZE
 3239        CALL STACK_CASE (ENTER(VAR(MPP1),0,0,0));                                   SYNTHESIZE
 3240     END;                                                                           SYNTHESIZE
 3241  /*     65   <IDENTIFIER LIST> ::= (                                  */           SYNTHESIZE CASE 65.
 3242     DO;                                                                            SYNTHESIZE
 3243        INX(MP) = 0;                                                                SYNTHESIZE
 3244        FIXL(MP) = CASEP;                                                           SYNTHESIZE
 3245     END;                                                                           SYNTHESIZE
 3246  /*     66                       ^ <IDENTIFIER LIST> <IDENTIFIER> ,   */           SYNTHESIZE CASE 66.
 3247     DO;                                                                            SYNTHESIZE
 3248        INX(MP) = INX(MP) + 1;                                                      SYNTHESIZE
 3249        CALL STACK_CASE (ENTER(VAR(MPP1),0,0,0));                                   SYNTHESIZE
 3250     END;                                                                           SYNTHESIZE
 3251                                                                                    SYNTHESIZE CASE 67.
 3252  /*     67   <INITIAL LIST> ::= <INITIAL HEAD> <CONSTANT> )           */           SYNTHESIZE
 3253     CALL SETINIT;                                                                  SYNTHESIZE
 3254                                                                                    SYNTHESIZE CASE 68.
 3255  /*     68   <INITIAL HEAD> ::= INITIAL (                             */           SYNTHESIZE
 3256     IF INX(MP-1) = 1 THEN                                                          SYNTHESIZE
 3257        ITYPE = TYPE (MP-1);  /* COPY INFORMATION FROM <TYPE DECLARATION> */        SYNTHESIZE
 3258     ELSE                                                                           SYNTHESIZE
 3259        DO;                                                                         SYNTHESIZE
 3260           CALL ERROR ('INITIAL MAY NOT BE USED WITH IDENTIFIER LIST',0);           SYNTHESIZE
 3261           ITYPE = 0;                                                               SYNTHESIZE
 3262        END;                                                                        SYNTHESIZE
 3263                                                                                    SYNTHESIZE CASE 69.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 104
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3264  /*     69                    ^ <INITIAL HEAD> <CONSTANT> ,           */           SYNTHESIZE
 3265     CALL SETINIT;                                                                  SYNTHESIZE
 3266  /*     70   <ASSIGNMENT> ::= <VARIABLE> <REPLACE> <EXPRESSION>       */           SYNTHESIZE CASE 70.
 3267     CALL GENSTORE(MP,SP);                                                          SYNTHESIZE
 3268  /*     71                  ^ <LEFT PART> <ASSIGNMENT>                */           SYNTHESIZE CASE 71.
 3269     CALL GENSTORE(MP,SP);                                                          SYNTHESIZE
 3270  /*     72   <REPLACE> ::= =                                          */           SYNTHESIZE CASE 72.
 3271     ;                                                                              SYNTHESIZE
 3272  /*     73   <LEFT PART> ::= <VARIABLE> ,                             */           SYNTHESIZE CASE 73.
 3273     ;                                                                              SYNTHESIZE
 3274  /*     74   <EXPRESSION> ::= <LOGICAL FACTOR>                        */           SYNTHESIZE CASE 74.
 3275     ;                                                                              SYNTHESIZE
 3276  /*     75                  ^ <EXPRESSION> ^ <LOGICAL FACTOR>         */           SYNTHESIZE CASE 75.
 3277     CALL ARITHEMIT (IOR,1);                                                        SYNTHESIZE
 3278  /*     76   <LOGICAL FACTOR> ::= <LOGICAL SECONDARY>                 */           SYNTHESIZE CASE 76.
 3279     ;                                                                              SYNTHESIZE
 3280  /*     77                      ^ <LOGICAL FACTOR> &                  */           SYNTHESIZE CASE 77.
 3281  /*     77                        <LOGICAL SECONDARY>                 */           SYNTHESIZE
 3282     CALL ARITHEMIT (AND,1);                                                        SYNTHESIZE
 3283  /*     78   <LOGICAL SECONDARY> ::= <LOGICAL PRIMARY>                */           SYNTHESIZE CASE 78.
 3284     ;                                                                              SYNTHESIZE
 3285  /*     79                         ^ \ <LOGICAL PRIMARY>              */           SYNTHESIZE CASE 79.
 3286     DO;                                                                            SYNTHESIZE
 3287        CALL MOVESTACKS (SP, MP);                                                   SYNTHESIZE
 3288         /* GET 1'S COMPLEMENT */                                                   SYNTHESIZE
 3289        CALL FORCEACCUMULATOR(MP);                                                  SYNTHESIZE
 3290        CALL EMITINST (SETCA,REG(MP),0,0,0,0);                                      SYNTHESIZE
 3291     END;                                                                           SYNTHESIZE
 3292                                                                                    SYNTHESIZE CASE 80.
 3293  /*     80   <LOGICAL PRIMARY> ::= <STRING EXPRESSION>                */           SYNTHESIZE
 3294     ;                                                                              SYNTHESIZE
 3295  /*     81                       ^ <STRING EXPRESSION> <RELATION>     */           SYNTHESIZE CASE 81.
 3296  /*     81                         <STRING EXPRESSION>                */           SYNTHESIZE
 3297        /* RELATIONS ARE ENCODED AS TO THEIR CAM? INSTRICTION CODE */               SYNTHESIZE
 3298        /*                                                                          SYNTHESIZE
 3299           <     1                                                                  SYNTHESIZE
 3300           >     7                                                                  SYNTHESIZE
 3301           \=    6                                                                  SYNTHESIZE
 3302           =     2                                                                  SYNTHESIZE
 3303           <=    3                                                                  SYNTHESIZE
 3304           \>    3                                                                  SYNTHESIZE
 3305           >=    5                                                                  SYNTHESIZE
 3306           \<    5                                                                  SYNTHESIZE
 3307        */                                                                          SYNTHESIZE
 3308     DO;                                                                            SYNTHESIZE
 3309        I = TYPE (MP);                                                              SYNTHESIZE
 3310        J = TYPE (SP);                                                              SYNTHESIZE
 3311        IF I = DESCRIPT ^ I = CHRTYPE THEN CALL STRINGCOMPARE; ELSE                 SYNTHESIZE
 3312        IF I = VARIABLE & SYTYPE(FIXL(MP)) = CHRTYPE THEN CALL STRINGCOMPARE; ELSE  SYNTHESIZE
 3313        IF J = DESCRIPT ^ J = CHRTYPE THEN CALL STRINGCOMPARE; ELSE                 SYNTHESIZE
 3314        IF J = VARIABLE & SYTYPE(FIXL(SP)) = CHRTYPE THEN CALL STRINGCOMPARE; ELSE  SYNTHESIZE
 3315           DO;                                                                      SYNTHESIZE
 3316              IF I = VARIABLE & SYTYPE(FIXL(MP)) = BYTETYPE THEN                    SYNTHESIZE
 3317                     CALL FORCEACCUMULATOR(MP);                                     SYNTHESIZE
 3318              IF J = VARIABLE & SYTYPE(FIXL(SP)) = BYTETYPE THEN                    SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 105
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3319                     CALL FORCEACCUMULATOR(SP);                                     SYNTHESIZE
 3320              IF SHOULDCOMMUTE THEN CALL FORCEACCUMULATOR(SP);                      SYNTHESIZE
 3321              ELSE CALL FORCEACCUMULATOR(MP);                                       SYNTHESIZE
 3322              I = FINDAR;                                                           SYNTHESIZE
 3323              CALL EMITINST(MOVEI,I,0,1,0,0);                                       SYNTHESIZE
 3324              CALL ARITHEMIT (CAM+INX(MPP1),1);                                     SYNTHESIZE
 3325              CALL EMITINST (MOVEI,I,0,0,0,0);                                      SYNTHESIZE
 3326              STILLCOND = INX(MPP1);                                                SYNTHESIZE
 3327              ACC(REG(MP))=AVAIL;                                                   SYNTHESIZE
 3328              REG(MP) = I;                                                          SYNTHESIZE
 3329              TYPE(MP) = ACCUMULATOR;                                               SYNTHESIZE
 3330           END;                                                                     SYNTHESIZE
 3331     END;                                                                           SYNTHESIZE
 3332                                                                                    SYNTHESIZE CASE 82.
 3333  /*     82   <RELATION> ::= =                                         */           SYNTHESIZE
 3334     INX(MP) = 2;                                                                   SYNTHESIZE
 3335  /*     83                ^ <                                         */           SYNTHESIZE CASE 83.
 3336     INX(MP) = 1;                                                                   SYNTHESIZE
 3337  /*     84                ^ >                                         */           SYNTHESIZE CASE 84.
 3338     INX(MP) = 7;                                                                   SYNTHESIZE
 3339  /*     85                ^ \ =                                       */           SYNTHESIZE CASE 85.
 3340     INX(MP) = 6;                                                                   SYNTHESIZE
 3341  /*     86                ^ \ <                                       */           SYNTHESIZE CASE 86.
 3342     INX (MP) = 5;                                                                  SYNTHESIZE
 3343  /*     87                ^ \ >                                       */           SYNTHESIZE CASE 87.
 3344     INX(MP) = 3;                                                                   SYNTHESIZE
 3345  /*     88                ^ < =                                       */           SYNTHESIZE CASE 88.
 3346     INX(MP) = 3;                                                                   SYNTHESIZE
 3347  /*     89                ^ > =                                       */           SYNTHESIZE CASE 89.
 3348     INX (MP) = 5;                                                                  SYNTHESIZE
 3349  /*     90   <STRING EXPRESSION> ::= <ARITHMETIC EXPRESSION>          */           SYNTHESIZE CASE 90.
 3350     ;                                                                              SYNTHESIZE
 3351                                                                                    SYNTHESIZE CASE 91.
 3352  /*     91                         ^ <STRING EXPRESSION> ^^           */           SYNTHESIZE
 3353  /*     91                           <ARITHMETIC EXPRESSION>          */           SYNTHESIZE
 3354      DO; /* CATENATE TWO STRINGS */                                                SYNTHESIZE
 3355        CALL FORCEDESCRIPTOR (MP);                                                  SYNTHESIZE
 3356        CALL DELETE_MOVE (MP,MOVEM,REG(MP),0,A,0,3);                                SYNTHESIZE
 3357        ACC(REG(MP)) = AVAIL;                                                       SYNTHESIZE
 3358        CALL FORCEDESCRIPTOR (SP);                                                  SYNTHESIZE
 3359        CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,B,0,3);                                SYNTHESIZE
 3360        ACC(REG(SP)) = AVAIL;                                                       SYNTHESIZE
 3361        CALL SAVE_ACS (2);                                                          SYNTHESIZE
 3362        IF ACC(11) \= AVAIL THEN CALL EMITINST (PUSH,15,0,11,0,0);                  SYNTHESIZE
 3363        CALL EMITINST (PUSHJ,15,0,CATENTRY,0,2);                                    SYNTHESIZE
 3364        IF ACC(11) \= AVAIL THEN CALL EMITINST (POP,15,0,11,0,0);                   SYNTHESIZE
 3365        CALL RESTORE_ACS (2);                                                       SYNTHESIZE
 3366        I = FINDAR;                                                                 SYNTHESIZE
 3367        CALL EMITINST (MOVE,I,0,0,0,0);                                             SYNTHESIZE
 3368        STILLINZERO = I;                                                            SYNTHESIZE
 3369        REG(MP) = I;                                                                SYNTHESIZE
 3370     END;                                                                           SYNTHESIZE
 3371                                                                                    SYNTHESIZE CASE 92.
 3372  /*     92   <ARITHMETIC EXPRESSION> ::= <TERM>                       */           SYNTHESIZE
 3373     ;                                                                              SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 106
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3374  /*     93                             ^ <ARITHMETIC EXPRESSION> +    */           SYNTHESIZE CASE 93.
 3375  /*     93                               <TERM>                       */           SYNTHESIZE
 3376     CALL ARITHEMIT (ADD,1);                                                        SYNTHESIZE
 3377  /*     94                             ^ <ARITHMETIC EXPRESSION> -    */           SYNTHESIZE CASE 94.
 3378  /*     94                               <TERM>                       */           SYNTHESIZE
 3379     CALL ARITHEMIT (SUB,0);                                                        SYNTHESIZE
 3380  /*     95                             ^ + <TERM>                     */           SYNTHESIZE CASE 95.
 3381     CALL MOVESTACKS (MPP1, MP);                                                    SYNTHESIZE
 3382                                                                                    SYNTHESIZE CASE 96.
 3383  /*     96                             ^ - <TERM>                     */           SYNTHESIZE
 3384     DO;                                                                            SYNTHESIZE
 3385        CALL MOVESTACKS (MPP1, MP);                                                 SYNTHESIZE
 3386        IF TYPE (MP) = CONSTANT THEN FIXV (MP) = - FIXV (MP);                       SYNTHESIZE
 3387        ELSE                                                                        SYNTHESIZE
 3388           DO;                                                                      SYNTHESIZE
 3389              CALL FORCEACCUMULATOR (MP);                                           SYNTHESIZE
 3390              CALL EMITINST (MOVN,REG(MP),0,REG(MP),0,0);                           SYNTHESIZE
 3391           END;                                                                     SYNTHESIZE
 3392     END;                                                                           SYNTHESIZE
 3393                                                                                    SYNTHESIZE CASE 97.
 3394  /*     97   <TERM> ::= <PRIMARY>                                     */           SYNTHESIZE
 3395     ;                                                                              SYNTHESIZE
 3396  /*     98            ^ <TERM> * <PRIMARY>                            */           SYNTHESIZE CASE 98.
 3397     CALL ARITHEMIT (IMUL,1);                                                       SYNTHESIZE
 3398  /*     99            ^ <TERM> / <PRIMARY>                            */           SYNTHESIZE CASE 99.
 3399     CALL DIVIDE_CODE(1);                                                           SYNTHESIZE
 3400  /*    100            ^ <TERM> MOD <PRIMARY>                          */           SYNTHESIZE CASE 100.
 3401     CALL DIVIDE_CODE(0);                                                           SYNTHESIZE
 3402  /*    101   <PRIMARY> ::= <CONSTANT>                                 */           SYNTHESIZE CASE 101.
 3403     ;                                                                              SYNTHESIZE
 3404  /*    102               ^ <VARIABLE>                                 */           SYNTHESIZE CASE 102.
 3405     ;                                                                              SYNTHESIZE
 3406  /*    103               ^ ( <EXPRESSION> )                           */           SYNTHESIZE CASE 103.
 3407     CALL MOVESTACKS (MPP1, MP);                                                    SYNTHESIZE
 3408                                                                                    SYNTHESIZE CASE 104.
 3409  /*    104   <VARIABLE> ::= <IDENTIFIER>                              */           SYNTHESIZE
 3410     /* THE FOLLOWING USE IS MADE OF THE PARALLEL STACKS BELOW <VARIABLE>           SYNTHESIZE
 3411            CNT      THE NUMBER OF SUBSCRIPTS                                       SYNTHESIZE
 3412            FIXL     THE SYMBOL TABLE POINTER                                       SYNTHESIZE
 3413            FIXV     BUILTIN CODE IF SPECIAL                                        SYNTHESIZE
 3414            TYPE     VARIABLE                                                       SYNTHESIZE
 3415            INX      ZERO OR ACCUMULATOR OF SUBSCRIPT                               SYNTHESIZE
 3416        AFTER THE VARIABLE IS FORCED INTO AN ACCUMULATOR                            SYNTHESIZE
 3417            TYPE     ACCUMULATOR OR DESCRIPT                                        SYNTHESIZE
 3418            REG      CURRENT ACCUMULATOR                                            SYNTHESIZE
 3419     */                                                                             SYNTHESIZE
 3420     DO;   /* FIND THE IDENTIFIER IN THE SYMBOL TABLE */                            SYNTHESIZE
 3421        CALL ID_LOOKUP (MP);                                                        SYNTHESIZE
 3422         IF FIXL (MP) = -1 THEN CALL UNDECLARED_ID (MP);                            SYNTHESIZE
 3423     END;                                                                           SYNTHESIZE
 3424                                                                                    SYNTHESIZE CASE 105.
 3425  /*    105                ^ <SUBSCRIPT HEAD> <EXPRESSION> )           */           SYNTHESIZE
 3426                                                                                    SYNTHESIZE
 3427     DO; /* EITHER A PROCEDURE CALL, ARRAY, OR BUILTIN FUNCTION */                  SYNTHESIZE
 3428        CNT (MP) = CNT (MP) + 1;          /* COUNT SUBSCRIPTS */                    SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 107
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3429        I = FIXV (MP);                    /* ZERO OR BUILTIN FUNCTION NUMBER */     SYNTHESIZE
 3430        IF I < 6 THEN DO CASE I;                                                    SYNTHESIZE
 3431           /* CASE 0 -- ARRAY OR CALL */                                            SYNTHESIZE CASE 0.
 3432           DO;                                                                      SYNTHESIZE
 3433              IF SYTYPE (FIXL (MP)) = PROCTYPE                                      SYNTHESIZE
 3434               ^ SYTYPE (FIXL (MP)) = CHARPROCTYPE THEN CALL STUFF_PARAMETER;       SYNTHESIZE
 3435              ELSE                                                                  SYNTHESIZE
 3436                 IF CNT (MP) > 1 THEN                                               SYNTHESIZE
 3437                    CALL ERROR ('MULTIPLE SUBSCRIPTS NOT ALLOWED', 0);              SYNTHESIZE
 3438                 ELSE                                                               SYNTHESIZE
 3439                    DO;                                                             SYNTHESIZE
 3440                       CALL FORCEACCUMULATOR (MPP1);                                SYNTHESIZE
 3441                       INX (MP) = REG(MPP1);                                        SYNTHESIZE
 3442                    END;                                                            SYNTHESIZE
 3443           END;                                                                     SYNTHESIZE
 3444           /* CASE 1 -- BUILTIN FUNCTION LENGTH */                                  SYNTHESIZE CASE 1.
 3445           DO;                                                                      SYNTHESIZE
 3446              CALL FORCEDESCRIPTOR (MPP1);                                          SYNTHESIZE
 3447              CALL EMITINST(LSH,REG(MPP1),0,    -27,0,0);/* SHIFT OUT ADDRESS */    SYNTHESIZE
 3448              TYPE (MP) = ACCUMULATOR;                                              SYNTHESIZE
 3449              REG(MP) = REG(MPP1);                                                  SYNTHESIZE
 3450           END;                                                                     SYNTHESIZE
 3451           /* CASE 2 -- BUILTIN FUNCTION SUBSTR */                                  SYNTHESIZE CASE 2.
 3452           DO;  /* BUILTIN FUNCTION SUBSTR */                                       SYNTHESIZE
 3453              IF CNT(MP) = 2 THEN                                                   SYNTHESIZE
 3454                 DO;                                                                SYNTHESIZE
 3455                    IF TYPE(MPP1) = CONSTANT THEN                                   SYNTHESIZE
 3456                       DO;  /* EMIT A COMPLEX CONSTANT */                           SYNTHESIZE
 3457                          CALL EMITCONSTANT (SHL(FIXV(MPP1),27)-FIXV(MPP1));        SYNTHESIZE
 3458                          CALL EMITINST (SUB,REG(MP),0,ADR,0,1);                    SYNTHESIZE
 3459                       END;                                                         SYNTHESIZE
 3460                    ELSE                                                            SYNTHESIZE
 3461                       DO;                                                          SYNTHESIZE
 3462                         CALL FORCEACCUMULATOR (MPP1);                              SYNTHESIZE
 3463                         CALL EMITINST (ADD,REG(MP),0,REG(MPP1),0,0);               SYNTHESIZE
 3464                         CALL EMITINST (LSH,REG(MPP1),0,    27,0,0);                SYNTHESIZE
 3465                         CALL EMITINST (SUB,REG(MP),0,REG(MPP1),0,0);               SYNTHESIZE
 3466                         ACC(REG(MPP1)) = AVAIL;                                    SYNTHESIZE
 3467                       END;                                                         SYNTHESIZE
 3468                 END;                                                               SYNTHESIZE
 3469              ELSE                                                                  SYNTHESIZE
 3470                 DO;  /* THREE ARGUMENTS */                                         SYNTHESIZE
 3471                    IF TYPE(MPP1) = CONSTANT THEN                                   SYNTHESIZE
 3472                       DO;  /* MAKE A CONSTANT LENGTH TO OR IN */                   SYNTHESIZE
 3473                          CALL EMITCONSTANT (SHL(FIXV(MPP1),27));                   SYNTHESIZE
 3474                          CALL EMITINST (IOR,REG(MP),0,ADR,0,1);                    SYNTHESIZE
 3475                       END;                                                         SYNTHESIZE
 3476                    ELSE                                                            SYNTHESIZE
 3477                       DO;                                                          SYNTHESIZE
 3478                          CALL FORCEACCUMULATOR (MPP1);                             SYNTHESIZE
 3479                          CALL EMITINST (LSH,REG(MPP1),0,    27,0,0);               SYNTHESIZE
 3480                          CALL EMITINST(IOR,REG(MP),0,REG(MPP1),0,0);               SYNTHESIZE
 3481                           ACC(REG(MPP1)) = AVAIL;                                  SYNTHESIZE
 3482                       END;                                                         SYNTHESIZE
 3483                 END;                                                               SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 108
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3484              TYPE (MP) = DESCRIPT;                                                 SYNTHESIZE
 3485           END;                                                                     SYNTHESIZE
 3486           /* CASE 3 -- BUILTIN FUNCTION BYTE */                                    SYNTHESIZE CASE 3.
 3487           DO;  /* BUILTIN FUNCTION BYTE */                                         SYNTHESIZE
 3488              IF CNT(MP) = 1 THEN                                                   SYNTHESIZE
 3489                 DO;                                                                SYNTHESIZE
 3490                    IF TYPE (MPP1) = CHRTYPE THEN                                   SYNTHESIZE
 3491                       DO;                                                          SYNTHESIZE
 3492                          FIXV(MP) = BYTE(VAR(MPP1));                               SYNTHESIZE
 3493                          TYPE (MP) = CONSTANT;                                     SYNTHESIZE
 3494                       END;                                                         SYNTHESIZE
 3495                    ELSE                                                            SYNTHESIZE
 3496                       DO;                                                          SYNTHESIZE
 3497                          CALL FORCEDESCRIPTOR (MPP1);                              SYNTHESIZE
 3498                          CALL EMITINST (AND,REG(MPP1),0,ADDRMASK,0,1);             SYNTHESIZE
 3499                          /* FAKE A COREBYTE */                                     SYNTHESIZE
 3500                          TYPE(MPP1) = VARIABLE;                                    SYNTHESIZE
 3501                          FIXL(MPP1) = COREBYTELOC;                                 SYNTHESIZE
 3502                          INX(MPP1) = REG(MPP1);                                    SYNTHESIZE
 3503                          CNT(MPP1) = 1;                                            SYNTHESIZE
 3504                          CALL FORCEACCUMULATOR (MPP1);                             SYNTHESIZE
 3505                          TYPE(MP) = TYPE(MPP1);                                    SYNTHESIZE
 3506                          REG(MP) = REG(MPP1);                                      SYNTHESIZE
 3507                       END;                                                         SYNTHESIZE
 3508                 END;                                                               SYNTHESIZE
 3509              ELSE IF CNT (MP) = 2 THEN                                             SYNTHESIZE
 3510                 DO;                                                                SYNTHESIZE
 3511                    SP = MPP1;  /* SO WE CAN USE ARITHEMIT */                       SYNTHESIZE
 3512                    CALL ARITHEMIT (ADD,1);                                         SYNTHESIZE
 3513                    /* FAKE A COREBYTE */                                           SYNTHESIZE
 3514                    TYPE(MPP1) = VARIABLE;                                          SYNTHESIZE
 3515                    FIXL(MPP1) = COREBYTELOC;                                       SYNTHESIZE
 3516                          CNT(MPP1) = 1;                                            SYNTHESIZE
 3517                    INX(MPP1) = REG(MP);                                            SYNTHESIZE
 3518                    CALL FORCEACCUMULATOR(MPP1);                                    SYNTHESIZE
 3519                    TYPE(MP) = TYPE(MPP1);                                          SYNTHESIZE
 3520                    REG(MP) = REG(MPP1);                                            SYNTHESIZE
 3521                 END;                                                               SYNTHESIZE
 3522              ELSE CALL ERROR (TOOMSG ^^ SYT(FIXL(MP)),0);                          SYNTHESIZE
 3523           END;                                                                     SYNTHESIZE
 3524           /* CASE 4 -- BUILTIN FUNCTION SHL */                                     SYNTHESIZE CASE 4.
 3525           CALL SHIFT_CODE (0);           /* <- */                                  SYNTHESIZE
 3526           /* CASE 5 -- BUILTIN FUNCTION SHR */                                     SYNTHESIZE CASE 5.
 3527           CALL SHIFT_CODE (1);           /* -> */                                  SYNTHESIZE
 3528        END; /* CASE ON I */                                                        SYNTHESIZE CASE 6.
 3529        ELSE IF I = 9 THEN CALL EMIT_INLINE(1);  /*BUILT-IN FUNCTION INLINE */      SYNTHESIZE
 3530        ELSE IF I = 18 THEN                                                         SYNTHESIZE
 3531           DO;  /* BUILTIN FUNCTION ADDR */                                         SYNTHESIZE
 3532              CALL FORCEADDRESS (MPP1);                                             SYNTHESIZE
 3533              TYPE (MP) = ACCUMULATOR;                                              SYNTHESIZE
 3534           END;                                                                     SYNTHESIZE
 3535        ELSE DO;    /* SOME SORT OF BUILTIN FUNCTION */                             SYNTHESIZE
 3536                CALL FORCEACCUMULATOR(MPP1);                                        SYNTHESIZE
 3537                IF CNT(MP) = 1 THEN REG(MP) = REG(MPP1);                            SYNTHESIZE
 3538                 ELSE INX(MP) = REG(MPP1);                                          SYNTHESIZE
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 109
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3539             END;                                                                   SYNTHESIZE
 3540     END;                                                                           SYNTHESIZE
 3541                                                                                    SYNTHESIZE CASE 106.
 3542  /*    106   <SUBSCRIPT HEAD> ::= <IDENTIFIER> (                      */           SYNTHESIZE
 3543     DO;                                                                            SYNTHESIZE
 3544        CALL ID_LOOKUP(MP);                                                         SYNTHESIZE
 3545        IF FIXL(MP) = -1 THEN CALL UNDECLARED_ID (MP);                              SYNTHESIZE
 3546     END;                                                                           SYNTHESIZE
 3547                                                                                    SYNTHESIZE CASE 107.
 3548  /*    107                      ^ <SUBSCRIPT HEAD> <EXPRESSION> ,     */           SYNTHESIZE
 3549                                                                                    SYNTHESIZE
 3550     DO; /* BUILTIN FUNCTION OR PROCEDURE CALL */                                   SYNTHESIZE
 3551        CNT (MP) = CNT (MP) + 1;                                                    SYNTHESIZE
 3552        IF FIXV (MP) = 0 THEN                                                       SYNTHESIZE
 3553           DO; /* NOT A BUILTIN FUNCTION */                                         SYNTHESIZE
 3554              IF SYTYPE(FIXL(MP)) = PROCTYPE                                        SYNTHESIZE
 3555               ^ SYTYPE(FIXL(MP)) = CHARPROCTYPE THEN CALL STUFF_PARAMETER;         SYNTHESIZE
 3556              ELSE CALL FORCEACCUMULATOR (MPP1);                                    SYNTHESIZE
 3557           END;                                                                     SYNTHESIZE
 3558        ELSE IF FIXV(MP) = 2 ^ FIXV (MP) = 3 THEN                                   SYNTHESIZE
 3559           DO; /* SUBSTR OR BYTE */                                                 SYNTHESIZE
 3560              IF CNT(MP) = 1 THEN                                                   SYNTHESIZE
 3561                 DO;                                                                SYNTHESIZE
 3562                    CALL FORCEDESCRIPTOR (MPP1);                                    SYNTHESIZE
 3563                    TYPE (MP) = ACCUMULATOR;                                        SYNTHESIZE
 3564                    REG(MP) = REG(MPP1);                                            SYNTHESIZE
 3565                 END;                                                               SYNTHESIZE
 3566              ELSE IF CNT (MP) = 2 & FIXV (MP) = 2 THEN                             SYNTHESIZE
 3567                 DO; /* JUST SUBSTR, WE'LL NOTE ERROR ON BYTE LATER */              SYNTHESIZE
 3568                    IF TYPE(MPP1) \= CONSTANT ^ FIXV(MPP1) \= 0 THEN                SYNTHESIZE
 3569                       DO;                                                          SYNTHESIZE
 3570                          SP = MPP1;  /* SO WE CAN USE ARITHEMIT */                 SYNTHESIZE
 3571                         CALL ARITHEMIT (ADD,1);                                    SYNTHESIZE
 3572                          FIXV(MP) = 2; /* IF IT COMMUTES, ARITHMIT CHANGES IT */   SYNTHESIZE
 3573                       END;                                                         SYNTHESIZE
 3574                    CALL EMITINST(AND,REG(MP),0,ADDRMASK,0,1);/* AND OUT LENGTH */  SYNTHESIZE
 3575                 END;                                                               SYNTHESIZE
 3576              ELSE CALL ERROR (TOOMSG ^^ SYT(FIXL(MP)),0);                          SYNTHESIZE
 3577           END;                                                                     SYNTHESIZE
 3578        ELSE IF FIXV(MP) = 4 ^ FIXV (MP) = 5 THEN                                   SYNTHESIZE
 3579           DO; /* SHR OR SHL */                                                     SYNTHESIZE
 3580              CALL FORCEACCUMULATOR (MPP1);                                         SYNTHESIZE
 3581              REG(MP) = REG(MPP1);                                                  SYNTHESIZE
 3582           END;                                                                     SYNTHESIZE
 3583        ELSE IF FIXV(MP) = 9 THEN CALL EMIT_INLINE(0); /* INLINE */                 SYNTHESIZE
 3584        ELSE DO; /* SOME SORT OF BUILTIN FUNCTION */                                SYNTHESIZE
 3585                IF CNT (MP) = 1 THEN                                                SYNTHESIZE
 3586                   DO;                                                              SYNTHESIZE
 3587                      CALL FORCEACCUMULATOR (MPP1); /* PICK UP THE VARIABLE */      SYNTHESIZE
 3588                      REG(MP) = REG(MPP1);                                          SYNTHESIZE
 3589                   END;                                                             SYNTHESIZE
 3590                ELSE CALL ERROR (TOOMSG ^^ SYT(FIXL(MP)),0);                        SYNTHESIZE
 3591             END;                                                                   SYNTHESIZE
 3592     END;                                                                           SYNTHESIZE
 3593                                                                                    SYNTHESIZE CASE 108.
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 110
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3594  /*    108   <CONSTANT> ::= <STRING>                                  */           SYNTHESIZE
 3595     TYPE (MP) = CHRTYPE;                                                           SYNTHESIZE
 3596  /*    109                ^ <NUMBER>                                  */           SYNTHESIZE CASE 109.
 3597     TYPE (MP) = CONSTANT;                                                          SYNTHESIZE
 3598                                                                                    SYNTHESIZE CASE 110.
 3599  END;  /* OF CASE ON PRODUCTION NUMBER */                                          SYNTHESIZE
 3600  END SYNTHESIZE;                                                                   SYNTHESIZE

SYMBOL TABLE DUMP

SYMBOL            TYPE       LOC   SEGMENT DEFINED REF COUNT
PRODUCTION_NUMBER FIXED     10479     DATA   2756       1
STACK_CASE        PROCEDURE  8802  PROGRAM   2760       5
  PARAMETER  1    FIXED     10486     DATA   2761       6
TOOMSG            CHARACTER   931   STRING   2758       3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 111
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3601                                                                                   *
 3602    /*              SYNTACTIC PARSING FUNCTIONS                              */    *
 3603                                                                                   *
 3604                                                                                   *
 3605   CONFLICT: PROCEDURE (CURRENT_STATE);                                            *
 3606                                                                                    CONFLICT
 3607           DECLARE I FIXED, CURRENT_STATE FIXED;                                    CONFLICT
 3608                                                                                    CONFLICT
 3609           /*   THIS PROC IS TRUE IF THE CURRENT TOKEN IS NOT   */                  CONFLICT
 3610           /*   A TRANSITION SYMBOL FROM THE CURRENT STATE      */                  CONFLICT
 3611                                                                                    CONFLICT
 3612           /*   (A CONFLICT THEREFORE EXISTS BETWEEN THE        */                  CONFLICT
 3613           /*   CURRENT STATE AND THE NEXT TOKEN)               */                  CONFLICT
 3614                                                                                    CONFLICT
 3615           I = INDEX1(CURRENT_STATE);   /*   STARTING POINT FOR STATE        */     CONFLICT
 3616                                        /*   TRANSITION SYMBOLS              */     CONFLICT
 3617           DO I = I TO I+INDEX2(CURRENT_STATE)-1;   /*   COMPARE WITH EACH   */     CONFLICT
 3618           IF READ1(I) = TOKEN THEN RETURN (FALSE); /*   FOUND IT            */     CONFLICT
 3619           END;                                                                     CONFLICT
 3620           RETURN (TRUE);   /*   NOT THERE   */                                     CONFLICT
 3621                                                                                    CONFLICT
 3622           END CONFLICT;                                                            CONFLICT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CURRENT_STATE   FIXED     10589     DATA   3605       2
I               FIXED     10588     DATA   3607       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 112
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3623                                                                                   *
 3624                                                                                   *
 3625   RECOVER: PROCEDURE;                                                             *
 3626                                                                                    RECOVER
 3627           DECLARE ANSWER BIT(1);                                                   RECOVER
 3628                                                                                    RECOVER
 3629           /*   THIS IS A VERY CRUDE ERROR RECOVERY PROCEDURE               */      RECOVER
 3630           /*   IT RETURNS TRUE IF THE PARSE MUST BE RESUMED IN             */      RECOVER
 3631           /*   A NEW STATE (THE ONE IN THE CURRENT POSITION OF THE STATE   */      RECOVER
 3632           /*   STACK)                                                      */      RECOVER
 3633           /*   IT RETURNS FALSE IF THE PARSE IS RESUMED WITH THE SAME      */      RECOVER
 3634           /*   STATE AS WAS INTENDED BEFORE RECOVER WAS CALLED             */      RECOVER
 3635                                                                                    RECOVER
 3636           ANSWER = FALSE;                                                          RECOVER
 3637           /*   IF THIS IS THE SECOND SUCCESSIVE CALL TO RECOVER, DISCARD   */      RECOVER
 3638           /*   ONE SYMBOL (FAILSOFT IS SET TRUE BY SCAN)                   */      RECOVER
 3639           IF \ FAILSOFT & 1 THEN CALL SCAN;                                        RECOVER
 3640           FAILSOFT = FALSE;                                                        RECOVER
 3641           /*   FIND SOMETHING SOLID IN THE TEXT   */                               RECOVER
 3642           DO WHILE (\STOPIT(TOKEN) & 1);                                           RECOVER
 3643           CALL SCAN;                                                               RECOVER
 3644           END;                                                                     RECOVER
 3645           NO_LOOK_AHEAD_DONE = FALSE;                                              RECOVER
 3646           /*   DELETE PARSE STACK UNTIL THE HARD TOKEN IS   */                     RECOVER
 3647           /*   LEGAL AS A TRANSITION SYMBOL                 */                     RECOVER
 3648           DO WHILE CONFLICT (STATE_STACK(SP));                                     RECOVER
 3649           IF SP > 0                                                                RECOVER
 3650                THEN DO;                                                            RECOVER
 3651                     /*   DELETE ONE ITEM FROM THE STACK   */                       RECOVER
 3652                     SP = SP - 1;                                                   RECOVER
 3653                     ANSWER = TRUE;   /*   PARSE TO BE RESUMED IN NEW STATE   */    RECOVER
 3654                     END;                                                           RECOVER
 3655                ELSE DO;   /*   STACK IS EMPTY   */                                 RECOVER
 3656                     /*   TRY TO FIND A LEGAL TOKEN (FOR START STATE)   */          RECOVER
 3657                      CALL SCAN;                                                    RECOVER
 3658                     IF TOKEN = EOFILE                                              RECOVER
 3659                          THEN DO;                                                  RECOVER
 3660                               /*   MUST STOP COMPILING                */           RECOVER
 3661                               /*   RESUME PARSE IN AN ILLEGAL STATE   */           RECOVER
 3662                               ANSWER = TRUE;                                       RECOVER
 3663                               STATE_STACK(SP) = 0;                                 RECOVER
 3664                               RETURN (ANSWER);                                     RECOVER
 3665                               END;                                                 RECOVER
 3666                     END;                                                           RECOVER
 3667           END;                                                                     RECOVER
 3668           /*   FOUND AN ACCEPTABLE TOKEN FROM WHICH TO RESUME THE PARSE   */       RECOVER
 3669           CALL PRINTLINE ('RESUME:' ^^ SUBSTR(POINTER,LENGTH(POINTER)-             RECOVER
 3670              (LINE_LENGTH+CP-TEXT_LIMIT-LB-1)+LENGTH(BCD)),-1);                    RECOVER
 3671           RETURN (ANSWER);                                                         RECOVER
 3672                                                                                    RECOVER
 3673           END RECOVER;                                                             RECOVER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 113
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 
ANSWER          BIT (9)   10591     DATA   3627       5
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 114
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3674                                                                                   *
 3675                                                                                   *
 3676   COMPILATION_LOOP:                                                               *
 3677     PROCEDURE;                                                                    *
 3678                                                                                    COMPILATION_LOOP
 3679           DECLARE OVERFLOW CHARACTER INITIAL (                                     COMPILATION_LOOP
 3680           'STACK OVERFLOW *** COMPILATION ABORTED ***');                           COMPILATION_LOOP
 3681           DECLARE I FIXED, J FIXED, STATE FIXED;                                   COMPILATION_LOOP
 3682           DECLARE END_OF_FILE CHARACTER INITIAL (                                  COMPILATION_LOOP
 3683           'END OF FILE FOUND UNEXPECTEDLY *** COMPILATION ABORTED ***');           COMPILATION_LOOP
 3684                                                                                    COMPILATION_LOOP
 3685           /*   THIS PROC PARSES THE INPUT STRING (BY CALLING THE SCANNER)   */     COMPILATION_LOOP
 3686           /*   AND CALLS THE CODE EMISSION PROC (SYNTHESIZE) WHENEVER A     */     COMPILATION_LOOP
 3687           /*   PRODUCTION CAN BE APPLIED                                    */     COMPILATION_LOOP
 3688                                                                                    COMPILATION_LOOP
 3689           /*   INITIALIZE                                                   */     COMPILATION_LOOP
 3690           COMPILING = TRUE;                                                        COMPILATION_LOOP
 3691           STATE = START_STATE;                                                     COMPILATION_LOOP
 3692           SP = -1;                                                                 COMPILATION_LOOP
 3693           /*   STOP COMPILING IF FINISHED                                   */     COMPILATION_LOOP
 3694   COMP:   DO WHILE (COMPILING);                                                    COMPILATION_LOOP
 3695           /*   FIND WHICH OF THE FOUR KINDS OF STATES WE ARE DEALING WITH:  */     COMPILATION_LOOP
 3696           /*   READ,APPLY PRODUCTION,LOOKAHEAD, OR PUSH STATE               */     COMPILATION_LOOP
 3697           IF STATE <= MAXR#                                                        COMPILATION_LOOP
 3698                THEN DO;   /*   READ STATE   */                                     COMPILATION_LOOP
 3699                     SP = SP+1;   /*   ADD AN ELEMENT TO THE STACK   */             COMPILATION_LOOP
 3700                     IF SP = STACKSIZE                                              COMPILATION_LOOP
 3701                          THEN DO;                                                  COMPILATION_LOOP
 3702                               CALL ERROR (OVERFLOW,2);                             COMPILATION_LOOP
 3703                               RETURN;                                              COMPILATION_LOOP
 3704                               END;                                                 COMPILATION_LOOP
 3705                     STATE_STACK(SP) = STATE;   /*   PUSH PRESENT STATE   */        COMPILATION_LOOP
 3706                     I = INDEX1(STATE);         /*   GET STARTING POINT   */        COMPILATION_LOOP
 3707                     IF NO_LOOK_AHEAD_DONE                                          COMPILATION_LOOP
 3708                          THEN DO;   /*   READ IF NECESSARY   */                    COMPILATION_LOOP
 3709                               CALL SCAN;                                           COMPILATION_LOOP
 3710                               NO_LOOK_AHEAD_DONE = FALSE;                          COMPILATION_LOOP
 3711                               END;                                                 COMPILATION_LOOP
 3712                     /*   COMPARE TOKEN WITH EACH TRANSITION SYMBOL IN    */        COMPILATION_LOOP
 3713                     /*   READ STATE                                      */        COMPILATION_LOOP
 3714                      DO I = I TO I+INDEX2(STATE)-1;                                COMPILATION_LOOP
 3715                     IF READ1(I) = TOKEN                                            COMPILATION_LOOP
 3716                          THEN DO;   /*   FOUND IT   */                             COMPILATION_LOOP
 3717                               VAR(SP) = BCD;                                       COMPILATION_LOOP
 3718                               FIXV(SP) = NUMBER_VALUE;                             COMPILATION_LOOP
 3719                               FIXL(SP) = CARD_COUNT;                               COMPILATION_LOOP
 3720                               PPSAVE(SP) = PP;                                     COMPILATION_LOOP
 3721                               STATE = READ2(I);                                    COMPILATION_LOOP
 3722                               NO_LOOK_AHEAD_DONE = TRUE;                           COMPILATION_LOOP
 3723                               GO TO COMP;                                          COMPILATION_LOOP
 3724                               END;                                                 COMPILATION_LOOP
 3725                     END;                                                           COMPILATION_LOOP
 3726                     /*   FOUND AN ERROR   */                                       COMPILATION_LOOP
 3727                     CALL ERROR ('ILLEGAL SYMBOL PAIR: ' ^^                         COMPILATION_LOOP
 3728                                 VOCAB(STATE_NAME(STATE)) ^^ X1 ^^                  COMPILATION_LOOP
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 115
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3729                                 VOCAB(TOKEN),1);                                   COMPILATION_LOOP
 3730                     CALL STACK_DUMP;    /*  DISPLAY THE STACK   */                 COMPILATION_LOOP
 3731                     /*   TRY TO RECOVER   */                                       COMPILATION_LOOP
 3732                     IF RECOVER                                                     COMPILATION_LOOP
 3733                          THEN DO;                                                  COMPILATION_LOOP
 3734                               STATE = STATE_STACK(SP);   /*   NEW STARTING PT  */  COMPILATION_LOOP
 3735                               IF STATE = 0                                         COMPILATION_LOOP
 3736                                    THEN DO;   /*   UNEXPECTED EOFILE   */          COMPILATION_LOOP
 3737                                         CALL ERROR (END_OF_FILE,2);                COMPILATION_LOOP
 3738                                         RETURN;                                    COMPILATION_LOOP
 3739                                         END;                                       COMPILATION_LOOP
 3740                               END;                                                 COMPILATION_LOOP
 3741                     SP = SP-1;   /*   STACK AT SP CONTAINS JUNK   */               COMPILATION_LOOP
 3742                     END;                                                           COMPILATION_LOOP
 3743                ELSE                                                                COMPILATION_LOOP
 3744           IF STATE > MAXP#                                                         COMPILATION_LOOP
 3745                THEN DO;   /*   APPLY PRODUCTION STATE   */                         COMPILATION_LOOP
 3746                     /*   SP POINTS AT RIGHT END OF PRODUCTION   */                 COMPILATION_LOOP
 3747                     /*   MP POINTS AT LEST END OF PRODUCTION   */                  COMPILATION_LOOP
 3748                     MP = SP-INDEX2(STATE);                                         COMPILATION_LOOP
 3749                     MPP1 = MP+1;                                                   COMPILATION_LOOP
 3750                     CALL SYNTHESIZE (STATE-MAXP#);   /*   APPLY PRODUCTION   */    COMPILATION_LOOP
 3751                     SP = MP;   /*   RESET STACK POINTER   */                       COMPILATION_LOOP
 3752                     I = INDEX1(STATE);                                             COMPILATION_LOOP
 3753                     /*   COMPARE TOP OF STATE STACK WITH TABLES   */               COMPILATION_LOOP
 3754                     J = STATE_STACK(SP);                                           COMPILATION_LOOP
 3755                     DO WHILE APPLY1(I) \= 0;                                       COMPILATION_LOOP
 3756                     IF J = APPLY1(I) THEN GO TO TOP_MATCH;                         COMPILATION_LOOP
 3757                     I = I+1;                                                       COMPILATION_LOOP
 3758                     END;                                                           COMPILATION_LOOP
 3759                     /*   HAS THE PROGRAM GOAL BEEN REACHED   */                    COMPILATION_LOOP
 3760          TOP_MATCH: IF APPLY2(I) =0                                                COMPILATION_LOOP
 3761                          THEN DO;   /*   YES IT HAS   */                           COMPILATION_LOOP
 3762                               COMPILING = FALSE;                                   COMPILATION_LOOP
 3763                               RETURN;                                              COMPILATION_LOOP
 3764                               END;                                                 COMPILATION_LOOP
 3765                     STATE = APPLY2(I);   /*   PICK UP THE NEXT STATE   */          COMPILATION_LOOP
 3766                     END;                                                           COMPILATION_LOOP
 3767                ELSE                                                                COMPILATION_LOOP
 3768           IF STATE <= MAXL#                                                        COMPILATION_LOOP
 3769                THEN DO;   /*   LOOKAHEAD STATE   */                                COMPILATION_LOOP
 3770                      I = INDEX1(STATE);   /*   INDEX INTO THE TABLE   */           COMPILATION_LOOP
 3771                     IF NO_LOOK_AHEAD_DONE                                          COMPILATION_LOOP
 3772                          THEN DO;   /*   GET A TOKEN   */                          COMPILATION_LOOP
 3773                               CALL SCAN;                                           COMPILATION_LOOP
 3774                               NO_LOOK_AHEAD_DONE = FALSE;                          COMPILATION_LOOP
 3775                               END;                                                 COMPILATION_LOOP
 3776                     /*   CHECK TOKEN AGAINST LEGAL LOOKAHEAD TRANSITION SYMBOLS*/  COMPILATION_LOOP
 3777                     DO WHILE LOOK1(I) \= 0;                                        COMPILATION_LOOP
 3778                     IF LOOK1(I) = TOKEN                                            COMPILATION_LOOP
 3779                          THEN GO TO LOOK_MATCH;   /*   FOUND ONE   */              COMPILATION_LOOP
 3780                     I = I+1;                                                       COMPILATION_LOOP
 3781                     END;                                                           COMPILATION_LOOP
 3782         LOOK_MATCH: STATE = LOOK2(I);                                              COMPILATION_LOOP
 3783                     END;                                                           COMPILATION_LOOP
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 116
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3784                ELSE DO;   /*   PUSH STATE   */                                     COMPILATION_LOOP
 3785                     SP = SP+1;   /*   PUSH A NON-TERMINAL ONTO THE STACK   */      COMPILATION_LOOP
 3786                     IF SP = STACKSIZE                                              COMPILATION_LOOP
 3787                          THEN DO;                                                  COMPILATION_LOOP
 3788                               CALL ERROR (OVERFLOW,2);                             COMPILATION_LOOP
 3789                               RETURN;                                              COMPILATION_LOOP
 3790                               END;                                                 COMPILATION_LOOP
 3791                     /*   PUSH A STATE # INTO THE STATE_STACK   */                  COMPILATION_LOOP
 3792                     STATE_STACK(SP) = INDEX2(STATE);                               COMPILATION_LOOP
 3793                     /*   GET NEXT STATE                        */                  COMPILATION_LOOP
 3794                     STATE = INDEX1(STATE);                                         COMPILATION_LOOP
 3795                     END;                                                           COMPILATION_LOOP
 3796           END;   /*   OF COMPILE LOOP   */                                         COMPILATION_LOOP
 3797                                                                                    COMPILATION_LOOP
 3798           END COMPILATION_LOOP;                                                    COMPILATION_LOOP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
COMP            LABEL     11377  PROGRAM   3694       1
END_OF_FILE     CHARACTER   950   STRING   3682       1
I               FIXED     10604     DATA   3681      19
J               FIXED     10605     DATA   3681       2
LOOK_MATCH      LABEL     11615  PROGRAM   3779       1
OVERFLOW        CHARACTER   949   STRING   3679       2
STATE           FIXED     10606     DATA   3681      20
TOP_MATCH       LABEL     11562  PROGRAM   3756       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 117
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3799                                                                                   *
 3800  PRINT_TIME:                                                                      *
 3801     PROCEDURE (TEXT, TIME);                                                       *
 3802     /* PRINT TEXT FOLLOWED BY TIME, WHICH IS IN MILLISECONDS */                    PRINT_TIME
 3803        DECLARE TEXT CHARACTER, TIME FIXED;                                         PRINT_TIME
 3804        K = TIME;                                                                   PRINT_TIME
 3805        I = K / 60000;                                                              PRINT_TIME
 3806        J = K MOD 60000 / 1000;                                                     PRINT_TIME
 3807        K = K MOD 1000;                                                             PRINT_TIME
 3808        CALL PRINTLINE (TEXT ^^ I ^^ ':' ^^ J ^^ '.' ^^ K,-1);                      PRINT_TIME
 3809     END PRINT_TIME;                                                                PRINT_TIME

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
TEXT            CHARACTER   952   STRING   3801       1
TIME            FIXED     10629     DATA   3801       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 118
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3810                                                                                   *
 3811     /*   E X E C U T I O N   S T A R T S   H E R E                          */    *
 3812                                                                                   *
 3813     DECLARE TIME_START FIXED,                                                     *
 3814             TIME_INIT FIXED,                                                      *
 3815             TIME_COMPILE FIXED,                                                   *
 3816             TIME_FINISH FIXED;                                                    *
 3817                                                                                   *
 3818     TIME_START = RUNTIME;           /* GET TIME(CPU) STARTED*/                    *
 3819     CALL INITIALIZE;                                                              *
 3820     TIME_INIT = RUNTIME;     /* TIME TO INITIALIZE */                             *
 3821     CALL COMPILATION_LOOP;                                                        *
 3822     TIME_COMPILE = RUNTIME;     /* TIME TO COMPILE THE PROGRAM*/                  *
 3823     CONTROL(BYTE('E')) = FALSE;                                                   *
 3824     CONTROL(BYTE('B')) = FALSE;                                                   *
 3825     SUBTITLE = '';                                                                *
 3826     IF CONTROL(BYTE('S')) THEN CALL SYMBOLDUMP;                                   *
 3827     ELSE EJECT_PAGE;                                                              *
 3828     /* NOW ENTER THE VALUE OF NDESCRIPT                                        */ *
 3829     CALL EMITLABEL (NDESC,5);            /* GENERATE LABEL */                     *
 3830     IF CONTROL(BYTE('A')) THEN                                                    *
 3831        OUTPUT(DATAFILE) = '$' ^^ NDESC ^^ ':'; /* LABEL FOR ASSEMBLER */          *
 3832     CALL EMITDATAWORD (DSP-1);           /* PUT DOWN NUMBER OF DESC'S */          *
 3833     IF CONTROL(BYTE('A')) THEN                                                    *
 3834        OUTPUT(DATAFILE) = 'S=.;';           /* START STRING SEGMENT */            *
 3835     /* ADD THE DESCRIPTORS TO THE DATA SEGMENT                                 */ *
 3836     DO I = 0 TO DSP-1;                                                            *
 3837        IF CONTROL(BYTE('A')) THEN                                                 *
 3838           OUTPUT(DATAFILE)='       BYTE (9)'^^DESCL(I)^^ '(27)' ^^DESCA(I)^^ ';'; *
 3839        CALL OUTPUT_DATAWORD (SHL(DESCL(I),27) + DESCA(I), DP);                    *
 3840        CALL EMITLABEL (I,3);                                                      *
 3841        DP = DP + 1;                                                               *
 3842     END;                                                                          *
 3843     /* FINAL CODE FOR SYSTEM INTERFACE                                         */ *
 3844     CALL EMITINST (4,0,0,0,0,0);                                                  *
 3845     CALL FLUSH_DATA_BUFFER;                                                       *
 3846     CALL FLUSH_LABELS;                                                            *
 3847     DO WHILE CODE_TAIL \= CODE_HEAD;                                              *
 3848        CALL OUTPUT_CODEWORD;                                                      *
 3849        END;                                                                       *
 3850     CALL OUTPUT_CODEWORD;                                                         *
 3851     CALL FLUSH_CODE_BUFFER;                                                       *
 3852     IF CONTROL(BYTE('A')) THEN                                                    *
 3853        DO;                                                                        *
 3854           OUTPUT (CODEFILE) = '       END $0;';                                   *
 3855           /* COPY CODE FILE TO END OF DATA FILE */                                *
 3856           CODESTRING = INPUT(CODEFILE);                                           *
 3857           DO WHILE LENGTH(CODESTRING) > 0;                                        *
 3858              OUTPUT(DATAFILE) = CODESTRING;                                       *
 3859              CODESTRING = INPUT(CODEFILE);                                        *
 3860           END;                                                                    *
 3861           OUTPUT (CODEFILE) = ' ';                                                *
 3862        END;                                                                       *
 3863                                                                                   *
 3864     FILE(RELFILE) = SYMB_TYPE + 2;      /* GENERATE EXTERNAL REFS */              *
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 119
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3865     FILE(RELFILE) = "(3)040000000000";                                            * C40 = 524288
 3866     FILE(RELFILE) = "(3)600000000000" + RADIX50 ('XPLLIB');                       * C41 = 4294967296
 3867     FILE(RELFILE) = LIBRARY;                                                      * C42 = -17179869184
 3868     FILE(RELFILE) = START_TYPE + 1;                                               *
 3869     FILE(RELFILE) = "(3)200000000000";                                            * C43 = 1835008
 3870     FILE(RELFILE) = "(3)400000" + STARTLOC;                                       *
 3871     FILE(RELFILE) = END_TYPE + 2;                                                 *
 3872     FILE(RELFILE) = "(3)240000000000";                                            *
 3873     FILE(RELFILE) = "(3)400000" + PP;                                             * C44 = 21474836480
 3874     FILE(RELFILE) = DP;                                                           *
 3875                                                                                   *
 3876     TIME_FINISH = RUNTIME;   /* TIME TO DO ALL BUT FINAL STATS */                 *
 3877     CALL PRINTLINE (SUBSTR(X70, 0, 40) ^^ 'C O M P I L E R   S T A T I S T I C S',-1);*
 3878     CALL PRINTLINE (CARD_COUNT ^^ ' LINES CONTAINING ' ^^ STATEMENT_COUNT ^^      * C45 = 5368709120
 3879        ' STATEMENTS WERE COMPILED.',0);                                           *
 3880     IF ERROR_COUNT = 0 THEN CALL PRINTLINE ('NO ERRORS WERE DETECTED.',-1);       *
 3881     ELSE IF ERROR_COUNT > 1 THEN                                                  *
 3882        CALL PRINTLINE (ERROR_COUNT ^^ ' ERRORS (' ^^ SEVERE_ERRORS                *
 3883        ^^ ' SEVERE) WERE DETECTED.',-1);                                          *
 3884     ELSE IF SEVERE_ERRORS = 1 THEN CALL PRINTLINE ('ONE SEVERE ERROR WAS DETECTED.',-1);*
 3885        ELSE CALL PRINTLINE ('ONE ERROR WAS DETECTED.',-1);                        *
 3886      IF PREVIOUS_ERROR > 0 THEN                                                   *
 3887         CALL PRINTLINE ('LAST ERROR WAS ON LINE ' ^^ PREVIOUS_ERROR ,-1);         *
 3888     CALL PRINTLINE (PP ^^ ' WORDS OF PROGRAM, ' ^^ DP-DSP ^^ ' WORDS OF DATA, AND ' ^^*
 3889        DSP ^^ ' WORDS OF DESCRIPTORS.  TOTAL CORE REQUIREMENT ' ^^ PP+DP ^^       *
 3890        ' WORDS.',-1);                                                             *
 3891                                                                                   *
 3892  /* NOW COMPUTE TIMES AND PRINT THEM */                                           *
 3893     TIME_INIT = TIME_INIT - TIME_START;                                           *
 3894     TIME_COMPILE = TIME_COMPILE - TIME_START;                                     *
 3895     TIME_FINISH = TIME_FINISH - TIME_START;                                       *
 3896                                                                                   *
 3897     CALL PRINT_TIME ('TOTAL TIME IN COMPILER    = ',TIME_FINISH);                 *
 3898     CALL PRINT_TIME ('INITIALIZATION TIME       = ',TIME_INIT);                   *
 3899     CALL PRINT_TIME ('ACTUAL COMPILATION TIME   = ',TIME_COMPILE - TIME_INIT);    *
 3900     CALL PRINT_TIME ('POST-COMPILATION CLEAN-UP = ',TIME_FINISH-TIME_COMPILE);    *
 3901                                                                                   *
 3902     IF CONTROL(BYTE('D')) THEN CALL DUMPIT;                                       *
 3903  EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF  *

SYMBOL TABLE DUMP

SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
A                     FIXED      1923     DATA    275      10
ACC                   FIXED      1929     DATA    280      43
ADD                   FIXED      6253     DATA    400       9
ADDI                  FIXED      6254     DATA    401       4
ADDM                  FIXED      6255     DATA    402       2
ADDRMASK              FIXED      1927     DATA    277       5
ADR                   FIXED      2139     DATA    347      16
AND                   FIXED      6256     DATA    403       8
ANDI                  FIXED      6257     DATA    404       3
AOSA                  FIXED      6258     DATA    405       1
APPLY1                BIT (9)     932     DATA    126       2
APPLY2                BIT (9)    1062     DATA    155       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 120
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
ARITHEMIT             PROCEDURE  4907  PROGRAM   1981       9
  PARAMETER  1        FIXED      9686     DATA   1981      21
  PARAMETER  2        FIXED      9687     DATA   1981      10
B                     FIXED      1924     DATA    275       9
BACKMSG               CHARACTER   750   STRING    537       4
BACKUP                PROCEDURE  3747  PROGRAM   1653       3
BALANCE               CHARACTER   103   STRING    236       8
BASE                  FIXED      1691     DATA    230       3
BCD                   CHARACTER    97   STRING    190      27
BCHAR                 PROCEDURE   920  PROGRAM    710       2
BLT                   FIXED      6259     DATA    406       2
BOOLBRANCH            PROCEDURE  5099  PROGRAM   2026       2
  PARAMETER  1        FIXED      9698     DATA   2026       7
  PARAMETER  2        FIXED      9699     DATA   2026       4
BUFFER                CHARACTER   100   STRING    222      15
BUILD_BCD             PROCEDURE   561  PROGRAM    614       2
  PARAMETER  1        BIT (9)    9149     DATA    615       3
BYTEPTRS              FIXED      1906     DATA    258       6
C                     FIXED      1925     DATA    275       3
CALLI                 FIXED      6260     DATA    407       1
CALLSUB               PROCEDURE  3694  PROGRAM   1635       1
  PARAMETER  1        FIXED      9602     DATA   1635       2
  PARAMETER  2        FIXED      9603     DATA   1635       2
  PARAMETER  3        FIXED      9604     DATA   1635       4
CALLTYPE              FIXED      1912     DATA    264       3
CAM                   FIXED      6261     DATA    408       5
CAMGE                 FIXED      6262     DATA    409       1
CAML                  FIXED      6263     DATA    410       1
CAMLE                 FIXED      6264     DATA    411       1
CAMN                  FIXED      6265     DATA    412       2
CARD_COUNT            FIXED      1684     DATA    223      13
CASEP                 FIXED      9095     DATA    533      12
CASESTACK             FIXED      8919     DATA    532       3
CATENTRY              FIXED      1909     DATA    261       2
CH                    FIXED      1384     DATA    190       7
CHAR                  PROCEDURE   894  PROGRAM    695       7
CHARTYPE              BIT (9)    1427     DATA    211       9
CHAR_TEMP             CHARACTER   259   STRING    462       7
CHECK_STRING_OVERFLOW PROCEDURE  3681  PROGRAM   1630       3
CLEARARS              PROCEDURE  3199  PROGRAM   1435       6
CMPRHI                FIXED      6266     DATA    413       2
CNT                   FIXED      8712     DATA    524      36
CODE                  CHARACTER   231   STRING    303       8
CODEMSG               CHARACTER   748   STRING    535       4
CODESTRING            CHARACTER   235   STRING    309       4
CODE_BUFFER           FIXED      1959     DATA    314       7
CODE_FULL             BIT (9)    1954     DATA    304       7
CODE_HEAD             FIXED      1955     DATA    305      26
CODE_PP               FIXED      2020     DATA    318       4
CODE_RBITS            FIXED      2024     DATA    319       4
CODE_REL              FIXED      2016     DATA    317       4
CODE_TAIL             FIXED      1956     DATA    306      13
COMPACTIFY            PROCEDURE   128  PROGRAM      0       1
COMPARESWAP           FIXED      6304     DATA    451       1
COMPILATION_LOOP      PROCEDURE 11371  PROGRAM   3676       1
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 121
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
COMPILING             FIXED      1901     DATA    251       6
CONCATENATE           FIXED      1699     DATA    235       2
CONFLICT              PROCEDURE 11246  PROGRAM   3605       1
  PARAMETER  1        FIXED     10589     DATA   3605       3
CONTROL               BIT (9)    1555     DATA    211      61
COREBYTELOC           FIXED      1915     DATA    267       3
COUNT_ARITH           FIXED      1948     DATA    286       3
COUNT_COMPACT         FIXED        33     DATA      0       3
COUNT_FORCE           FIXED      1947     DATA    285       3
COUNT_INST            FIXED      1946     DATA    284       3
COUNT_SCAN            FIXED      1945     DATA    283       3
COUNT_STORE           FIXED      1949     DATA    287       3
CP                    FIXED      1385     DATA    190      62
CURRENT_PROCEDURE     CHARACTER   102   STRING    226       7
DATACARD              CHARACTER   230   STRING    301      13
DATAMSG               CHARACTER   749   STRING    536       5
DATA_BUFFER           FIXED      1978     DATA    315       6
DCTR                  FIXED      2031     DATA    324      15
DEBLANK               PROCEDURE   907  PROGRAM    703       3
DELETE_MOVE           PROCEDURE  3782  PROGRAM   1663       8
  PARAMETER  1        FIXED      9605     DATA   1664      12
  PARAMETER  2        FIXED      9606     DATA   1664      11
  PARAMETER  3        FIXED      9607     DATA   1664      11
  PARAMETER  4        FIXED      9608     DATA   1664      10
  PARAMETER  5        FIXED      9609     DATA   1664      11
  PARAMETER  6        FIXED      9610     DATA   1664      10
  PARAMETER  7        FIXED      9611     DATA   1664      10
DESCA                 FIXED      2147     DATA    352       3
DESCL                 FIXED      3148     DATA    353       3
DESCREF               FIXED      4149     DATA    354       5
DIVIDE                FIXED      1695     DATA    233       2
DIVIDE_CODE           PROCEDURE  5399  PROGRAM   2109       2
  PARAMETER  1        FIXED      9711     DATA   2109       4
DLOC                  FIXED      2032     DATA    325       5
DP                    FIXED      1957     DATA    307      60
DPB                   FIXED      6267     DATA    414       3
DPOFFSET              FIXED      1958     DATA    308      21
DPTR                  FIXED      2030     DATA    323      12
DSP                   FIXED      5150     DATA    355      24
DUMPIT                PROCEDURE  6113  PROGRAM   2294       1
EMITBLOCK             PROCEDURE  2007  PROGRAM   1077       3
  PARAMETER  1        FIXED      9252     DATA   1078       5
EMITBYTE              PROCEDURE  2148  PROGRAM   1103       4
  PARAMETER  1        FIXED      9261     DATA   1104       7
EMITCODEWORD          PROCEDURE  2299  PROGRAM   1133       1
  PARAMETER  1        CHARACTER   788   STRING   1133       2
  PARAMETER  2        FIXED      9477     DATA   1133       2
  PARAMETER  3        FIXED      9478     DATA   1133       2
EMITCONSTANT          PROCEDURE  2204  PROGRAM   1114      10
  PARAMETER  1        FIXED      9266     DATA   1115      15
EMITDATAWORD          PROCEDURE  2073  PROGRAM   1089      19
  PARAMETER  1        FIXED      9259     DATA   1090      21
EMITDESC              PROCEDURE  2825  PROGRAM   1307       7
  PARAMETER  1        FIXED      9513     DATA   1307       9
  PARAMETER  2        FIXED      9514     DATA   1307       9
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 122
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
EMITINST              PROCEDURE  2613  PROGRAM   1231     219
  PARAMETER  1        FIXED      9495     DATA   1231     224
  PARAMETER  2        FIXED      9496     DATA   1231     221
  PARAMETER  3        FIXED      9497     DATA   1231     221
  PARAMETER  4        FIXED      9498     DATA   1231     226
  PARAMETER  5        FIXED      9499     DATA   1231     222
  PARAMETER  6        FIXED      9500     DATA   1231     222
EMITLABEL             PROCEDURE  2396  PROGRAM   1160      13
  PARAMETER  1        FIXED      9480     DATA   1160      19
  PARAMETER  2        FIXED      9481     DATA   1160      18
EMIT_INLINE           PROCEDURE  3844  PROGRAM   1694       2
  PARAMETER  1        BIT (9)    9612     DATA   1695       3
ENTER                 PROCEDURE  2921  PROGRAM   1338       8
  PARAMETER  1        CHARACTER   812   STRING   1338      13
  PARAMETER  2        FIXED      9525     DATA   1338      11
  PARAMETER  3        FIXED      9526     DATA   1338      10
  PARAMETER  4        FIXED      9527     DATA   1338      10
EOFILE                FIXED      1696     DATA    233       3
ERROR                 PROCEDURE   431  PROGRAM    581      56
  PARAMETER  1        CHARACTER   760   STRING    582      60
  PARAMETER  2        FIXED      9123     DATA    582      57
ERROR_COUNT           FIXED      1685     DATA    223       5
EXPANSION_COUNT       FIXED      1888     DATA    241       4
FAILSOFT              FIXED      1900     DATA    251       3
FALSELOC              FIXED      1905     DATA    257       1
FILEMSG               CHARACTER   751   STRING    538       2
FINDAR                PROCEDURE  3210  PROGRAM   1442      12
FINDLABEL             PROCEDURE  2888  PROGRAM   1322      11
FIXL                  FIXED      8865     DATA    528      78
FIXV                  FIXED      8763     DATA    526      58
FLUSH_CODE_BUFFER     PROCEDURE  1634  PROGRAM    953       3
FLUSH_DATACARD        PROCEDURE  1940  PROGRAM   1065       6
FLUSH_DATA_BUFFER     PROCEDURE  1598  PROGRAM    936       3
FLUSH_LABELS          PROCEDURE  1843  PROGRAM   1020       2
FORCEACCUMULATOR      PROCEDURE  4037  PROGRAM   1772      33
  PARAMETER  1        FIXED      9636     DATA   1772      67
FORCEADDRESS          PROCEDURE  3280  PROGRAM   1475       1
  PARAMETER  1        FIXED      9568     DATA   1476       2
FORCEDESCRIPTOR       PROCEDURE  4502  PROGRAM   1882      11
  PARAMETER  1        FIXED      9665     DATA   1883      21
FOR_COUNT             FIXED      2136     DATA    331      13
FOR_LABEL             FIXED      2085     DATA    330       6
FOR_REF               FIXED      2034     DATA    329       7
FREEBASE              FIXED        32     DATA      0       2
FREELIMIT             FIXED        11     DATA      0       2
GENSTORE              PROCEDURE  4569  PROGRAM   1900       3
  PARAMETER  1        FIXED      9666     DATA   1900      20
  PARAMETER  2        FIXED      9667     DATA   1900      23
GET_CARD              PROCEDURE   590  PROGRAM    621       5
HASH                  FIXED      7868     DATA    512       9
HASHER                PROCEDURE  2895  PROGRAM   1330       5
  PARAMETER  1        CHARACTER   811   STRING   1331       8
HLL                   FIXED      6268     DATA    415       5
HLRZ                  FIXED      6269     DATA    416       1
HRLI                  FIXED      6270     DATA    417       2
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 123
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
HRLM                  FIXED      6271     DATA    418       1
HRREI                 FIXED      6272     DATA    419       1
I                     FIXED      6321     DATA    464     144
IDCOMPARES            FIXED      6315     DATA    455       5
IDENT                 FIXED      1692     DATA    233       3
IDIV                  FIXED      6273     DATA    420       1
IDIVI                 FIXED      6274     DATA    421       1
IDPB                  FIXED      6275     DATA    422       3
IDX                   FIXED      8545     DATA    514       7
ID_LOOKUP             PROCEDURE  3089  PROGRAM   1386       3
  PARAMETER  1        FIXED      9548     DATA   1387      12
ILDB                  FIXED      6276     DATA    423       3
IMUL                  FIXED      6277     DATA    424       1
INDEX1                FIXED      1089     DATA    162       5
INDEX2                BIT (9)    1324     DATA    175       4
INFO                  CHARACTER   258   STRING    461       8
INITIALIZE            PROCEDURE  6436  PROGRAM   2348       1
INSTRUCT              FIXED      5741     DATA    398       8
INX                   FIXED      8661     DATA    523      53
IOR                   FIXED      6278     DATA    425       4
ITYPE                 FIXED      2140     DATA    348       4
I_FORMAT              PROCEDURE   351  PROGRAM    545       6
  PARAMETER  1        FIXED      9111     DATA    546       7
  PARAMETER  2        FIXED      9112     DATA    546       8
I_STRING              CHARACTER   260   STRING    463      12
J                     FIXED      6322     DATA    464      46
JBASE                 FIXED      1690     DATA    230      10
JRST                  FIXED      6279     DATA    426      12
JUMP                  FIXED      6280     DATA    427       2
JUMPE                 FIXED      6281     DATA    428       2
JUMPGE                FIXED      6282     DATA    429       1
JUMPN                 FIXED      6283     DATA    430       2
K                     FIXED      6323     DATA    464      22
L                     FIXED      6324     DATA    464       2
LABELSET              FIXED      1697     DATA    234       1
LABEL_BUFFER          FIXED      1997     DATA    316       5
LABEL_COUNT           FIXED      2033     DATA    326      10
LABEL_GEN             CHARACTER   226   STRING    279       7
LABEL_SINK            FIXED      1928     DATA    278       3
LB                    FIXED      1700     DATA    236      12
LDB                   FIXED      6284     DATA    431       2
LENGTHMASK            FIXED      1926     DATA    276       4
LIBRARY               FIXED      1919     DATA    271       2
LIBRARY_CALL          PROCEDURE  3948  PROGRAM   1727       5
  PARAMETER  1        FIXED      9627     DATA   1727       8
  PARAMETER  2        FIXED      9628     DATA   1727       7
  PARAMETER  3        FIXED      9629     DATA   1727       9
  PARAMETER  4        FIXED      9630     DATA   1727       9
LIBRARY_SAVE          FIXED      1920     DATA    272       1
LIMITWORD             FIXED      1916     DATA    268       3
LINE_COUNT            FIXED      1951     DATA    292      10
LINE_LENGTH           FIXED      1688     DATA    225       3
LOOK1                 BIT (9)     914     DATA    120       2
LOOK2                 BIT (9)    1044     DATA    150       1
LSH                   FIXED      6285     DATA    432      14
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 124
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
LSHC                  FIXED      6286     DATA    433       7
MACRO_COUNT           FIXED      1765     DATA    239       6
MACRO_DECLARE         FIXED      1826     DATA    239       4
MACRO_INDEX           BIT (9)    1701     DATA    238       5
MACRO_NAME            CHARACTER   104   STRING    237      11
MACRO_TEXT            CHARACTER   165   STRING    238       5
MAXNDECSY             FIXED      6327     DATA    465       3
MONITOR_CALL          PROCEDURE  4005  PROGRAM   1757       3
  PARAMETER  1        FIXED      9632     DATA   1757       4
  PARAMETER  2        FIXED      9634     DATA   1757       5
  PARAMETER  3        FIXED      9633     DATA   1757       4
MOVE                  FIXED      6287     DATA    434      34
MOVEI                 FIXED      6288     DATA    435      21
MOVEM                 FIXED      6289     DATA    436      19
MOVER                 FIXED      1913     DATA    265       3
MOVESTACKS            PROCEDURE  3246  PROGRAM   1462       9
  PARAMETER  1        FIXED      9566     DATA   1463      17
  PARAMETER  2        FIXED      9567     DATA   1463      17
MOVM                  FIXED      6290     DATA    437       1
MOVN                  FIXED      6291     DATA    438       2
MP                    FIXED      8917     DATA    529     252
MPP1                  FIXED      8918     DATA    529     112
NDECSY                FIXED      6326     DATA    465      38
NDESC                 FIXED      1918     DATA    270       4
NEWDP                 FIXED      2141     DATA    349      10
NEWDPOFFSET           FIXED      2143     DATA    349       6
NEWDSP                FIXED      2142     DATA    349       4
NMBRENTRY             FIXED      1910     DATA    262       2
NOT_LETTER_OR_DIGIT   BIT (9)    1619     DATA    212       4
NO_LOOK_AHEAD_DONE    BIT (9)    1902     DATA    254       7
NUMBER                FIXED      1694     DATA    233       3
NUMBER_VALUE          FIXED      1689     DATA    230       8
OLDDP                 FIXED      2144     DATA    350       4
OLDDPOFFSET           FIXED      2146     DATA    350       4
OLDDSP                FIXED      2145     DATA    350       2
OPNAME                CHARACTER   237   STRING    357       2
ORSYMBOL              FIXED      1698     DATA    235       2
OUTPUTLABEL           PROCEDURE  2374  PROGRAM   1152       2
  PARAMETER  1        FIXED      9479     DATA   1153       3
OUTPUT_CODEWORD       PROCEDURE  1760  PROGRAM    994       5
OUTPUT_DATAWORD       PROCEDURE  1880  PROGRAM   1040       3
  PARAMETER  1        FIXED      9248     DATA   1041       5
  PARAMETER  2        FIXED      9249     DATA   1041       6
PAGE_COUNT            FIXED      1950     DATA    291       4
PARCT                 FIXED      6328     DATA    465      18
POINTER               CHARACTER    99   STRING    198       4
POP                   FIXED      6292     DATA    439       2
POPJ                  FIXED      6293     DATA    440      13
PP                    FIXED      1953     DATA    302      42
PPSAVE                FIXED      8814     DATA    527      12
PREVIOUS_ERROR        FIXED      1687     DATA    224       5
PRINTLINE             PROCEDURE   374  PROGRAM    556      50
  PARAMETER  1        CHARACTER   752   STRING    557      52
  PARAMETER  2        FIXED      9114     DATA    557      54
PRINT_TIME            PROCEDURE 11653  PROGRAM   3800       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 125
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
  PARAMETER  1        CHARACTER   952   STRING   3801       5
  PARAMETER  2        FIXED     10629     DATA   3801       5
PROCMARK              FIXED      6325     DATA    465      21
PROC_START            PROCEDURE  3473  PROGRAM   1542       4
PSBITS                FIXED      1907     DATA    259       6
PTR                   FIXED      8124     DATA    513       9
PUSH                  FIXED      6294     DATA    441       2
PUSHJ                 FIXED      6295     DATA    442      10
PWORD                 FIXED      2137     DATA    332       4
RADIX50               PROCEDURE  1670  PROGRAM    970       2
  PARAMETER  1        CHARACTER   777   STRING    971       6
RCTR                  FIXED      2029     DATA    322      15
READ1                 BIT (9)     829     DATA    105       2
READ2                 BIT (9)     959     DATA    132       1
READING               BIT (9)    1952     DATA    300       4
RECOVER               PROCEDURE 11279  PROGRAM   3625       1
REFCHECK              PROCEDURE  2554  PROGRAM   1201       3
  PARAMETER  1        FIXED      9486     DATA   1202      12
REG                   FIXED      8610     DATA    522     123
RESERVED_LIMIT        FIXED      1426     DATA    201       3
RESTORE_ACS           PROCEDURE  3444  PROGRAM   1532       4
  PARAMETER  1        FIXED      9591     DATA   1533       6
RETURNED_TYPE         FIXED      6329     DATA    466      13
ROT                   FIXED      6296     DATA    443       4
RPTR                  FIXED      2028     DATA    321      13
S                     CHARACTER   236   STRING    356      21
SAVE_ACS              PROCEDURE  3419  PROGRAM   1523       4
  PARAMETER  1        FIXED      9588     DATA   1524       5
SCAN                  PROCEDURE   988  PROGRAM    729       6
SETCA                 FIXED      6297     DATA    444       1
SETINIT               PROCEDURE  3307  PROGRAM   1486       2
SETLIMIT              PROCEDURE  5242  PROGRAM   2063       2
SETZM                 FIXED      6298     DATA    445       2
SEVERE_ERRORS         FIXED      1686     DATA    224       5
SHIFT_CODE            PROCEDURE  5511  PROGRAM   2151       2
  PARAMETER  1        FIXED      9723     DATA   2152       4
SHOULDCOMMUTE         PROCEDURE  4851  PROGRAM   1974       2
SKIP                  FIXED      6299     DATA    446       1
SKIPE                 FIXED      6300     DATA    447       1
SOJG                  FIXED      6301     DATA    448       3
SOURCE                CHARACTER   229   STRING    295      11
SP                    FIXED      8916     DATA    529      97
STACK_DUMP            PROCEDURE  8740  PROGRAM   2736       2
STARTLOC              FIXED      2138     DATA    333       2
STATEMENT_COUNT       FIXED      6314     DATA    454       4
STATE_NAME            BIT (9)     804     DATA     93       2
STATE_STACK           BIT (9)    8546     DATA    520       7
STEPK                 FIXED      1922     DATA    274       3
STILLCOND             FIXED      6312     DATA    452       5
STILLINZERO           FIXED      6313     DATA    453      11
STOPIT                BIT (9)    1889     DATA    251       7
STR                   FIXED      1921     DATA    273       4
STRCOMP               FIXED      1911     DATA    263       2
STRING                FIXED      1693     DATA    233       5
STRINGCOMPARE         PROCEDURE  5585  PROGRAM   2176       4
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 126
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
STRING_CHECK          FIXED      1908     DATA    260       2
STRING_RECOVER        FIXED      1914     DATA    266       5
STUFF_PARAMETER       PROCEDURE  5279  PROGRAM   2078       2
SUB                   FIXED      6302     DATA    449       5
SUBI                  FIXED      6303     DATA    450       6
SUBTITLE              CHARACTER   228   STRING    290      11
SYMBOLDUMP            PROCEDURE  5678  PROGRAM   2197       2
SYNTHESIZE            PROCEDURE  8801  PROGRAM   2755       1
  PARAMETER  1        FIXED     10479     DATA   2756       2
SYT                   CHARACTER   276   STRING    490      28
SYTCARD               FIXED      7447     DATA    510       4
SYTCO                 FIXED      7026     DATA    509      14
SYTLOC                FIXED      6499     DATA    504      26
SYTSEG                BIT (9)    6920     DATA    507      18
SYTYPE                BIT (9)    6393     DATA    497      34
TARGET_REGISTER       FIXED      1903     DATA    255      11
TDECLARE              PROCEDURE  3519  PROGRAM   1551       2
  PARAMETER  1        FIXED      9595     DATA   1552       3
TEXT                  CHARACTER   101   STRING    222      44
TEXT_LIMIT            FIXED      1683     DATA    222      18
TIME_COMPILE          FIXED     10633     DATA   3815       5
TIME_FINISH           FIXED     10634     DATA   3816       5
TIME_INIT             FIXED     10632     DATA   3814       5
TIME_START            FIXED     10631     DATA   3813       4
TITLE                 CHARACTER   227   STRING    289       5
TOKEN                 FIXED      1383     DATA    190      18
TOP_MACRO             FIXED      1887     DATA    240      10
TRUELOC               FIXED      1904     DATA    256       3
TSA                   FIXED      1917     DATA    269      12
TX                    BIT (9)    1491     DATA    211       2
TYPE                  FIXED      8559     DATA    521      80
TYPENAME              CHARACTER   261   STRING    480       2
UNDECLARED_ID         PROCEDURE  3156  PROGRAM   1416       2
  PARAMETER  1        FIXED      9551     DATA   1417       9
VAR                   CHARACTER   697   STRING    525      27
VOCAB                 CHARACTER     5   STRING     71      10
X1                    CHARACTER   253   STRING    456      18
X2                    CHARACTER   254   STRING    457       4
X3                    CHARACTER   255   STRING    458       2
X4                    CHARACTER   256   STRING    459       5
X7                    CHARACTER   257   STRING    460       4
X70                   CHARACTER    98   STRING    196      19
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 127

 
                                        C O M P I L E R   S T A T I S T I C S

3903 LINES CONTAINING 2090 STATEMENTS WERE COMPILED.
NO ERRORS WERE DETECTED.
12136 WORDS OF PROGRAM, 10761 WORDS OF DATA, AND 981 WORDS OF DESCRIPTORS.  TOTAL CORE REQUIREMENT 23878 WORDS.
TOTAL TIME IN COMPILER    = 1:13.356
INITIALIZATION TIME       = 0:0.71
ACTUAL COMPILATION TIME   = 0:58.663
POST-COMPILATION CLEAN-UP = 0:14.622

MACRO DEFINITIONS:
 
NAME             AT LINE REF COUNT LITERAL VALUE
P#                   91        0    109
TRUE                194       27    "1"
BUSY                281        8    1
MAXR#                57        2    99
MAXL#                59        1    125
MAXP#                61        2    125
MAXS#                63        2    234
RSIZE                99        2    337
LSIZE               101        2    69
ASIZE               103        2    105
FALSE               194       24    "0"
AVAIL               281       35    0
VOCAB#               69        2    91
DX_SIZE               0        2    500
VERSION              53        1    '4.0'
FOREVER             195        4    WHILE TRUE
RELFILE             298       25    4
LIBFILE             299        2    5
FOR_MAX             328        3    50
CHRTYPE             471       18    6
SPECIAL             476       25    11
SYTSIZE             489       10    420
PAGE_MAX            293        4    54
DATAFILE            296       22    2
CODEFILE            297        7    3
END_TYPE            339        1    "(3)5000000"
VARIABLE            469       13    3
CONSTANT            470       18    4
BYTETYPE            473        6    8
DESCRIPT            475       12    10
PROCTYPE            478        5    13
TERMINAL#            67        7    42
CODE_TYPE           336        2    "(3)1000000"
SYMB_TYPE           337        1    "(3)2000000"
NAME_TYPE           340        1    "(3)6000000"
DESCLIMIT           351        4    1000
LABELTYPE           467        3    1
FIXEDTYPE           472       17    7
STACKSIZE           519       11    50
CASELIMIT           531        2    175
EJECT_PAGE          294        3    LINE_COUNT = PAGE_MAX+1
BUFFERSIZE          313        7    18
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 128
NAME             AT LINE REF COUNT LITERAL VALUE
 
HISEG_TYPE          338        1    "(3)3000000"
START_TYPE          341        1    "(3)7000000"
START_STATE          65        1    1
MACRO_LIMIT         237        5    60
INTREQ_TYPE         342        1    "(3)10000000"
ACCUMULATOR         468       16    2
FORWARDTYPE         474        7    9
FORWARDCALL         477        6    12
CHARPROCTYPE        479        7    14
EXPANSION_LIMIT     241        1    300
 
ID COMPARES       = 8188
SYMBOL TABLE SIZE = 410
MACRO DEFINITIONS = 52
SCAN              = 26322
EMITINST          = 13005
FORCE ACCUMULATOR = 5946
ARITHEMIT         = 862
GENERATE STORE    = 1026
FREE STRING AREA  = 14160
COMPACTIFICATIONS = 153
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 129
INSTRUCTION FREQUENCIES
 
.INIT.    1
.INPT.    6
.OUTP.    41
.EXIT.    3
.FILO.    24
.NAME.    6
CALLI     6
ILDB      3
LDB       158
IDPB      3
DPB       65
MOVE      3163
MOVEI     252
MOVEM     2540
MOVN      3
MOVM      1
IMULI     11
IDIVI     18
ROT       4
LSH       311
LSHC      7
BLT       2
JRST      714
PUSHJ     952
PUSH      62
POP       62
POPJ      137
ADD       114
ADDI      308
ADDM      2
SUB       71
SUBI      80
CAIL      14
CAIE      175
CAILE     7
CAIGE     14
CAIN      37
CAIG      54
CAML      16
CAME      21
CAMLE     62
CAMGE     6
CAMN      7
CAMG      8
JUMP      1
JUMPE     106
JUMPA     284
JUMPGE    1
JUMPN     2
SKIPE     18
SKIPGE    1
SKIPN     1
SKIPG     2
AOSA      52
SOJG      3
XCOM.XPL  COMPILED 12-MAY-1977  AT 22:34:47 BY VERSION 4.0                               PAGE 130
INSTRUCTION FREQUENCIES
 
SETZM     838
AND       79
ANDI      328
IOR       70
SETCA     7
HLL       5
HRLI      2
HRLM      1
HLRZ      1
HRREI     783