ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 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   */                                 *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 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  *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 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    *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 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.      *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 5
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  221        PROCEDURE_DEPTH CONTAINS THE CURRENT NUMBER OF PROCEDURES NESTED.          *
  222        ALPHABET CONTAINS THE ABC'S IN UPPER CASE                                  *
  223     */                                                                            *
  224     DECLARE ALPHABET CHARACTER INITIAL ('ABCDEFGHIJKLMNOPQRSTUVWXYZ');            *
  225     DECLARE BUFFER CHARACTER, TEXT CHARACTER, TEXT_LIMIT FIXED,                   *
  226         CARD_COUNT FIXED, ERROR_COUNT FIXED,                                      *
  227         SEVERE_ERRORS FIXED, PREVIOUS_ERROR FIXED,                                *
  228         LINE_LENGTH  FIXED,         /* LENGTH OF SOURCE STATEMENT */              *
  229         CURRENT_PROCEDURE CHARACTER,                                              *
  230         PROCEDURE_DEPTH FIXED;                                                    *
  231                                                                                   *
  232     /* NUMBER_VALUE CONTAINS THE NUMERIC VALUE OF THE LAST CONSTANT SCANNED,      *
  233     */                                                                            *
  234     DECLARE NUMBER_VALUE FIXED, JBASE FIXED, BASE FIXED;                          *
  235     /* EACH OF THE FOLLOWING CONTAINS THE INDEX INTO V() OF THE CORRESPONDING     *
  236        SYMBOL.   WE ASK:    IF TOKEN = IDENT    ETC.    */                        *
  237     DECLARE IDENT FIXED, STRING FIXED, NUMBER FIXED, DIVIDE FIXED, EOFILE FIXED,  *
  238        LABELSET FIXED;                                                            *
  239     DECLARE ORSYMBOL FIXED, CONCATENATE FIXED;                                    *
  240     DECLARE BALANCE CHARACTER, LB FIXED ;                                         *
  241     DECLARE MACRO_LIMIT LITERALLY '60', MACRO_NAME (MACRO_LIMIT) CHARACTER,       *
  242        MACRO_TEXT(MACRO_LIMIT) CHARACTER, MACRO_INDEX (255) BIT (8),              *
  243        MACRO_COUNT (MACRO_LIMIT) FIXED, MACRO_DECLARE (MACRO_LIMIT) FIXED,        *
  244        TOP_MACRO FIXED;                                                           *
  245     DECLARE EXPANSION_COUNT FIXED, EXPANSION_LIMIT LITERALLY '300';               *
  246     /* STOPIT() IS A TABLE OF SYMBOLS WHICH ARE ALLOWED TO TERMINATE THE ERROR    *
  247        FLUSH PROCESS.  IN GENERAL THEY ARE SYMBOLS OF SUFFICIENT SYNTACTIC        *
  248        HIERARCHY THAT WE EXPECT TO AVOID ATTEMPTING TO START CHECKING AGAIN       *
  249        RIGHT INTO ANOTHER ERROR PRODUCING SITUATION.  THE TOKEN STACK IS ALSO     *
  250        FLUSHED DOWN TO SOMETHING ACCEPTABLE TO A STOPIT() SYMBOL.                 *
  251        FAILSOFT IS A BIT WHICH ALLOWS THE COMPILER ONE ATTEMPT AT A GENTLE        *
  252        RECOVERY.   THEN IT TAKES A STRONG HAND.   WHEN THERE IS REAL TROUBLE      *
  253        COMPILING IS SET TO FALSE, THEREBY TERMINATING THE COMPILATION.            *
  254     */                                                                            *
  255     DECLARE STOPIT(TERMINAL#) BIT(1), FAILSOFT FIXED, COMPILING FIXED;            *
  256     /*   THE FOLLOWING SWITCH IS USED BY THE LALR PARSER   */                     *
  257                                                                                   *
  258     DECLARE NO_LOOK_AHEAD_DONE BIT(1);                                            *
  259     DECLARE TARGET_REGISTER FIXED;       /* FOR FINDAR */                         *
  260     DECLARE TRUELOC FIXED;               /* LOCATION OF CONSTANT 1 */             *
  261     DECLARE FALSELOC FIXED;              /* LOCATION OF CONSTANT 0 */             *
  262     DECLARE BYTEPTRS FIXED,              /* LOCATION OF 4 PTRS FOR LDB & DPB */   *
  263             PSBITS FIXED;                /* BYTE PTRS FORE MOVE */                *
  264     DECLARE STRING_CHECK FIXED,          /* COMPACTIFY CALLER */                  *
  265             CATENTRY FIXED,              /* CATENATION SUBROUTINE */              *
  266             NMBRENTRY FIXED,             /* NUMBER TO STRING SUBROUTINE */        *
  267             STRCOMP FIXED,               /* STRING COMPARE SUBROUTINE */          *
  268             CALLTYPE FIXED INITIAL (1),  /* DIST BETWEEN SUB & FUNCTION */        *
  269             MOVER FIXED,                 /* STRING MOVE SUBROUTINE */             *
  270             STRING_RECOVER FIXED,        /* SYT LOCATION OF COMPACTIFY */         *
  271             COREBYTELOC FIXED,           /* SYT LOCATION OF COREBYTE */           *
  272             LIMITWORD FIXED,             /* ADDRESS OF FREELIMIT */               *
  273             TSA FIXED;                   /* ADDRESS OF FREEPOINT */               *
  274     DECLARE NDESC FIXED;                 /* ADDRESS OF NDESCRIPT               */ *
  275     DECLARE LIBRARY FIXED,               /* ADDRESS OF RUNTIME LIBRARY */         *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 6
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  276             LIBRARY_SAVE FIXED,          /* PLACE TO STORE R11 ON LIB CALLS */    *
  277             STR  FIXED;                  /* DESCRIPTOR OF LAST STRING */          *
  278     DECLARE STEPK FIXED;                 /* USED FOR DO LOOPS */                  *
  279     DECLARE A FIXED, B FIXED, C FIXED;   /* FOR CATENATION & CONVERSION */        *
  280     DECLARE LENGTHMASK FIXED;            /* ADDR OF DV LENGTH MASK */             *
  281     DECLARE ADDRMASK FIXED;              /* ADDRESS OF "FFFFF" */                 *
  282     DECLARE LABEL_SINK FIXED INITIAL(0); /* FOR LABEL GENERATOR */                *
  283     DECLARE LABEL_GEN CHARACTER;         /* CONTAINS LABEL FOR NEXT INST*/        *
  284     DECLARE ACC(15) FIXED;               /* KEEPS TRACK OF ACCUMULATORS */        *
  285     DECLARE AVAIL LITERALLY '0', BUSY LITERALLY '1';                              *
  286      /* CALL COUNTS OF IMPORTANT PROCEDURES */                                    *
  287     DECLARE COUNT_SCAN FIXED, /* SCAN               */                            *
  288              COUNT_INST FIXED,  /* EMITINST           */                          *
  289              COUNT_FORCE FIXED, /* FORCEACCUMULATOR   */                          *
  290              COUNT_ARITH FIXED, /* ARITHEMIT          */                          *
  291              COUNT_STORE FIXED; /* GENSTORE           */                          *
  292                                                                                   *
  293     DECLARE TITLE        CHARACTER,     /*TITLE LINE FOR LISTING */               *
  294             SUBTITLE     CHARACTER,     /*SUBTITLE FOR LISTING */                 *
  295             PAGE_COUNT   FIXED,         /*CURRENT PAGE NUMBER FOR LISTING*/       *
  296             LINE_COUNT   FIXED,         /*NUMBER OF LINES PRINTED */              *
  297             PAGE_MAX LITERALLY '54',    /*MAX NO OF LINES ON PAGE*/               *
  298             EJECT_PAGE LITERALLY 'LINE_COUNT = PAGE_MAX+1';                       *
  299     DECLARE SOURCE CHARACTER;           /*FILE NAME BEING COMPILED*/              *
  300     DECLARE DATAFILE LITERALLY '2';     /* SCRATCH FILE FOR DATA */               *
  301     DECLARE CODEFILE LITERALLY '3';     /* SCRATCH FILE FOR CODE */               *
  302     DECLARE RELFILE  LITERALLY '4';     /* BINARY OUTPUT FILE */                  *
  303     DECLARE LIBFILE  LITERALLY '5';     /* SOURCE LIBRARY FILE */                 *
  304     DECLARE READING  BIT(1);            /* 0 IFF READING LIBFILE */               *
  305     DECLARE DATACARD CHARACTER;         /* DATA BUFFER */                         *
  306     DECLARE PP      FIXED,              /* CURRENT PROGRAM POINTER */             *
  307             CODE(3) CHARACTER,           /* THE CODE BUFFER */                    *
  308             CODE_FULL(3) BIT(1),         /* FULLNESS FLAG */                      *
  309             CODE_HEAD FIXED,             /* FRONT OF BUFFER */                    *
  310             CODE_TAIL FIXED,             /* END OF BUFFER */                      *
  311             DP      FIXED,              /* CURRENT DATA POINTER */                *
  312             DPOFFSET FIXED;             /* CURRENT DP BYTE OFFSET */              *
  313     DECLARE CODESTRING CHARACTER;     /*FOR COPYING CODE INTO DATA FILE*/         *
  314                                                                                   *
  315     /*   THE FOLLOWING ARE FOR RELOCATABLE BINARY CODE EMISSION */                *
  316                                                                                   *
  317     DECLARE BUFFERSIZE LITERALLY '18';   /* SIZE OF BINARY BUFFERS */             *
  318     DECLARE CODE_BUFFER (BUFFERSIZE) FIXED;   /*CODE (HIGH) BUFFER */             *
  319     DECLARE DATA_BUFFER (BUFFERSIZE) FIXED;   /* DATA (LOW) BUFFER */             *
  320     DECLARE LABEL_BUFFER (BUFFERSIZE) FIXED;  /* LABELS DEFINED BUFFER */         *
  321     DECLARE CODE_REL(3) FIXED,         /* BINARY CODE BUFFER (SEE CODE) */        *
  322             CODE_PP(3) FIXED,                                                     *
  323             CODE_RBITS(3) FIXED;                                                  *
  324                                                                                   *
  325     DECLARE RPTR FIXED,                  /* POINTER TO CODE_BUFFER */             *
  326             RCTR FIXED,                  /* COUNTER FOR CODE_BUFFER */            *
  327             DPTR FIXED,                   /* POINTER TO DATA_BUFFER */            *
  328             DCTR FIXED,                  /* COUNTER FOR DATA_BUFFER */            *
  329             DLOC FIXED;                   /* LOCATION OF NEXT WORD IN DATA BUFFER */*
  330     DECLARE LABEL_COUNT FIXED;            /*NO OF LABELS IN LABEL_BUFFER */       *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 7
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  331                                                                                   *
  332     DECLARE FOR_MAX  LITERALLY '50';      /* MAXIMUM FORWARD REFERENCES */        *
  333     DECLARE FOR_REF   (FOR_MAX) FIXED,    /* FORWARD REFERENCED LABELS */         *
  334             FOR_LABEL (FOR_MAX) FIXED,    /* LABEL REFERENCED */                  *
  335             FOR_COUNT FIXED;              /* COUNT OF CURRENT FORWARD REFS */     *
  336     DECLARE PWORD FIXED;                  /* PART-WORD ACC. FOR BYTES*/           *
  337     DECLARE STARTLOC FIXED;               /* FIRST INSTRUCTION TO BE EXECUTED */  *
  338                                                                                   *
  339                                                                                   *
  340     DECLARE CODE_TYPE LITERALLY '"(3)1000000"';   /* CODE & DATA TYPE BLOCK */    *
  341     DECLARE SYMB_TYPE LITERALLY '"(3)2000000"';   /* SYMBOL DEFN TYPE BLOCK */    *
  342     DECLARE HISEG_TYPE LITERALLY '"(3)3000000"';  /* HIGH SEGMENT TYPE BLOCK */   *
  343     DECLARE END_TYPE LITERALLY '"(3)5000000"';    /* END TYPE BLOCK */            *
  344     DECLARE NAME_TYPE LITERALLY '"(3)6000000"';   /* NAME TYPE BLOCK */           *
  345     DECLARE START_TYPE LITERALLY '"(3)7000000"';  /* START ADDRESS TYPE BLOCK */  *
  346     DECLARE INTREQ_TYPE LITERALLY '"(3)10000000"'; /* INTERNAL REQUEST TYPE BLOCK */*
  347                                                                                   *
  348                                                                                   *
  349     /* END OF DEFINITIONS FOR RELOCATABLE BINARY FILES */                         *
  350                                                                                   *
  351     DECLARE ADR     FIXED;                                                        *
  352     DECLARE ITYPE FIXED;                                                          *
  353     DECLARE NEWDP FIXED, NEWDSP FIXED, NEWDPOFFSET FIXED; /* FOR ALLOCATION */    *
  354     DECLARE OLDDP FIXED, OLDDSP FIXED, OLDDPOFFSET FIXED; /* FOR ALLOCATION */    *
  355     DECLARE DESCLIMIT LITERALLY '1000', /* NUMBER OF STRING DESCRIPTORS */        *
  356             DESCA (DESCLIMIT) FIXED,     /* STRING DESCRIPTOR ADDRESS */          *
  357             DESCL (DESCLIMIT) FIXED,     /* STRING DESCRIPTOR LENGTH */           *
  358             DESCREF (DESCLIMIT) FIXED,    /* LAST REFERENCE TO STRING */          *
  359             DSP     FIXED;              /* DESCRIPTOR POINTER */                  *
  360     DECLARE S CHARACTER;                                                          *
  361     DECLARE OPNAME (15) CHARACTER INITIAL (                                       *
  362  '      .INIT..INPT..OUTP..EXIT.      .FILI..FILO..NAME.',                        *
  363  'CALL  INIT  UUO042UUO043UUO044UUO045UUO046CALLI OPEN  TTCALLUUO052UUO053UUO054  *
  364  RENAMEIN    OUT   SETSTSSTATO GETSTSSTATZ INBUF OUTBUFINPUT OUTPUTCLOSE          *
  365  RELEASMTAPE UGETF USETI USETO LOOKUPENTER ',                                     *
  366  'UUO100UUO101UUO102UUO103UUO104UUO105UUO106UUO107UUO110UUO111UUO112UUO113UUO114U *
  367  UO115UUO116UUO117UUO120UUO121UUO122UUO123UUO124UUO125UUO126UUO127UFA   DFN   FSC *
  368     IBP   ILDB  LDB   IDPB  DPB   ',                                              *
  369  '',                                                                              *
  370  'MOVE  MOVEI MOVEM MOVES MOVS  MOVSI MOVSM MOVSS MOVN  MOVNI MOVNM MOVNS MOVM  M *
  371  OVMI MOVMM MOVMS IMUL  IMULI IMULM IMULB MUL   MULI  MULM  MULB  IDIV  IDIVI IDI *
  372  VM IDIVB DIV   DIVI  DIVM  DIVB  ',                                              *
  373  'ASH   ROT   LSH   JFFO  ASHC  ROTC  LSHC  ......EXCH  BLT   AOBJP AOBJN JRST  J *
  374  FCL  XCT   ......PUSHJ PUSH  POP   POPJ  JSR   JSP   JSA   JRA   ADD   ADDI  ADD *
  375  M  ADDB  SUB   SUBI  SUBM  SUBB  ',                                              *
  376  'CAI   CAIL  CAIE  CAILE CAIA  CAIGE CAIN  CAIG  CAM   CAML  CAME  CAMLE CAMA  C *
  377  AMGE CAMN  CAMG  JUMP  JUMPL JUMPE JUMPLEJUMPA JUMPGEJUMPN JUMPG SKIP  SKIPL SKI *
  378  PE SKIPLESKIPA SKIPGESKIPN SKIPG ',                                              *
  379   'AOJ   AOJL  AOJE  AOJLE AOJA  AOJGE AOJN  AOJG  AOS   AOSL  AOSE  AOSLE AOSA  A*
  380  OSGE AOSN  AOSG  SOJ   SOJL  SOJE  SOJLE SOJA  SOJGE SOJN  SOJG  SOS   SOSL  SOS *
  381  E  SOSLE SOSA  SOSGE SOSN  SOSG  ',                                              *
  382  'SETZ  SETZI SETZM SETZB AND   ANDI  ANMD  ANDB  ANDCA ANDCAIANDCAMANDCABSETM  S *
  383  ETMI SETMM SETMB ANDCM ANDCMIANDCMMANDCMBSETA  SETAI SETAM SETAB XOR   XORI  XOR *
  384  M  XORB  IOR   IORI  IORM  IORB  ',                                              *
  385  'ANDCB ANDCBIANDCBMANDCBBEQV   EQVI  EQVM  EQVB  SETCA SETCAISETCAMSETCABORCA  O *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 8
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  386  RCAI ORCAM ORCAB SETCM SETCMISETCMMSETCMBORCM  ORCMI ORCMM ORCMB ORCB  ORCBI ORC *
  387  BM ORCBB SETO  SETOI SETOM SETOB ',                                              *
  388  'HLL   HLLI  HLLM  HLLS  HRL   HRLI  HRLM  HRLS  HLLZ  HLLZI HLLZM HLLZS HRLZ  H *
  389  RLZI HRLZM HRLZS HLLO  HLLOI HLLOM HLLOS HRLO  HRLOI HRLOM HRLOS HLLE  HLLEI HLL *
  390  EM HLLES HRLE  HRLEI HRLEM HRLES ',                                              *
  391  'HRR   HRRI  HRRM  HRRS  HLR   HLRI  HLRM  HLRS  HRRZ  HRRZI HRRZM HRRZS HLRZ  H *
  392  LRZI HLRZM HLRZS HRRO  HRROI HRROM HRROS HLRO  HLROI HLROM HLROS HRRE  HRREI HRR *
  393  EM HRRES HLRE  HLREI HLREM HLRES ',                                              *
  394  'TRN   TLN   TRNE  TLNE  TRNA  TLNA  TRNN  TLNN  TDN   TSN   TDNE  TSNE  TDNA  T *
  395  SNA  TDNN  TSNN  TRZ   TLZ   TRZE  TLZE  TRZA  TLZA  TRZN  TLZN  TDZ   TSZ   TDZ *
  396  E  TSZE  TDZA  TSZA  TDZN  TSZN  ',                                              *
  397  'TRC   TLC   TRCE  TLCE  TRCA  TLCA  TRCN  TLCN  TDC   TSC   TDCE  TSCE  TDCA  T *
  398  SCA  TDCN  TSCN  TRO   TLO   TROE  TLOE  TROA  TLOA  TRON  TLON  TDO   TSO   TDO *
  399  E  TSOE  TDOA  TSOA  TDON  TSON  ',                                              *
  400  '',                                                                              *
  401  '');                                                                             *
  402     DECLARE INSTRUCT(511) FIXED;         /* COUNT OF THE INSTRUCTIONS ISSUED */   *
  403           /* COMMONLY USED OPCODES */                                             *
  404     DECLARE ADD    FIXED INITIAL ("(3)270"),                                      *
  405             ADDI   FIXED INITIAL ("(3)271"),                                      *
  406             ADDM   FIXED INITIAL ("(3)272"),                                      *
  407             AND    FIXED INITIAL ("(3)404"),                                      *
  408             ANDI   FIXED INITIAL ("(3)405"),                                      *
  409             AOSA   FIXED INITIAL ("(3)354"),                                      *
  410             BLT    FIXED INITIAL ("(3)251"),                                      *
  411             CALLI  FIXED INITIAL ("(3)047"),                                      *
  412             CAM    FIXED INITIAL ("(3)310"),                                      *
  413             CAMGE  FIXED INITIAL ("(3)315"),                                      *
  414             CAML   FIXED INITIAL ("(3)311"),                                      *
  415             CAMLE  FIXED INITIAL ("(3)313"),                                      *
  416             CAMN   FIXED INITIAL ("(3)316"),                                      *
  417             CMPRHI FIXED INITIAL ("(3)317"),                                      *
  418             DPB    FIXED INITIAL ("(3)137"),                                      *
  419             HLL    FIXED INITIAL ("(3)500"),                                      *
  420             HLRZ   FIXED INITIAL ("(3)554"),                                      *
  421             HRLI   FIXED INITIAL ("(3)505"),                                      *
  422             HRLM   FIXED INITIAL ("(3)506"),                                      *
  423             HRREI  FIXED INITIAL ("(3)571"),                                      *
  424             IDIV   FIXED INITIAL ("(3)230"),                                      *
  425             IDIVI  FIXED INITIAL ("(3)231"),                                      *
  426             IDPB   FIXED INITIAL ("(3)136"),                                      *
  427             ILDB   FIXED INITIAL ("(3)134"),                                      *
  428             IMUL   FIXED INITIAL ("(3)220"),                                      *
  429             IOR    FIXED INITIAL ("(3)434"),                                      *
  430             JRST   FIXED INITIAL ("(3)254"),                                      *
  431             JUMP   FIXED INITIAL ("(3)320"),                                      *
  432             JUMPE  FIXED INITIAL ("(3)322"),                                      *
  433             JUMPGE FIXED INITIAL ("(3)325"),                                      *
  434             JUMPN  FIXED INITIAL ("(3)326"),                                      *
  435             LDB    FIXED INITIAL ("(3)135"),                                      *
  436             LSH    FIXED INITIAL ("(3)242"),                                      *
  437             LSHC   FIXED INITIAL ("(3)246"),                                      *
  438             MOVE   FIXED INITIAL ("(3)200"),                                      *
  439             MOVEI  FIXED INITIAL ("(3)201"),                                      *
  440             MOVEM  FIXED INITIAL ("(3)202"),                                      *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 9
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  441             MOVM   FIXED INITIAL ("(3)214"),                                      *
  442             MOVN   FIXED INITIAL ("(3)210"),                                      *
  443             POP    FIXED INITIAL ("(3)262"),                                      *
  444             POPJ   FIXED INITIAL ("(3)263"),                                      *
  445             PUSH   FIXED INITIAL ("(3)261"),                                      *
  446             PUSHJ  FIXED INITIAL ("(3)260"),                                      *
  447             ROT    FIXED INITIAL ("(3)241"),                                      *
  448             SETCA  FIXED INITIAL ("(3)450"),                                      *
  449             SETZM  FIXED INITIAL ("(3)402"),                                      *
  450             SKIP   FIXED INITIAL ("(3)330"),                                      *
  451             SKIPE  FIXED INITIAL ("(3)332"),                                      *
  452             SOJG   FIXED INITIAL ("(3)367"),                                      *
  453             SUB    FIXED INITIAL ("(3)274"),                                      *
  454             SUBI   FIXED INITIAL ("(3)275");                                      *
  455     DECLARE COMPARESWAP (7) FIXED INITIAL (0,7,2,5,0,3,6,1);                      *
  456     DECLARE STILLCOND FIXED,            /* PEEP HOLE FOR BOOL BRANCHING */        *
  457             STILLINZERO FIXED;          /* PEEPHOLE FOR REDUNDANT MOVES */        *
  458     DECLARE STATEMENT_COUNT FIXED;      /* A COUNT OF THE XPL STATEMENTS */       *
  459     DECLARE IDCOMPARES FIXED;                                                     *
  460     DECLARE X1 CHARACTER INITIAL (' ');                                           *
  461     DECLARE X2 CHARACTER INITIAL ('  ');                                          *
  462     DECLARE X3 CHARACTER INITIAL ('   ');                                         *
  463     DECLARE X4 CHARACTER INITIAL ('    ');                                        *
  464     DECLARE X7 CHARACTER INITIAL ('       ');                                     *
  465     DECLARE INFO CHARACTER;         /* FOR LISTING INFORMATION*/                  *
  466     DECLARE CHAR_TEMP CHARACTER;                                                  *
  467     DECLARE I_STRING CHARACTER;      /* FOR I_FORMAT */                           *
  468     DECLARE I FIXED, J FIXED, K FIXED, L FIXED;                                   *
  469     DECLARE PROCMARK FIXED, NDECSY FIXED, MAXNDECSY FIXED, PARCT FIXED;           *
  470     DECLARE RETURNED_TYPE FIXED;                                                  *
  471     DECLARE LABELTYPE     LITERALLY  '1',                                         *
  472             ACCUMULATOR   LITERALLY  '2',                                         *
  473             VARIABLE      LITERALLY  '3',                                         *
  474             CONSTANT      LITERALLY  '4',                                         *
  475             CHRTYPE       LITERALLY  '6',                                         *
  476             FIXEDTYPE     LITERALLY  '7',                                         *
  477             BYTETYPE      LITERALLY  '8',                                         *
  478             FORWARDTYPE   LITERALLY  '9',                                         *
  479             DESCRIPT      LITERALLY '10',                                         *
  480             SPECIAL       LITERALLY '11',                                         *
  481             FORWARDCALL   LITERALLY '12',                                         *
  482             PROCTYPE      LITERALLY '13',                                         *
  483             CHARPROCTYPE  LITERALLY '14';                                         *
  484     DECLARE TYPENAME (14) CHARACTER INITIAL ('', 'LABEL    ', '', '', '', '',     *
  485             'CHARACTER', 'FIXED    ', 'BIT (9)  ' , '', '', '', '',               *
  486             'PROCEDURE','CHARACTER PROCEDURE');                                   *
  487     /*  THE SYMBOL TABLE IS INITIALIZED WITH THE NAMES OF ALL                     *
  488         BUILTIN FUNCTIONS AND PSEUDO VARIABLES.  THE PROCEDURE                    *
  489         INITIALIZE DEPENDS ON THE ORDER AND PLACEMENT OF THESE                    *
  490         NAMES.  CHANGES SHOULD BE MADE OBSERVING DUE CAUTION TO                   *
  491         AVOID MESSING THINGS UP.                                                  *
  492     */                                                                            *
  493     DECLARE SYTSIZE LITERALLY '420';     /* THE SYMBOL TABLE SIZE */              *
  494     DECLARE SYT (SYTSIZE) CHARACTER      /* THE VARIABLE NAME */                  *
  495        INITIAL ('COREWORD', 'COREBYTE', 'FREEPOINT', 'DESCRIPTOR',                *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 10
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  496           'NDESCRIPT',   'LENGTH', 'SUBSTR', 'BYTE', 'SHL', 'SHR',                *
  497           'INPUT', 'OUTPUT', 'FILE', 'INLINE', 'TRACE', 'UNTRACE',                *
  498           'EXIT', 'TIME', 'DATE', 'CLOCK_TRAP', 'INTERRUPT_TRAP',                 *
  499           'MONITOR', 'ADDR', 'RUNTIME', 'FILENAME',                               *
  500           'COMPACTIFY', 'FREELIMIT', 'FREEBASE');                                 *
  501     DECLARE SYTYPE (SYTSIZE) BIT (8)     /* TYPE OF VARIABLE */                   *
  502        INITIAL (FIXEDTYPE, BYTETYPE, FIXEDTYPE, FIXEDTYPE,                        *
  503           FIXEDTYPE, SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                 *
  504           SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                   *
  505            SPECIAL, SPECIAL, SPECIAL, SPECIAL, SPECIAL,                           *
  506           SPECIAL, SPECIAL, SPECIAL, SPECIAL,                                     *
  507           FORWARDCALL, FIXEDTYPE, FIXEDTYPE);                                     *
  508     DECLARE SYTLOC (SYTSIZE) FIXED       /* LOCATION OF VARIABLE */               *
  509        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,     *
  510            0,0,0);                                                                *
  511     DECLARE SYTSEG (SYTSIZE) BIT(8)      /* SEGMENT OF VARIABLE */                *
  512        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);         *
  513     DECLARE SYTCO (SYTSIZE) FIXED;       /* A COUNT OF REFERENCES */              *
  514     DECLARE SYTCARD (SYTSIZE) FIXED;     /* WHERE SYMBOL IS DEFINED */            *
  515                                                                                   *
  516     DECLARE HASH (255)      FIXED,       /* HASH TABLE INTO SYMBOL TABLE*/        *
  517             PTR  (SYTSIZE)  FIXED,       /* POINTS TO NEXT SYMBOL IN HASH*/       *
  518             IDX             FIXED;       /* INDEX WHILE USING HASH*/              *
  519                                                                                   *
  520     /*  THE COMPILER STACKS DECLARED BELOW ARE USED TO DRIVE THE SYNTACTIC        *
  521        ANALYSIS ALGORITHM AND STORE INFORMATION RELEVANT TO THE INTERPRETATION    *
  522        OF THE TEXT.  THE STACKS ARE ALL POINTED TO BY THE STACK POINTER SP.  */   *
  523     DECLARE STACKSIZE LITERALLY '50';  /* SIZE OF STACK  */                       *
  524     DECLARE STATE_STACK (STACKSIZE)  BIT (8);                                     *
  525     DECLARE TYPE        (STACKSIZE)  FIXED;                                       *
  526     DECLARE REG         (STACKSIZE)  FIXED;                                       *
  527     DECLARE INX         (STACKSIZE)  FIXED;                                       *
  528     DECLARE CNT         (STACKSIZE)  FIXED;                                       *
  529     DECLARE VAR         (STACKSIZE)  CHARACTER;                                   *
  530     DECLARE FIXV        (STACKSIZE)  FIXED;                                       *
  531     DECLARE PPSAVE      (STACKSIZE)  FIXED;                                       *
  532     DECLARE FIXL        (STACKSIZE)  FIXED;                                       *
  533     DECLARE SP FIXED, MP FIXED, MPP1 FIXED;                                       *
  534                                                                                   *
  535     DECLARE CASELIMIT LITERALLY '175',                                            *
  536             CASESTACK (CASELIMIT) FIXED, /* CONTAINS ADDR OF STMTS OF CASE */     *
  537             CASEP  FIXED;                /* POINTS TO CURRENT CASESTACK ENTRY */  *
  538                                                                                   *
  539     DECLARE CODEMSG  CHARACTER INITIAL ('CODE = '),                               *
  540             DATAMSG  CHARACTER INITIAL ('DATA = '),                               *
  541             BACKMSG  CHARACTER INITIAL ('BACK UP CODE EMITTER'),                  *
  542             FILEMSG  CHARACTER INITIAL ('MISSING NUMBER FOR FILE');               *
  543                                                                                   *
  544                                                                                   *
  545  /*                                                                               *
  546            G L O B A L   P R O C E D U R E S                                      *
  547  */                                                                               *
  548                                                                                   *
  549  I_FORMAT:                                                                        *
  550     PROCEDURE (NUMBER, WIDTH);                                                    *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 11
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  551     DECLARE NUMBER  FIXED,                                                         I_FORMAT
  552             WIDTH   FIXED;                                                         I_FORMAT
  553     DECLARE L       FIXED;                                                         I_FORMAT
  554     I_STRING = NUMBER;                                                             I_FORMAT
  555     L = LENGTH (I_STRING);                                                         I_FORMAT
  556     IF L < WIDTH THEN                                                              I_FORMAT
  557           I_STRING = SUBSTR(X70,0,WIDTH-L) ^^ I_STRING;                            I_FORMAT
  558     END  I_FORMAT;                                                                 I_FORMAT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
L               FIXED      9121     DATA    553       3
NUMBER          FIXED      9119     DATA    550       1
WIDTH           FIXED      9120     DATA    550       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 12
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  559                                                                                   *
  560  PRINTLINE:                                                                       *
  561     PROCEDURE (LINE, IND);                                                        *
  562     DECLARE LINE CHARACTER,             /*LINE TO BE PRINTED */                    PRINTLINE
  563             IND FIXED;                  /*FORMAT INDICATOR*/                       PRINTLINE
  564     DECLARE CTL(5) CHARACTER INITIAL ('0','1','','','','');                        PRINTLINE
  565     DECLARE SKIPS (5) FIXED INITIAL (2,99,0,0,0,0);                                PRINTLINE
  566     IF LINE_COUNT > PAGE_MAX THEN                                                  PRINTLINE
  567        DO;                                                                         PRINTLINE
  568           PAGE_COUNT = PAGE_COUNT + 1;                                             PRINTLINE
  569           OUTPUT(1) = TITLE ^^ PAGE_COUNT;                                         PRINTLINE
  570           OUTPUT = SUBTITLE;                                                       PRINTLINE
  571           OUTPUT = ' ';                                                            PRINTLINE
  572           LINE_COUNT = 0;                                                          PRINTLINE
  573        END;                                                                        PRINTLINE
  574     IF IND < 0 ^ IND > 5 THEN                                                      PRINTLINE
  575        DO;                                                                         PRINTLINE
  576           OUTPUT = LINE;                                                           PRINTLINE
  577           LINE_COUNT = LINE_COUNT + 1;                                             PRINTLINE
  578        END;                                                                        PRINTLINE
  579     ELSE                                                                           PRINTLINE
  580        DO;                                                                         PRINTLINE
  581           OUTPUT(1) = CTL(IND) ^^ LINE;                                            PRINTLINE
  582           LINE_COUNT = LINE_COUNT + SKIPS(IND);                                    PRINTLINE
  583        END;                                                                        PRINTLINE
  584  END PRINTLINE;                                                                    PRINTLINE

SYMBOL TABLE DUMP

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

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9132     DATA    592       2
MSG             CHARACTER   761   STRING    586       4
SEVERITY        FIXED      9131     DATA    586       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 14
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  617     /*                THE SCANNER PROCEDURES              */                      *
  618     BUILD_BCD:                                                                    *
  619        PROCEDURE (C);                                                             *
  620        DECLARE C BIT(9);                                                           BUILD_BCD
  621        IF LENGTH(BCD) > 0 THEN BCD = BCD ^^ X1;                                    BUILD_BCD
  622        ELSE BCD = SUBSTR(X1 ^^ X1, 1);                                             BUILD_BCD
  623        COREBYTE(FREEPOINT-1) = C;                                                  BUILD_BCD C5 = 134217727
  624     END BUILD_BCD;                                                                 BUILD_BCD

SYMBOL TABLE DUMP

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

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9159     DATA    628      27
TEMP2           CHARACTER   766   STRING    628       7
TEMPO           CHARACTER   765   STRING    628      15
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 17
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  710     CHAR:                                                                         *
  711        PROCEDURE;                                                                 *
  712        CP = CP + 1;                                                                CHAR
  713        IF CP <= TEXT_LIMIT THEN RETURN;                                            CHAR
  714        CP = 0;                                                                     CHAR
  715        TEXT = '';                                                                  CHAR
  716        CALL GET_CARD;                                                              CHAR
  717     END CHAR;                                                                      CHAR
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 18
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  718     DEBLANK:                                                                      *
  719        PROCEDURE;                                                                 *
  720        CALL CHAR;                                                                  DEBLANK
  721        DO WHILE BYTE (TEXT, CP) = BYTE (' ');                                      DEBLANK
  722           CALL CHAR;                                                               DEBLANK
  723        END;                                                                        DEBLANK
  724     END DEBLANK;                                                                   DEBLANK
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 19
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  725     BCHAR:                                                                        *
  726        PROCEDURE;                                                                 *
  727        DO FOREVER;                                                                 BCHAR
  728           CALL DEBLANK;                                                            BCHAR
  729           CH = BYTE(TEXT, CP);                                                     BCHAR
  730           IF CH \= BYTE ('(') THEN RETURN;                                         BCHAR
  731           /*  (BASE WIDTH)  */                                                     BCHAR
  732            CALL DEBLANK;                                                           BCHAR
  733           JBASE = BYTE (TEXT, CP) - BYTE ('0');  /* WIDTH */                       BCHAR
  734           IF JBASE < 1 ^ JBASE > 4 THEN                                            BCHAR
  735              DO;                                                                   BCHAR
  736                 CALL ERROR ('ILLEGAL BIT STRING WIDTH: ' ^^ SUBSTR(TEXT,CP,1),0);  BCHAR
  737                 JBASE = 4;  /* DEFAULT WIDTH FOR ERROR */                          BCHAR C7 = 134217728
  738              END;                                                                  BCHAR
  739           BASE = SHL(1, JBASE);                                                    BCHAR
  740           CALL DEBLANK;                                                            BCHAR
  741          IF BYTE(TEXT,CP)\=BYTE(')')THEN CALL ERROR('MISSING ) IN BIT STRING',0);  BCHAR
  742        END;                                                                        BCHAR
  743     END BCHAR;                                                                     BCHAR
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 20
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  744                                                                                   *
  745     LOWUP:       /* CONVERT S TO UPPER CASE */                                    *
  746       PROCEDURE (S) CHARACTER;                                                    *
  747       DECLARE (S,T) CHARACTER;                                                     LOWUP
  748       T = '';                                                                      LOWUP
  749       DO I = 0 TO LENGTH(S)-1;                                                     LOWUP
  750          IF BYTE(S,I) > 96 THEN                                                    LOWUP
  751             T = T ^^ SUBSTR(ALPHABET,BYTE(S,I)-97,1);                              LOWUP
  752          ELSE                                                                      LOWUP
  753             T = T ^^ SUBSTR(S,I,1);                                                LOWUP
  754          END;                                                                      LOWUP
  755       RETURN T;                                                                    LOWUP
  756       END LOWUP;                                                                   LOWUP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
S               CHARACTER   772   STRING    746       4
T               CHARACTER   773   STRING    747       6
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 21
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  757                                                                                   *
  758     SCAN:                                                                         *
  759        PROCEDURE;     /* GET THE NEXT TOKEN FROM THE TEXT  */                     *
  760        DECLARE S1 FIXED, S2 FIXED;                                                 SCAN
  761     DECLARE LSTRNGM CHARACTER INITIAL ('STRING TOO LONG');                         SCAN
  762     DECLARE LBITM CHARACTER INITIAL ('BIT STRING TOO LONG');                       SCAN
  763      COUNT_SCAN = COUNT_SCAN + 1;                                                  SCAN
  764        FAILSOFT = TRUE;                                                            SCAN
  765        BCD = '';  NUMBER_VALUE = 0;                                                SCAN
  766     RESCAN:                                                                        SCAN
  767        IF CP > TEXT_LIMIT THEN                                                     SCAN
  768           DO;                                                                      SCAN
  769              TEXT = '';                                                            SCAN
  770              CALL GET_CARD;                                                        SCAN
  771           END;                                                                     SCAN
  772        ELSE                                                                        SCAN
  773           DO;                                                                      SCAN
  774              TEXT_LIMIT = TEXT_LIMIT - CP;                                         SCAN
  775              TEXT = SUBSTR(TEXT, CP);                                              SCAN
  776           END;                                                                     SCAN
  777        CP = 0;                                                                     SCAN
  778     /*  BRANCH ON NEXT CHARACTER IN TEXT                  */                       SCAN
  779        DO CASE CHARTYPE(BYTE(TEXT));                                               SCAN
  780           /*  CASE 0  */                                                           SCAN CASE 0.
  781           /* ILLEGAL CHARACTERS FALL HERE  */                                      SCAN
  782           CALL ERROR ('ILLEGAL CHARACTER: ' ^^ SUBSTR (TEXT, 0, 1) ^^              SCAN
  783              '  (' ^^ BYTE(TEXT) ^^ ')', 0);                                       SCAN
  784           /*  CASE 1  */                                                           SCAN CASE 1.
  785           /*  BLANK  */                                                            SCAN
  786           DO CP = 1 TO TEXT_LIMIT;                                                 SCAN
  787              IF BYTE (TEXT, CP) \= BYTE (' ') THEN GOTO RESCAN;                    SCAN
  788           END;                                                                     SCAN
  789           /*  CASE 2  */                                                           SCAN CASE 2.
  790           DO FOREVER;   /* STRING QUOTE ('):  CHARACTER STRING       */            SCAN
  791              TOKEN = STRING;                                                       SCAN
  792              DO CP = CP + 1 TO TEXT_LIMIT;                                         SCAN
  793                 IF BYTE (TEXT, CP) = BYTE ('''') THEN                              SCAN
  794                    DO;                                                             SCAN
  795                       IF LENGTH(BCD) + CP > 257 THEN                               SCAN
  796                          DO;                                                       SCAN
  797                             CALL ERROR (LSTRNGM, 0);                               SCAN
  798                             RETURN;                                                SCAN
  799                          END;                                                      SCAN
  800                       IF CP > 1 THEN                                               SCAN
  801                       BCD = BCD ^^ SUBSTR(TEXT, 1, CP-1);                          SCAN
  802                       CALL CHAR;                                                   SCAN
  803                        IF BYTE (TEXT, CP) = BYTE ('''') THEN                       SCAN
  804                           IF LENGTH(BCD) = 255 THEN                                SCAN
  805                             DO;                                                    SCAN
  806                               CALL ERROR (LSTRNGM, 0);                             SCAN
  807                               RETURN;                                              SCAN
  808                             END;                                                   SCAN
  809                          ELSE                                                      SCAN
  810                             DO;                                                    SCAN
  811                                BCD = BCD ^^ SUBSTR(TEXT, CP, 1);                   SCAN
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 22
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  812                                GO TO RESCAN;                                       SCAN
  813                             END;                                                   SCAN
  814                       RETURN;                                                      SCAN
  815                    END;                                                            SCAN
  816              END;                                                                  SCAN
  817              /*  WE HAVE RUN OFF A CARD  */                                        SCAN
  818              IF LENGTH(BCD) + CP > 257 THEN                                        SCAN
  819                 DO;                                                                SCAN
  820                   CALL ERROR (LSTRNGM, 0);                                         SCAN
  821                   RETURN;                                                          SCAN
  822                 END;                                                               SCAN
  823              IF CP > 1 THEN BCD = BCD ^^ SUBSTR(TEXT, 1, CP-1);                    SCAN
  824              TEXT = X1;                                                            SCAN
  825              CP = 0;                                                               SCAN
  826              CALL GET_CARD;                                                        SCAN
  827           END;                                                                     SCAN
  828           /*  CASE 3  */                                                           SCAN CASE 3.
  829           DO;      /*  BIT QUOTE("):  BIT STRING  */                               SCAN
  830              JBASE = 4;  BASE = 16;  /* DEFAULT WIDTH */                           SCAN
  831              TOKEN = NUMBER;                                                       SCAN
  832              S1 = 0;                                                               SCAN
  833              CALL BCHAR;                                                           SCAN
  834              DO WHILE CH \= BYTE ('"');                                            SCAN
  835                 S1 = S1 + JBASE;                                                   SCAN
  836                 IF CH >= BYTE ('0') & CH <= BYTE ('9') THEN S2 = CH - BYTE ('0');  SCAN
  837                 ELSE S2 = CH + 10 - BYTE ('A');                                    SCAN
  838                 IF S2 >= BASE ^ S2 < 0 THEN                                        SCAN
  839                    CALL ERROR ('ILLEGAL CHARACTER IN BIT STRING: '                 SCAN
  840                    ^^ SUBSTR(TEXT, CP, 1), 0);                                     SCAN
  841                 IF S1 > 36 THEN TOKEN = STRING;                                    SCAN
  842                 IF TOKEN = STRING THEN                                             SCAN
  843                    DO WHILE S1 - JBASE >= 9;                                       SCAN
  844                       IF LENGTH(BCD) >= 255 THEN                                   SCAN
  845                          DO;                                                       SCAN
  846                             CALL ERROR ( LBITM, 0);                                SCAN
  847                             RETURN;                                                SCAN
  848                          END;                                                      SCAN
  849                       S1 = S1 - 9;                                                 SCAN
  850                       CALL BUILD_BCD (SHR(NUMBER_VALUE, S1-JBASE));                SCAN
  851                    END;                                                            SCAN
  852                 NUMBER_VALUE = SHL(NUMBER_VALUE, JBASE) + S2;                      SCAN
  853                 CALL BCHAR;                                                        SCAN
  854              END;     /* OF DO WHILE CH...  */                                     SCAN
  855              CP = CP + 1;                                                          SCAN
  856              IF TOKEN = STRING THEN                                                SCAN
  857                 IF LENGTH(BCD) >= 255 THEN CALL ERROR (LBITM,0);                   SCAN
  858                 ELSE CALL BUILD_BCD (SHL(NUMBER_VALUE, 9 - S1));                   SCAN
  859               RETURN;                                                              SCAN
  860           END;                                                                     SCAN
  861           /*  CASE 4  */                                                           SCAN CASE 4.
  862           DO FOREVER;   /*  A LETTER:  IDENTIFIERS AND RESERVED WORDS  */          SCAN
  863              DO CP = CP + 1 TO TEXT_LIMIT;                                         SCAN
  864                 IF NOT_LETTER_OR_DIGIT(BYTE(TEXT, CP)) THEN                        SCAN
  865                    DO;  /* END OF IDENTIFIER  */                                   SCAN
  866                       BCD = LOWUP(SUBSTR(TEXT, 0, CP));                            SCAN
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 23
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  867                       IF CP > 1 THEN IF CP <= RESERVED_LIMIT THEN                  SCAN
  868                          /* CHECK FOR RESERVED WORDS */                            SCAN
  869                          DO I = 1 TO TERMINAL#;                                    SCAN
  870                             IF BCD = VOCAB(I) THEN                                 SCAN C8 = 42
  871                                DO;                                                 SCAN
  872                                   TOKEN = I;                                       SCAN
  873                                   RETURN;                                          SCAN
  874                                END;                                                SCAN
  875                          END;                                                      SCAN
  876                       DO I = MACRO_INDEX(CP-1) TO MACRO_INDEX(CP) - 1;             SCAN
  877                          IF BCD = MACRO_NAME(I) THEN                               SCAN
  878                             DO;                                                    SCAN
  879                              MACRO_COUNT(I) = MACRO_COUNT(I) + 1;                  SCAN
  880                                BCD = MACRO_TEXT(I);                                SCAN
  881                                IF EXPANSION_COUNT < EXPANSION_LIMIT THEN           SCAN
  882                                   EXPANSION_COUNT = EXPANSION_COUNT + 1;           SCAN
  883                                ELSE CALL PRINTLINE ('** WARNING, TOO MANY EXPANSIONS FOR SCAN
  884   THE MACRO: ' ^^ BCD,-1);                                                         SCAN
  885                                TEXT = SUBSTR(TEXT, CP);                            SCAN
  886                                TEXT_LIMIT = TEXT_LIMIT - CP;                       SCAN
  887                                IF LENGTH(BCD) + TEXT_LIMIT > 255 THEN              SCAN
  888                                   DO;                                              SCAN
  889                                      IF LB + TEXT_LIMIT > 255 THEN                 SCAN
  890                                         CALL ERROR('MACRO EXPANSION TOO LONG',0);  SCAN
  891                                      ELSE                                          SCAN
  892                                         DO;                                        SCAN
  893                                            BALANCE = TEXT ^^ BALANCE;              SCAN
  894                                            LB = LENGTH(BALANCE);                   SCAN
  895                                            TEXT = BCD;                             SCAN
  896                                         END;                                       SCAN
  897                                   END;                                             SCAN
  898                                ELSE TEXT = BCD ^^ TEXT;                            SCAN
  899                                BCD = '';                                           SCAN
  900                                TEXT_LIMIT = LENGTH(TEXT) - 1;                      SCAN
  901                                CP = 0;                                             SCAN
  902                                GO TO RESCAN;                                       SCAN
  903                             END;                                                   SCAN
  904                       END;                                                         SCAN
  905                       /*  RESERVED WORDS EXIT HIGHER:  THEREFORE <IDENTIFIER> */   SCAN
  906                       TOKEN = IDENT;                                               SCAN
  907                       RETURN;                                                      SCAN
  908                    END;                                                            SCAN
  909              END;                                                                  SCAN
  910              /*  END OF CARD  */                                                   SCAN
  911              CALL GET_CARD;                                                        SCAN
  912              CP = CP - 1;                                                          SCAN
  913           END;                                                                     SCAN
  914           /*  CASE 5  */                                                           SCAN CASE 5.
  915            DO FOREVER;   /*  DIGIT:  A NUMBER  */                                  SCAN
  916              TOKEN = NUMBER;                                                       SCAN
  917              DO CP = CP TO TEXT_LIMIT;                                             SCAN
  918                 S1 = BYTE(TEXT, CP);                                               SCAN
  919                 IF S1 < BYTE ('0') ^ S1 > BYTE ('9') THEN RETURN;                  SCAN
  920                 NUMBER_VALUE = 10 * NUMBER_VALUE + S1 - BYTE ('0');                SCAN
  921              END;                                                                  SCAN
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 24
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  922              CALL GET_CARD;                                                        SCAN
  923           END;                                                                     SCAN
  924           /*  CASE 6  */                                                           SCAN CASE 6.
  925           DO;      /*  A /:  MAY BE DIVIDE OR START OF COMMENT  */                 SCAN
  926              CALL CHAR;                                                            SCAN
  927              IF BYTE (TEXT, CP) \= BYTE ('*') THEN                                 SCAN
  928                 DO;                                                                SCAN
  929                    TOKEN = DIVIDE;                                                 SCAN
  930                    RETURN;                                                         SCAN
  931                 END;                                                               SCAN
  932              /* WE HAVE A COMMENT  */                                              SCAN
  933              S1, S2 = BYTE (' ');                                                  SCAN
  934              DO WHILE S1 \= BYTE ('*') ^ S2 \= BYTE ('/');                         SCAN
  935                 IF S1 = BYTE ('$') THEN /* A CONTROL CHAR */                       SCAN
  936                      CONTROL(S2) = \CONTROL(S2) & 1;                               SCAN
  937                 S1 = S2;                                                           SCAN
  938                 CALL CHAR;                                                         SCAN
  939                 S2 = BYTE(TEXT, CP);                                               SCAN
  940              END;                                                                  SCAN
  941           END;                                                                     SCAN
  942           /*  CASE 7  */                                                           SCAN CASE 7.
  943           DO;      /*  SPECIAL CHARACTERS  */                                      SCAN
  944              TOKEN = TX(BYTE(TEXT));                                               SCAN
  945              CP = 1;                                                               SCAN
  946              RETURN;                                                               SCAN
  947           END;                                                                     SCAN
  948           /*  CASE 8  */                                                           SCAN CASE 8.
  949           DO;   /* A ^:  MAY BE  ^  OR  ^^  */                                     SCAN
  950              CALL CHAR;                                                            SCAN
  951              IF BYTE(TEXT, CP) = BYTE('^') THEN                                    SCAN
  952                 DO;                                                                SCAN
  953                    CALL CHAR;                                                      SCAN
  954                    TOKEN = CONCATENATE;                                            SCAN
  955                 END;                                                               SCAN
  956              ELSE TOKEN = ORSYMBOL;                                                SCAN
  957              RETURN;                                                               SCAN
  958           END;                                                                     SCAN
  959        END;     /* OF CASE ON CHARTYPE  */                                         SCAN CASE 9.
  960        CP = CP + 1;  /* ADVANCE SCANNER AND RESUME SEARCH FOR TOKEN  */            SCAN
  961        GO TO RESCAN;                                                               SCAN
  962     END SCAN;                                                                      SCAN

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LBITM           CHARACTER   775   STRING    762       2
LSTRNGM         CHARACTER   774   STRING    761       3
RESCAN          LABEL      1098  PROGRAM    766       4
S1              FIXED      9193     DATA    760      17
S2              FIXED      9194     DATA    760      11
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 25
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  963     /*                                                                            *
  964              C O D E   E M I S S I O N   P R O C E D U R E S                      *
  965   */                                                                              *
  966  FLUSH_DATA_BUFFER:                                                               *
  967     PROCEDURE;                                                                    *
  968        /* CLEAN OUT THE DATA BUFFER AND STICK ALL CURRENT CONTENTS                 FLUSH_DATA_BUFFER
  969           INTO THE REL FILE */                                                     FLUSH_DATA_BUFFER
  970        DECLARE I FIXED, J FIXED;                                                   FLUSH_DATA_BUFFER
  971        IF (DPTR+DCTR) > 1 THEN                                                     FLUSH_DATA_BUFFER
  972           DO;                                                                      FLUSH_DATA_BUFFER
  973              J = (DPTR/19)*18 + DCTR -1;                                           FLUSH_DATA_BUFFER
  974              FILE(RELFILE) = CODE_TYPE + J;                                        FLUSH_DATA_BUFFER
  975              I = DPTR+DCTR-1;                                                      FLUSH_DATA_BUFFER C9 = 262144
  976              DO J = 0 TO I;                                                        FLUSH_DATA_BUFFER
  977                 FILE(RELFILE) = DATA_BUFFER(J);                                    FLUSH_DATA_BUFFER
  978                 END;                                                               FLUSH_DATA_BUFFER
  979           END;                                                                     FLUSH_DATA_BUFFER
  980        DPTR = 0;                                                                   FLUSH_DATA_BUFFER
  981        DCTR = 1;                                                                   FLUSH_DATA_BUFFER
  982     END FLUSH_DATA_BUFFER;                                                         FLUSH_DATA_BUFFER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9243     DATA    970       2
J               FIXED      9244     DATA    970       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 26
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  983  FLUSH_CODE_BUFFER:                                                               *
  984     PROCEDURE;                                                                    *
  985        /* CLEAN OUT THE CODE BUFFER AND STICK ALL CURRENT CONTENTS                 FLUSH_CODE_BUFFER
  986           INTO THE REL FILE */                                                     FLUSH_CODE_BUFFER
  987        DECLARE I FIXED, J FIXED;                                                   FLUSH_CODE_BUFFER
  988        IF (RPTR+RCTR) > 1 THEN                                                     FLUSH_CODE_BUFFER
  989           DO;                                                                      FLUSH_CODE_BUFFER
  990              I = (RPTR/19)*18 + RCTR -1;                                           FLUSH_CODE_BUFFER
  991              J = RPTR+RCTR-1;                                                      FLUSH_CODE_BUFFER
  992              FILE (RELFILE) = CODE_TYPE+I;                                         FLUSH_CODE_BUFFER
  993              DO I = 0 TO J;                                                        FLUSH_CODE_BUFFER
  994                 FILE(RELFILE) = CODE_BUFFER(I);                                    FLUSH_CODE_BUFFER
  995                 END;                                                               FLUSH_CODE_BUFFER
  996           END;                                                                     FLUSH_CODE_BUFFER
  997        RPTR = 0;                                                                   FLUSH_CODE_BUFFER
  998                                                                                    FLUSH_CODE_BUFFER
  999        RCTR = 1;                                                                   FLUSH_CODE_BUFFER
 1000     END FLUSH_CODE_BUFFER;                                                         FLUSH_CODE_BUFFER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9247     DATA    987       4
J               FIXED      9248     DATA    987       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 27
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1001                                                                                   *
 1002  RADIX50:                                                                         *
 1003     PROCEDURE (SYMBOL);                                                           *
 1004     /* PROCEDURE TO RETURN THE RADIX-50 REPRESENTATION OF A SYMBOL.                RADIX50
 1005        ONLY THE FIRST 6 CHARACTERS ARE USED. */                                    RADIX50
 1006     DECLARE SYMBOL CHARACTER;                                                      RADIX50
 1007     DECLARE (I,J,K,L) FIXED;                                                       RADIX50
 1008                                                                                    RADIX50
 1009     J = 0;                                                                         RADIX50
 1010     IF LENGTH(SYMBOL) < 6 THEN SYMBOL = SYMBOL ^^ X7;                              RADIX50
 1011     DO L = 0 TO 5;                                                                 RADIX50
 1012        I = BYTE(SYMBOL,L);                                                         RADIX50 C10 = 5
 1013        IF I = BYTE(' ') THEN K = 0;                                                RADIX50
 1014                                                                                    RADIX50
 1015           ELSE IF I = BYTE ('.') THEN K = "(3)45";                                 RADIX50
 1016                                                                                    RADIX50
 1017           ELSE IF I = BYTE ('$') THEN K = "(3)46";                                 RADIX50
 1018                                                                                    RADIX50
 1019           ELSE IF I = BYTE ('%') THEN K = "(3)47";                                 RADIX50
 1020           ELSE IF I >= BYTE ('0') & I <= BYTE ('9') THEN                           RADIX50
 1021                                                                                    RADIX50
 1022                      K = I-BYTE('0') + "(3)1";                                     RADIX50
 1023           ELSE IF I >= BYTE ('A') & I <= BYTE ('Z') THEN                           RADIX50
 1024                      K = I - BYTE ('A') + "(3)13";                                 RADIX50
 1025           ELSE RETURN J;                                                           RADIX50
 1026        J = J * "(3)50" + K;                                                        RADIX50
 1027        END;                                                                        RADIX50
 1028     RETURN J;                                                                      RADIX50
 1029     END RADIX50;                                                                   RADIX50

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9250     DATA   1007      11
J               FIXED      9251     DATA   1007       5
K               FIXED      9252     DATA   1007       7
L               FIXED      9253     DATA   1007       2
SYMBOL          CHARACTER   782   STRING   1003       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 28
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1030  OUTPUT_CODEWORD:                                                                 *
 1031     PROCEDURE;                                                                    *
 1032     /* SPIT OUT THE INSTRUCTION AT CODEXXX(CODE_TAIL) */                           OUTPUT_CODEWORD
 1033                                                                                    OUTPUT_CODEWORD
 1034     IF CODE_FULL(CODE_TAIL) THEN                                                   OUTPUT_CODEWORD
 1035                                                                                    OUTPUT_CODEWORD
 1036        DO;                                                                         OUTPUT_CODEWORD
 1037           IF CONTROL(BYTE('A')) THEN OUTPUT (CODEFILE) = CODE (CODE_TAIL);         OUTPUT_CODEWORD
 1038                                                                                    OUTPUT_CODEWORD
 1039           IF RCTR+RPTR = 1 THEN                                                    OUTPUT_CODEWORD
 1040              DO;                                                                   OUTPUT_CODEWORD
 1041                 CODE_BUFFER(0) =SHL(1,34);                                         OUTPUT_CODEWORD
 1042                 CODE_BUFFER(1) = CODE_PP(CODE_TAIL) + "(3)400000";                 OUTPUT_CODEWORD
 1043                 RCTR = RCTR +1;                                                    OUTPUT_CODEWORD
 1044              END;                                                                  OUTPUT_CODEWORD
 1045           CODE_BUFFER(RPTR) = SHL(CODE_RBITS(CODE_TAIL),36-RCTR*2)^CODE_BUFFER(RPTR); OUTPUT_CODEWORD
 1046           CODE_BUFFER(RPTR+RCTR) = CODE_REL(CODE_TAIL);                            OUTPUT_CODEWORD
 1047           RCTR = RCTR +1;                                                          OUTPUT_CODEWORD
 1048           IF RPTR+RCTR > BUFFERSIZE THEN CALL FLUSH_CODE_BUFFER;                   OUTPUT_CODEWORD
 1049           IF RCTR > 18 THEN                                                        OUTPUT_CODEWORD
 1050              DO;                                                                   OUTPUT_CODEWORD
 1051                 RPTR = RPTR +19;                                                   OUTPUT_CODEWORD
 1052                 RCTR = 1;                                                          OUTPUT_CODEWORD
 1053                 CODE_BUFFER(RPTR) = 0;                                             OUTPUT_CODEWORD
 1054              END;                                                                  OUTPUT_CODEWORD
 1055        END;                                                                        OUTPUT_CODEWORD
 1056     CODE_FULL(CODE_TAIL) = FALSE;                                                  OUTPUT_CODEWORD
 1057     CODE_TAIL = (CODE_TAIL+1) & 3;                                                 OUTPUT_CODEWORD
 1058     END OUTPUT_CODEWORD;                                                           OUTPUT_CODEWORD
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 29
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1059  FLUSH_LABELS:                                                                    *
 1060     PROCEDURE;                                                                    *
 1061        /* CLEAN OUT LABEL BUFFER BY GENERATING INTERNAL REQUEST                    FLUSH_LABELS
 1062           TYPE BLOCK AND DEFINING ALL LABELS NOW KNOWN */                          FLUSH_LABELS
 1063        DECLARE I FIXED;                                                            FLUSH_LABELS
 1064        IF LABEL_COUNT = 0 THEN RETURN;                                             FLUSH_LABELS
 1065        DO WHILE CODE_TAIL \= CODE_HEAD;                                            FLUSH_LABELS
 1066           CALL OUTPUT_CODEWORD;                                                    FLUSH_LABELS
 1067           END;                                                                     FLUSH_LABELS
 1068        CALL OUTPUT_CODEWORD;                                                       FLUSH_LABELS
 1069        CODE_TAIL = CODE_HEAD;      /* RESET POINTERS, SINCE BUFFERS NOW EMPTY */   FLUSH_LABELS
 1070        STILLCOND, STILLINZERO = 0; /* MAKE SURE PEEPHOLE WORKS */                  FLUSH_LABELS
 1071        CALL FLUSH_CODE_BUFFER;                                                     FLUSH_LABELS
 1072        FILE (RELFILE) = INTREQ_TYPE+LABEL_COUNT;                                   FLUSH_LABELS
 1073        DO I = 0 TO LABEL_COUNT;                                                    FLUSH_LABELS C11 = 2097152
 1074           FILE (RELFILE) = LABEL_BUFFER(I);                                        FLUSH_LABELS
 1075           END;                                                                     FLUSH_LABELS
 1076        LABEL_COUNT = 0;                                                            FLUSH_LABELS
 1077        LABEL_BUFFER(0) = 0;                                                        FLUSH_LABELS
 1078     END FLUSH_LABELS;                                                              FLUSH_LABELS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9255     DATA   1063       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 30
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1079  OUTPUT_DATAWORD:                                                                 *
 1080     PROCEDURE (W,LOC);                                                            *
 1081        /* OUTPUT A WORD TO THE LOW SEGMENT */                                      OUTPUT_DATAWORD
 1082        DECLARE W  FIXED, LOC FIXED;                                                OUTPUT_DATAWORD
 1083        IF (DPTR+DCTR)>BUFFERSIZE ^ DLOC \= LOC THEN CALL FLUSH_DATA_BUFFER;        OUTPUT_DATAWORD
 1084        IF DPTR+DCTR = 1 THEN                                                       OUTPUT_DATAWORD
 1085           DO;                                                                      OUTPUT_DATAWORD
 1086              DATA_BUFFER(0) = "(3)200000000000";                                   OUTPUT_DATAWORD
 1087              DATA_BUFFER(1) = LOC;                                                 OUTPUT_DATAWORD C12 = 17179869184
 1088              DATA_BUFFER(2) = W;                                                   OUTPUT_DATAWORD
 1089              DLOC = LOC + 1;                                                       OUTPUT_DATAWORD
 1090              DCTR = DCTR + 2;                                                      OUTPUT_DATAWORD
 1091              RETURN;                                                               OUTPUT_DATAWORD
 1092           END;                                                                     OUTPUT_DATAWORD
 1093        DATA_BUFFER (DPTR+DCTR) = W;                                                OUTPUT_DATAWORD
 1094        DCTR = DCTR +1;                                                             OUTPUT_DATAWORD
 1095        DLOC = DLOC + 1;                                                            OUTPUT_DATAWORD
 1096        IF DPTR+DCTR > BUFFERSIZE THEN CALL FLUSH_DATA_BUFFER;                      OUTPUT_DATAWORD
 1097        IF DCTR > 18 THEN                                                           OUTPUT_DATAWORD
 1098          DO;                                                                       OUTPUT_DATAWORD
 1099              DCTR = 1;                                                             OUTPUT_DATAWORD
 1100              DPTR = DPTR + 19;                                                     OUTPUT_DATAWORD
 1101              DATA_BUFFER(DPTR) = 0;                                                OUTPUT_DATAWORD
 1102           END;                                                                     OUTPUT_DATAWORD
 1103     END OUTPUT_DATAWORD;                                                           OUTPUT_DATAWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LOC             FIXED      9259     DATA   1080       3
W               FIXED      9258     DATA   1080       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 31
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1104  FLUSH_DATACARD:PROCEDURE;                                                        *
 1105        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             FLUSH_DATACARD
 1106           DO;                                                                      FLUSH_DATACARD
 1107              DATACARD = DATACARD ^^ '; D' ^^ DP;                                   FLUSH_DATACARD
 1108              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              FLUSH_DATACARD
 1109              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   FLUSH_DATACARD
 1110           END;                                                                     FLUSH_DATACARD
 1111        CALL OUTPUT_DATAWORD (PWORD,DP);                                            FLUSH_DATACARD
 1112        PWORD = 0;                                                                  FLUSH_DATACARD
 1113        DPOFFSET = 0;                                                               FLUSH_DATACARD
 1114        DP = DP + 1;                                                                FLUSH_DATACARD
 1115  END FLUSH_DATACARD;                                                               FLUSH_DATACARD
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 32
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1116  EMITBLOCK:                                                                       *
 1117     PROCEDURE (I);                                                                *
 1118        /* RESERVE A BLOCK OF I WORDS */                                            EMITBLOCK
 1119        DECLARE I FIXED;                                                            EMITBLOCK
 1120        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITBLOCK
 1121           DO;                                                                      EMITBLOCK
 1122              DATACARD = '       REPEAT ' ^^ I ^^ ',<0>; D' ^^ DP;                  EMITBLOCK
 1123              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              EMITBLOCK
 1124              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   EMITBLOCK
 1125           END;                                                                     EMITBLOCK
 1126        DP = DP + I;                                                                EMITBLOCK
 1127  END EMITBLOCK;                                                                    EMITBLOCK

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9262     DATA   1117       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 33
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1128  EMITDATAWORD:                                                                    *
 1129     PROCEDURE (W);                                                                *
 1130        DECLARE W FIXED;                                                            EMITDATAWORD
 1131        /* SEND AN 80 CHARACTER CARD TO THE DATA FILE */                            EMITDATAWORD
 1132        IF DPOFFSET > 0 THEN CALL FLUSH_DATACARD;                                   EMITDATAWORD
 1133        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITDATAWORD
 1134           DO;                                                                      EMITDATAWORD
 1135              DATACARD = X7 ^^ W ^^ '; D' ^^ DP;                                    EMITDATAWORD
 1136              IF CONTROL(BYTE('A')) THEN OUTPUT (DATAFILE) = DATACARD;              EMITDATAWORD
 1137              IF CONTROL(BYTE('B')) THEN CALL PRINTLINE (DATAMSG ^^ DATACARD,-1);   EMITDATAWORD
 1138           END;                                                                     EMITDATAWORD
 1139        CALL OUTPUT_DATAWORD(W,DP);                                                 EMITDATAWORD
 1140        DP = DP + 1;                                                                EMITDATAWORD
 1141  END EMITDATAWORD;                                                                 EMITDATAWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
W               FIXED      9269     DATA   1129       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 34
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1142  EMITBYTE:                                                                        *
 1143     PROCEDURE (C);                                                                *
 1144        DECLARE C FIXED;                                                            EMITBYTE
 1145        /* SEND ONE 9-BIT BYTE TO THE DATA AREA */                                  EMITBYTE
 1146        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('B')) THEN                             EMITBYTE
 1147           IF DPOFFSET = 0 THEN DATACARD = '       BYTE (9)'^^ C;                   EMITBYTE
 1148           ELSE DATACARD = DATACARD ^^ ',' ^^ C;                                    EMITBYTE
 1149        PWORD = PWORD + SHL(C&"(3)777",9*(3-DPOFFSET));                             EMITBYTE
 1150        DPOFFSET = DPOFFSET + 1;                                                    EMITBYTE
 1151        IF DPOFFSET = 4 THEN CALL FLUSH_DATACARD;                                   EMITBYTE
 1152  END EMITBYTE;                                                                     EMITBYTE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
C               FIXED      9271     DATA   1143       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 35
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1153  EMITCONSTANT:                                                                    *
 1154     PROCEDURE (C);                                                                *
 1155        DECLARE C FIXED;                                                            EMITCONSTANT
 1156        DECLARE CTAB (100) FIXED, CADD (100) FIXED, NC FIXED, I FIXED;              EMITCONSTANT
 1157        /* SEE IF C HAS ALREADY BEEN EMITED, AND IF NOT, EMIT IT.  SET UP ADR.  */  EMITCONSTANT
 1158        DO I = 1 TO NC;                  /* STEP THRU THE CONSTANTS */              EMITCONSTANT
 1159           IF CTAB (I) = C THEN                                                     EMITCONSTANT
 1160              DO;                                                                   EMITCONSTANT
 1161                 ADR = CADD (I);                                                    EMITCONSTANT
 1162                 RETURN;                                                            EMITCONSTANT
 1163              END;                                                                  EMITCONSTANT
 1164        END;                                                                        EMITCONSTANT
 1165        CTAB (I) = C;                                                               EMITCONSTANT
 1166        CALL EMITDATAWORD (C);                                                      EMITCONSTANT
 1167        ADR, CADD (I) = DP - 1;                                                     EMITCONSTANT
 1168        IF I < 100 THEN NC = I;                                                     EMITCONSTANT
 1169        IF CONTROL(BYTE('C')) THEN CALL PRINTLINE ('* CONSTANT ' ^^ NC ^^ ' = ' ^^ C,-1); EMITCONSTANT
 1170           ELSE IF CONTROL(BYTE('L')) THEN INFO=INFO^^ ' C'^^ NC ^^' = ' ^^ C;      EMITCONSTANT
 1171  END EMITCONSTANT;                                                                 EMITCONSTANT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
C               FIXED      9276     DATA   1154       5
CADD            FIXED      9378     DATA   1156       2
CTAB            FIXED      9277     DATA   1156       2
I               FIXED      9480     DATA   1156       7
NC              FIXED      9479     DATA   1156       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 36
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1172  EMITCODEWORD:PROCEDURE (W,WORD,RBITS);                                           *
 1173         DECLARE W CHARACTER;                                                       EMITCODEWORD
 1174        DECLARE WORD FIXED;                                                         EMITCODEWORD
 1175        DECLARE RBITS FIXED;                                                        EMITCODEWORD
 1176        /* SEND AN 80 CHARACTER CODE CARD TO THE BUFFER AREA */                     EMITCODEWORD
 1177        CODE_HEAD = (CODE_HEAD+1) & 3;                                              EMITCODEWORD
 1178        IF CODE_HEAD = CODE_TAIL THEN CALL OUTPUT_CODEWORD;                         EMITCODEWORD
 1179        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('E')) THEN                             EMITCODEWORD
 1180              CODE(CODE_HEAD) = LABEL_GEN ^^ W;                                     EMITCODEWORD
 1181        IF CONTROL(BYTE('E')) THEN                                                  EMITCODEWORD
 1182              CALL PRINTLINE (CODEMSG ^^ CODE(CODE_HEAD),-1);                       EMITCODEWORD
 1183        CODE_REL(CODE_HEAD) = WORD;                                                 EMITCODEWORD
 1184        CODE_PP(CODE_HEAD) = PP;                                                    EMITCODEWORD
 1185        CODE_RBITS(CODE_HEAD) = RBITS;                                              EMITCODEWORD
 1186        CODE_FULL(CODE_HEAD) = TRUE;                                                EMITCODEWORD
 1187        LABEL_GEN = '';                                                             EMITCODEWORD
 1188        STILLCOND, STILLINZERO = 0;                                                 EMITCODEWORD
 1189        PP = PP + 1;                                                                EMITCODEWORD
 1190  END EMITCODEWORD;                                                                 EMITCODEWORD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
RBITS           FIXED      9488     DATA   1172       1
W               CHARACTER   793   STRING   1172       1
WORD            FIXED      9487     DATA   1172       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 37
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1191  OUTPUTLABEL:                                                                     *
 1192     PROCEDURE (J);                                                                *
 1193     DECLARE J FIXED;                                                               OUTPUTLABEL
 1194     LABEL_COUNT = LABEL_COUNT+1;                                                   OUTPUTLABEL
 1195     LABEL_BUFFER(0) = SHL(3,36-LABEL_COUNT*2)^LABEL_BUFFER(0);                     OUTPUTLABEL
 1196     LABEL_BUFFER(LABEL_COUNT) = J;                                                 OUTPUTLABEL
 1197     IF(LABEL_COUNT >= BUFFERSIZE) THEN CALL FLUSH_LABELS;                          OUTPUTLABEL
 1198     END OUTPUTLABEL;                                                               OUTPUTLABEL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
J               FIXED      9489     DATA   1192       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 38
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1199  EMITLABEL:PROCEDURE(L,R);                                                        *
 1200        DECLARE L FIXED;                                                            EMITLABEL
 1201        DECLARE R FIXED;                                                            EMITLABEL
 1202        DECLARE I FIXED;                                                            EMITLABEL
 1203        DECLARE J FIXED;                                                            EMITLABEL
 1204        IF R = 3 THEN                                                               EMITLABEL
 1205           DO;                                                                      EMITLABEL
 1206              IF DESCREF(L) = 0 THEN RETURN;                                        EMITLABEL
 1207              J = SHL(DESCREF(L),18) + DP;                                          EMITLABEL
 1208              CALL OUTPUTLABEL(J);                                                  EMITLABEL
 1209              DESCREF(L) = 0;                                                       EMITLABEL
 1210              RETURN;                                                               EMITLABEL
 1211           END;                                                                     EMITLABEL
 1212        STILLINZERO = 0;    /* DON'T TRY OPTIMIZING OVER LABEL */                   EMITLABEL
 1213        J = SHL(R,18) + L;                                                          EMITLABEL
 1214        DO I = 1 TO FOR_COUNT;                                                      EMITLABEL
 1215           IF J = FOR_LABEL(I) THEN                                                 EMITLABEL
 1216              DO;                                                                   EMITLABEL
 1217                 J = SHL(FOR_REF(I)+"(3)400000",18);                                EMITLABEL
 1218                 IF R = 4 THEN J = J + PP + "(3)400000";                            EMITLABEL
 1219                          ELSE J = J + DP;                                          EMITLABEL
 1220                 CALL OUTPUTLABEL(J);                                               EMITLABEL
 1221                 J = I;                                                             EMITLABEL
 1222                 DO WHILE J < FOR_COUNT;                                            EMITLABEL
 1223                    FOR_LABEL(J) = FOR_LABEL(J+1);                                  EMITLABEL
 1224                    FOR_REF(J) = FOR_REF(J+1);                                      EMITLABEL
 1225                    J = J + 1;                                                      EMITLABEL
 1226                 END;                                                               EMITLABEL
 1227                 FOR_LABEL(FOR_COUNT) = 0;                                          EMITLABEL
 1228                 FOR_REF(FOR_COUNT) = 0;                                            EMITLABEL
 1229                 FOR_COUNT = FOR_COUNT -1;                                          EMITLABEL
 1230                 /* PUT A LABEL ON THE NEXT INSTRUCTION GENERATED */                EMITLABEL
 1231                 IF R = 4 & (CONTROL(BYTE('A')) ^ CONTROL(BYTE('E'))) THEN          EMITLABEL
 1232                              LABEL_GEN = LABEL_GEN ^^ '$' ^^ L ^^ ':';             EMITLABEL
 1233                 RETURN;                                                            EMITLABEL
 1234              END;                                                                  EMITLABEL
 1235        END;                                                                        EMITLABEL
 1236        IF R = 4 & (CONTROL(BYTE('A')) ^ CONTROL(BYTE('E'))) THEN                   EMITLABEL
 1237            LABEL_GEN = LABEL_GEN ^^ '$' ^^ L ^^ ':';                               EMITLABEL
 1238        RETURN;                                                                     EMITLABEL
 1239  END EMITLABEL;                                                                    EMITLABEL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9492     DATA   1202       4
J               FIXED      9493     DATA   1203      18
L               FIXED      9490     DATA   1199       6
R               FIXED      9491     DATA   1199       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 39
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1240  REFCHECK:                                                                        *
 1241     PROCEDURE (I);                                                                *
 1242        /* CHECK TO SEE IF THIS SATISFIES ANY FORWARD REFERENCES.                   REFCHECK
 1243           IF SO, SET UP LABEL BUFFER.  IF NOT, CHECK IF THIS                       REFCHECK
 1244           SHOULD BE CHAINED. */                                                    REFCHECK
 1245        DECLARE I FIXED;                                                            REFCHECK
 1246        DECLARE J FIXED;                                                            REFCHECK
 1247        IF SHR(I,18) = 3 THEN                                                       REFCHECK
 1248           DO;                                                                      REFCHECK
 1249              I = I & "(3)777777";                                                  REFCHECK
 1250              J = DESCREF(I);                                                       REFCHECK
 1251              DESCREF(I) = PP + "(3)400000";                                        REFCHECK
 1252              RETURN J;                                                             REFCHECK
 1253           END;                                                                     REFCHECK
 1254        J = 1;                                                                      REFCHECK
 1255        DO WHILE J <= FOR_COUNT;                                                    REFCHECK
 1256           IF FOR_LABEL(J) = I THEN                                                 REFCHECK
 1257              DO;                                                                   REFCHECK
 1258                 I = FOR_REF(J) + "(3)400000";                                      REFCHECK
 1259                 FOR_REF(J) = PP;                                                   REFCHECK
 1260                 RETURN I;                                                          REFCHECK
 1261              END;                                                                  REFCHECK
 1262           J=J+1;                                                                   REFCHECK
 1263        END;                                                                        REFCHECK
 1264        FOR_COUNT = FOR_COUNT +1;                                                   REFCHECK
 1265        IF FOR_COUNT > FOR_MAX THEN CALL ERROR ('TOO MANY FORWARD REFERENCES',3);   REFCHECK
 1266        FOR_REF(FOR_COUNT) = PP;                                                    REFCHECK
 1267        FOR_LABEL(FOR_COUNT) = I;                                                   REFCHECK
 1268        RETURN 0;                                                                   REFCHECK
 1269     END REFCHECK;                                                                  REFCHECK

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9496     DATA   1241       9
J               FIXED      9497     DATA   1246       9
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 40
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1270  EMITINST:PROCEDURE (OPCODE,TREG,INDIRECT,OPERAND,IREG,RELOCATION);               *
 1271        DECLARE OPCODE FIXED,                                                       EMITINST
 1272                TREG FIXED,                                                         EMITINST
 1273                INDIRECT FIXED,                                                     EMITINST
 1274                OPERAND FIXED,                                                      EMITINST
 1275                IREG FIXED,                                                         EMITINST
 1276                RELOCATION FIXED;                                                   EMITINST
 1277        DECLARE RBITS FIXED,                                                        EMITINST
 1278                WORD FIXED;                                                         EMITINST
 1279        /* EMIT A 80 CHARACTER INSTRUCTION IMAGE */                                 EMITINST
 1280        DECLARE RELOC (5) CHARACTER                                                 EMITINST
 1281                INITIAL ('', 'D+', 'P+', 'S+', '$', '$');                           EMITINST
 1282        DECLARE I FIXED,                                                            EMITINST
 1283                J FIXED,                                                            EMITINST
 1284                CARD CHARACTER,                                                     EMITINST
 1285                INDIR (1) CHARACTER INITIAL ('', '@');                              EMITINST
 1286        COUNT_INST = COUNT_INST + 1;                                                EMITINST
 1287                                                                                    EMITINST
 1288        WORD = SHL(OPCODE,27) + SHL(TREG&"F",23) + SHL(INDIRECT&1,22)               EMITINST
 1289               + SHL(IREG&"F",18);                                                  EMITINST
 1290        DO CASE RELOCATION;                                                         EMITINST
 1291           /* CASE 0 : ABSOLUTE ADDRESS - NO RELOCATION */                          EMITINST CASE 0.
 1292           DO;                                                                      EMITINST
 1293              WORD = WORD + (OPERAND&"(3)777777");                                  EMITINST
 1294              RBITS = 0;                                                            EMITINST
 1295           END;                                                                     EMITINST
 1296                                                                                    EMITINST CASE 1.
 1297           /* CASE 1 : RELATIVE TO THE BEGINNING OF DATA SEGMENT */                 EMITINST
 1298           DO;                                                                      EMITINST
 1299              WORD = WORD + (OPERAND&"(3)777777");                                  EMITINST
 1300              RBITS = 1;                                                            EMITINST
 1301           END;                                                                     EMITINST
 1302                                                                                    EMITINST CASE 2.
 1303           /* CASE 2 : RELATIVE TO BEGINNING OF CODE SEGMENT */                     EMITINST
 1304           DO;                                                                      EMITINST
 1305              WORD = WORD + (OPERAND&"(3)777777") + "(3)400000";                    EMITINST
 1306              RBITS = 1;                                                            EMITINST
 1307           END;                                                                     EMITINST
 1308                                                                                    EMITINST CASE 3.
 1309           /* CASE 3 : RELATIVE TO BEGINNING OF STRINGS */                          EMITINST
 1310           DO;                                                                      EMITINST
 1311              I = SHL(RELOCATION,18) + (OPERAND&"(3)777777");                       EMITINST
 1312              J = REFCHECK(I);                                                      EMITINST
 1313              WORD = WORD + J;                                                      EMITINST
 1314              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1315                       ELSE RBITS = 1;                                              EMITINST
 1316           END;                                                                     EMITINST
 1317                                                                                    EMITINST CASE 4.
 1318           /* CASE 4 : FORWARD LABEL REFERENCE IN CODE AREA */                      EMITINST
 1319           DO;                                                                      EMITINST
 1320              J = REFCHECK("(3)4000000" + (OPERAND&"(3)777777"));                   EMITINST
 1321              WORD = WORD + J;                                                      EMITINST C13 = 1048576
 1322              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1323                       ELSE RBITS = 1;                                              EMITINST
 1324           END;                                                                     EMITINST
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 41
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1325                                                                                    EMITINST CASE 5.
 1326           /* CASE 5 : FORWARD LABEL REFERENCE IN DATA AREA */                      EMITINST
 1327           DO;                                                                      EMITINST
 1328              J = REFCHECK("(3)5000000" + (OPERAND&"(3)777777"));                   EMITINST
 1329              WORD = WORD + J;                                                      EMITINST C14 = 1310720
 1330              IF J = 0 THEN RBITS = 0;                                              EMITINST
 1331                       ELSE RBITS = 1;                                              EMITINST
 1332           END;                                                                     EMITINST
 1333        END;  /* END OF DO CASE RELOCATION */                                       EMITINST CASE 6.
 1334                                                                                    EMITINST
 1335        IF CONTROL(BYTE('A')) ^ CONTROL(BYTE('E')) THEN                             EMITINST
 1336           DO;                                                                      EMITINST
 1337              I = SHR(OPCODE,5);                                                    EMITINST
 1338              CARD = X7 ^^ SUBSTR(OPNAME(I),(OPCODE-I*32)*6,6) ^^ X1 ^^TREG ^^ ','  EMITINST
 1339                     ^^ INDIR(INDIRECT) ^^ RELOC(RELOCATION) ^^ OPERAND;            EMITINST C15 = 805306368
 1340              IF IREG > 0 THEN CARD = CARD ^^ '(' ^^ IREG ^^ ')';                   EMITINST
 1341              CARD = CARD ^^ '; P' ^^ PP;                                           EMITINST
 1342           END;                                                                     EMITINST
 1343        INSTRUCT(OPCODE) = INSTRUCT(OPCODE) + 1;                                    EMITINST
 1344        CALL EMITCODEWORD (CARD,WORD,RBITS);                                        EMITINST
 1345  END EMITINST;                                                                     EMITINST

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CARD            CHARACTER   805   STRING   1284       6
I               FIXED      9515     DATA   1282       5
INDIR           CHARACTER   806   STRING   1285       1
INDIRECT        FIXED      9507     DATA   1270       2
IREG            FIXED      9509     DATA   1270       3
J               FIXED      9516     DATA   1283       9
OPCODE          FIXED      9505     DATA   1270       5
OPERAND         FIXED      9508     DATA   1270       7
RBITS           FIXED      9511     DATA   1277      10
RELOC           CHARACTER   799   STRING   1280       1
RELOCATION      FIXED      9510     DATA   1270       3
TREG            FIXED      9506     DATA   1270       2
WORD            FIXED      9512     DATA   1278      14
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 42
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1346  EMITDESC:PROCEDURE (L,A);                                                        *
 1347        DECLARE L FIXED,                                                            EMITDESC
 1348                A FIXED;                                                            EMITDESC
 1349        /* SEND A LENGTH AND STRING ADDRESS TO THE DESCRIPTOR AREA */               EMITDESC
 1350        IF DSP > DESCLIMIT THEN                                                     EMITDESC
 1351           DO;                                                                      EMITDESC
 1352              CALL ERROR ('TOO MANY STRINGS',1);                                    EMITDESC
 1353              DSP = 0;                                                              EMITDESC
 1354           END;                                                                     EMITDESC
 1355         IF CONTROL(BYTE('B')) THEN                                                 EMITDESC
 1356           CALL PRINTLINE (X70 ^^ 'DESC =        ' ^^ L ^^ ',' ^^ A ^^ '; S' ^^ DSP,-1); EMITDESC
 1357        DESCL(DSP) = L;                                                             EMITDESC
 1358        DESCA(DSP) = A;                                                             EMITDESC
 1359        DSP = DSP + 1;                                                              EMITDESC
 1360  END EMITDESC;                                                                     EMITDESC

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
A               FIXED      9524     DATA   1346       2
L               FIXED      9523     DATA   1346       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 43
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1361  FINDLABEL:PROCEDURE;                                                             *
 1362        LABEL_SINK = LABEL_SINK + 1;                                                FINDLABEL
 1363        RETURN (LABEL_SINK);                                                        FINDLABEL
 1364  END FINDLABEL;                                                                    FINDLABEL
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 44
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1365   /*                                                                              *
 1366             S Y M B O L   T A B L E   P R O C E D U R E S                         *
 1367   */                                                                              *
 1368                                                                                   *
 1369  HASHER:                                                                          *
 1370     PROCEDURE (ID);          /* CALCULATE HASH INDEX INTO HASH TABLE*/            *
 1371     DECLARE ID   CHARACTER;                                                        HASHER
 1372     DECLARE L    FIXED;                                                            HASHER
 1373     L = LENGTH (ID);                                                               HASHER
 1374     RETURN (BYTE (ID) + BYTE (ID, L-1) + SHL (L,4)) & "FF";                        HASHER
 1375     END HASHER;                                                                    HASHER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
ID              CHARACTER   816   STRING   1370       3
L               FIXED      9534     DATA   1372       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 45
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1376                                                                                   *
 1377  ENTER:PROCEDURE (N, T, L, S);                                                    *
 1378        DECLARE T FIXED, L FIXED, S FIXED;                                          ENTER
 1379        DECLARE N CHARACTER;                                                        ENTER
 1380   /* ENTER THE NAME N IN THE SYMBOL TABLE WITH TYPE T AT LOCATION L SEGMENT S */   ENTER
 1381        DECLARE I FIXED, K FIXED;                                                   ENTER
 1382        IDX = HASHER (N);                                                           ENTER
 1383        I = HASH (IDX);                                                             ENTER
 1384        DO WHILE I >= PROCMARK;                                                     ENTER
 1385           IDCOMPARES = IDCOMPARES + 1;                                             ENTER
 1386           IF N = SYT (I) THEN                                                      ENTER
 1387              DO;                                                                   ENTER
 1388                 K = SYTYPE (I);                                                    ENTER
 1389                 IF T = LABELTYPE & (K = FORWARDTYPE ^ K = FORWARDCALL) THEN        ENTER
 1390                    DO;                                                             ENTER
 1391                       IF CONTROL (BYTE ('E')) THEN                                 ENTER
 1392                          CALL PRINTLINE (X70 ^^ 'FIXED REFERENCES TO: ' ^^ N,-1);  ENTER
 1393                       IF K = FORWARDTYPE THEN                                      ENTER
 1394                          DO;                                                       ENTER
 1395                             CALL EMITLABEL(SYTLOC(I),4);                           ENTER
 1396                             SYTLOC(I) = L;                                         ENTER
 1397                             SYTSEG(I) = S;                                         ENTER
 1398                          END;                                                      ENTER
 1399                       SYTYPE (I) = T;                                              ENTER
 1400                    END;                                                            ENTER
 1401                 ELSE IF PROCMARK + PARCT < I THEN                                  ENTER
 1402                    CALL ERROR ('DUPLICATE DECLARATION FOR: ' ^^ N, 0);             ENTER
 1403                 RETURN I;                                                          ENTER
 1404              END;                                                                  ENTER
 1405           I = PTR (I);                                                             ENTER
 1406        END;                                                                        ENTER
 1407        NDECSY = NDECSY + 1;                                                        ENTER
 1408        IF NDECSY > MAXNDECSY THEN                                                  ENTER
 1409           IF NDECSY > SYTSIZE THEN                                                 ENTER
 1410              DO;                                                                   ENTER
 1411                 CALL ERROR ('SYMBOL TABLE OVERFLOW', 1);                           ENTER
 1412                 NDECSY = NDECSY - 1;                                               ENTER
 1413              END;                                                                  ENTER
 1414           ELSE MAXNDECSY = NDECSY;                                                 ENTER
 1415        SYT (NDECSY) = N;                                                           ENTER
 1416        SYTYPE (NDECSY) = T;                                                        ENTER
 1417        SYTLOC (NDECSY) = L;                                                        ENTER
 1418        SYTSEG (NDECSY) = S;                                                        ENTER
 1419        SYTCO (NDECSY) = 0;                                                         ENTER
 1420        SYTCARD (NDECSY) = CARD_COUNT;                                              ENTER
 1421        PTR (NDECSY) = HASH (IDX);                                                  ENTER
 1422        HASH (IDX) = NDECSY;                                                        ENTER
 1423        RETURN (NDECSY);                                                            ENTER
 1424  END ENTER;                                                                        ENTER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9538     DATA   1381      12
K               FIXED      9539     DATA   1381       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 46
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 
L               FIXED      9536     DATA   1377       2
N               CHARACTER   817   STRING   1377       5
S               FIXED      9537     DATA   1377       2
T               FIXED      9535     DATA   1377       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 47
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1425   ID_LOOKUP:                                                                      *
 1426     PROCEDURE (P);                                                                *
 1427        /* LOOKS UP THE IDENTIFIER AT P IN THE ANALYSIS STACK IN THE                ID_LOOKUP
 1428           SYMBOL TABLE AND INITIALIZES FIXL, CNT, TYPE, AND INX                    ID_LOOKUP
 1429           APPROPRIATELY.  IF THE IDENTIFIER IS NOT FOUND, FIXL IS                  ID_LOOKUP
 1430           SET TO -1                                                                ID_LOOKUP
 1431        */                                                                          ID_LOOKUP
 1432        DECLARE P FIXED, I FIXED;                                                   ID_LOOKUP
 1433        CHAR_TEMP = VAR (P);                                                        ID_LOOKUP
 1434        I = HASH (HASHER (CHAR_TEMP));                                              ID_LOOKUP
 1435        DO WHILE I \= -1;                                                           ID_LOOKUP
 1436           IDCOMPARES = IDCOMPARES + 1;                                             ID_LOOKUP C16 = -1
 1437           IF SYT(I) = CHAR_TEMP THEN                                               ID_LOOKUP
 1438              DO;                                                                   ID_LOOKUP
 1439                 FIXL (P) = I;                                                      ID_LOOKUP
 1440                 CNT (P) = 0;        /* INITIALIZE SUBSCRIPT COUNT */               ID_LOOKUP
 1441                 TYPE (P) = VARIABLE;                                               ID_LOOKUP
 1442                 IF SYTYPE (I) = SPECIAL THEN                                       ID_LOOKUP
 1443                    FIXV (P) = SYTLOC (I);    /* BUILTIN FUNCTION */                ID_LOOKUP
 1444                 ELSE                                                               ID_LOOKUP
 1445                    FIXV (P) = 0;                                                   ID_LOOKUP
 1446                 INX (P) = 0;       /* LOCATION OF INDEX */                         ID_LOOKUP
 1447                 REG(P) = 0;                                                        ID_LOOKUP
 1448                 SYTCO (I) = SYTCO (I) + 1;                                         ID_LOOKUP
 1449                 RETURN;                                                            ID_LOOKUP
 1450              END;                                                                  ID_LOOKUP
 1451           I = PTR (I);                                                             ID_LOOKUP
 1452        END;                                                                        ID_LOOKUP
 1453        FIXL (P) = -1;              /* IDENTIFIER NOT FOUND */                      ID_LOOKUP
 1454  END ID_LOOKUP;                                                                    ID_LOOKUP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9559     DATA   1432      10
P               FIXED      9558     DATA   1426       9
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 48
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1455  UNDECLARED_ID:                                                                   *
 1456     PROCEDURE (P);                                                                *
 1457        /* ISSUES AN ERROR MESSAGE FOR UNDECLARED IDENTIFIERS AND                   UNDECLARED_ID
 1458           ENTERS THEM WITH DEFAULT TYPE IN THE SYMBOL TABLE                        UNDECLARED_ID
 1459       */                                                                           UNDECLARED_ID
 1460        DECLARE P FIXED;                                                            UNDECLARED_ID
 1461        CALL ERROR ('UNDECLARED IDENTIFIER: ' ^^ VAR (P), 0);                       UNDECLARED_ID
 1462        CALL EMITDATAWORD (0);                                                      UNDECLARED_ID
 1463        FIXL (P) = ENTER (VAR (P), FIXEDTYPE, DP-1, 1);                             UNDECLARED_ID
 1464        CNT (P) = 0;                                                                UNDECLARED_ID
 1465        FIXV (P) = 0;                                                               UNDECLARED_ID
 1466        INX (P) = 0;                                                                UNDECLARED_ID
 1467        SYTCO (NDECSY) = 1;            /* COUNT FIRST REFERENCE */                  UNDECLARED_ID
 1468        SYTCARD (NDECSY) = -1;         /* FLAG UNDECLARED IDENTIFIER */             UNDECLARED_ID
 1469        TYPE (P) = VARIABLE;                                                        UNDECLARED_ID
 1470  END UNDECLARED_ID;                                                                UNDECLARED_ID

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9561     DATA   1456       7
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 49
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1471   /*                                                                              *
 1472          A R I T H E M E T I C   P R O C E D U R E S                              *
 1473   */                                                                              *
 1474  CLEARARS:                                                                        *
 1475     PROCEDURE;                                                                    *
 1476        /* FREE ALL THE TEMPROARY ARITHEMETIC REGISTERS */                          CLEARARS
 1477        DO I = 0 TO 11;                                                             CLEARARS
 1478           ACC(I) = AVAIL;                                                          CLEARARS C17 = 11
 1479        END;                                                                        CLEARARS
 1480  END CLEARARS;                                                                     CLEARARS
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 50
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1481  FINDAR:                                                                          *
 1482     PROCEDURE;                                                                    *
 1483         DECLARE I FIXED;                                                           FINDAR
 1484        /* GET A TEMPORARY ARITHEMETIC REGISTER */                                  FINDAR
 1485        IF TARGET_REGISTER > -1 THEN                                                FINDAR
 1486           IF ACC (TARGET_REGISTER) = AVAIL THEN                                    FINDAR
 1487              DO;                                                                   FINDAR
 1488                 ACC (TARGET_REGISTER) = BUSY;                                      FINDAR
 1489                 RETURN TARGET_REGISTER;                                            FINDAR
 1490              END;                                                                  FINDAR
 1491        DO I = 1 TO 11;                                                             FINDAR
 1492           IF ACC(I) = AVAIL THEN                                                   FINDAR
 1493              DO;                                                                   FINDAR
 1494                 ACC(I) = BUSY;                                                     FINDAR
 1495                 RETURN (I);                                                        FINDAR
 1496              END;                                                                  FINDAR
 1497        END;                                                                        FINDAR
 1498        CALL ERROR ('USED ALL ACCUMULATORS', 0);                                    FINDAR
 1499        RETURN (0);                                                                 FINDAR
 1500  END FINDAR;                                                                       FINDAR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9569     DATA   1483       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 51
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1501  MOVESTACKS:                                                                      *
 1502     PROCEDURE (F, T);                                                             *
 1503        DECLARE F FIXED, T FIXED;                                                   MOVESTACKS
 1504        /* MOVE ALL COMPILER STACKS DOWN FROM F TO T */                             MOVESTACKS
 1505        TYPE (T) = TYPE (F);                                                        MOVESTACKS
 1506        REG (T) = REG (F);                                                          MOVESTACKS
 1507        CNT (T) = CNT (F);                                                          MOVESTACKS
 1508        VAR (T) = VAR (F);                                                          MOVESTACKS
 1509        FIXL (T) = FIXL (F);                                                        MOVESTACKS
 1510        FIXV (T) = FIXV (F);                                                        MOVESTACKS
 1511        INX (T) = INX (F);                                                          MOVESTACKS
 1512        PPSAVE (T) = PPSAVE (F);                                                    MOVESTACKS
 1513  END MOVESTACKS;                                                                   MOVESTACKS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
F               FIXED      9576     DATA   1502       8
T               FIXED      9577     DATA   1502       8
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 52
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1514  FORCEADDRESS:                                                                    *
 1515     PROCEDURE(SP);                                                                *
 1516        /* GENERATES THE ADDRESS OF <VARIABLE> IN THE ANALYSIS STACK                FORCEADDRESS
 1517           AT SP.                                                                   FORCEADDRESS
 1518        */                                                                          FORCEADDRESS
 1519        DECLARE SP FIXED, J FIXED, R FIXED;                                         FORCEADDRESS
 1520        R = FINDAR;                                                                 FORCEADDRESS
 1521        J = FIXL(SP);                                                               FORCEADDRESS
 1522        CALL EMITINST (MOVEI,R,0,SYTLOC(J),0,SYTSEG(J));                            FORCEADDRESS
 1523        REG(J) = R;                                                                 FORCEADDRESS
 1524  END FORCEADDRESS;                                                                 FORCEADDRESS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
J               FIXED      9579     DATA   1519       4
R               FIXED      9580     DATA   1519       3
SP              FIXED      9578     DATA   1515       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 53
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1525  SETINIT:                                                                         *
 1526     PROCEDURE;                                                                    *
 1527        /* PLACES INITIAL VALUES INTO DATA AREA */                                  SETINIT
 1528        DECLARE TMIIIL CHARACTER INITIAL ('TOO MANY ITEMS IN INITIAL LIST');        SETINIT
 1529        IF ITYPE = CHRTYPE THEN                                                     SETINIT
 1530           DO;                                                                      SETINIT
 1531              IF DSP < NEWDSP THEN                                                  SETINIT
 1532                 DO;                                                                SETINIT
 1533                    IF TYPE (MPP1) \= CHRTYPE THEN S = FIXV (MPP1);                 SETINIT
 1534                    ELSE S = VAR (MPP1);     /* THE STRING */                       SETINIT
 1535                    I = LENGTH (S);                                                 SETINIT
 1536                    IF I = 0 THEN                                                   SETINIT
 1537                       CALL EMITDESC (0,0);                                         SETINIT
 1538                    ELSE                                                            SETINIT
 1539                       DO;                                                          SETINIT
 1540                          CALL EMITDESC (I, DPOFFSET+SHL(DP,2));                    SETINIT
 1541                          DO J = 0 TO I - 1;                                        SETINIT
 1542                             CALL EMITBYTE (BYTE (S, J));                           SETINIT
 1543                          END;                                                      SETINIT
 1544                        END;                                                        SETINIT
 1545                 END;                                                               SETINIT
 1546              ELSE CALL ERROR (TMIIIL,0);                                           SETINIT
 1547           END;                                                                     SETINIT
 1548        ELSE                                                                        SETINIT
 1549           IF TYPE (MPP1) \= CONSTANT THEN                                          SETINIT
 1550              CALL ERROR ('ILLEGAL CONSTANT IN INITIAL LIST',0);                    SETINIT
 1551           ELSE                                                                     SETINIT
 1552              IF ITYPE = FIXEDTYPE THEN                                             SETINIT
 1553                 DO;                                                                SETINIT
 1554                 IF DP < NEWDP THEN CALL EMITDATAWORD (FIXV(MPP1));                 SETINIT
 1555                 ELSE CALL ERROR (TMIIIL,0);                                        SETINIT
 1556                 END;                                                               SETINIT
 1557              ELSE   /* MUST BE BYTETYPE */                                         SETINIT
 1558                 IF DP < NEWDP ^ (DP = NEWDP & DPOFFSET < NEWDPOFFSET) THEN         SETINIT
 1559                    CALL EMITBYTE(FIXV(MPP1));                                      SETINIT
 1560                 ELSE CALL ERROR (TMIIIL,0);                                        SETINIT
 1561  END SETINIT;                                                                      SETINIT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
TMIIIL          CHARACTER   823   STRING   1528       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 54
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1562  SAVE_ACS:                                                                        *
 1563     PROCEDURE (N);                                                                *
 1564        /* GENERATE CODE TO SAVE BUSY ACS, UP TO AC-N */                            SAVE_ACS
 1565        DECLARE N FIXED;                                                            SAVE_ACS
 1566        DECLARE I FIXED;                                                            SAVE_ACS
 1567        DO I = 1 TO N;                                                              SAVE_ACS
 1568           IF (ACC(I) = BUSY) THEN CALL EMITINST (PUSH,15,0,I,0,0);                 SAVE_ACS
 1569        END;                                                                        SAVE_ACS
 1570  END SAVE_ACS;                                                                     SAVE_ACS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9599     DATA   1566       3
N               FIXED      9598     DATA   1563       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 55
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1571  RESTORE_ACS:                                                                     *
 1572     PROCEDURE (N);                                                                *
 1573        /* GENERATE CODE TO RESTORE BUSY ACS, UP TO AC-N  */                        RESTORE_ACS
 1574        DECLARE N FIXED;                                                            RESTORE_ACS
 1575        DECLARE I FIXED, J FIXED;                                                   RESTORE_ACS
 1576        DO I = 1 TO N;                                                              RESTORE_ACS
 1577           J = N - I + 1;                                                           RESTORE_ACS
 1578           IF (ACC(J) = BUSY) THEN CALL EMITINST (POP,15,0,J,0,0);                  RESTORE_ACS
 1579        END;                                                                        RESTORE_ACS
 1580  END RESTORE_ACS;                                                                  RESTORE_ACS

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9602     DATA   1575       2
J               FIXED      9603     DATA   1575       3
N               FIXED      9601     DATA   1572       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 56
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1581  PROC_START:                                                                      *
 1582     PROCEDURE;                                                                    *
 1583        /* GENERATES CODE FOR THE HEAD OF A PROCEDURE */                            PROC_START
 1584        PPSAVE(MP) = FINDLABEL;           /* SOMETHING TO GOTO */                   PROC_START
 1585        CALL EMITINST (JRST,0,0,PPSAVE(MP),0,4); /* GO AROUND PROC */               PROC_START
 1586        IF SYTSEG(FIXL(MP)) = 4 THEN CALL EMITLABEL(SYTLOC(FIXL(MP)),4);            PROC_START
 1587        SYTSEG(FIXL(MP)) = 2;                                                       PROC_START
 1588        SYTLOC(FIXL(MP)) = PP;            /* ADDR OF PROC */                        PROC_START
 1589  END PROC_START;                                                                   PROC_START
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 57
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1590  TDECLARE:                                                                        *
 1591     PROCEDURE (DIM);                                                              *
 1592     /* ALLOCATES STORAGE FOR IDENTIFIERS IN DECLARATION */                         TDECLARE
 1593        DECLARE DIM FIXED;                                                          TDECLARE
 1594        DECLARE I   FIXED;                                                          TDECLARE
 1595     ALLOCATE:                                                                      TDECLARE
 1596        PROCEDURE (P, DIM);                                                         TDECLARE
 1597           /* ALLOCATES STORAGE FOR THE IDENTIFIER AT P IN THE ANALYSIS             ALLOCATE
 1598              STACK WITH DIMENSION DIM                                              ALLOCATE
 1599           */                                                                       ALLOCATE
 1600           DECLARE P FIXED, DIM FIXED, J FIXED, K FIXED;                            ALLOCATE
 1601           DIM = DIM + 1;                    /* ACTUAL NUMBER OF ITEMS */           ALLOCATE
 1602           DO CASE TYPE (P);                                                        ALLOCATE
 1603              ;    /*  CASE 0 -- DUMMY */                                           ALLOCATE CASE 0.
 1604              ;    /*  CASE 1 -- LABEL TYPE */                                      ALLOCATE CASE 1.
 1605              ;    /*  CASE 2 -- ACCUMULATOR */                                     ALLOCATE CASE 2.
 1606              ;    /*  CASE 3 -- VARIABLE */                                        ALLOCATE CASE 3.
 1607              ;    /*  CASE 4 -- CONSTANT */                                        ALLOCATE CASE 4.
 1608              ;    /*  CASE 5 -- CONDITION */                                       ALLOCATE CASE 5.
 1609              DO;   /* CASE 6 -- CHRTYPE */                                         ALLOCATE CASE 6.
 1610                 J = DSP; K = 3;                                                    ALLOCATE
 1611                 NEWDSP = DSP + DIM;                                                ALLOCATE
 1612              END;                                                                  ALLOCATE
 1613              DO;  /*  CASE 7 -- FIXEDTYPE */                                       ALLOCATE CASE 7.
 1614                 IF DPOFFSET > 0 THEN                                               ALLOCATE
 1615                    DO;                                                             ALLOCATE
 1616                       CALL FLUSH_DATACARD;                                         ALLOCATE
 1617                       OLDDP = DP;                                                  ALLOCATE
 1618                       OLDDPOFFSET = 0;                                             ALLOCATE
 1619                    END;                                                            ALLOCATE
 1620                 J = DP; K = 1;                                                     ALLOCATE
 1621                 NEWDP = DP + DIM; NEWDPOFFSET = 0;                                 ALLOCATE
 1622              END;                                                                  ALLOCATE
 1623              DO;  /*  CASE 8 -- BYTETYPE */                                        ALLOCATE CASE 8.
 1624                 IF DPOFFSET > 0 THEN                                               ALLOCATE
 1625                    IF I = 1 THEN                                                   ALLOCATE
 1626                       DO;                                                          ALLOCATE
 1627                          CALL FLUSH_DATACARD;                                      ALLOCATE
 1628                          OLDDP = DP; OLDDPOFFSET = 0;                              ALLOCATE
 1629                       END;                                                         ALLOCATE
 1630                    ELSE                                                            ALLOCATE
 1631                       DO;                                                          ALLOCATE
 1632                          DP = DP + 1; DPOFFSET = 0;                                ALLOCATE
 1633                       END;                                                         ALLOCATE
 1634                 NEWDPOFFSET = DIM MOD 4;                                           ALLOCATE
 1635                 NEWDP = DP + DIM/4;                                                ALLOCATE
 1636                 J = DP; K = 1;                                                     ALLOCATE
 1637              END;                                                                  ALLOCATE
 1638              DO;  /*  CASE 9 -- FORWARDTYPE */                                     ALLOCATE CASE 9.
 1639                 J = FINDLABEL; K = 4;                                              ALLOCATE
 1640                 NEWDP = DP; NEWDPOFFSET = DPOFFSET; /* COPY OLD POINTERS  */       ALLOCATE
 1641              END;                                                                  ALLOCATE
 1642              ;    /*  CASE 10 -- DESCRIPT */                                       ALLOCATE CASE 10.
 1643              ;    /*  CASE 11 -- SPECIAL */                                        ALLOCATE CASE 11.
 1644              ;    /*  CASE 12 -- FORWARDCALL */                                    ALLOCATE CASE 12.
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 58
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1645              ;    /*  CASE 13 -- PROCTYPE */                                       ALLOCATE CASE 13.
 1646              ;    /*  CASE 14 -- CHARPROCTYPE */                                   ALLOCATE CASE 14.
 1647           END; /* CASE ON TYPE (P) */                                              ALLOCATE CASE 15.
 1648           SYTYPE (FIXL(P)) = TYPE (P);                                             ALLOCATE
 1649           SYTLOC (FIXL (P)) = J;                                                   ALLOCATE
 1650           SYTSEG (FIXL (P)) = K;                                                   ALLOCATE
 1651     END ALLOCATE;                                                                  ALLOCATE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
DIM             FIXED      9608     DATA   1596       6
J               FIXED      9609     DATA   1600       5
K               FIXED      9610     DATA   1600       5
P               FIXED      9607     DATA   1596       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 59
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1652                                                                                    TDECLARE
 1653        OLDDP = DP;                                                                 TDECLARE
 1654        OLDDSP = DSP;                                                               TDECLARE
 1655        OLDDPOFFSET = DPOFFSET;                                                     TDECLARE
 1656        TYPE(MP) = TYPE(SP);                                                        TDECLARE
 1657        CASEP = FIXL(MP);                                                           TDECLARE
 1658        DO I = 1 TO INX(MP);                                                        TDECLARE
 1659           FIXL(MP) = CASESTACK(CASEP+I); /* SYMBOL TABLE POINTER */                TDECLARE
 1660           CALL ALLOCATE (MP,DIM);                                                  TDECLARE
 1661           DP = NEWDP;                                                              TDECLARE
 1662           DSP = NEWDSP;                                                            TDECLARE
 1663           DPOFFSET = NEWDPOFFSET;                                                  TDECLARE
 1664           END;                                                                     TDECLARE
 1665        DP = OLDDP;                                                                 TDECLARE
 1666        DSP = OLDDSP;                                                               TDECLARE
 1667        DPOFFSET = OLDDPOFFSET;                                                     TDECLARE
 1668  END TDECLARE;                                                                     TDECLARE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
ALLOCATE        PROCEDURE  3644  PROGRAM   1595       1
  PARAMETER  1  FIXED      9607     DATA   1596       6
  PARAMETER  2  FIXED      9608     DATA   1596       7
DIM             FIXED      9605     DATA   1591       1
I               FIXED      9606     DATA   1594       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 60
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1669  CHECK_STRING_OVERFLOW:                                                           *
 1670     PROCEDURE;                                                                    *
 1671        /* GENERATE A CHECK TO SEE IF COMPACTIFY NEEDS TO BE CALLED */              CHECK_STRING_OVERFLOW
 1672        CALL EMITINST (PUSHJ,15,0,STRING_CHECK,0,2);                                CHECK_STRING_OVERFLOW
 1673  END CHECK_STRING_OVERFLOW;                                                        CHECK_STRING_OVERFLOW
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 61
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1674  CALLSUB:PROCEDURE (SL,F,P);                                                      *
 1675        /* GENERATES CODE TO CALL A FUNCTION OR PROCEDURE AT SL                     CALLSUB
 1676           ALSO DOES HOUSEKEEPING FOR RETURN VALUES                                 CALLSUB
 1677        */                                                                          CALLSUB
 1678        DECLARE SL FIXED, F FIXED, P FIXED;                                         CALLSUB
 1679        CALL SAVE_ACS (11);                                                         CALLSUB
 1680        CALL EMITINST (PUSHJ,15,0,SL,0,SYTSEG(FIXL(P)));                            CALLSUB
 1681        CALL RESTORE_ACS (11);                                                      CALLSUB
 1682        IF F = 1 THEN                                                               CALLSUB
 1683           DO;  /* MOVE RETURNED VALUE FROM REGISTER ZERO */                        CALLSUB
 1684              I = FINDAR;                                                           CALLSUB
 1685              IF I \= 0 THEN CALL EMITINST (MOVE,I,0,0,0,0);                        CALLSUB
 1686              TYPE(P) = ACCUMULATOR;                                                CALLSUB
 1687              REG(P) = I;                                                           CALLSUB
 1688              ACC(I) = BUSY;                                                        CALLSUB
 1689              STILLINZERO = I;                                                      CALLSUB
 1690           END;                                                                     CALLSUB
 1691  END CALLSUB;                                                                      CALLSUB

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
F               FIXED      9613     DATA   1674       1
P               FIXED      9614     DATA   1674       3
SL              FIXED      9612     DATA   1674       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 62
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1692  BACKUP:                                                                          *
 1693     PROCEDURE;                                                                    *
 1694           CODE_FULL(CODE_HEAD) = FALSE;                                            BACKUP
 1695           CODE_HEAD = (CODE_HEAD-1) & 3;                                           BACKUP
 1696           INSTRUCT(MOVE) = INSTRUCT(MOVE) -1;                                      BACKUP
 1697           PP = PP - 1;                                                             BACKUP
 1698           STILLINZERO = 0;                                                         BACKUP
 1699           IF CONTROL(BYTE('E')) THEN                                               BACKUP
 1700              CALL PRINTLINE (BACKMSG,-1);                                          BACKUP
 1701     END BACKUP;                                                                    BACKUP
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 63
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1702  DELETE_MOVE:                                                                     *
 1703     PROCEDURE (P,OP,AC,IND,OPERAND,INDEX,RELOC);                                  *
 1704     /*  CHECK STILLINZERO FLAG TO SEE IF THE DATUM ABOUT TO                        DELETE_MOVE
 1705          BE MOVED IS STILL IN REGISTER ZERO.  IF SO, THEN DELETE                   DELETE_MOVE
 1706          THE LAST INSTRUCTION GENERATED (IF A "MOVE"),                             DELETE_MOVE
 1707          AND MOVE IT DIRECTLY FROM 0 TO THE DESRIED DEST.                          DELETE_MOVE
 1708          THIS IS DESIGNED TO ELIMINATE MOST EXTRA MOVES                            DELETE_MOVE
 1709          OF FUNCTION RESULTS. */                                                   DELETE_MOVE
 1710        DECLARE P FIXED;                                                            DELETE_MOVE
 1711        DECLARE OP FIXED, AC FIXED, IND FIXED, OPERAND FIXED,                       DELETE_MOVE
 1712             INDEX FIXED, RELOC FIXED;                                              DELETE_MOVE
 1713        IF STILLINZERO \= 0 THEN                                                    DELETE_MOVE
 1714           DO;                                                                      DELETE_MOVE
 1715              IF OP = MOVEM & STILLINZERO = AC THEN                                 DELETE_MOVE
 1716                 DO;                                                                DELETE_MOVE
 1717                    CALL BACKUP;                                                    DELETE_MOVE
 1718                    ACC(REG(P)) = AVAIL;                                            DELETE_MOVE
 1719                    REG(P) = 0;                                                     DELETE_MOVE
 1720                    AC = 0;                                                         DELETE_MOVE
 1721                 END;                                                               DELETE_MOVE
 1722              ELSE IF OP = MOVE  & STILLINZERO = OPERAND                            DELETE_MOVE
 1723                                 & (IND + INDEX + RELOC) = 0 THEN                   DELETE_MOVE
 1724                 DO;                                                                DELETE_MOVE
 1725                    CALL BACKUP;                                                    DELETE_MOVE
 1726                    ACC(REG(P)) = AVAIL;                                            DELETE_MOVE
 1727                    REG(P) = 0;                                                     DELETE_MOVE
 1728                    OPERAND = 0;                                                    DELETE_MOVE
 1729                 END;                                                               DELETE_MOVE
 1730           END;                                                                     DELETE_MOVE
 1731        CALL EMITINST (OP,AC,IND,OPERAND,INDEX,RELOC);                              DELETE_MOVE
 1732     END DELETE_MOVE;                                                               DELETE_MOVE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
AC              FIXED      9617     DATA   1703       3
IND             FIXED      9618     DATA   1703       2
INDEX           FIXED      9620     DATA   1703       2
OP              FIXED      9616     DATA   1703       3
OPERAND         FIXED      9619     DATA   1703       3
P               FIXED      9615     DATA   1703       4
RELOC           FIXED      9621     DATA   1703       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 64
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1733  EMIT_INLINE:                                                                     *
 1734     PROCEDURE (FLAG);                                                             *
 1735     /* GENERATE AN ARBITRARY INSTRUCTION SPECIFIED BY PROGRAMMER */                EMIT_INLINE
 1736        DECLARE FLAG BIT(1);                                                        EMIT_INLINE
 1737        DECLARE FL FIXED;                                                           EMIT_INLINE
 1738        DECLARE INST(5) FIXED;                                                      EMIT_INLINE
 1739        DECLARE BINLM CHARACTER INITIAL ('IMPROPER ARGUMENT TO INLINE');            EMIT_INLINE
 1740        IF CNT(MP) < 5 THEN                                                         EMIT_INLINE
 1741           DO;                                                                      EMIT_INLINE
 1742              IF TYPE(MPP1) = CONSTANT THEN INST(CNT(MP)-1) = FIXV(MPP1);           EMIT_INLINE
 1743              ELSE CALL ERROR (BINLM,1);                                            EMIT_INLINE
 1744              IF FLAG THEN CALL ERROR (BINLM,1);                                    EMIT_INLINE
 1745           END;                                                                     EMIT_INLINE
 1746        ELSE IF CNT(MP) = 5 THEN                                                    EMIT_INLINE
 1747           DO;                                                                      EMIT_INLINE
 1748              IF TYPE(MPP1) = CONSTANT THEN                                         EMIT_INLINE
 1749                 DO;                                                                EMIT_INLINE
 1750                    INST(4) = FIXV(MPP1);                                           EMIT_INLINE
 1751                    INST(5) = 0;                                                    EMIT_INLINE
 1752                 END;                                                               EMIT_INLINE
 1753              ELSE IF TYPE(MPP1) = VARIABLE THEN                                    EMIT_INLINE
 1754                 DO;                                                                EMIT_INLINE
 1755                    FL = FIXL(MPP1);                                                EMIT_INLINE
 1756                    INST(4) = SYTLOC(FL);                                           EMIT_INLINE
 1757                    INST(5) = SYTSEG(FL);                                           EMIT_INLINE
 1758                 END;                                                               EMIT_INLINE
 1759              ELSE CALL ERROR (BINLM,1);                                            EMIT_INLINE
 1760              CALL EMITINST (INST(0),INST(1),INST(2),INST(4),INST(3),INST(5));      EMIT_INLINE
 1761              REG(MP) = INST(1);                                                    EMIT_INLINE
 1762              TYPE(MP) = ACCUMULATOR;                                               EMIT_INLINE
 1763           END;                                                                     EMIT_INLINE
 1764        ELSE CALL ERROR (BINLM,1);  /* TOO MANY ARGS TO INLINE */                   EMIT_INLINE
 1765     END EMIT_INLINE;                                                               EMIT_INLINE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
BINLM           CHARACTER   825   STRING   1739       4
FL              FIXED      9623     DATA   1737       3
FLAG            BIT (9)    9622     DATA   1734       1
INST            FIXED      9624     DATA   1738      12
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 65
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1766  LIBRARY_CALL:   PROCEDURE (RESULT, CODE, MP, SP);                                *
 1767     /*                                                                             LIBRARY_CALL
 1768     GENERATE THE CODE FOR A CALL TO THE RUN-TIME ROUTINES.                         LIBRARY_CALL
 1769     */                                                                             LIBRARY_CALL
 1770     DECLARE RESULT FIXED,   /* 0 = L.H.S. OF = */                                  LIBRARY_CALL
 1771             CODE FIXED,     /* CODE FOR RUN-TIME ROUTINE*/                         LIBRARY_CALL
 1772             MP   FIXED,     /* STACK POINTER */                                    LIBRARY_CALL
 1773             SP   FIXED;     /* TOP OF STACK POINTER */                             LIBRARY_CALL
 1774     DECLARE R    FIXED;                                                            LIBRARY_CALL
 1775                                                                                    LIBRARY_CALL
 1776     IF RESULT = 0 THEN                                                             LIBRARY_CALL
 1777        DO;                                                                         LIBRARY_CALL
 1778           IF STILLINZERO = REG(SP) THEN                                            LIBRARY_CALL
 1779              DO;                                                                   LIBRARY_CALL
 1780                 CALL BACKUP;                                                       LIBRARY_CALL
 1781                 ACC(REG(SP)) = AVAIL;                                              LIBRARY_CALL
 1782                 REG(SP) = 0;                                                       LIBRARY_CALL
 1783              END;                                                                  LIBRARY_CALL
 1784           R = REG(SP);                                                             LIBRARY_CALL
 1785        END;                                                                        LIBRARY_CALL
 1786     ELSE                                                                           LIBRARY_CALL
 1787        R = FINDAR;                                                                 LIBRARY_CALL
 1788     IF CNT(MP) > 0 THEN CALL EMITINST (CODE+1,R,0,0,REG(MP),0);                    LIBRARY_CALL
 1789                    ELSE CALL EMITINST (CODE+1,R,0,0,0,0);                          LIBRARY_CALL
 1790     IF RESULT \= 0 THEN                                                            LIBRARY_CALL
 1791        DO;                                                                         LIBRARY_CALL
 1792           REG(MP) = R;                                                             LIBRARY_CALL
 1793           TYPE(MP) = RESULT;                                                       LIBRARY_CALL
 1794        END;                                                                        LIBRARY_CALL
 1795     END LIBRARY_CALL;                                                              LIBRARY_CALL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CODE            FIXED      9638     DATA   1766       2
MP              FIXED      9639     DATA   1766       4
R               FIXED      9641     DATA   1774       5
RESULT          FIXED      9637     DATA   1766       3
SP              FIXED      9640     DATA   1766       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 66
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1796  MONITOR_CALL:   PROCEDURE (CODE, P, JOBFLG);                                     *
 1797     /*                                                                             MONITOR_CALL
 1798     ROUTINE TO GENERATE CODE FOR PDP-10 CALLI UUO.                                 MONITOR_CALL
 1799     */                                                                             MONITOR_CALL
 1800     DECLARE CODE  FIXED,    /* CALLI NUMBER */                                     MONITOR_CALL
 1801            JOBFLG FIXED,  /* CLEAR AC FLAG */                                      MONITOR_CALL
 1802             P     FIXED;    /* STACK POINTER*/                                     MONITOR_CALL
 1803     DECLARE R     FIXED;    /* CONTAINS REGISTER TO USE */                         MONITOR_CALL
 1804                                                                                    MONITOR_CALL
 1805     R = FINDAR;                                                                    MONITOR_CALL
 1806     IF JOBFLG THEN CALL EMITINST (MOVEI,R,0,0,0,0);                                MONITOR_CALL
 1807     CALL EMITINST (CALLI,R,0,CODE,0,0);                                            MONITOR_CALL
 1808     REG(P) = R;                                                                    MONITOR_CALL
 1809     TYPE(P) = ACCUMULATOR;                                                         MONITOR_CALL
 1810  END MONITOR_CALL;                                                                 MONITOR_CALL

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CODE            FIXED      9642     DATA   1796       1
JOBFLG          FIXED      9643     DATA   1796       1
P               FIXED      9644     DATA   1796       2
R               FIXED      9645     DATA   1803       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 67
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1811  FORCEACCUMULATOR:PROCEDURE (P);                                                  *
 1812        DECLARE P FIXED;                                                            FORCEACCUMULATOR
 1813        /* FORCE THE OPERAND AT P INTO AN ACCUMULATOR */                            FORCEACCUMULATOR
 1814        DECLARE SL FIXED, TP FIXED, SFP FIXED, SS FIXED;                            FORCEACCUMULATOR
 1815        DECLARE T1 CHARACTER;                                                       FORCEACCUMULATOR
 1816        DECLARE R FIXED;                                                            FORCEACCUMULATOR
 1817        COUNT_FORCE = COUNT_FORCE + 1;                                              FORCEACCUMULATOR
 1818        TP = TYPE(P);                                                               FORCEACCUMULATOR
 1819        IF TP = VARIABLE THEN                                                       FORCEACCUMULATOR
 1820            DO;                                                                     FORCEACCUMULATOR
 1821              SL = SYTLOC(FIXL(P));                                                 FORCEACCUMULATOR
 1822              SS = SYTSEG(FIXL(P));                                                 FORCEACCUMULATOR
 1823              SFP = SYTYPE(FIXL(P));                                                FORCEACCUMULATOR
 1824              IF SFP = PROCTYPE ^ SFP = FORWARDCALL ^ SFP = CHARPROCTYPE THEN       FORCEACCUMULATOR
 1825                 DO;                                                                FORCEACCUMULATOR
 1826                    CALL CALLSUB (SL,CALLTYPE,P);                                   FORCEACCUMULATOR
 1827                    R = FIXL(P)+CNT(P)+1;                                           FORCEACCUMULATOR
 1828                    IF LENGTH(SYT(R)) = 0 THEN                                      FORCEACCUMULATOR
 1829                       IF R <= NDECSY THEN                                          FORCEACCUMULATOR
 1830                          CALL PRINTLINE ('** WARNING--NOT ALL PARAMETERS SUPPLIED.',-1); FORCEACCUMULATOR
 1831                    IF SFP = CHARPROCTYPE THEN TYPE(P) = DESCRIPT;                  FORCEACCUMULATOR
 1832                 END;                                                               FORCEACCUMULATOR
 1833              ELSE IF SFP = SPECIAL THEN                                            FORCEACCUMULATOR
 1834                 DO;                                                                FORCEACCUMULATOR
 1835                    IF SL = 6 THEN                                                  FORCEACCUMULATOR
 1836                       DO;  /* BUILTIN FUNCTION INPUT */                            FORCEACCUMULATOR
 1837                          CALL CHECK_STRING_OVERFLOW;                               FORCEACCUMULATOR
 1838                          CALL EMITINST (MOVE,13,0,TSA,0,1);                        FORCEACCUMULATOR
 1839                          CALL LIBRARY_CALL (DESCRIPT,1,P,0);                       FORCEACCUMULATOR
 1840                          CALL EMITINST (MOVEM,13,0,TSA,0,1);                       FORCEACCUMULATOR
 1841                          CALL EMITINST (MOVEM,12,0,STR,0,3);                       FORCEACCUMULATOR
 1842                       END;                                                         FORCEACCUMULATOR
 1843                    ELSE IF SL = 8 THEN                                             FORCEACCUMULATOR
 1844                       DO;  /* BUILT-IN FUNCTION FILE */                            FORCEACCUMULATOR
 1845                        IF CNT(P) \= 1 THEN CALL ERROR (FILEMSG,0);                 FORCEACCUMULATOR
 1846                           ELSE CALL LIBRARY_CALL (ACCUMULATOR,5,P,0);              FORCEACCUMULATOR
 1847                       END;                                                         FORCEACCUMULATOR
 1848                    ELSE IF SL = 12 THEN                                            FORCEACCUMULATOR
 1849                       DO;  /* EXIT */                                              FORCEACCUMULATOR
 1850                          CALL EMITINST (4,0,0,0,0,0);                              FORCEACCUMULATOR
 1851                       END;                                                         FORCEACCUMULATOR
 1852                    ELSE IF SL = 13 THEN CALL MONITOR_CALL (19,P,0);                FORCEACCUMULATOR
 1853                    ELSE IF SL = 14 THEN CALL MONITOR_CALL (12,P,0);                FORCEACCUMULATOR
 1854                    ELSE IF SL = 19 THEN CALL MONITOR_CALL (23,P,1);                FORCEACCUMULATOR
 1855                    ELSE CALL ERROR ('ILLEGAL USE OF ' ^^ SYT(FIXL(P)),0);          FORCEACCUMULATOR
 1856                 END;                                                               FORCEACCUMULATOR
 1857              ELSE                                                                  FORCEACCUMULATOR
 1858                 DO;  /* FETCH THE VARIABLE (ALL ELSE HAS FAILED) */                FORCEACCUMULATOR
 1859                    IF SFP \= BYTETYPE THEN                                         FORCEACCUMULATOR
 1860                       DO;   /* WE DON'T HAVE TO DO CRAZY ADDRESSING */             FORCEACCUMULATOR
 1861                          R = FINDAR;     /* GET REG FOR RESULT */                  FORCEACCUMULATOR
 1862                          CALL EMITINST (MOVE,R,0,SL,INX(P),SS);                    FORCEACCUMULATOR
 1863                       END;                                                         FORCEACCUMULATOR
 1864                    ELSE                                                            FORCEACCUMULATOR
 1865                       DO;  /* BYTE ADDRESSING */                                   FORCEACCUMULATOR
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 68
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1866                          IF INX(P) \= 0 THEN                                       FORCEACCUMULATOR
 1867                             DO; /* GOOD GRIEF, SUBSCRIPTING OF BYTES */            FORCEACCUMULATOR
 1868                                R = FINDAR;                                         FORCEACCUMULATOR
 1869                                CALL EMITINST (MOVE,12,0,INX(P),0,0);               FORCEACCUMULATOR
 1870                                CALL EMITINST (LSH,12,0,    -2,0,0);                FORCEACCUMULATOR
 1871                                CALL EMITINST (ANDI,INX(P),0,3,0,0);                FORCEACCUMULATOR
 1872                                IF (SL ^ SS) \= 0 THEN CALL EMITINST (ADDI,12,0,SL,0,SS); FORCEACCUMULATOR
 1873                                CALL EMITINST (LDB,R,0,BYTEPTRS,INX(P),1);          FORCEACCUMULATOR
 1874                             END;                                                   FORCEACCUMULATOR
 1875                           ELSE                                                     FORCEACCUMULATOR
 1876                             DO; /* NON-SUBSCRIPTED BYTE */                         FORCEACCUMULATOR
 1877                                R = FINDAR;                                         FORCEACCUMULATOR
 1878                                CALL EMITINST (MOVEI,12,0,SL,0,SS);                 FORCEACCUMULATOR
 1879                                CALL EMITINST (LDB,R,0,BYTEPTRS,0,1);               FORCEACCUMULATOR
 1880                             END;                                                   FORCEACCUMULATOR
 1881                       END;                                                         FORCEACCUMULATOR
 1882                    IF SFP = CHRTYPE THEN TYPE(P) = DESCRIPT;                       FORCEACCUMULATOR
 1883                    ELSE TYPE(P) = ACCUMULATOR;                                     FORCEACCUMULATOR
 1884                    REG(P) = R;                                                     FORCEACCUMULATOR
 1885                    IF INX(P) \= 0 THEN ACC(INX(P)) = AVAIL;                        FORCEACCUMULATOR
 1886                 END;                                                               FORCEACCUMULATOR
 1887           END;                                                                     FORCEACCUMULATOR
 1888        ELSE IF TP = CONSTANT THEN                                                  FORCEACCUMULATOR
 1889           DO;  /* FETCH A CONSTANT INTO AN ACCUMULATOR */                          FORCEACCUMULATOR
 1890              R = FINDAR;                                                           FORCEACCUMULATOR
 1891              IF FIXV(P) < "20000" & FIXV(P) > - "20000" THEN                       FORCEACCUMULATOR
 1892                 CALL EMITINST (HRREI,R,0,FIXV(P),0,0);                             FORCEACCUMULATOR
 1893              ELSE                                                                  FORCEACCUMULATOR C18 = -131072
 1894                 DO;  /* PUT DOWN A CONSTANT AND PICK IT UP */                      FORCEACCUMULATOR
 1895                    CALL EMITCONSTANT (FIXV(P));                                    FORCEACCUMULATOR
 1896                    CALL EMITINST (MOVE,R,0,ADR,0,1);                               FORCEACCUMULATOR
 1897                 END;                                                               FORCEACCUMULATOR
 1898              REG(P) = R;                                                           FORCEACCUMULATOR
 1899              TYPE(P) = ACCUMULATOR;                                                FORCEACCUMULATOR
 1900           END;                                                                     FORCEACCUMULATOR
 1901        ELSE IF TP = CHRTYPE THEN                                                   FORCEACCUMULATOR
 1902           DO;  /* FETCH A DESCRIPTOR INTO AN ACCUMULATOR */                        FORCEACCUMULATOR
 1903              R = FINDAR;                                                           FORCEACCUMULATOR
 1904              TYPE(P) = DESCRIPT;                                                   FORCEACCUMULATOR
 1905              REG(P) = R;                                                           FORCEACCUMULATOR
 1906              T1 = VAR(P);                                                          FORCEACCUMULATOR
 1907              SL = LENGTH(T1);                                                      FORCEACCUMULATOR
 1908              IF SL = 0 THEN CALL EMITINST (MOVEI,R,0,0,0,0);                       FORCEACCUMULATOR
 1909              ELSE                                                                  FORCEACCUMULATOR
 1910                 DO;  /* GENERATE DESCRIPTOR AND STRING, THEN PICK IT UP */         FORCEACCUMULATOR
 1911                    CALL EMITINST (MOVE,R,0,DSP,0,3);                               FORCEACCUMULATOR
 1912                    CALL EMITDESC (SL,SHL(DP,2)+DPOFFSET);                          FORCEACCUMULATOR
 1913                    DO SL = 0 TO SL-1;                                              FORCEACCUMULATOR
 1914                       CALL EMITBYTE (BYTE(T1,SL));                                 FORCEACCUMULATOR
 1915                    END;                                                            FORCEACCUMULATOR
 1916                 END;                                                               FORCEACCUMULATOR
 1917           END;                                                                     FORCEACCUMULATOR
 1918        ELSE IF TP \= ACCUMULATOR THEN IF TP \= DESCRIPT THEN                       FORCEACCUMULATOR
 1919                 CALL ERROR ('FORCEACCUMULATOR FAILED ***',1);                      FORCEACCUMULATOR
 1920  END FORCEACCUMULATOR;                                                             FORCEACCUMULATOR
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 69
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9646     DATA   1811      34
R               FIXED      9651     DATA   1816      18
SFP             FIXED      9649     DATA   1814       8
SL              FIXED      9647     DATA   1814      18
SS              FIXED      9650     DATA   1814       5
T1              CHARACTER   826   STRING   1815       3
TP              FIXED      9648     DATA   1814       6
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 70
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1921  FORCEDESCRIPTOR:                                                                 *
 1922     PROCEDURE (P);                                                                *
 1923        /* GET A DESCRIPTOR FOR THE OPERAND P */                                    FORCEDESCRIPTOR
 1924        DECLARE P FIXED;                                                            FORCEDESCRIPTOR
 1925        CALL FORCEACCUMULATOR (P);                                                  FORCEDESCRIPTOR
 1926        IF TYPE (P) \= DESCRIPT THEN                                                FORCEDESCRIPTOR
 1927           DO; /* USE THE NUMBER TO DECIMAL STRING CONVERSION ROUTINE */            FORCEDESCRIPTOR
 1928              CALL DELETE_MOVE (P,MOVEM,REG(P),0,C,0,1);  /* SAVE AS C */           FORCEDESCRIPTOR
 1929              ACC(REG(P)) = AVAIL;                                                  FORCEDESCRIPTOR
 1930              CALL SAVE_ACS (1);                                                    FORCEDESCRIPTOR
 1931              CALL EMITINST (PUSHJ,15,0,NMBRENTRY,0,2);                             FORCEDESCRIPTOR
 1932              CALL RESTORE_ACS (1);                                                 FORCEDESCRIPTOR
 1933              ACC(REG(P)) = BUSY;                                                   FORCEDESCRIPTOR
 1934              IF REG(P) \= 0 THEN CALL EMITINST (MOVE,REG(P),0,0,0,0);              FORCEDESCRIPTOR
 1935              TYPE (P) = DESCRIPT;             /* IT IS NOW A STRING */             FORCEDESCRIPTOR
 1936              STILLINZERO = REG(P);                                                 FORCEDESCRIPTOR
 1937           END;                                                                     FORCEDESCRIPTOR
 1938  END FORCEDESCRIPTOR;                                                              FORCEDESCRIPTOR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
P               FIXED      9675     DATA   1922      10
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 71
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1939  GENSTORE:PROCEDURE (MP, SP);                                                     *
 1940        DECLARE MP FIXED, SP FIXED;                                                 GENSTORE
 1941        /* GENERATE TYPE CONVERSION (IF NECESSARY) & STORAGE CODE --                GENSTORE
 1942           ALSO HANDLES OUTPUT ON THE LEFT OF THE REPLACEMENT OPERATOR              GENSTORE
 1943        */                                                                          GENSTORE
 1944        DECLARE SL FIXED, SFP FIXED, SS FIXED;                                      GENSTORE
 1945        COUNT_STORE = COUNT_STORE + 1;                                              GENSTORE
 1946        SL = SYTLOC(FIXL(MP));                                                      GENSTORE
 1947        SS = SYTSEG(FIXL(MP));                                                      GENSTORE
 1948        SFP = SYTYPE(FIXL(MP));                                                     GENSTORE
 1949        IF SFP = SPECIAL THEN                                                       GENSTORE
 1950           DO;                                                                      GENSTORE
 1951              IF SL = 7 THEN                                                        GENSTORE
 1952                 DO;  /* BUILTIN FUNCTION OUTPUT */                                 GENSTORE
 1953                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1954                    CALL LIBRARY_CALL (0,2,MP,SP);                                  GENSTORE
 1955                 END;                                                               GENSTORE
 1956              ELSE IF SL = 8 THEN                                                   GENSTORE
 1957                 DO;   /* BUILTIN FUNCTION FILE */                                  GENSTORE
 1958                    IF CNT(MP) \= 1 THEN                                            GENSTORE
 1959                       CALL ERROR (FILEMSG,0);                                      GENSTORE
 1960                    CALL FORCEACCUMULATOR (SP);                                     GENSTORE
 1961                    CALL LIBRARY_CALL (0,6,MP,SP);                                  GENSTORE
 1962                 END;                                                               GENSTORE
 1963              ELSE IF SL = 20 THEN                                                  GENSTORE
 1964                 DO;    /* BUILT-IN FUNCTION  FILENAME */                           GENSTORE
 1965                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1966                    CALL LIBRARY_CALL (0,7,MP,SP);                                  GENSTORE
 1967                 END;                                                               GENSTORE
 1968              ELSE CALL ERROR ('ILLEGAL USE OF ' ^^ SYT(FIXL(MP)),0);               GENSTORE
 1969           END;                                                                     GENSTORE
 1970        ELSE                                                                        GENSTORE
 1971           DO;                                                                      GENSTORE
 1972              IF SFP = CHRTYPE THEN                                                 GENSTORE
 1973                 DO;                                                                GENSTORE
 1974                    CALL FORCEDESCRIPTOR(SP);                                       GENSTORE
 1975                    CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,SL,INX(MP),SS);            GENSTORE
 1976                 END;                                                               GENSTORE
 1977              ELSE IF TYPE(SP) = DESCRIPT ^ TYPE(SP) = CHRTYPE THEN                 GENSTORE
 1978                   CALL ERROR ('ASSIGNMENT REQUIRES ILLEGAL TYPE CONVERSION.',0);   GENSTORE
 1979              ELSE                                                                  GENSTORE
 1980                 DO;     /* FIXEDTYPE OR BYTETYPE */                                GENSTORE
 1981                    IF SFP = FIXEDTYPE THEN                                         GENSTORE
 1982                       DO;                                                          GENSTORE
 1983                       IF TYPE(SP) = CONSTANT & FIXV(SP) = 0 THEN                   GENSTORE
 1984                          CALL EMITINST(SETZM,0,0,SL,INX(MP),SS);                   GENSTORE
 1985                          ELSE                                                      GENSTORE
 1986                             DO;                                                    GENSTORE
 1987                                CALL FORCEACCUMULATOR(SP);                          GENSTORE
 1988                                CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,SL,INX(MP),SS); GENSTORE
 1989                             END;                                                   GENSTORE
 1990                       END;                                                         GENSTORE
 1991                    ELSE                                                            GENSTORE
 1992                       DO;      /* MUST BE BYTETYPE */                              GENSTORE
 1993                          CALL FORCEACCUMULATOR(SP);                                GENSTORE
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 72
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 1994                          IF INX(MP) \= 0 THEN                                      GENSTORE
 1995                             DO;  /* GOOD GRIEF, SUBSCRIPTING */                    GENSTORE
 1996                                 CALL EMITINST (MOVE,12,0,INX(MP),0,0);             GENSTORE
 1997                                 CALL EMITINST (LSH,12,0,    -2,0,0);               GENSTORE
 1998                                 CALL EMITINST (ANDI,INX(MP),0,3,0,0);              GENSTORE
 1999                                 IF (SL ^ SS) \= 0 THEN CALL EMITINST (ADDI,12,0,SL,0,SS); GENSTORE
 2000                                 CALL EMITINST (DPB,REG(SP),0,BYTEPTRS,INX(MP),1);  GENSTORE
 2001                             END;                                                   GENSTORE
 2002                          ELSE                                                      GENSTORE
 2003                             DO;                                                    GENSTORE
 2004                                 CALL EMITINST (MOVEI,12,0,SL,0,SS);                GENSTORE
 2005                                 CALL EMITINST (DPB,REG(SP),0,BYTEPTRS,0,1);        GENSTORE
 2006                             END;                                                   GENSTORE
 2007                       END;                                                         GENSTORE
 2008                 END;                                                               GENSTORE
 2009           END;                                                                     GENSTORE
 2010        ACC(INX(MP)) = AVAIL;                                                       GENSTORE
 2011        CALL MOVESTACKS (SP,MP);                                                    GENSTORE
 2012  END GENSTORE;                                                                     GENSTORE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MP              FIXED      9676     DATA   1939      17
SFP             FIXED      9679     DATA   1944       4
SL              FIXED      9678     DATA   1944      10
SP              FIXED      9677     DATA   1939      20
SS              FIXED      9680     DATA   1944       7
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 73
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2013  SHOULDCOMMUTE:PROCEDURE;                                                         *
 2014        IF TYPE(SP) = CONSTANT THEN RETURN (FALSE);                                 SHOULDCOMMUTE
 2015        IF TYPE(MP) = CONSTANT THEN RETURN (TRUE);                                  SHOULDCOMMUTE
 2016        IF TYPE(SP) = VARIABLE & SYTYPE(FIXL(SP)) = FIXEDTYPE THEN RETURN (FALSE);  SHOULDCOMMUTE
 2017        IF TYPE(MP) = VARIABLE & SYTYPE(FIXL(MP)) = FIXEDTYPE THEN RETURN (TRUE);   SHOULDCOMMUTE
 2018        RETURN FALSE;                                                               SHOULDCOMMUTE
 2019  END SHOULDCOMMUTE;                                                                SHOULDCOMMUTE
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 74
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2020  ARITHEMIT:PROCEDURE(OP,COMMUTATIVE);                                             *
 2021     DECLARE OP FIXED, COMMUTATIVE FIXED, TP FIXED;                                 ARITHEMIT
 2022     DECLARE AWASD CHARACTER INITIAL ('ARITHMETIC WITH A STRING DESCRIPTOR');       ARITHEMIT
 2023     /* EMIT AN INSTRUCTION FOR AN INFIX OPERATOR -- CONNECT MP & SP */             ARITHEMIT
 2024     COUNT_ARITH = COUNT_ARITH + 1;                                                 ARITHEMIT
 2025     TP = 0;                                                                        ARITHEMIT
 2026     IF COMMUTATIVE THEN                                                            ARITHEMIT
 2027        IF SHOULDCOMMUTE THEN                                                       ARITHEMIT
 2028           DO;                                                                      ARITHEMIT
 2029              TP = MP; MP = SP; SP = TP;                                            ARITHEMIT
 2030              IF OP >= CAM & OP <= CMPRHI THEN OP = COMPARESWAP(OP-CAM)+CAM;        ARITHEMIT
 2031           END;                                                                     ARITHEMIT
 2032     CALL FORCEACCUMULATOR(MP);  /* GET THE LEFT ONE INTO AN ACCUMULATOR */         ARITHEMIT
 2033     IF TYPE(MP) = DESCRIPT THEN CALL ERROR (AWASD,0);                              ARITHEMIT
 2034     ELSE IF TYPE(SP) = VARIABLE & SYTYPE(FIXL(SP)) = FIXEDTYPE THEN                ARITHEMIT
 2035        DO;  /* OPERATE FROM STORAGE */                                             ARITHEMIT
 2036           CALL EMITINST (OP,REG(MP),0,SYTLOC(FIXL(SP)),INX(SP),SYTSEG(FIXL(SP)));  ARITHEMIT
 2037           ACC(INX(SP)) = AVAIL;                                                    ARITHEMIT
 2038                                                                                    ARITHEMIT
 2039        END;                                                                        ARITHEMIT
 2040     ELSE IF TYPE(SP) = CONSTANT THEN                                               ARITHEMIT
 2041        DO;                                                                         ARITHEMIT
 2042           IF FIXV(SP) < "40000" & FIXV(SP) >= 0 THEN /* USE IMMEDIATE */           ARITHEMIT
 2043              DO;                                                                   ARITHEMIT
 2044                 IF OP >= CAM & OP <= CMPRHI THEN OP=OP-9; /* SOB CODE ORDER */     ARITHEMIT
 2045                    CALL EMITINST(OP+1,REG(MP),0,FIXV(SP),0,0);                     ARITHEMIT
 2046              END;                                                                  ARITHEMIT
 2047           ELSE                                                                     ARITHEMIT
 2048              DO;                                                                   ARITHEMIT
 2049                 CALL EMITCONSTANT (FIXV(SP));                                      ARITHEMIT
 2050                 CALL EMITINST (OP,REG(MP),0,ADR,0,1);                              ARITHEMIT
 2051              END;                                                                  ARITHEMIT
 2052        END;                                                                        ARITHEMIT
 2053     ELSE                                                                           ARITHEMIT
 2054         DO;                                                                        ARITHEMIT
 2055           CALL FORCEACCUMULATOR(SP);                                               ARITHEMIT
 2056           IF TYPE(SP) \= ACCUMULATOR THEN CALL ERROR (AWASD,0);                    ARITHEMIT
 2057           ELSE CALL EMITINST (OP,REG(MP),0,REG(SP),0,0);                           ARITHEMIT
 2058           ACC(REG(SP)) = AVAIL;                                                    ARITHEMIT
 2059        END;                                                                        ARITHEMIT
 2060     IF TP \= 0 THEN                                                                ARITHEMIT
 2061        DO;                                                                         ARITHEMIT
 2062           SP = MP; MP = TP;                                                        ARITHEMIT
 2063           CALL MOVESTACKS (SP,MP);                                                 ARITHEMIT
 2064        END;                                                                        ARITHEMIT
 2065  END ARITHEMIT;                                                                    ARITHEMIT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
AWASD           CHARACTER   832   STRING   2022       2
COMMUTATIVE     FIXED      9697     DATA   2020       1
OP              FIXED      9696     DATA   2020      12
TP              FIXED      9698     DATA   2021       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 75
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2066  BOOLBRANCH:PROCEDURE (SP,MP);                                                    *
 2067     DECLARE SP FIXED, MP FIXED, R FIXED;                                           BOOLBRANCH
 2068     /* GENERATE A CONDITIONAL BRANCH FOR DO WHILE OR AN IF STATEMENT               BOOLBRANCH
 2069        PLACE THE ADDRESS OF THIS BRANCH IN FIXL(MP)                                BOOLBRANCH
 2070     */                                                                             BOOLBRANCH
 2071     IF STILLCOND \= 0 THEN                                                         BOOLBRANCH
 2072        DO;  /* WE HAVE NOT GENERATED CODE SINCE SETTING THE CONDITION */           BOOLBRANCH
 2073           /* REMOVE THE MOVEI =1 AND MOVEI =0 AROUND THE CAM? */                   BOOLBRANCH
 2074           CODE_HEAD = (CODE_HEAD-2) &3; /* BACK UP PTR */                          BOOLBRANCH
 2075           R = (CODE_HEAD + 1) & 3;                                                 BOOLBRANCH
 2076           CODE(CODE_HEAD) = CODE(R);                                               BOOLBRANCH
 2077           CODE_REL(CODE_HEAD) = CODE_REL(R);                                       BOOLBRANCH
 2078           CODE_PP(CODE_HEAD) = CODE_PP(R) -1;                                      BOOLBRANCH
 2079           CODE_RBITS(CODE_HEAD) = CODE_RBITS(R);                                   BOOLBRANCH
 2080           CODE_FULL(R) = FALSE;                                                    BOOLBRANCH
 2081           CODE_FULL(R+1&3) = FALSE;                                                BOOLBRANCH
 2082           PP = PP - 2;                                                             BOOLBRANCH
 2083           CODE(CODE_HEAD) = CODE(CODE_HEAD) ^^ ' P' ^^ PP-1;                       BOOLBRANCH
 2084           IF CONTROL(BYTE('E')) THEN                                               BOOLBRANCH
 2085              DO;                                                                   BOOLBRANCH
 2086                 CALL PRINTLINE (BACKMSG,-1);                                       BOOLBRANCH
 2087                 CALL PRINTLINE (CODEMSG ^^ CODE(CODE_HEAD),-1);                    BOOLBRANCH
 2088              END;                                                                  BOOLBRANCH
 2089           INSTRUCT(MOVEI) = INSTRUCT(MOVEI) - 2;                                   BOOLBRANCH
 2090           ACC(REG(SP)) = AVAIL;          /* FREE CONDITION REGISTER */             BOOLBRANCH
 2091           R = 4;                         /* JUMP ALWAYS */                         BOOLBRANCH
 2092        END;                                                                        BOOLBRANCH
 2093     ELSE                                                                           BOOLBRANCH
 2094        DO;                                                                         BOOLBRANCH
 2095           CALL FORCEACCUMULATOR(SP);                                               BOOLBRANCH
 2096           CALL EMITINST (ANDI,REG(SP),0,1,0,0);  /* TEST ONLY LOW ORDER BIT */     BOOLBRANCH
 2097           ACC(REG(SP)) = AVAIL;          /* FREE UP VARIABLE REGISTER */           BOOLBRANCH
 2098           R = 2;                         /* JUMP IF REGISTER ZERO */               BOOLBRANCH
 2099        END;                                                                        BOOLBRANCH
 2100     FIXL(MP) = FINDLABEL;                /* GET A NEW LABEL */                     BOOLBRANCH
 2101     CALL EMITINST (JUMP+R,REG(SP),0,FIXL(MP),0,4);                                 BOOLBRANCH
 2102  END BOOLBRANCH;                                                                   BOOLBRANCH

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MP              FIXED      9709     DATA   2066       2
R               FIXED      9710     DATA   2067      10
SP              FIXED      9708     DATA   2066       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 76
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2103  SETLIMIT:                                                                        *
 2104     PROCEDURE;                                                                    *
 2105        /* SETS DO LOOP LIMIT FOR <ITERATION CONTROL> */                            SETLIMIT
 2106        IF TYPE (MPP1) = CONSTANT THEN                                              SETLIMIT
 2107           CALL EMITCONSTANT (FIXV(MPP1));                                          SETLIMIT
 2108        ELSE                                                                        SETLIMIT
 2109           DO;                                                                      SETLIMIT
 2110              CALL FORCEACCUMULATOR (MPP1);  /* GET LOOP LIMIT */                   SETLIMIT
 2111              CALL EMITDATAWORD (0);                                                SETLIMIT
 2112              ADR = DP - 1;                                                         SETLIMIT
 2113              CALL EMITINST(MOVEM,REG(MPP1),0,ADR,0,1); /* SAVE IT */               SETLIMIT
 2114              ACC(REG(MPP1)) = AVAIL;                                               SETLIMIT
 2115           END;                                                                     SETLIMIT
 2116        FIXV (MP) = ADR;                                                            SETLIMIT
 2117   END SETLIMIT;                                                                    SETLIMIT
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 77
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2118  STUFF_PARAMETER:                                                                 *
 2119     PROCEDURE;                                                                    *
 2120        /* GENERATE CODE TO SEND AN ACTUAL PARAMETER TO A PROCEDURE */              STUFF_PARAMETER
 2121        DECLARE (I,J) FIXED;                                                        STUFF_PARAMETER
 2122        I = FIXL (MP) + CNT (MP);  J = SYTLOC (I);                                  STUFF_PARAMETER
 2123        IF LENGTH (SYT(I)) = 0 THEN                                                 STUFF_PARAMETER
 2124           DO;                                                                      STUFF_PARAMETER
 2125              SYTCO (I) = SYTCO (I) + 1;  /* COUNT THE REFERENCE                */  STUFF_PARAMETER
 2126                 DO;                                                                STUFF_PARAMETER
 2127                    IF SYTYPE(I) = BYTETYPE THEN                                    STUFF_PARAMETER
 2128                      DO;                                                           STUFF_PARAMETER
 2129                         CALL FORCEACCUMULATOR(MPP1);                               STUFF_PARAMETER
 2130                         CALL EMITINST (MOVEI,12,0,J,0,SYTSEG(I));                  STUFF_PARAMETER
 2131                         CALL EMITINST (DPB,REG(MPP1),0,BYTEPTRS,0,1);              STUFF_PARAMETER
 2132                      END;                                                          STUFF_PARAMETER
 2133                    ELSE                                                            STUFF_PARAMETER
 2134                      DO;                                                           STUFF_PARAMETER
 2135                         IF TYPE(MPP1) = CONSTANT & FIXV(MPP1) = 0 THEN             STUFF_PARAMETER
 2136                            DO;                                                     STUFF_PARAMETER
 2137                               CALL EMITINST (SETZM,0,0,J,0,SYTSEG(I));             STUFF_PARAMETER
 2138                               RETURN;                                              STUFF_PARAMETER
 2139                            END;                                                    STUFF_PARAMETER
 2140                         CALL FORCEACCUMULATOR (MPP1);                              STUFF_PARAMETER
 2141                         CALL DELETE_MOVE (MPP1,MOVEM,REG(MPP1),0,J,0,SYTSEG(I));   STUFF_PARAMETER
 2142                      END;                                                          STUFF_PARAMETER
 2143                    ACC(REG(MPP1)) = AVAIL;                                         STUFF_PARAMETER
 2144                 END;                                                               STUFF_PARAMETER
 2145           END;                                                                     STUFF_PARAMETER
 2146        ELSE                                                                        STUFF_PARAMETER
 2147           CALL ERROR ('TOO MANY ACTUAL PARAMETERS', 1);                            STUFF_PARAMETER
 2148  END STUFF_PARAMETER;                                                              STUFF_PARAMETER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      9712     DATA   2121       9
J               FIXED      9713     DATA   2121       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 78
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2149  DIVIDE_CODE:PROCEDURE(T);                                                        *
 2150     DECLARE T FIXED, I FIXED;                                                      DIVIDE_CODE
 2151     /* EMIT CODE TO PERFORM A DIVIDE (T=1) OR MOD (T=0) */                         DIVIDE_CODE
 2152     /* FIND A FREE REGISTER PAIR FOR THE DIVIDEND */                               DIVIDE_CODE
 2153     IF TYPE(MP) = ACCUMULATOR THEN                                                 DIVIDE_CODE
 2154        DO;   /* WE MAY BE ABLE TO USE THE REGISTER TO THE RIGHT */                 DIVIDE_CODE
 2155           I = REG(MP);                                                             DIVIDE_CODE
 2156           IF ACC(I+1) = AVAIL THEN GOTO FITS;                                      DIVIDE_CODE
 2157        END;                                                                        DIVIDE_CODE
 2158     DO I = T TO 11;                                                                DIVIDE_CODE
 2159        IF ACC(I) = AVAIL THEN IF ACC(I+1) = AVAIL THEN GOTO FIT;                   DIVIDE_CODE
 2160     END;                                                                           DIVIDE_CODE
 2161     CALL ERROR ('NO FREE REGISTERS FOR DIVISION OR MOD.',0);                       DIVIDE_CODE
 2162     RETURN;                                                                        DIVIDE_CODE
 2163  FIT:                                                                              DIVIDE_CODE
 2164     TARGET_REGISTER = I;                                                           DIVIDE_CODE
 2165     CALL FORCEACCUMULATOR(MP);                                                     DIVIDE_CODE
 2166     TARGET_REGISTER = -1;                                                          DIVIDE_CODE
 2167     IF REG(MP) \= I THEN                                                           DIVIDE_CODE
 2168        DO;                                                                         DIVIDE_CODE
 2169           CALL EMITINST (MOVE,I,0,REG(MP),0,0);                                    DIVIDE_CODE
 2170           ACC(REG(MP)) = AVAIL;                                                    DIVIDE_CODE
 2171           REG(MP) = I;                                                             DIVIDE_CODE
 2172        END;                                                                        DIVIDE_CODE
 2173        ACC(I) = BUSY;                                                              DIVIDE_CODE
 2174   FITS:                                                                            DIVIDE_CODE
 2175     ACC(I+1) = BUSY;                                                               DIVIDE_CODE
 2176     CALL ARITHEMIT (IDIV,0);                                                       DIVIDE_CODE
 2177     IF T = 0 THEN                                                                  DIVIDE_CODE
 2178        DO;  /* MOD, SWITCH REGISTER TO POINT TO REMAINDER */                       DIVIDE_CODE
 2179           ACC(I) = AVAIL;                /* FREE QUOTIENT */                       DIVIDE_CODE
 2180           REG(MP) = I+1;                 /* POINT TO REMAINDER */                  DIVIDE_CODE
 2181        END;                                                                        DIVIDE_CODE
 2182     ELSE ACC(I+1) = AVAIL;               /* FREE REMAINDER */                      DIVIDE_CODE
 2183     IF REG(MP) =12 THEN                                                            DIVIDE_CODE
 2184        DO;  /* TRANSFER THE MOD REMAINDER FROM A SCRATCH REGISTER */               DIVIDE_CODE
 2185           I = FINDAR;                                                              DIVIDE_CODE
 2186           CALL EMITINST (MOVE,I,0,REG(MP),0,0);                                    DIVIDE_CODE
 2187           ACC(REG(MP)) = AVAIL;                                                    DIVIDE_CODE
 2188           REG(MP) = I;                                                             DIVIDE_CODE
 2189        END;                                                                        DIVIDE_CODE
 2190  END DIVIDE_CODE;                                                                  DIVIDE_CODE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
FIT             LABEL      5558  PROGRAM   2159       1
FITS            LABEL      5589  PROGRAM   2156       1
I               FIXED      9722     DATA   2150      17
T               FIXED      9721     DATA   2149       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 79
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2191  SHIFT_CODE:                                                                      *
 2192     PROCEDURE (OP);                                                               *
 2193        DECLARE OP FIXED;                                                           SHIFT_CODE
 2194        /* GENERATE CODE FOR THE BUILTIN FUNCTIONS SHL AND SHR */                   SHIFT_CODE
 2195        /* OP: LEFT = 0, RIGHT = 1 */                                               SHIFT_CODE
 2196        SP = MPP1;                                                                  SHIFT_CODE
 2197        IF CNT (MP) \= 2 THEN                                                       SHIFT_CODE
 2198           CALL ERROR ('SHIFT REQUIRES TWO ARGUMENTS', 0);                          SHIFT_CODE
 2199        ELSE                                                                        SHIFT_CODE
 2200           IF TYPE (MPP1) = CONSTANT THEN                                           SHIFT_CODE
 2201              DO;                                                                   SHIFT_CODE
 2202                 IF OP = 1 THEN FIXV(MPP1) = -FIXV(MPP1);                           SHIFT_CODE
 2203                 CALL EMITINST(LSH,REG(MP),0,FIXV(MPP1),0,0);                       SHIFT_CODE
 2204              END;                                                                  SHIFT_CODE
 2205        ELSE                                                                        SHIFT_CODE
 2206           DO;                                                                      SHIFT_CODE
 2207              /* DO SHIFT WITH VARIABLE */                                          SHIFT_CODE
 2208              CALL FORCEACCUMULATOR(MPP1);                                          SHIFT_CODE
 2209              IF OP = 1 THEN                                                        SHIFT_CODE
 2210                    CALL EMITINST (MOVN,REG(MPP1),0,REG(MPP1),0,0);                 SHIFT_CODE
 2211              CALL EMITINST (LSH,REG(MP),0,0,REG(MPP1),0);                          SHIFT_CODE
 2212              ACC(REG(MPP1)) = AVAIL;                                               SHIFT_CODE
 2213           END;                                                                     SHIFT_CODE
 2214        TYPE(MP) = ACCUMULATOR;                                                     SHIFT_CODE
 2215  END SHIFT_CODE;                                                                   SHIFT_CODE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
OP              FIXED      9733     DATA   2192       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 80
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2216  STRINGCOMPARE:                                                                   *
 2217     PROCEDURE;                                                                    *
 2218        /* GENERATES CODE TO COMPARE THE STRINGS AT SP AND MP.                      STRINGCOMPARE
 2219           COMPARISONS ARE DONE FIRST ON LENGTH, AND SECOND ON A                    STRINGCOMPARE
 2220           CHARACTER BY CHARACTER COMPARISON USING THE PDP-10 COLLATING             STRINGCOMPARE
 2221           SEQUENCE.                                                                STRINGCOMPARE
 2222        */                                                                          STRINGCOMPARE
 2223        CALL FORCEDESCRIPTOR (SP);                                                  STRINGCOMPARE
 2224        CALL DELETE_MOVE (SP,MOVEM,REG(SP),0,B,0,3);                                STRINGCOMPARE
 2225        ACC(REG(SP)) = AVAIL;                                                       STRINGCOMPARE
 2226        CALL FORCEDESCRIPTOR (MP);                                                  STRINGCOMPARE
 2227        CALL DELETE_MOVE (MP,MOVEM,REG(MP),0,A,0,3);                                STRINGCOMPARE
 2228        CALL SAVE_ACS (5);                                                          STRINGCOMPARE
 2229        CALL EMITINST (PUSHJ,15,0,STRCOMP,0,2); /* CALL STRING COMPARE */           STRINGCOMPARE
 2230        CALL RESTORE_ACS (5);                                                       STRINGCOMPARE
 2231        CALL EMITINST (MOVEI,REG(MP),0,1,0,0);                                      STRINGCOMPARE
 2232         CALL EMITINST (SKIP+INX(MPP1),0,0,0,0,0);                                  STRINGCOMPARE
 2233        CALL EMITINST (MOVEI,REG(MP),0,0,0,0);                                      STRINGCOMPARE
 2234        TYPE(MP) = ACCUMULATOR;                                                     STRINGCOMPARE
 2235        STILLCOND = INX(MPP1);                                                      STRINGCOMPARE
 2236  END STRINGCOMPARE;                                                                STRINGCOMPARE
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 81
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2237  SYMBOLDUMP:                                                                      *
 2238     PROCEDURE;                                                                    *
 2239        /* LIST THE SYMBOLS IN THE PROCEDURE THAT HAS JUST BEEN                     SYMBOLDUMP
 2240           COMPILED IF TOGGLE S IS ENABLED AND L IS ENABLED.                        SYMBOLDUMP
 2241        */                                                                          SYMBOLDUMP
 2242        DECLARE SUBTITLE_SAVE CHARACTER;                                            SYMBOLDUMP
 2243        DECLARE HEADING CHARACTER INITIAL ('TYPE       LOC   SEGMENT DEFINED REF COUNT'); SYMBOLDUMP
 2244        DECLARE SEG(4) CHARACTER INITIAL ('ABSOLUTE','    DATA',' PROGRAM',         SYMBOLDUMP
 2245                 '  STRING','   LABEL');                                            SYMBOLDUMP
 2246        DECLARE EXCHANGES FIXED, I FIXED, LMAX FIXED,                               SYMBOLDUMP
 2247           J FIXED, K FIXED, L FIXED, M FIXED, SYTSORT (SYTSIZE) FIXED;             SYMBOLDUMP
 2248        DECLARE BLANKS CHARACTER,                                                   SYMBOLDUMP
 2249                TAG    CHARACTER;                                                   SYMBOLDUMP
 2250                                                                                    SYMBOLDUMP
 2251     STRING_GT:                                                                     SYMBOLDUMP
 2252        PROCEDURE (A,B);                                                            SYMBOLDUMP
 2253           /* DO AN HONEST STRING COMPARISON:                                       STRING_GT
 2254              XPL CAN BE TRUSTED ONLY IF STRINGS ARE OF THE SAME LENGTH.            STRING_GT
 2255              IF LENGTHS DIFFER, LET XPL SEE ONLY THE SHORTER, AND THE              STRING_GT
 2256              MATCHING PART OF THE LONGER, AND ARRANGE COMPARISONS SO               STRING_GT
 2257              THAT RESULT IS RIGHT.   */                                            STRING_GT
 2258           DECLARE A CHARACTER,                                                     STRING_GT
 2259                   B CHARACTER;                                                     STRING_GT
 2260           DECLARE LA FIXED,  LB FIXED;                                             STRING_GT
 2261                                                                                    STRING_GT
 2262           LA = LENGTH (A);                                                         STRING_GT
 2263           LB = LENGTH (B);                                                         STRING_GT
 2264           IF LA = LB THEN RETURN (A > B);                                          STRING_GT
 2265           ELSE IF LA > LB THEN RETURN (SUBSTR (A,0,LB) >= B);                      STRING_GT
 2266                ELSE RETURN (A > SUBSTR(B,0,LA));                                   STRING_GT
 2267        END STRING_GT;                                                              STRING_GT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
A               CHARACTER   846   STRING   2252       4
B               CHARACTER   847   STRING   2252       4
LA              FIXED     10190     DATA   2260       4
LB              FIXED     10191     DATA   2260       4
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 82
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2268                                                                                    SYMBOLDUMP
 2269        IF CONTROL(BYTE('L'))  = 0 THEN RETURN; /* DON'T DUMP IF NOT LISTING */     SYMBOLDUMP
 2270        IF PROCMARK <= NDECSY THEN                                                  SYMBOLDUMP
 2271           DO;                                                                      SYMBOLDUMP
 2272              CALL PRINTLINE ('SYMBOL TABLE DUMP',0);                               SYMBOLDUMP
 2273              LMAX = 15;                                                            SYMBOLDUMP
 2274              DO I = PROCMARK TO NDECSY;  /* PAD ALL NAMES TO THE SAME LENGTH */    SYMBOLDUMP
 2275                 IF LENGTH (SYT (I)) > LMAX THEN                                    SYMBOLDUMP
 2276                    LMAX = LENGTH (SYT (I));                                        SYMBOLDUMP
 2277                 SYTSORT (I) = I;                                                   SYMBOLDUMP
 2278              END;                                                                  SYMBOLDUMP
 2279              IF LMAX > 70 THEN LMAX = 70;                                          SYMBOLDUMP
 2280              BLANKS = SUBSTR (X70,0,LMAX);                                         SYMBOLDUMP
 2281              EXCHANGES = TRUE;                                                     SYMBOLDUMP
 2282              K = NDECSY - PROCMARK;                                                SYMBOLDUMP
 2283              DO WHILE EXCHANGES;                                                   SYMBOLDUMP
 2284                 EXCHANGES = FALSE;                                                 SYMBOLDUMP
 2285                 DO J = 0 TO K - 1;                                                 SYMBOLDUMP
 2286                    I = NDECSY - J;                                                 SYMBOLDUMP
 2287                    L = I - 1;                                                      SYMBOLDUMP
 2288                    IF STRING_GT(SYT (SYTSORT(L)),SYT(SYTSORT(I))) THEN             SYMBOLDUMP
 2289                       DO;                                                          SYMBOLDUMP
 2290                          M = SYTSORT (I);                                          SYMBOLDUMP
 2291                          SYTSORT (I) = SYTSORT (L);                                SYMBOLDUMP
 2292                          SYTSORT (L) = M;                                          SYMBOLDUMP
 2293                          EXCHANGES = TRUE;                                         SYMBOLDUMP
 2294                          K = J;          /* RECORD THE LAST SWAP */                SYMBOLDUMP
 2295                       END;                                                         SYMBOLDUMP
 2296                  END;                                                              SYMBOLDUMP
 2297              END;                                                                  SYMBOLDUMP
 2298              I = PROCMARK;                                                         SYMBOLDUMP
 2299              DO WHILE LENGTH (SYT (SYTSORT (I))) = 0;                              SYMBOLDUMP
 2300                 I = I + 1;               /* IGNORE NULL NAMES */                   SYMBOLDUMP
 2301              END;                                                                  SYMBOLDUMP
 2302              SUBTITLE_SAVE = SUBTITLE;                                             SYMBOLDUMP
 2303              SUBTITLE = 'SYMBOL' ^^ SUBSTR(BLANKS,0,LMAX-5) ^^ HEADING;            SYMBOLDUMP
 2304              CALL PRINTLINE (SUBTITLE,0);                                          SYMBOLDUMP
 2305              DO I = I TO NDECSY;                                                   SYMBOLDUMP
 2306                 K = SYTSORT (I);                                                   SYMBOLDUMP
 2307                 TAG = SYT(K) ^^ SUBSTR(X70,0,LMAX-LENGTH(SYT(K)));                 SYMBOLDUMP
 2308                 CALL I_FORMAT (SYTLOC(K),5);                                       SYMBOLDUMP
 2309                 TAG = TAG ^^ X1 ^^ TYPENAME(SYTYPE(K)) ^^ X1 ^^ I_STRING;          SYMBOLDUMP
 2310                 CALL I_FORMAT (SYTCARD(K),5);                                      SYMBOLDUMP
 2311                 TAG = TAG ^^ X1 ^^ SEG(SYTSEG(K)) ^^ X2 ^^ I_STRING;               SYMBOLDUMP
 2312                 CALL I_FORMAT (SYTCO(K),5);                                        SYMBOLDUMP
 2313                 IF SYTCO(K) = 0 THEN I_STRING = I_STRING ^^ ' *';                  SYMBOLDUMP
 2314                 CALL PRINTLINE (TAG ^^ X3 ^^ I_STRING,-1);                         SYMBOLDUMP
 2315                                                                                    SYMBOLDUMP
 2316                 K = K + 1;                                                         SYMBOLDUMP
 2317                 DO WHILE (LENGTH (SYT (K)) = 0) & (K <= NDECSY);                   SYMBOLDUMP
 2318                    J = K - SYTSORT (I);                                            SYMBOLDUMP
 2319                    TAG = '  PARAMETER  ' ^^ J ^^ SUBSTR(BLANKS,13) ^^              SYMBOLDUMP
 2320                          TYPENAME(SYTYPE(K));                                      SYMBOLDUMP C19 = 1744830451
 2321                    CALL I_FORMAT (SYTLOC(K),5);                                    SYMBOLDUMP
 2322                    TAG = TAG ^^ X1 ^^ I_STRING;                                    SYMBOLDUMP
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 83
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2323                    CALL I_FORMAT (SYTCARD(K),5);                                   SYMBOLDUMP
 2324                    TAG = TAG ^^ X1 ^^ SEG(SYTSEG(K)) ^^ X2 ^^ I_STRING;            SYMBOLDUMP
 2325                    CALL I_FORMAT (SYTCO(K),5);                                     SYMBOLDUMP
 2326                    CALL PRINTLINE (TAG ^^ X3 ^^ I_STRING,-1);                      SYMBOLDUMP
 2327                    K = K + 1;                                                      SYMBOLDUMP
 2328                 END;                                                               SYMBOLDUMP
 2329              END;                                                                  SYMBOLDUMP
 2330              SUBTITLE = SUBTITLE_SAVE;                                             SYMBOLDUMP
 2331           END;                                                                     SYMBOLDUMP
 2332           EJECT_PAGE;                                                              SYMBOLDUMP
 2333  END SYMBOLDUMP;                                                                   SYMBOLDUMP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
BLANKS          CHARACTER   844   STRING   2248       3
EXCHANGES       FIXED      9762     DATA   2246       4
HEADING         CHARACTER   838   STRING   2243       1
I               FIXED      9763     DATA   2246      18
J               FIXED      9765     DATA   2247       5
K               FIXED      9766     DATA   2247      24
L               FIXED      9767     DATA   2247       4
LMAX            FIXED      9764     DATA   2246       8
M               FIXED      9768     DATA   2247       2
SEG             CHARACTER   839   STRING   2244       2
STRING_GT       PROCEDURE  5803  PROGRAM   2251       1
  PARAMETER  1  CHARACTER   846   STRING   2252       5
  PARAMETER  2  CHARACTER   847   STRING   2252       5
SUBTITLE_SAVE   CHARACTER   837   STRING   2242       2
SYTSORT         FIXED      9769     DATA   2247      10
TAG             CHARACTER   845   STRING   2249      12
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 84
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2334  DUMPIT:                                                                          *
 2335     PROCEDURE;                                                                    *
 2336        DECLARE CHAR360 CHARACTER;                                                  DUMPIT
 2337        DECLARE T1 CHARACTER, T2 CHARACTER, L FIXED, LL FIXED;                      DUMPIT
 2338        /* PUT OUT STATISTICS KEPT WITHIN THE COMPILER */                           DUMPIT
 2339       IF TOP_MACRO >= 0 THEN                                                       DUMPIT
 2340            DO; /* DUMP MACRO DICTIONARY */                                         DUMPIT
 2341               CALL PRINTLINE ( 'MACRO DEFINITIONS:',0);                            DUMPIT
 2342               CALL PRINTLINE (X1,-1);                                              DUMPIT
 2343               L = LENGTH (MACRO_NAME(TOP_MACRO));                                  DUMPIT
 2344               IF L > 70 THEN L = 70;                                               DUMPIT
 2345               SUBTITLE = 'NAME' ^^ SUBSTR (X70,0,L-2) ^^                           DUMPIT
 2346                          'AT LINE REF COUNT LITERAL VALUE';                        DUMPIT
 2347               CALL PRINTLINE (SUBTITLE,-1);                                        DUMPIT
 2348               DO I = 0 TO TOP_MACRO;                                               DUMPIT
 2349                  K = LENGTH (MACRO_NAME(I));                                       DUMPIT
 2350                  IF K < L THEN                                                     DUMPIT
 2351                     DO;                                                            DUMPIT
 2352                         CHAR360 = SUBSTR (X70,0,L-K);                              DUMPIT
 2353                         MACRO_NAME (I) = MACRO_NAME (I) ^^ CHAR360;                DUMPIT
 2354                     END;                                                           DUMPIT
 2355                  ELSE                                                              DUMPIT
 2356                     MACRO_NAME(I) = SUBSTR(MACRO_NAME(I),0,L);                     DUMPIT
 2357                  T1 = MACRO_DECLARE(I);                                            DUMPIT
 2358                  T2 = MACRO_COUNT(I);                                              DUMPIT
 2359                  LL = LENGTH (T1);                                                 DUMPIT
 2360                  IF LL < 8 THEN T1 = SUBSTR(X70,0,8-LL) ^^ T1;                     DUMPIT
 2361                  LL = LENGTH (T2);                                                 DUMPIT
 2362                  IF LL < 9 THEN T2 = SUBSTR(X70,0,9-LL) ^^ T2;                     DUMPIT
 2363                  CALL PRINTLINE (MACRO_NAME(I) ^^ T1 ^^ T2 ^^ X4 ^^ MACRO_TEXT(I),-1); DUMPIT
 2364               END;                                                                 DUMPIT
 2365            END;                                                                    DUMPIT
 2366        SUBTITLE = '';                                                              DUMPIT
 2367        CALL PRINTLINE (X1,-1);                                                     DUMPIT
 2368        CALL PRINTLINE ('ID COMPARES       = ' ^^ IDCOMPARES,-1);                   DUMPIT
 2369        CALL PRINTLINE ('SYMBOL TABLE SIZE = ' ^^ MAXNDECSY,-1);                    DUMPIT
 2370        CALL PRINTLINE ('MACRO DEFINITIONS = ' ^^ TOP_MACRO + 1,-1);                DUMPIT
 2371        CALL PRINTLINE ('SCAN              = ' ^^ COUNT_SCAN,-1);                   DUMPIT
 2372        CALL PRINTLINE ('EMITINST          = ' ^^ COUNT_INST,-1);                   DUMPIT
 2373        CALL PRINTLINE ('FORCE ACCUMULATOR = ' ^^ COUNT_FORCE,-1);                  DUMPIT
 2374        CALL PRINTLINE ('ARITHEMIT         = ' ^^ COUNT_ARITH,-1);                  DUMPIT
 2375        CALL PRINTLINE ('GENERATE STORE    = ' ^^ COUNT_STORE,-1);                  DUMPIT
 2376        CALL PRINTLINE ('FREE STRING AREA  = ' ^^ FREELIMIT - FREEBASE,-1);         DUMPIT
 2377        CALL PRINTLINE ('COMPACTIFICATIONS = ' ^^ COUNT_COMPACT,-1);                DUMPIT
 2378        SUBTITLE = 'INSTRUCTION FREQUENCIES';                                       DUMPIT
 2379        EJECT_PAGE;                                                                 DUMPIT
 2380        DO I = 0 TO 15;                                                             DUMPIT
 2381           J = I * 32;                                                              DUMPIT C20 = 15
 2382           DO K = 0 TO 31;                                                          DUMPIT
 2383              IF INSTRUCT(J+K) > 0 THEN                                             DUMPIT C21 = 31
 2384                  CALL PRINTLINE (SUBSTR(OPNAME(I),K*6,6) ^^ X4 ^^ INSTRUCT(J+K),-1); DUMPIT
 2385           END;                                                                     DUMPIT
 2386        END;                                                                        DUMPIT
 2387  END DUMPIT;                                                                       DUMPIT

SYMBOL TABLE DUMP
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 85
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 

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

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CH              CHARACTER   869   STRING   2390       8
DATE1           FIXED     10286     DATA   2392       6
DAY             FIXED     10287     DATA   2392       2
HOURS           FIXED     10283     DATA   2391       2
L               FIXED     10289     DATA   2392       2
MINUTES         FIXED     10284     DATA   2391       2
MONTH           CHARACTER   870   STRING   2393       2
MONTHS          CHARACTER   871   STRING   2394       1
SECS            FIXED     10285     DATA   2391       2
TIME1           FIXED     10282     DATA   2391       4
YEAR            FIXED     10288     DATA   2392       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 94
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2798  STACK_DUMP:                                                                      *
 2799     PROCEDURE;                                                                    *
 2800        DECLARE LINE CHARACTER;                                                     STACK_DUMP
 2801        IF \ CONTROL(BYTE('R')) THEN RETURN;  /* 'R' IS BARF SWITCH */              STACK_DUMP
 2802        LINE = 'PARTIAL PARSE TO THIS POINT IS: ';                                  STACK_DUMP
 2803        DO I = 0 TO SP;                                                             STACK_DUMP
 2804           IF LENGTH(LINE) > 105 THEN                                               STACK_DUMP
 2805              DO;                                                                   STACK_DUMP
 2806                 CALL PRINTLINE (LINE,-1);                                          STACK_DUMP
 2807                 LINE = X4;                                                         STACK_DUMP
 2808              END;                                                                  STACK_DUMP
 2809           LINE = LINE ^^ X1 ^^ VOCAB(STATE_NAME(STATE_STACK(I)));                  STACK_DUMP
 2810        END;                                                                        STACK_DUMP
 2811        CALL PRINTLINE (LINE,-1);                                                   STACK_DUMP
 2812     END STACK_DUMP;                                                                STACK_DUMP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LINE            CHARACTER   935   STRING   2800       7
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 95
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 2813                                                                                   *
 2814    /*                  THE SYNTHESIS ALGORITHM FOR XPL                      */    *
 2815                                                                                   *
 2816                                                                                   *
 2817  SYNTHESIZE:                                                                      *
 2818  PROCEDURE(PRODUCTION_NUMBER);                                                    *
 2819     DECLARE PRODUCTION_NUMBER FIXED;                                               SYNTHESIZE
 2820     DECLARE TOOMSG CHARACTER INITIAL ('TOO MANY ARGUMENTS FOR ');                  SYNTHESIZE
 2821                                                                                    SYNTHESIZE
 2822     STACK_CASE:                                                                    SYNTHESIZE
 2823        PROCEDURE (DATUM);                                                          SYNTHESIZE
 2824           DECLARE DATUM FIXED;                                                     STACK_CASE
 2825           DECLARE DCLRM CHARACTER                                                  STACK_CASE
 2826                 INITIAL ('TOO MANY CASES OR FACTORED DECLARATIONS');               STACK_CASE
 2827           IF CASEP >= CASELIMIT THEN CALL ERROR (DCLRM,1);                         STACK_CASE
 2828                                 ELSE CASEP = CASEP + 1;                            STACK_CASE
 2829           CASESTACK(CASEP) = DATUM;                                                STACK_CASE
 2830     END STACK_CASE;                                                                STACK_CASE

SYMBOL TABLE DUMP

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

SYMBOL TABLE DUMP

SYMBOL            TYPE       LOC   SEGMENT DEFINED REF COUNT
PRODUCTION_NUMBER FIXED     10492     DATA   2818       1
STACK_CASE        PROCEDURE  9014  PROGRAM   2822       5
  PARAMETER  1    FIXED     10499     DATA   2823       6
TOOMSG            CHARACTER   937   STRING   2820       3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 112
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3670                                                                                   *
 3671    /*              SYNTACTIC PARSING FUNCTIONS                              */    *
 3672                                                                                   *
 3673                                                                                   *
 3674   CONFLICT: PROCEDURE (CURRENT_STATE);                                            *
 3675                                                                                    CONFLICT
 3676           DECLARE I FIXED, CURRENT_STATE FIXED;                                    CONFLICT
 3677                                                                                    CONFLICT
 3678           /*   THIS PROC IS TRUE IF THE CURRENT TOKEN IS NOT   */                  CONFLICT
 3679           /*   A TRANSITION SYMBOL FROM THE CURRENT STATE      */                  CONFLICT
 3680                                                                                    CONFLICT
 3681           /*   (A CONFLICT THEREFORE EXISTS BETWEEN THE        */                  CONFLICT
 3682           /*   CURRENT STATE AND THE NEXT TOKEN)               */                  CONFLICT
 3683                                                                                    CONFLICT
 3684           I = INDEX1(CURRENT_STATE);   /*   STARTING POINT FOR STATE        */     CONFLICT
 3685                                        /*   TRANSITION SYMBOLS              */     CONFLICT
 3686           DO I = I TO I+INDEX2(CURRENT_STATE)-1;   /*   COMPARE WITH EACH   */     CONFLICT
 3687           IF READ1(I) = TOKEN THEN RETURN (FALSE); /*   FOUND IT            */     CONFLICT
 3688           END;                                                                     CONFLICT
 3689           RETURN (TRUE);   /*   NOT THERE   */                                     CONFLICT
 3690                                                                                    CONFLICT
 3691           END CONFLICT;                                                            CONFLICT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
CURRENT_STATE   FIXED     10602     DATA   3674       2
I               FIXED     10601     DATA   3676       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 113
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3692                                                                                   *
 3693                                                                                   *
 3694   RECOVER: PROCEDURE;                                                             *
 3695                                                                                    RECOVER
 3696           DECLARE ANSWER BIT(1);                                                   RECOVER
 3697                                                                                    RECOVER
 3698           /*   THIS IS A VERY CRUDE ERROR RECOVERY PROCEDURE               */      RECOVER
 3699           /*   IT RETURNS TRUE IF THE PARSE MUST BE RESUMED IN             */      RECOVER
 3700           /*   A NEW STATE (THE ONE IN THE CURRENT POSITION OF THE STATE   */      RECOVER
 3701           /*   STACK)                                                      */      RECOVER
 3702           /*   IT RETURNS FALSE IF THE PARSE IS RESUMED WITH THE SAME      */      RECOVER
 3703           /*   STATE AS WAS INTENDED BEFORE RECOVER WAS CALLED             */      RECOVER
 3704                                                                                    RECOVER
 3705           ANSWER = FALSE;                                                          RECOVER
 3706           /*   IF THIS IS THE SECOND SUCCESSIVE CALL TO RECOVER, DISCARD   */      RECOVER
 3707           /*   ONE SYMBOL (FAILSOFT IS SET TRUE BY SCAN)                   */      RECOVER
 3708           IF \ FAILSOFT & 1 THEN CALL SCAN;                                        RECOVER
 3709           FAILSOFT = FALSE;                                                        RECOVER
 3710           /*   FIND SOMETHING SOLID IN THE TEXT   */                               RECOVER
 3711           DO WHILE (\STOPIT(TOKEN) & 1);                                           RECOVER
 3712           CALL SCAN;                                                               RECOVER
 3713           END;                                                                     RECOVER
 3714           NO_LOOK_AHEAD_DONE = FALSE;                                              RECOVER
 3715           /*   DELETE PARSE STACK UNTIL THE HARD TOKEN IS   */                     RECOVER
 3716           /*   LEGAL AS A TRANSITION SYMBOL                 */                     RECOVER
 3717           DO WHILE CONFLICT (STATE_STACK(SP));                                     RECOVER
 3718           IF SP > 0                                                                RECOVER
 3719                THEN DO;                                                            RECOVER
 3720                     /*   DELETE ONE ITEM FROM THE STACK   */                       RECOVER
 3721                     SP = SP - 1;                                                   RECOVER
 3722                     ANSWER = TRUE;   /*   PARSE TO BE RESUMED IN NEW STATE   */    RECOVER
 3723                     END;                                                           RECOVER
 3724                ELSE DO;   /*   STACK IS EMPTY   */                                 RECOVER
 3725                     /*   TRY TO FIND A LEGAL TOKEN (FOR START STATE)   */          RECOVER
 3726                      CALL SCAN;                                                    RECOVER
 3727                     IF TOKEN = EOFILE                                              RECOVER
 3728                          THEN DO;                                                  RECOVER
 3729                               /*   MUST STOP COMPILING                */           RECOVER
 3730                               /*   RESUME PARSE IN AN ILLEGAL STATE   */           RECOVER
 3731                               ANSWER = TRUE;                                       RECOVER
 3732                               STATE_STACK(SP) = 0;                                 RECOVER
 3733                               RETURN (ANSWER);                                     RECOVER
 3734                               END;                                                 RECOVER
 3735                     END;                                                           RECOVER
 3736           END;                                                                     RECOVER
 3737           /*   FOUND AN ACCEPTABLE TOKEN FROM WHICH TO RESUME THE PARSE   */       RECOVER
 3738           CALL PRINTLINE ('RESUME:' ^^ SUBSTR(POINTER,LENGTH(POINTER)-             RECOVER
 3739              (LINE_LENGTH+CP-TEXT_LIMIT-LB-1)+LENGTH(BCD)),-1);                    RECOVER
 3740           RETURN (ANSWER);                                                         RECOVER
 3741                                                                                    RECOVER
 3742           END RECOVER;                                                             RECOVER

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 114
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 
ANSWER          BIT (9)   10604     DATA   3696       5
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 115
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3743                                                                                   *
 3744                                                                                   *
 3745   COMPILATION_LOOP:                                                               *
 3746     PROCEDURE;                                                                    *
 3747                                                                                    COMPILATION_LOOP
 3748           DECLARE OVERFLOW CHARACTER INITIAL (                                     COMPILATION_LOOP
 3749           'STACK OVERFLOW *** COMPILATION ABORTED ***');                           COMPILATION_LOOP
 3750           DECLARE I FIXED, J FIXED, STATE FIXED;                                   COMPILATION_LOOP
 3751           DECLARE END_OF_FILE CHARACTER INITIAL (                                  COMPILATION_LOOP
 3752           'END OF FILE FOUND UNEXPECTEDLY *** COMPILATION ABORTED ***');           COMPILATION_LOOP
 3753                                                                                    COMPILATION_LOOP
 3754           /*   THIS PROC PARSES THE INPUT STRING (BY CALLING THE SCANNER)   */     COMPILATION_LOOP
 3755           /*   AND CALLS THE CODE EMISSION PROC (SYNTHESIZE) WHENEVER A     */     COMPILATION_LOOP
 3756           /*   PRODUCTION CAN BE APPLIED                                    */     COMPILATION_LOOP
 3757                                                                                    COMPILATION_LOOP
 3758           /*   INITIALIZE                                                   */     COMPILATION_LOOP
 3759           COMPILING = TRUE;                                                        COMPILATION_LOOP
 3760           STATE = START_STATE;                                                     COMPILATION_LOOP
 3761           SP = -1;                                                                 COMPILATION_LOOP
 3762           /*   STOP COMPILING IF FINISHED                                   */     COMPILATION_LOOP
 3763   COMP:   DO WHILE (COMPILING);                                                    COMPILATION_LOOP
 3764           /*   FIND WHICH OF THE FOUR KINDS OF STATES WE ARE DEALING WITH:  */     COMPILATION_LOOP
 3765           /*   READ,APPLY PRODUCTION,LOOKAHEAD, OR PUSH STATE               */     COMPILATION_LOOP
 3766           IF STATE <= MAXR#                                                        COMPILATION_LOOP
 3767                THEN DO;   /*   READ STATE   */                                     COMPILATION_LOOP
 3768                     SP = SP+1;   /*   ADD AN ELEMENT TO THE STACK   */             COMPILATION_LOOP
 3769                     IF SP = STACKSIZE                                              COMPILATION_LOOP
 3770                          THEN DO;                                                  COMPILATION_LOOP
 3771                               CALL ERROR (OVERFLOW,2);                             COMPILATION_LOOP
 3772                               RETURN;                                              COMPILATION_LOOP
 3773                               END;                                                 COMPILATION_LOOP
 3774                     STATE_STACK(SP) = STATE;   /*   PUSH PRESENT STATE   */        COMPILATION_LOOP
 3775                     I = INDEX1(STATE);         /*   GET STARTING POINT   */        COMPILATION_LOOP
 3776                     IF NO_LOOK_AHEAD_DONE                                          COMPILATION_LOOP
 3777                          THEN DO;   /*   READ IF NECESSARY   */                    COMPILATION_LOOP
 3778                               CALL SCAN;                                           COMPILATION_LOOP
 3779                               NO_LOOK_AHEAD_DONE = FALSE;                          COMPILATION_LOOP
 3780                               END;                                                 COMPILATION_LOOP
 3781                     /*   COMPARE TOKEN WITH EACH TRANSITION SYMBOL IN    */        COMPILATION_LOOP
 3782                     /*   READ STATE                                      */        COMPILATION_LOOP
 3783                      DO I = I TO I+INDEX2(STATE)-1;                                COMPILATION_LOOP
 3784                     IF READ1(I) = TOKEN                                            COMPILATION_LOOP
 3785                          THEN DO;   /*   FOUND IT   */                             COMPILATION_LOOP
 3786                               VAR(SP) = BCD;                                       COMPILATION_LOOP
 3787                               FIXV(SP) = NUMBER_VALUE;                             COMPILATION_LOOP
 3788                               FIXL(SP) = CARD_COUNT;                               COMPILATION_LOOP
 3789                               PPSAVE(SP) = PP;                                     COMPILATION_LOOP
 3790                               STATE = READ2(I);                                    COMPILATION_LOOP
 3791                               NO_LOOK_AHEAD_DONE = TRUE;                           COMPILATION_LOOP
 3792                               GO TO COMP;                                          COMPILATION_LOOP
 3793                               END;                                                 COMPILATION_LOOP
 3794                     END;                                                           COMPILATION_LOOP
 3795                     /*   FOUND AN ERROR   */                                       COMPILATION_LOOP
 3796                     CALL ERROR ('ILLEGAL SYMBOL PAIR: ' ^^                         COMPILATION_LOOP
 3797                                 VOCAB(STATE_NAME(STATE)) ^^ X1 ^^                  COMPILATION_LOOP
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 116
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3798                                 VOCAB(TOKEN),1);                                   COMPILATION_LOOP
 3799                     CALL STACK_DUMP;    /*  DISPLAY THE STACK   */                 COMPILATION_LOOP
 3800                     /*   TRY TO RECOVER   */                                       COMPILATION_LOOP
 3801                     IF RECOVER                                                     COMPILATION_LOOP
 3802                          THEN DO;                                                  COMPILATION_LOOP
 3803                               STATE = STATE_STACK(SP);   /*   NEW STARTING PT  */  COMPILATION_LOOP
 3804                               IF STATE = 0                                         COMPILATION_LOOP
 3805                                    THEN DO;   /*   UNEXPECTED EOFILE   */          COMPILATION_LOOP
 3806                                         CALL ERROR (END_OF_FILE,2);                COMPILATION_LOOP
 3807                                         RETURN;                                    COMPILATION_LOOP
 3808                                         END;                                       COMPILATION_LOOP
 3809                               END;                                                 COMPILATION_LOOP
 3810                     SP = SP-1;   /*   STACK AT SP CONTAINS JUNK   */               COMPILATION_LOOP
 3811                     END;                                                           COMPILATION_LOOP
 3812                ELSE                                                                COMPILATION_LOOP
 3813           IF STATE > MAXP#                                                         COMPILATION_LOOP
 3814                THEN DO;   /*   APPLY PRODUCTION STATE   */                         COMPILATION_LOOP
 3815                     /*   SP POINTS AT RIGHT END OF PRODUCTION   */                 COMPILATION_LOOP
 3816                     /*   MP POINTS AT LEST END OF PRODUCTION   */                  COMPILATION_LOOP
 3817                     MP = SP-INDEX2(STATE);                                         COMPILATION_LOOP
 3818                     MPP1 = MP+1;                                                   COMPILATION_LOOP
 3819                     CALL SYNTHESIZE (STATE-MAXP#);   /*   APPLY PRODUCTION   */    COMPILATION_LOOP
 3820                     SP = MP;   /*   RESET STACK POINTER   */                       COMPILATION_LOOP
 3821                     I = INDEX1(STATE);                                             COMPILATION_LOOP
 3822                     /*   COMPARE TOP OF STATE STACK WITH TABLES   */               COMPILATION_LOOP
 3823                     J = STATE_STACK(SP);                                           COMPILATION_LOOP
 3824                     DO WHILE APPLY1(I) \= 0;                                       COMPILATION_LOOP
 3825                     IF J = APPLY1(I) THEN GO TO TOP_MATCH;                         COMPILATION_LOOP
 3826                     I = I+1;                                                       COMPILATION_LOOP
 3827                     END;                                                           COMPILATION_LOOP
 3828                     /*   HAS THE PROGRAM GOAL BEEN REACHED   */                    COMPILATION_LOOP
 3829          TOP_MATCH: IF APPLY2(I) =0                                                COMPILATION_LOOP
 3830                          THEN DO;   /*   YES IT HAS   */                           COMPILATION_LOOP
 3831                               COMPILING = FALSE;                                   COMPILATION_LOOP
 3832                               RETURN;                                              COMPILATION_LOOP
 3833                               END;                                                 COMPILATION_LOOP
 3834                     STATE = APPLY2(I);   /*   PICK UP THE NEXT STATE   */          COMPILATION_LOOP
 3835                     END;                                                           COMPILATION_LOOP
 3836                ELSE                                                                COMPILATION_LOOP
 3837           IF STATE <= MAXL#                                                        COMPILATION_LOOP
 3838                THEN DO;   /*   LOOKAHEAD STATE   */                                COMPILATION_LOOP
 3839                      I = INDEX1(STATE);   /*   INDEX INTO THE TABLE   */           COMPILATION_LOOP
 3840                     IF NO_LOOK_AHEAD_DONE                                          COMPILATION_LOOP
 3841                          THEN DO;   /*   GET A TOKEN   */                          COMPILATION_LOOP
 3842                               CALL SCAN;                                           COMPILATION_LOOP
 3843                               NO_LOOK_AHEAD_DONE = FALSE;                          COMPILATION_LOOP
 3844                               END;                                                 COMPILATION_LOOP
 3845                     /*   CHECK TOKEN AGAINST LEGAL LOOKAHEAD TRANSITION SYMBOLS*/  COMPILATION_LOOP
 3846                     DO WHILE LOOK1(I) \= 0;                                        COMPILATION_LOOP
 3847                     IF LOOK1(I) = TOKEN                                            COMPILATION_LOOP
 3848                          THEN GO TO LOOK_MATCH;   /*   FOUND ONE   */              COMPILATION_LOOP
 3849                     I = I+1;                                                       COMPILATION_LOOP
 3850                     END;                                                           COMPILATION_LOOP
 3851         LOOK_MATCH: STATE = LOOK2(I);                                              COMPILATION_LOOP
 3852                     END;                                                           COMPILATION_LOOP
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 117
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3853                ELSE DO;   /*   PUSH STATE   */                                     COMPILATION_LOOP
 3854                     SP = SP+1;   /*   PUSH A NON-TERMINAL ONTO THE STACK   */      COMPILATION_LOOP
 3855                     IF SP = STACKSIZE                                              COMPILATION_LOOP
 3856                          THEN DO;                                                  COMPILATION_LOOP
 3857                               CALL ERROR (OVERFLOW,2);                             COMPILATION_LOOP
 3858                               RETURN;                                              COMPILATION_LOOP
 3859                               END;                                                 COMPILATION_LOOP
 3860                     /*   PUSH A STATE # INTO THE STATE_STACK   */                  COMPILATION_LOOP
 3861                     STATE_STACK(SP) = INDEX2(STATE);                               COMPILATION_LOOP
 3862                     /*   GET NEXT STATE                        */                  COMPILATION_LOOP
 3863                     STATE = INDEX1(STATE);                                         COMPILATION_LOOP
 3864                     END;                                                           COMPILATION_LOOP
 3865           END;   /*   OF COMPILE LOOP   */                                         COMPILATION_LOOP
 3866                                                                                    COMPILATION_LOOP
 3867           END COMPILATION_LOOP;                                                    COMPILATION_LOOP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
COMP            LABEL     11608  PROGRAM   3763       1
END_OF_FILE     CHARACTER   956   STRING   3751       1
I               FIXED     10617     DATA   3750      19
J               FIXED     10618     DATA   3750       2
LOOK_MATCH      LABEL     11846  PROGRAM   3848       1
OVERFLOW        CHARACTER   955   STRING   3748       2
STATE           FIXED     10619     DATA   3750      20
TOP_MATCH       LABEL     11793  PROGRAM   3825       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 118
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3868                                                                                   *
 3869  PRINT_TIME:                                                                      *
 3870     PROCEDURE (TEXT, TIME);                                                       *
 3871     /* PRINT TEXT FOLLOWED BY TIME, WHICH IS IN MILLISECONDS */                    PRINT_TIME
 3872        DECLARE TEXT CHARACTER, TIME FIXED;                                         PRINT_TIME
 3873        K = TIME;                                                                   PRINT_TIME
 3874        I = K / 60000;                                                              PRINT_TIME
 3875        J = K MOD 60000 / 1000;                                                     PRINT_TIME
 3876        K = K MOD 1000;                                                             PRINT_TIME
 3877        CALL PRINTLINE (TEXT ^^ I ^^ ':' ^^ J ^^ '.' ^^ K,-1);                      PRINT_TIME
 3878     END PRINT_TIME;                                                                PRINT_TIME

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
TEXT            CHARACTER   958   STRING   3870       1
TIME            FIXED     10642     DATA   3870       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 119
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3879                                                                                   *
 3880     /*   E X E C U T I O N   S T A R T S   H E R E                          */    *
 3881                                                                                   *
 3882     DECLARE TIME_START FIXED,                                                     *
 3883             TIME_INIT FIXED,                                                      *
 3884             TIME_COMPILE FIXED,                                                   *
 3885             TIME_FINISH FIXED;                                                    *
 3886                                                                                   *
 3887     TIME_START = RUNTIME;           /* GET TIME(CPU) STARTED*/                    *
 3888     CALL INITIALIZE;                                                              *
 3889     TIME_INIT = RUNTIME;     /* TIME TO INITIALIZE */                             *
 3890     CALL COMPILATION_LOOP;                                                        *
 3891     TIME_COMPILE = RUNTIME;     /* TIME TO COMPILE THE PROGRAM*/                  *
 3892     CONTROL(BYTE('E')) = FALSE;                                                   *
 3893     CONTROL(BYTE('B')) = FALSE;                                                   *
 3894     SUBTITLE = '';                                                                *
 3895     IF CONTROL(BYTE('S')) THEN CALL SYMBOLDUMP;                                   *
 3896     ELSE EJECT_PAGE;                                                              *
 3897     /* NOW ENTER THE VALUE OF NDESCRIPT                                        */ *
 3898     CALL EMITLABEL (NDESC,5);            /* GENERATE LABEL */                     *
 3899     IF CONTROL(BYTE('A')) THEN                                                    *
 3900        OUTPUT(DATAFILE) = '$' ^^ NDESC ^^ ':'; /* LABEL FOR ASSEMBLER */          *
 3901     CALL EMITDATAWORD (DSP-1);           /* PUT DOWN NUMBER OF DESC'S */          *
 3902     IF CONTROL(BYTE('A')) THEN                                                    *
 3903        OUTPUT(DATAFILE) = 'S=.;';           /* START STRING SEGMENT */            *
 3904     /* ADD THE DESCRIPTORS TO THE DATA SEGMENT                                 */ *
 3905     DO I = 0 TO DSP-1;                                                            *
 3906        IF CONTROL(BYTE('A')) THEN                                                 *
 3907           OUTPUT(DATAFILE)='       BYTE (9)'^^DESCL(I)^^ '(27)' ^^DESCA(I)^^ ';'; *
 3908        CALL OUTPUT_DATAWORD (SHL(DESCL(I),27) + DESCA(I), DP);                    *
 3909        CALL EMITLABEL (I,3);                                                      *
 3910        DP = DP + 1;                                                               *
 3911     END;                                                                          *
 3912     /* FINAL CODE FOR SYSTEM INTERFACE                                         */ *
 3913     CALL EMITINST (4,0,0,0,0,0);                                                  *
 3914     CALL FLUSH_DATA_BUFFER;                                                       *
 3915     CALL FLUSH_LABELS;                                                            *
 3916     DO WHILE CODE_TAIL \= CODE_HEAD;                                              *
 3917        CALL OUTPUT_CODEWORD;                                                      *
 3918        END;                                                                       *
 3919     CALL OUTPUT_CODEWORD;                                                         *
 3920     CALL FLUSH_CODE_BUFFER;                                                       *
 3921     IF CONTROL(BYTE('A')) THEN                                                    *
 3922        DO;                                                                        *
 3923           OUTPUT (CODEFILE) = '       END $0;';                                   *
 3924           /* COPY CODE FILE TO END OF DATA FILE */                                *
 3925           CODESTRING = INPUT(CODEFILE);                                           *
 3926           DO WHILE LENGTH(CODESTRING) > 0;                                        *
 3927              OUTPUT(DATAFILE) = CODESTRING;                                       *
 3928              CODESTRING = INPUT(CODEFILE);                                        *
 3929           END;                                                                    *
 3930           OUTPUT (CODEFILE) = ' ';                                                *
 3931        END;                                                                       *
 3932                                                                                   *
 3933     FILE(RELFILE) = SYMB_TYPE + 2;      /* GENERATE EXTERNAL REFS */              *
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 120
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
 3934     FILE(RELFILE) = "(3)040000000000";                                            * C40 = 524288
 3935     FILE(RELFILE) = "(3)600000000000" + RADIX50 ('XPLLIB');                       * C41 = 4294967296
 3936     FILE(RELFILE) = LIBRARY;                                                      * C42 = -17179869184
 3937     FILE(RELFILE) = START_TYPE + 1;                                               *
 3938     FILE(RELFILE) = "(3)200000000000";                                            * C43 = 1835008
 3939     FILE(RELFILE) = "(3)400000" + STARTLOC;                                       *
 3940     FILE(RELFILE) = END_TYPE + 2;                                                 *
 3941     FILE(RELFILE) = "(3)240000000000";                                            *
 3942     FILE(RELFILE) = "(3)400000" + PP;                                             * C44 = 21474836480
 3943     FILE(RELFILE) = DP;                                                           *
 3944                                                                                   *
 3945     TIME_FINISH = RUNTIME;   /* TIME TO DO ALL BUT FINAL STATS */                 *
 3946     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);*
 3947     CALL PRINTLINE (CARD_COUNT ^^ ' LINES CONTAINING ' ^^ STATEMENT_COUNT ^^      * C45 = 5368709120
 3948        ' STATEMENTS WERE COMPILED.',0);                                           *
 3949     IF ERROR_COUNT = 0 THEN CALL PRINTLINE ('NO ERRORS WERE DETECTED.',-1);       *
 3950     ELSE IF ERROR_COUNT > 1 THEN                                                  *
 3951        CALL PRINTLINE (ERROR_COUNT ^^ ' ERRORS (' ^^ SEVERE_ERRORS                *
 3952        ^^ ' SEVERE) WERE DETECTED.',-1);                                          *
 3953     ELSE IF SEVERE_ERRORS = 1 THEN CALL PRINTLINE ('ONE SEVERE ERROR WAS DETECTED.',-1);*
 3954        ELSE CALL PRINTLINE ('ONE ERROR WAS DETECTED.',-1);                        *
 3955      IF PREVIOUS_ERROR > 0 THEN                                                   *
 3956         CALL PRINTLINE ('LAST ERROR WAS ON LINE ' ^^ PREVIOUS_ERROR ,-1);         *
 3957     CALL PRINTLINE (PP ^^ ' WORDS OF PROGRAM, ' ^^ DP-DSP ^^ ' WORDS OF DATA, AND ' ^^*
 3958        DSP ^^ ' WORDS OF DESCRIPTORS.  TOTAL CORE REQUIREMENT ' ^^ PP+DP ^^       *
 3959        ' WORDS.',-1);                                                             *
 3960                                                                                   *
 3961  /* NOW COMPUTE TIMES AND PRINT THEM */                                           *
 3962     TIME_INIT = TIME_INIT - TIME_START;                                           *
 3963     TIME_COMPILE = TIME_COMPILE - TIME_START;                                     *
 3964     TIME_FINISH = TIME_FINISH - TIME_START;                                       *
 3965                                                                                   *
 3966     CALL PRINT_TIME ('TOTAL TIME IN COMPILER    = ',TIME_FINISH);                 *
 3967     CALL PRINT_TIME ('INITIALIZATION TIME       = ',TIME_INIT);                   *
 3968     CALL PRINT_TIME ('ACTUAL COMPILATION TIME   = ',TIME_COMPILE - TIME_INIT);    *
 3969     CALL PRINT_TIME ('POST-COMPILATION CLEAN-UP = ',TIME_FINISH-TIME_COMPILE);    *
 3970                                                                                   *
 3971     IF CONTROL(BYTE('D')) THEN CALL DUMPIT;                                       *
 3972  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      1931     DATA    279      10
ACC                   FIXED      1937     DATA    284      43
ADD                   FIXED      6261     DATA    404       9
ADDI                  FIXED      6262     DATA    405       4
ADDM                  FIXED      6263     DATA    406       2
ADDRMASK              FIXED      1935     DATA    281       5
ADR                   FIXED      2147     DATA    351      16
ALPHABET              CHARACTER   100   STRING    224       1
AND                   FIXED      6264     DATA    407       8
ANDI                  FIXED      6265     DATA    408       3
AOSA                  FIXED      6266     DATA    409       1
APPLY1                BIT (9)     932     DATA    126       2
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 121
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
APPLY2                BIT (9)    1062     DATA    155       2
ARITHEMIT             PROCEDURE  5031  PROGRAM   2020       9
  PARAMETER  1        FIXED      9696     DATA   2020      21
  PARAMETER  2        FIXED      9697     DATA   2020      10
B                     FIXED      1932     DATA    279       9
BACKMSG               CHARACTER   751   STRING    541       4
BACKUP                PROCEDURE  3871  PROGRAM   1692       3
BALANCE               CHARACTER   104   STRING    240       8
BASE                  FIXED      1699     DATA    234       3
BCD                   CHARACTER    97   STRING    190      27
BCHAR                 PROCEDURE   971  PROGRAM    725       2
BLT                   FIXED      6267     DATA    410       2
BOOLBRANCH            PROCEDURE  5223  PROGRAM   2066       2
  PARAMETER  1        FIXED      9708     DATA   2066       7
  PARAMETER  2        FIXED      9709     DATA   2066       4
BUFFER                CHARACTER   101   STRING    225      15
BUILD_BCD             PROCEDURE   561  PROGRAM    618       2
  PARAMETER  1        BIT (9)    9157     DATA    619       3
BYTEPTRS              FIXED      1914     DATA    262       6
C                     FIXED      1933     DATA    279       3
CALLI                 FIXED      6268     DATA    411       1
CALLSUB               PROCEDURE  3818  PROGRAM   1674       1
  PARAMETER  1        FIXED      9612     DATA   1674       2
  PARAMETER  2        FIXED      9613     DATA   1674       2
  PARAMETER  3        FIXED      9614     DATA   1674       4
CALLTYPE              FIXED      1920     DATA    268       3
CAM                   FIXED      6269     DATA    412       5
CAMGE                 FIXED      6270     DATA    413       1
CAML                  FIXED      6271     DATA    414       1
CAMLE                 FIXED      6272     DATA    415       1
CAMN                  FIXED      6273     DATA    416       2
CARD_COUNT            FIXED      1691     DATA    226      13
CASEP                 FIXED      9103     DATA    537      12
CASESTACK             FIXED      8927     DATA    536       3
CATENTRY              FIXED      1917     DATA    265       2
CH                    FIXED      1384     DATA    190       7
CHAR                  PROCEDURE   945  PROGRAM    710       7
CHARTYPE              BIT (9)    1427     DATA    211      11
CHAR_TEMP             CHARACTER   260   STRING    466       7
CHECK_STRING_OVERFLOW PROCEDURE  3805  PROGRAM   1669       3
CLEARARS              PROCEDURE  3323  PROGRAM   1474       6
CMPRHI                FIXED      6274     DATA    417       2
CNT                   FIXED      8720     DATA    528      36
CODE                  CHARACTER   232   STRING    307       8
CODEMSG               CHARACTER   749   STRING    539       4
CODESTRING            CHARACTER   236   STRING    313       4
CODE_BUFFER           FIXED      1967     DATA    318       7
CODE_FULL             BIT (9)    1962     DATA    308       7
CODE_HEAD             FIXED      1963     DATA    309      26
CODE_PP               FIXED      2028     DATA    322       4
CODE_RBITS            FIXED      2032     DATA    323       4
CODE_REL              FIXED      2024     DATA    321       4
CODE_TAIL             FIXED      1964     DATA    310      13
COMPACTIFY            PROCEDURE   128  PROGRAM      0       1
COMPARESWAP           FIXED      6312     DATA    455       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 122
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
COMPILATION_LOOP      PROCEDURE 11602  PROGRAM   3745       1
COMPILING             FIXED      1909     DATA    255       6
CONCATENATE           FIXED      1707     DATA    239       2
CONFLICT              PROCEDURE 11477  PROGRAM   3674       1
  PARAMETER  1        FIXED     10602     DATA   3674       3
CONTROL               BIT (9)    1555     DATA    211      61
COREBYTELOC           FIXED      1923     DATA    271       3
COUNT_ARITH           FIXED      1956     DATA    290       3
COUNT_COMPACT         FIXED        33     DATA      0       3
COUNT_FORCE           FIXED      1955     DATA    289       3
COUNT_INST            FIXED      1954     DATA    288       3
COUNT_SCAN            FIXED      1953     DATA    287       3
COUNT_STORE           FIXED      1957     DATA    291       3
CP                    FIXED      1385     DATA    190      62
CURRENT_PROCEDURE     CHARACTER   103   STRING    229       8
DATACARD              CHARACTER   231   STRING    305      13
DATAMSG               CHARACTER   750   STRING    540       5
DATA_BUFFER           FIXED      1986     DATA    319       6
DCTR                  FIXED      2039     DATA    328      15
DEBLANK               PROCEDURE   958  PROGRAM    718       3
DELETE_MOVE           PROCEDURE  3906  PROGRAM   1702       8
  PARAMETER  1        FIXED      9615     DATA   1703      12
  PARAMETER  2        FIXED      9616     DATA   1703      11
  PARAMETER  3        FIXED      9617     DATA   1703      11
  PARAMETER  4        FIXED      9618     DATA   1703      10
  PARAMETER  5        FIXED      9619     DATA   1703      11
  PARAMETER  6        FIXED      9620     DATA   1703      10
  PARAMETER  7        FIXED      9621     DATA   1703      10
DESCA                 FIXED      2155     DATA    356       3
DESCL                 FIXED      3156     DATA    357       3
DESCREF               FIXED      4157     DATA    358       5
DIVIDE                FIXED      1703     DATA    237       2
DIVIDE_CODE           PROCEDURE  5523  PROGRAM   2149       2
  PARAMETER  1        FIXED      9721     DATA   2149       4
DLOC                  FIXED      2040     DATA    329       5
DP                    FIXED      1965     DATA    311      60
DPB                   FIXED      6275     DATA    418       3
DPOFFSET              FIXED      1966     DATA    312      21
DPTR                  FIXED      2038     DATA    327      12
DSP                   FIXED      5158     DATA    359      24
DUMPIT                PROCEDURE  6237  PROGRAM   2334       1
EMITBLOCK             PROCEDURE  2131  PROGRAM   1116       3
  PARAMETER  1        FIXED      9262     DATA   1117       5
EMITBYTE              PROCEDURE  2272  PROGRAM   1142       4
  PARAMETER  1        FIXED      9271     DATA   1143       7
EMITCODEWORD          PROCEDURE  2423  PROGRAM   1172       1
  PARAMETER  1        CHARACTER   793   STRING   1172       2
  PARAMETER  2        FIXED      9487     DATA   1172       2
  PARAMETER  3        FIXED      9488     DATA   1172       2
EMITCONSTANT          PROCEDURE  2328  PROGRAM   1153      10
  PARAMETER  1        FIXED      9276     DATA   1154      15
EMITDATAWORD          PROCEDURE  2197  PROGRAM   1128      19
  PARAMETER  1        FIXED      9269     DATA   1129      21
EMITDESC              PROCEDURE  2949  PROGRAM   1346       7
  PARAMETER  1        FIXED      9523     DATA   1346       9
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 123
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
  PARAMETER  2        FIXED      9524     DATA   1346       9
EMITINST              PROCEDURE  2737  PROGRAM   1270     219
  PARAMETER  1        FIXED      9505     DATA   1270     224
  PARAMETER  2        FIXED      9506     DATA   1270     221
  PARAMETER  3        FIXED      9507     DATA   1270     221
  PARAMETER  4        FIXED      9508     DATA   1270     226
  PARAMETER  5        FIXED      9509     DATA   1270     222
  PARAMETER  6        FIXED      9510     DATA   1270     222
EMITLABEL             PROCEDURE  2520  PROGRAM   1199      13
  PARAMETER  1        FIXED      9490     DATA   1199      19
  PARAMETER  2        FIXED      9491     DATA   1199      18
EMIT_INLINE           PROCEDURE  3968  PROGRAM   1733       2
  PARAMETER  1        BIT (9)    9622     DATA   1734       3
ENTER                 PROCEDURE  3045  PROGRAM   1377       8
  PARAMETER  1        CHARACTER   817   STRING   1377      13
  PARAMETER  2        FIXED      9535     DATA   1377      11
  PARAMETER  3        FIXED      9536     DATA   1377      10
  PARAMETER  4        FIXED      9537     DATA   1377      10
EOFILE                FIXED      1704     DATA    237       3
ERROR                 PROCEDURE   431  PROGRAM    585      56
  PARAMETER  1        CHARACTER   761   STRING    586      60
  PARAMETER  2        FIXED      9131     DATA    586      57
ERROR_COUNT           FIXED      1692     DATA    226       5
EXPANSION_COUNT       FIXED      1896     DATA    245       4
FAILSOFT              FIXED      1908     DATA    255       3
FALSELOC              FIXED      1913     DATA    261       1
FILEMSG               CHARACTER   752   STRING    542       2
FINDAR                PROCEDURE  3334  PROGRAM   1481      12
FINDLABEL             PROCEDURE  3012  PROGRAM   1361      11
FIXL                  FIXED      8873     DATA    532      78
FIXV                  FIXED      8771     DATA    530      58
FLUSH_CODE_BUFFER     PROCEDURE  1758  PROGRAM    983       3
FLUSH_DATACARD        PROCEDURE  2064  PROGRAM   1104       6
FLUSH_DATA_BUFFER     PROCEDURE  1722  PROGRAM    966       3
FLUSH_LABELS          PROCEDURE  1967  PROGRAM   1059       2
FORCEACCUMULATOR      PROCEDURE  4161  PROGRAM   1811      33
  PARAMETER  1        FIXED      9646     DATA   1811      67
FORCEADDRESS          PROCEDURE  3404  PROGRAM   1514       1
  PARAMETER  1        FIXED      9578     DATA   1515       2
FORCEDESCRIPTOR       PROCEDURE  4626  PROGRAM   1921      11
  PARAMETER  1        FIXED      9675     DATA   1922      21
FOR_COUNT             FIXED      2144     DATA    335      13
FOR_LABEL             FIXED      2093     DATA    334       6
FOR_REF               FIXED      2042     DATA    333       7
FREEBASE              FIXED        32     DATA      0       2
FREELIMIT             FIXED        11     DATA      0       2
GENSTORE              PROCEDURE  4693  PROGRAM   1939       3
  PARAMETER  1        FIXED      9676     DATA   1939      20
  PARAMETER  2        FIXED      9677     DATA   1939      23
GET_CARD              PROCEDURE   590  PROGRAM    625       5
HASH                  FIXED      7876     DATA    516       9
HASHER                PROCEDURE  3019  PROGRAM   1369       5
  PARAMETER  1        CHARACTER   816   STRING   1370       8
HLL                   FIXED      6276     DATA    419       5
HLRZ                  FIXED      6277     DATA    420       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 124
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
HRLI                  FIXED      6278     DATA    421       2
HRLM                  FIXED      6279     DATA    422       1
HRREI                 FIXED      6280     DATA    423       1
I                     FIXED      6329     DATA    468     152
IDCOMPARES            FIXED      6323     DATA    459       5
IDENT                 FIXED      1700     DATA    237       3
IDIV                  FIXED      6281     DATA    424       1
IDIVI                 FIXED      6282     DATA    425       1
IDPB                  FIXED      6283     DATA    426       3
IDX                   FIXED      8553     DATA    518       7
ID_LOOKUP             PROCEDURE  3213  PROGRAM   1425       3
  PARAMETER  1        FIXED      9558     DATA   1426      12
ILDB                  FIXED      6284     DATA    427       3
IMUL                  FIXED      6285     DATA    428       1
INDEX1                FIXED      1089     DATA    162       5
INDEX2                BIT (9)    1324     DATA    175       4
INFO                  CHARACTER   259   STRING    465       8
INITIALIZE            PROCEDURE  6560  PROGRAM   2388       1
INSTRUCT              FIXED      5749     DATA    402       8
INX                   FIXED      8669     DATA    527      53
IOR                   FIXED      6286     DATA    429       4
ITYPE                 FIXED      2148     DATA    352       4
I_FORMAT              PROCEDURE   351  PROGRAM    549       6
  PARAMETER  1        FIXED      9119     DATA    550       7
  PARAMETER  2        FIXED      9120     DATA    550       8
I_STRING              CHARACTER   261   STRING    467      12
J                     FIXED      6330     DATA    468      55
JBASE                 FIXED      1698     DATA    234      10
JRST                  FIXED      6287     DATA    430      12
JUMP                  FIXED      6288     DATA    431       2
JUMPE                 FIXED      6289     DATA    432       2
JUMPGE                FIXED      6290     DATA    433       1
JUMPN                 FIXED      6291     DATA    434       2
K                     FIXED      6331     DATA    468      22
L                     FIXED      6332     DATA    468       2
LABELSET              FIXED      1705     DATA    238       1
LABEL_BUFFER          FIXED      2005     DATA    320       5
LABEL_COUNT           FIXED      2041     DATA    330      10
LABEL_GEN             CHARACTER   227   STRING    283       7
LABEL_SINK            FIXED      1936     DATA    282       3
LB                    FIXED      1708     DATA    240      12
LDB                   FIXED      6292     DATA    435       2
LENGTHMASK            FIXED      1934     DATA    280       4
LIBRARY               FIXED      1927     DATA    275       2
LIBRARY_CALL          PROCEDURE  4072  PROGRAM   1766       5
  PARAMETER  1        FIXED      9637     DATA   1766       8
  PARAMETER  2        FIXED      9638     DATA   1766       7
  PARAMETER  3        FIXED      9639     DATA   1766       9
  PARAMETER  4        FIXED      9640     DATA   1766       9
LIBRARY_SAVE          FIXED      1928     DATA    276       1
LIMITWORD             FIXED      1924     DATA    272       3
LINE_COUNT            FIXED      1959     DATA    296      10
LINE_LENGTH           FIXED      1695     DATA    228       3
LOOK1                 BIT (9)     914     DATA    120       2
LOOK2                 BIT (9)    1044     DATA    150       1
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 125
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
LOWUP                 CHARACTER PROCEDURE  1039  PROGRAM    745       1
  PARAMETER  1        CHARACTER   772   STRING    746       5
LSH                   FIXED      6293     DATA    436      14
LSHC                  FIXED      6294     DATA    437       7
MACRO_COUNT           FIXED      1773     DATA    243       6
MACRO_DECLARE         FIXED      1834     DATA    243       4
MACRO_INDEX           BIT (9)    1709     DATA    242       5
MACRO_NAME            CHARACTER   105   STRING    241      11
MACRO_TEXT            CHARACTER   166   STRING    242       5
MAXNDECSY             FIXED      6335     DATA    469       3
MONITOR_CALL          PROCEDURE  4129  PROGRAM   1796       3
  PARAMETER  1        FIXED      9642     DATA   1796       4
  PARAMETER  2        FIXED      9644     DATA   1796       5
  PARAMETER  3        FIXED      9643     DATA   1796       4
MOVE                  FIXED      6295     DATA    438      34
MOVEI                 FIXED      6296     DATA    439      21
MOVEM                 FIXED      6297     DATA    440      19
MOVER                 FIXED      1921     DATA    269       3
MOVESTACKS            PROCEDURE  3370  PROGRAM   1501       9
  PARAMETER  1        FIXED      9576     DATA   1502      17
  PARAMETER  2        FIXED      9577     DATA   1502      17
MOVM                  FIXED      6298     DATA    441       1
MOVN                  FIXED      6299     DATA    442       2
MP                    FIXED      8925     DATA    533     252
MPP1                  FIXED      8926     DATA    533     112
NDECSY                FIXED      6334     DATA    469      38
NDESC                 FIXED      1926     DATA    274       4
NEWDP                 FIXED      2149     DATA    353      10
NEWDPOFFSET           FIXED      2151     DATA    353       6
NEWDSP                FIXED      2150     DATA    353       4
NMBRENTRY             FIXED      1918     DATA    266       2
NOT_LETTER_OR_DIGIT   BIT (9)    1619     DATA    212       5
NO_LOOK_AHEAD_DONE    BIT (9)    1910     DATA    258       7
NUMBER                FIXED      1702     DATA    237       3
NUMBER_VALUE          FIXED      1697     DATA    234       8
OLDDP                 FIXED      2152     DATA    354       4
OLDDPOFFSET           FIXED      2154     DATA    354       4
OLDDSP                FIXED      2153     DATA    354       2
OPNAME                CHARACTER   238   STRING    361       2
ORSYMBOL              FIXED      1706     DATA    239       2
OUTPUTLABEL           PROCEDURE  2498  PROGRAM   1191       2
  PARAMETER  1        FIXED      9489     DATA   1192       3
OUTPUT_CODEWORD       PROCEDURE  1884  PROGRAM   1030       5
OUTPUT_DATAWORD       PROCEDURE  2004  PROGRAM   1079       3
  PARAMETER  1        FIXED      9258     DATA   1080       5
  PARAMETER  2        FIXED      9259     DATA   1080       6
PAGE_COUNT            FIXED      1958     DATA    295       4
PARCT                 FIXED      6336     DATA    469      18
POINTER               CHARACTER    99   STRING    198       4
POP                   FIXED      6300     DATA    443       2
POPJ                  FIXED      6301     DATA    444      13
PP                    FIXED      1961     DATA    306      42
PPSAVE                FIXED      8822     DATA    531      12
PREVIOUS_ERROR        FIXED      1694     DATA    227       5
PRINTLINE             PROCEDURE   374  PROGRAM    560      50
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 126
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
  PARAMETER  1        CHARACTER   753   STRING    561      52
  PARAMETER  2        FIXED      9122     DATA    561      54
PRINT_TIME            PROCEDURE 11884  PROGRAM   3869       4
  PARAMETER  1        CHARACTER   958   STRING   3870       5
  PARAMETER  2        FIXED     10642     DATA   3870       5
PROCEDURE_DEPTH       FIXED      1696     DATA    230       6
PROCMARK              FIXED      6333     DATA    469      21
PROC_START            PROCEDURE  3597  PROGRAM   1581       4
PSBITS                FIXED      1915     DATA    263       6
PTR                   FIXED      8132     DATA    517       9
PUSH                  FIXED      6302     DATA    445       2
PUSHJ                 FIXED      6303     DATA    446      10
PWORD                 FIXED      2145     DATA    336       4
RADIX50               PROCEDURE  1794  PROGRAM   1002       2
  PARAMETER  1        CHARACTER   782   STRING   1003       6
RCTR                  FIXED      2037     DATA    326      15
READ1                 BIT (9)     829     DATA    105       2
READ2                 BIT (9)     959     DATA    132       1
READING               BIT (9)    1960     DATA    304       4
RECOVER               PROCEDURE 11510  PROGRAM   3694       1
REFCHECK              PROCEDURE  2678  PROGRAM   1240       3
  PARAMETER  1        FIXED      9496     DATA   1241      12
REG                   FIXED      8618     DATA    526     123
RESERVED_LIMIT        FIXED      1426     DATA    201       3
RESTORE_ACS           PROCEDURE  3568  PROGRAM   1571       4
  PARAMETER  1        FIXED      9601     DATA   1572       6
RETURNED_TYPE         FIXED      6337     DATA    470      13
ROT                   FIXED      6304     DATA    447       4
RPTR                  FIXED      2036     DATA    325      13
S                     CHARACTER   237   STRING    360      21
SAVE_ACS              PROCEDURE  3543  PROGRAM   1562       4
  PARAMETER  1        FIXED      9598     DATA   1563       5
SCAN                  PROCEDURE  1090  PROGRAM    758       6
SETCA                 FIXED      6305     DATA    448       1
SETINIT               PROCEDURE  3431  PROGRAM   1525       2
SETLIMIT              PROCEDURE  5366  PROGRAM   2103       2
SETZM                 FIXED      6306     DATA    449       2
SEVERE_ERRORS         FIXED      1693     DATA    227       5
SHIFT_CODE            PROCEDURE  5635  PROGRAM   2191       2
  PARAMETER  1        FIXED      9733     DATA   2192       4
SHOULDCOMMUTE         PROCEDURE  4975  PROGRAM   2013       2
SKIP                  FIXED      6307     DATA    450       1
SKIPE                 FIXED      6308     DATA    451       1
SOJG                  FIXED      6309     DATA    452       3
SOURCE                CHARACTER   230   STRING    299      18
SP                    FIXED      8924     DATA    533      97
STACK_DUMP            PROCEDURE  8952  PROGRAM   2798       2
STARTLOC              FIXED      2146     DATA    337       2
STATEMENT_COUNT       FIXED      6322     DATA    458       4
STATE_NAME            BIT (9)     804     DATA     93       2
STATE_STACK           BIT (9)    8554     DATA    524       7
STEPK                 FIXED      1930     DATA    278       3
STILLCOND             FIXED      6320     DATA    456       5
STILLINZERO           FIXED      6321     DATA    457      11
STOPIT                BIT (9)    1897     DATA    255       7
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 127
SYMBOL                TYPE       LOC   SEGMENT DEFINED REF COUNT
 
STR                   FIXED      1929     DATA    277       4
STRCOMP               FIXED      1919     DATA    267       2
STRING                FIXED      1701     DATA    237       5
STRINGCOMPARE         PROCEDURE  5709  PROGRAM   2216       4
STRING_CHECK          FIXED      1916     DATA    264       2
STRING_RECOVER        FIXED      1922     DATA    270       5
STUFF_PARAMETER       PROCEDURE  5403  PROGRAM   2118       2
SUB                   FIXED      6310     DATA    453       5
SUBI                  FIXED      6311     DATA    454       6
SUBTITLE              CHARACTER   229   STRING    294      11
SYMBOLDUMP            PROCEDURE  5802  PROGRAM   2237       2
SYNTHESIZE            PROCEDURE  9013  PROGRAM   2817       1
  PARAMETER  1        FIXED     10492     DATA   2818       2
SYT                   CHARACTER   277   STRING    494      28
SYTCARD               FIXED      7455     DATA    514       4
SYTCO                 FIXED      7034     DATA    513      14
SYTLOC                FIXED      6507     DATA    508      26
SYTSEG                BIT (9)    6928     DATA    511      18
SYTYPE                BIT (9)    6401     DATA    501      34
TARGET_REGISTER       FIXED      1911     DATA    259      11
TDECLARE              PROCEDURE  3643  PROGRAM   1590       2
  PARAMETER  1        FIXED      9605     DATA   1591       3
TEXT                  CHARACTER   102   STRING    225      45
TEXT_LIMIT            FIXED      1690     DATA    225      18
TIME_COMPILE          FIXED     10646     DATA   3884       5
TIME_FINISH           FIXED     10647     DATA   3885       5
TIME_INIT             FIXED     10645     DATA   3883       5
TIME_START            FIXED     10644     DATA   3882       4
TITLE                 CHARACTER   228   STRING    293       5
TOKEN                 FIXED      1383     DATA    190      18
TOP_MACRO             FIXED      1895     DATA    244      10
TRUELOC               FIXED      1912     DATA    260       3
TSA                   FIXED      1925     DATA    273      12
TX                    BIT (9)    1491     DATA    211       2
TYPE                  FIXED      8567     DATA    525      80
TYPENAME              CHARACTER   262   STRING    484       2
UNDECLARED_ID         PROCEDURE  3280  PROGRAM   1455       2
  PARAMETER  1        FIXED      9561     DATA   1456       9
VAR                   CHARACTER   698   STRING    529      27
VOCAB                 CHARACTER     5   STRING     71      10
X1                    CHARACTER   254   STRING    460      18
X2                    CHARACTER   255   STRING    461       4
X3                    CHARACTER   256   STRING    462       2
X4                    CHARACTER   257   STRING    463       5
X7                    CHARACTER   258   STRING    464       4
X70                   CHARACTER    98   STRING    196      21
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 128

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

3972 LINES CONTAINING 2116 STATEMENTS WERE COMPILED.
NO ERRORS WERE DETECTED.
12367 WORDS OF PROGRAM, 10774 WORDS OF DATA, AND 987 WORDS OF DESCRIPTORS.  TOTAL CORE REQUIREMENT 24128 WORDS.
TOTAL TIME IN COMPILER    = 1:21.909
INITIALIZATION TIME       = 0:0.72
ACTUAL COMPILATION TIME   = 1:6.835
POST-COMPILATION CLEAN-UP = 0:15.2

MACRO DEFINITIONS:
 
NAME             AT LINE REF COUNT LITERAL VALUE
P#                   91        0    109
TRUE                194       27    "1"
BUSY                285        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       25    "0"
AVAIL               285       35    0
VOCAB#               69        2    91
DX_SIZE               0        2    500
VERSION              53        1    '4.0'
FOREVER             195        4    WHILE TRUE
RELFILE             302       25    4
LIBFILE             303        2    5
FOR_MAX             332        3    50
CHRTYPE             475       18    6
SPECIAL             480       25    11
SYTSIZE             493       10    420
PAGE_MAX            297        4    54
DATAFILE            300       22    2
CODEFILE            301        7    3
END_TYPE            343        1    "(3)5000000"
VARIABLE            473       13    3
CONSTANT            474       18    4
BYTETYPE            477        6    8
DESCRIPT            479       12    10
PROCTYPE            482        5    13
TERMINAL#            67        7    42
CODE_TYPE           340        2    "(3)1000000"
SYMB_TYPE           341        1    "(3)2000000"
NAME_TYPE           344        1    "(3)6000000"
DESCLIMIT           355        4    1000
LABELTYPE           471        3    1
FIXEDTYPE           476       17    7
STACKSIZE           523       11    50
CASELIMIT           535        2    175
EJECT_PAGE          298        3    LINE_COUNT = PAGE_MAX+1
BUFFERSIZE          317        7    18
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 129
NAME             AT LINE REF COUNT LITERAL VALUE
 
HISEG_TYPE          342        1    "(3)3000000"
START_TYPE          345        1    "(3)7000000"
START_STATE          65        1    1
MACRO_LIMIT         241        5    60
INTREQ_TYPE         346        1    "(3)10000000"
ACCUMULATOR         472       16    2
FORWARDTYPE         478        7    9
FORWARDCALL         481        6    12
CHARPROCTYPE        483        7    14
EXPANSION_LIMIT     245        1    300
 
ID COMPARES       = 8365
SYMBOL TABLE SIZE = 414
MACRO DEFINITIONS = 52
SCAN              = 26676
EMITINST          = 13257
FORCE ACCUMULATOR = 6066
ARITHEMIT         = 891
GENERATE STORE    = 1048
FREE STRING AREA  = 14084
COMPACTIFICATIONS = 158
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 130
INSTRUCTION FREQUENCIES
 
.INIT.    1
.INPT.    6
.OUTP.    42
.EXIT.    3
.FILO.    24
.NAME.    7
CALLI     6
ILDB      3
LDB       163
IDPB      3
DPB       68
MOVE      3215
MOVEI     257
MOVEM     2576
MOVN      3
MOVM      1
IMULI     11
IDIVI     20
ROT       4
LSH       329
LSHC      7
BLT       2
JRST      725
PUSHJ     963
PUSH      64
POP       64
POPJ      139
ADD       121
ADDI      317
ADDM      2
SUB       74
SUBI      84
CAIL      15
CAIE      179
CAILE     7
CAIGE     14
CAIN      37
CAIG      55
CAML      16
CAME      22
CAMLE     64
CAMGE     7
CAMN      7
CAMG      8
JUMP      1
JUMPE     107
JUMPA     290
JUMPGE    1
JUMPN     2
SKIPE     18
SKIPGE    1
SKIPN     1
SKIPG     2
AOSA      54
SOJG      3
ULXCOM.XPL  COMPILED 26-JUL-1977  AT 20:16:29 BY VERSION 4.0                             PAGE 131
INSTRUCTION FREQUENCIES
 
SETZM     841
AND       89
ANDI      337
IOR       77
SETCA     7
HLL       5
HRLI      2
HRLM      1
HLRZ      1
HRREI     792