Google
 

Trailing-Edge - PDP-10 Archives - decuslib20-04 - decus/20-0122/sklton.lst
There is 1 other file named sklton.lst in the archive. Click here to see a list.
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 1
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
    1   /*   SKELETON                                                                   *
    2    06-Jul-77, JBD - Changes made to SKLTON.XPL:                                   *
    3    References to TRACE and UNTRACE were removed. This of course,                  *
    4    renders the $T switch completly useless.                                       *
    5    All "[" were changed to \. (character set incompatibilities)                   *
    6    Reference to DATE_OF_GENERATION and TIME_OF_GENERATION were                    *
    7     removed.                                                                      *
    8                                                                                   *
    9    15-Jul-77, JBD - More changes:                                                 *
   10    Code was added to take source from a file.                                     *
   11    The access mechanism to C1 had to be changed in order to                       *
   12    handle 9-bit bytes...ugh.                                                      *
   13    Stuff was added here and there to tell the user what was                       *
   14    happening in Synthesize.                                                       *
   15    X70 was all tabs, so I had to change that.                                     *
   16    It handles tabs, but the listing comes out jagging.                            *
   17            THE PROTO-COMPILER OF THE XPL SYSTEM                                   *
   18                                                                                   *
   19                                                                                   *
   20  W. M. MCKEEMAN           J. J. HORNING           D. B. WORTMAN                   *
   21                                                                                   *
   22  INFORMATION &            COMPUTER SCIENCE        COMPUTER SCIENCE                *
   23  COMPUTER SCIENCE,      DEPARTMENT,               DEPARTMENT,                     *
   24                                                                                   *
   25  UNIVERSITY OF            STANFORD                STANFORD                        *
   26  CALIFORNIA AT            UNIVERSITY,             UNIVERSITY,                     *
   27                                                                                   *
   28  SANTA CRUZ,              STANFORD,               STANFORD,                       *
   29  CALIFORNIA               CALIFORNIA              CALIFORNIA                      *
   30  95060                    94305                   94305                           *
   31                                                                                   *
   32  DEVELOPED AT THE STANFORD COMPUTATION CENTER, CAMPUS FACILITY,     1966-69       *
   33  AND THE UNIVERSITY OF CALIFORNIA COMPUTATION CENTER, SANTA CRUZ, 1968-69.        *
   34                                                                                   *
   35  DISTRIBUTED THROUGH THE SHARE ORGANIZATION.                                      *
   36  THIS VERSION OF SKELETON IS A SYNTAX CHECKER FOR THE FOLLOWING GRAMMAR:          *
   37                                                                                   *
   38  <PROGRAM>  ::=    <STATEMENT LIST>                                               *
   39                                                                                   *
   40  <STATEMENT LIST>  ::=  <STATEMENT>                                               *
   41                ^  <STATEMENT LIST> <STATEMENT>                                    *
   42                                                                                   *
   43  <STATEMENT>  ::=  <ASSIGNMENT> ;                                                 *
   44                                                                                   *
   45  <ASSIGNMENT>  ::=  <VARIABLE> = <EXPRESSION>                                     *
   46                                                                                   *
   47  <EXPRESSION>  ::=  <ARITH EXPRESSION>                                            *
   48            ^  <IF CLAUSE> THEN <EXPRESSION> ELSE <EXPRESSION>                     *
   49                                                                                   *
   50  <IF CLAUSE>  ::=  IF <LOG EXPRESSION>                                            *
   51                                                                                   *
   52  <LOG EXPRESSION>  ::=  TRUE                                                      *
   53                ^  FALSE                                                           *
   54                ^  <EXPRESSION> <RELATION> <EXPRESSION>                            *
   55                ^  <IF CLAUSE> THEN <LOG EXPRESSION> ELSE <LOG EXPRESSION>         *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 2
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
   56                                                                                   *
   57  <RELATION>  ::=  =                                                               *
   58          ^  <                                                                     *
   59          ^  >                                                                     *
   60                                                                                   *
   61  <ARITH EXPRESSION>  ::=  <TERM>                                                  *
   62                  ^  <ARITH EXPRESSION> + <TERM>                                   *
   63                  ^  <ARITH EXPRESSION> - <TERM>                                   *
   64                                                                                   *
   65  <TERM>    ::=  <PRIMARY>                                                         *
   66      ^  <TERM> * <PRIMARY>                                                        *
   67      ^  <TERM> / <PRIMARY>                                                        *
   68                                                                                   *
   69  <PRIMARY>  ::=    <VARIABLE>                                                     *
   70         ^  <NUMBER>                                                               *
   71         ^  ( <EXPRESSION> )                                                       *
   72                                                                                   *
   73  <VARIABLE>  ::=  <IDENTIFIER>                                                    *
   74          ^  <VARIABLE> ( <EXPRESSION> )                                           *
   75                                                                          */       *
   76                                                                                   *
   77     /*  FIRST WE INITIALIZE THE GLOBAL CONSTANTS THAT DEPEND UPON THE INPUT       *
   78        GRAMMAR.    THE FOLLOWING CARDS ARE PUNCHED BY THE SYNTAX PRE-PROCESSOR  */*
   79                                                                                   *
   80     DECLARE NSY LITERALLY '32', NT LITERALLY '18';                                *
   81     DECLARE V(NSY) CHARACTER INITIAL ( '<ERROR: TOKEN = 0>', ';', '=', '<', '>',  *
   82        '+', '-', '*', '/', '(', ')', 'IF', '_^_', 'THEN', 'ELSE', 'TRUE',         *
   83        'FALSE', '<NUMBER>', '<IDENTIFIER>', '<TERM>', '<PROGRAM>', '<PRIMARY>',   *
   84        '<VARIABLE>', '<RELATION>', '<STATEMENT>', '<IF CLAUSE>', '<ASSIGNMENT>',  *
   85        '<EXPRESSION>', '<STATEMENT LIST>', '<ARITH EXPRESSION>',                  *
   86        '<LOG EXPRESSION>', 'ELSE', 'ELSE');                                       *
   87     DECLARE V_INDEX(12) BIT(16) INITIAL ( 1, 11, 12, 13, 16, 17, 17, 17, 18, 18,  *
   88        18, 18, 19);                                                               *
   89     DECLARE C1(NSY) BIT(38) INITIAL (                                             *
   90        "(2) 00000 00000 00000 0000",                                              *
   91        "(2) 00000 00000 00200 0002",                                              *
   92        "(2) 00000 00003 03000 0033",                                              *
   93        "(2) 00000 00002 02000 0022",                                              *
   94        "(2) 00000 00002 02000 0022",                                              *
   95        "(2) 00000 00001 00000 0011",                                              *
   96        "(2) 00000 00001 00000 0011",                                              *
   97        "(2) 00000 00001 00000 0011",                                              *
   98        "(2) 00000 00001 00000 0011",                                              *
   99        "(2) 00000 00001 01000 0011",                                              *
  100        "(2) 02222 22222 20022 0000",                                              *
  101        "(2) 00000 00001 01000 1111",                                              *
  102        "(2) 00000 00000 00000 0001",                                              *
  103        "(2) 00000 00001 01000 1111",                                              *
  104        "(2) 00000 00002 02000 2222",                                              *
  105        "(2) 00000 00000 00022 0000",                                              *
  106        "(2) 00000 00000 00022 0000",                                              *
  107        "(2) 02222 22220 20022 0000",                                              *
  108        "(2) 02222 22222 20022 0000",                                              *
  109        "(2) 02222 22110 20022 0000",                                              *
  110        "(2) 00000 00000 00000 0000",                                              *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 3
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  111        "(2) 02222 22220 20022 0000",                                              *
  112        "(2) 02322 22221 20022 0000",                                              *
  113        "(2) 00000 00001 01000 0011",                                              *
  114        "(2) 00000 00000 00200 0002",                                              *
  115        "(2) 00000 00000 00010 0000",                                              *
  116        "(2) 01000 00000 00000 0000",                                              *
  117        "(2) 02333 00000 30023 0000",                                              *
  118        "(2) 00000 00000 00200 0001",                                              *
  119        "(2) 02222 11000 20022 0000",                                              *
  120        "(2) 00000 00000 00023 0000",                                              *
  121        "(2) 00000 00001 01000 0011",                                              *
  122        "(2) 00000 00001 01000 1111");                                             *
  123     DECLARE NC1TRIPLES LITERALLY '17';                                            *
  124     DECLARE C1TRIPLES(NC1TRIPLES) FIXED INITIAL ( 596746, 727810, 727811, 727812, *
  125        792066, 858882, 858883, 858884, 858894, 859662, 1442313, 1442315, 1442321, *
  126        1442322, 1840642, 2104066, 2104067, 2104068);                              *
  127     DECLARE PRTB(28) FIXED INITIAL (0, 26, 0, 0, 0, 1444123, 2331, 0, 0, 0, 0, 0, *
  128        0, 7429, 7430, 0, 4871, 4872, 0, 0, 28, 0, 420289311, 5634, 6935, 0, 0,    *
  129        420290080, 11);                                                            *
  130     DECLARE PRDTB(28) BIT(8) INITIAL (0, 4, 13, 14, 15, 26, 24, 0, 0, 9, 10, 23,  *
  131        25, 17, 18, 16, 20, 21, 19, 22, 3, 2, 7, 5, 11, 1, 6, 12, 8);              *
  132     DECLARE HDTB(28) BIT(8) INITIAL (0, 24, 23, 23, 23, 22, 21, 31, 32, 30, 30,   *
  133        21, 22, 29, 29, 29, 19, 19, 19, 21, 28, 28, 27, 26, 30, 20, 27, 30, 25);   *
  134     DECLARE PRLENGTH(28) BIT(8) INITIAL (0, 2, 1, 1, 1, 4, 3, 1, 1, 1, 1, 1, 1,   *
  135        3, 3, 1, 3, 3, 1, 1, 2, 1, 5, 3, 3, 1, 1, 5, 2);                           *
  136     DECLARE CONTEXT_CASE(28) BIT(8) INITIAL (0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,  *
  137        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);                        *
  138     DECLARE LEFT_CONTEXT(0) BIT(8) INITIAL ( 27);                                 *
  139     DECLARE LEFT_INDEX(14) BIT(8) INITIAL ( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   *
  140        0, 1, 1);                                                                  *
  141     DECLARE CONTEXT_TRIPLE(0) FIXED INITIAL ( 0);                                 *
  142     DECLARE TRIPLE_INDEX(14) BIT(8) INITIAL ( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, *
  143        0, 0, 1);                                                                  *
  144     DECLARE PR_INDEX(32) BIT(8) INITIAL ( 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 7, 7, 7,  *
  145        7, 9, 10, 11, 12, 13, 16, 16, 19, 20, 20, 22, 22, 22, 25, 26, 27, 29, 29,  *
  146        29);                                                                       *
  147                                                                                   *
  148     /*  END OF CARDS PUNCHED BY SYNTAX                                        */  *
  149                                                                                   *
  150     /*  DECLARATIONS FOR THE SCANNER                                          */  *
  151                                                                                   *
  152     /* TOKEN IS THE INDEX INTO THE VOCABULARY V() OF THE LAST SYMBOL SCANNED,     *
  153        CP IS THE POINTER TO THE LAST CHARACTER SCANNED IN THE CARDIMAGE,          *
  154        BCD IS THE LAST SYMBOL SCANNED (LITERAL CHARACTER STRING). */              *
  155     DECLARE (TOKEN, CP) FIXED, BCD CHARACTER;                                     *
  156                                                                                   *
  157     /* SET UP SOME CONVENIENT ABBREVIATIONS FOR PRINTER CONTROL */                *
  158     DECLARE EJECT_PAGE LITERALLY 'OUTPUT(1) = PAGE',                              *
  159        PAGE CHARACTER INITIAL ('1'), DOUBLE CHARACTER INITIAL ('0'),              *
  160        DOUBLE_SPACE LITERALLY 'OUTPUT(1) = DOUBLE',                               *
  161        X70 CHARACTER INITIAL ('                                                   *
  162                      ');                                                          *
  163                                                                                   *
  164     /* LENGTH OF LONGEST SYMBOL IN V */                                           *
  165     DECLARE (RESERVED_LIMIT, MARGIN_CHOP) FIXED;                                  *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 4
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  166                                                                                   *
  167     /* CHARTYPE() IS USED TO DISTINGUISH CLASSES OF SYMBOLS IN THE SCANNER.       *
  168        TX() IS A TABLE USED FOR TRANSLATING FROM ONE CHARACTER SET TO ANOTHER.    *
  169        CONTROL() HOLDS THE VALUE OF THE COMPILER CONTROL TOGGLES SET IN $ CARDS.  *
  170        NOT_LETTER_OR_DIGIT() IS SIMILIAR TO CHARTYPE() BUT USED IN SCANNING       *
  171        IDENTIFIERS ONLY.                                                          *
  172                                                                                   *
  173        ALL ARE USED BY THE SCANNER AND CONTROL() IS SET THERE.                    *
  174     */                                                                            *
  175     DECLARE (CHARTYPE, TX) (255) BIT(8),                                          *
  176       (CONTROL, NOT_LETTER_OR_DIGIT)(255) BIT(1);                                 *
  177                                                                                   *
  178     /* ALPHABET CONSISTS OF THE SYMBOLS CONSIDERED ALPHABETIC IN BUILDING         *
  179        IDENTIFIERS     */                                                         *
  180     DECLARE ALPHABET CHARACTER INITIAL ('ABCDEFGHIJKLMNOPQRSTUVWXYZ_$@#');        *
  181                                                                                   *
  182     /* BUFFER HOLDS THE LATEST CARDIMAGE,                                         *
  183        TEXT HOLDS THE PRESENT STATE OF THE INPUT TEXT                             *
  184        (NOT INCLUDING THE PORTIONS DELETED BY THE SCANNER),                       *
  185        TEXT_LIMIT IS A CONVENIENT PLACE TO STORE THE POINTER TO THE END OF TEXT,  *
  186        CARD_COUNT IS INCREMENTED BY ONE FOR EVERY SOURCE CARD READ,               *
  187        ERROR_COUNT TABULATES THE ERRORS AS THEY ARE DETECTED,                     *
  188        SEVERE_ERRORS TABULATES THOSE ERRORS OF FATAL SIGNIFICANCE.                *
  189     */                                                                            *
  190     DECLARE (BUFFER, TEXT) CHARACTER,                                             *
  191        (TEXT_LIMIT, CARD_COUNT, ERROR_COUNT, SEVERE_ERRORS, PREVIOUS_ERROR) FIXED *
  192        ;                                                                          *
  193                                                                                   *
  194     /* NUMBER_VALUE CONTAINS THE NUMERIC VALUE OF THE LAST CONSTANT SCANNED,      *
  195     */                                                                            *
  196     DECLARE NUMBER_VALUE FIXED;                                                   *
  197                                                                                   *
  198     /* EACH OF THE FOLLOWING CONTAINS THE INDEX INTO V() OF THE CORRESPONDING     *
  199        SYMBOL.     WE ASK:    IF TOKEN = IDENT    ETC.    */                      *
  200     DECLARE (IDENT, NUMBER, DIVIDE, EOFILE) FIXED;                                *
  201                                                                                   *
  202     /* STOPIT() IS A TABLE OF SYMBOLS WHICH ARE ALLOWED TO TERMINATE THE ERROR    *
  203        FLUSH PROCESS.  IN GENERAL THEY ARE SYMBOLS OF SUFFICIENT SYNTACTIC        *
  204        HIERARCHY THAT WE EXPECT TO AVOID ATTEMPTING TO START CHECKING AGAIN       *
  205        RIGHT INTO ANOTHER ERROR PRODUCING SITUATION.  THE TOKEN STACK IS ALSO     *
  206        FLUSHED DOWN TO SOMETHING ACCEPTABLE TO A STOPIT() SYMBOL.                 *
  207        FAILSOFT IS A BIT WHICH ALLOWS THE COMPILER ONE ATTEMPT AT A GENTLE        *
  208        RECOVERY.   THEN IT TAKES A STRONG HAND.     WHEN THERE IS REAL TROUBLE    *
  209        COMPILING IS SET TO FALSE, THEREBY TERMINATING THE COMPILATION.            *
  210     */                                                                            *
  211     DECLARE STOPIT(100) BIT(1), (FAILSOFT, COMPILING) BIT(1);                     *
  212                                                                                   *
  213     DECLARE S CHARACTER;  /* A TEMPORARY USED VARIOUS PLACES */                   *
  214                                                                                   *
  215     /* THE ENTRIES IN PRMASK() ARE USED TO SELECT OUT PORTIONS OF CODED           *
  216        PRODUCTIONS AND THE STACK TOP FOR COMPARISON IN THE ANALYSIS ALGORITHM */  *
  217     DECLARE PRMASK(5) FIXED INITIAL (0, 0, "FF", "FFFF", "FFFFFF", "FFFFFFFF");   *
  218                                                                                   *
  219                                                                                   *
  220     /*THE PROPER SUBSTRING OF POINTER IS USED TO PLACE AN  ^  UNDER THE POINT     *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 5
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  221        OF DETECTION OF AN ERROR DURING CHECKING.  IT MARKS THE LAST CHARACTER     *
  222        SCANNED.    */                                                             *
  223     DECLARE POINTER CHARACTER INITIAL ('                                          *
  224                                       ^');                                        *
  225     DECLARE CALLCOUNT(20) FIXED     /* COUNT THE CALLS OF IMPORTANT PROCEDURES */ *
  226        INITIAL(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);                        *
  227                                                                                   *
  228     /* RECORD THE TIMES OF IMPORTANT POINTS DURING CHECKING */                    *
  229     DECLARE CLOCK(5) FIXED;                                                       *
  230                                                                                   *
  231                                                                                   *
  232     /* COMMONLY USED STRINGS */                                                   *
  233     DECLARE X1 CHARACTER INITIAL(' '), X4 CHARACTER INITIAL('      ');            *
  234     DECLARE PERIOD CHARACTER INITIAL ('.');                                       *
  235                                                                                   *
  236     /* TEMPORARIES USED THROUGHOUT THE COMPILER */                                *
  237     DECLARE (I, J, K, L) FIXED;                                                   *
  238                                                                                   *
  239     DECLARE TRUE LITERALLY '1', FALSE LITERALLY '0', FOREVER LITERALLY 'WHILE 1'; *
  240                                                                                   *
  241     /*  THE STACKS DECLARED BELOW ARE USED TO DRIVE THE SYNTACTIC                 *
  242        ANALYSIS ALGORITHM AND STORE INFORMATION RELEVANT TO THE INTERPRETATION    *
  243        OF THE TEXT.  THE STACKS ARE ALL POINTED TO BY THE STACK POINTER SP.  */   *
  244                                                                                   *
  245     DECLARE STACKSIZE LITERALLY '75';  /* SIZE OF STACK    */                     *
  246     DECLARE PARSE_STACK (STACKSIZE) BIT(8); /* TOKENS OF THE PARTIALLY PARSED     *
  247                                          TEXT */                                  *
  248     DECLARE VAR (STACKSIZE) CHARACTER;/* EBCDIC NAME OF ITEM */                   *
  249     DECLARE FIXV (STACKSIZE) FIXED;   /* FIXED (NUMERIC) VALUE */                 *
  250                                                                                   *
  251     /* SP POINTS TO THE RIGHT END OF THE REDUCIBLE STRING IN THE PARSE STACK,     *
  252        MP POINTS TO THE LEFT END, AND                                             *
  253        MPP1 = MP+1.                                                               *
  254     */                                                                            *
  255     DECLARE (SP, MP, MPP1) FIXED;                                                 *
  256                                                                                   *
  257                                                                                   *
  258   /*       TO MASK OUT THE REMAINING 4 BITS FROM A 36 BIT WORD     */             *
  259     DECLARE B32 LITERALLY '&"FFFFFFFF"';                                          *
  260                                                                                   *
  261                                                                                   *
  262                                                                                   *
  263     /*                 P R O C E D U R E S                                  */    *
  264                                                                                   *
  265                                                                                   *
  266                                                                                   *
  267  PAD:                                                                             *
  268     PROCEDURE (STRING, WIDTH) CHARACTER;                                          *
  269        DECLARE STRING CHARACTER, (WIDTH, L) FIXED;                                 PAD
  270                                                                                    PAD
  271        L = LENGTH(STRING);                                                         PAD
  272        IF L >= WIDTH THEN RETURN STRING;                                           PAD
  273        ELSE RETURN STRING ^^ SUBSTR(X70, 0, WIDTH-L);                              PAD
  274     END PAD;                                                                       PAD

SYMBOL TABLE DUMP
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 6
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
L               FIXED      1263     DATA    269       3
STRING          CHARACTER   159   STRING    268       3
WIDTH           FIXED      1262     DATA    268       2
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 7
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  275                                                                                   *
  276  I_FORMAT:                                                                        *
  277     PROCEDURE (NUMBER, WIDTH) CHARACTER;                                          *
  278        DECLARE (NUMBER, WIDTH, L) FIXED, STRING CHARACTER;                         I_FORMAT
  279                                                                                    I_FORMAT
  280        STRING = NUMBER;                                                            I_FORMAT
  281        L = LENGTH(STRING);                                                         I_FORMAT
  282        IF L >= WIDTH THEN RETURN STRING;                                           I_FORMAT
  283        ELSE RETURN SUBSTR(X70, 0, WIDTH-L) ^^ STRING;                              I_FORMAT
  284     END I_FORMAT;                                                                  I_FORMAT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
L               FIXED      1266     DATA    278       3
NUMBER          FIXED      1264     DATA    277       1
STRING          CHARACTER   160   STRING    278       4
WIDTH           FIXED      1265     DATA    277       2
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 8
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  285                                                                                   *
  286  ERROR:                                                                           *
  287     PROCEDURE(MSG, SEVERITY);                                                     *
  288        /* PRINTS AND ACCOUNTS FOR ALL ERROR MESSAGES */                            ERROR
  289        /* IF SEVERITY IS NOT SUPPLIED, 0 IS ASSUMED */                             ERROR
  290        DECLARE MSG CHARACTER, SEVERITY FIXED;                                      ERROR
  291        ERROR_COUNT = ERROR_COUNT + 1;                                              ERROR
  292        /* IF LISTING IS SUPPRESSED, FORCE PRINTING OF THIS LINE */                 ERROR
  293        IF \ CONTROL(BYTE('L')) THEN                                                ERROR
  294     OUTPUT = I_FORMAT (CARD_COUNT, 4) ^^ ' ^' ^^ BUFFER ^^ '^';                    ERROR
  295        OUTPUT = SUBSTR(POINTER, TEXT_LIMIT-CP+MARGIN_CHOP);                        ERROR
  296        OUTPUT(-1), OUTPUT = '*** ERROR, ' ^^ MSG ^^                                ERROR
  297        '.  LAST PREVIOUS ERROR WAS DETECTED ON LINE ' ^^                           ERROR
  298        PREVIOUS_ERROR ^^ '.  ***';                                                 ERROR
  299        PREVIOUS_ERROR = CARD_COUNT;                                                ERROR
  300        IF SEVERITY > 0 THEN                                                        ERROR
  301     IF SEVERE_ERRORS > 25 THEN                                                     ERROR
  302        DO;                                                                         ERROR
  303           OUTPUT = '*** TOO MANY SEVERE ERRORS, CHECKING ABORTED ***';             ERROR
  304           COMPILING = FALSE;                                                       ERROR
  305        END;                                                                        ERROR
  306     ELSE SEVERE_ERRORS = SEVERE_ERRORS + 1;                                        ERROR
  307     END ERROR;                                                                     ERROR

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MSG             CHARACTER   161   STRING    287       1
SEVERITY        FIXED      1267     DATA    287       1
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 9
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  308                                                                                   *
  309                                                                                   *
  310                                                                                   *
  311                                                                                   *
  312                                                                                   *
  313    /*                     CARD IMAGE HANDLING PROCEDURE                      */   *
  314                                                                                   *
  315                                                                                   *
  316  GET_CARD:                                                                        *
  317     PROCEDURE;                                                                    *
  318        /* DOES ALL CARD READING AND LISTING                                   */   GET_CARD
  319        DECLARE I FIXED, (TEMP, TEMP0, REST) CHARACTER, READING BIT(1);             GET_CARD
  320        BUFFER = INPUT;                                                             GET_CARD
  321        IF LENGTH(BUFFER) = 0 THEN                                                  GET_CARD
  322           DO; /* SIGNAL FOR EOF */                                                 GET_CARD
  323              CALL ERROR ('EOF MISSING OR COMMENT STARTING IN COLUMN 1.',1);        GET_CARD
  324              BUFFER = PAD (' /*''/* */ EOF;END;EOF', 80);                          GET_CARD
  325           END;                                                                     GET_CARD
  326        ELSE CARD_COUNT = CARD_COUNT + 1;  /* USED TO PRINT ON LISTING */           GET_CARD
  327         BUFFER = PAD(BUFFER,80);                                                   GET_CARD
  328        IF MARGIN_CHOP > 0 THEN                                                     GET_CARD
  329     DO; /* THE MARGIN CONTROL FROM DOLLAR ^ */                                     GET_CARD
  330        I = LENGTH(BUFFER) - MARGIN_CHOP;                                           GET_CARD
  331        REST = SUBSTR(BUFFER, I);                                                   GET_CARD
  332        BUFFER = SUBSTR(BUFFER, 0, I);                                              GET_CARD
  333     END;                                                                           GET_CARD
  334        ELSE REST = '';                                                             GET_CARD
  335        TEXT = BUFFER;                                                              GET_CARD
  336        TEXT_LIMIT = LENGTH(TEXT) - 1;                                              GET_CARD
  337        IF CONTROL(BYTE('M')) THEN OUTPUT = BUFFER;                                 GET_CARD
  338        ELSE IF CONTROL(BYTE('L')) THEN                                             GET_CARD
  339     OUTPUT = I_FORMAT (CARD_COUNT, 4) ^^ ' ^' ^^ BUFFER ^^ '^' ^^ REST;            GET_CARD
  340        CP = 0;                                                                     GET_CARD
  341     END GET_CARD;                                                                  GET_CARD

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      1296     DATA    319       3
READING         BIT (9)    1297     DATA    319       0 *
REST            CHARACTER   170   STRING    319       3
TEMP            CHARACTER   168   STRING    319       0 *
TEMP0           CHARACTER   169   STRING    319       0 *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 10
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  342                                                                                   *
  343                                                                                   *
  344     /*                  THE SCANNER PROCEDURES              */                    *
  345                                                                                   *
  346                                                                                   *
  347  CHAR:                                                                            *
  348     PROCEDURE;                                                                    *
  349        /* USED FOR STRINGS TO AVOID CARD BOUNDARY PROBLEMS */                      CHAR
  350        CP = CP + 1;                                                                CHAR
  351        IF CP <= TEXT_LIMIT THEN RETURN;                                            CHAR
  352        CALL GET_CARD;                                                              CHAR
  353     END CHAR;                                                                      CHAR
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 11
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  354                                                                                   *
  355                                                                                   *
  356  SCAN:                                                                            *
  357     PROCEDURE;                                                                    *
  358        DECLARE (S1, S2) FIXED;                                                     SCAN
  359        CALLCOUNT(3) = CALLCOUNT(3) + 1;                                            SCAN
  360        FAILSOFT = TRUE;                                                            SCAN
  361        BCD = '';  NUMBER_VALUE = 0;                                                SCAN
  362     SCAN1:                                                                         SCAN
  363        DO FOREVER;                                                                 SCAN
  364     IF CP > TEXT_LIMIT THEN CALL GET_CARD;                                         SCAN
  365     ELSE                                                                           SCAN
  366        DO; /* DISCARD LAST SCANNED VALUE */                                        SCAN
  367           TEXT_LIMIT = TEXT_LIMIT - CP;                                            SCAN
  368           TEXT = SUBSTR(TEXT, CP);                                                 SCAN
  369           CP = 0;                                                                  SCAN
  370        END;                                                                        SCAN
  371     /*  BRANCH ON NEXT CHARACTER IN TEXT                  */                       SCAN
  372     DO CASE CHARTYPE(BYTE(TEXT));                                                  SCAN
  373                                                                                    SCAN CASE 0.
  374        /*  CASE 0  */                                                              SCAN
  375                                                                                    SCAN
  376        /* ILLEGAL CHARACTERS FALL HERE  */                                         SCAN
  377        CALL ERROR ('ILLEGAL CHARACTER: ' ^^ SUBSTR(TEXT, 0, 1)                     SCAN
  378             ^^ '(' ^^ BYTE(TEXT) ^^ ')');                                          SCAN C5 = 134217728
** WARNING--NOT ALL PARAMETERS SUPPLIED.
  379                                                                                    SCAN CASE 1.
  380        /*  CASE 1  */                                                              SCAN
  381                                                                                    SCAN
  382        /*  BLANK  */                                                               SCAN
  383        DO;                                                                         SCAN
  384           CP = 1;                                                                  SCAN
  385           DO WHILE CHARTYPE(BYTE(TEXT,CP)) = 1 & CP <= TEXT_LIMIT;                 SCAN
  386              CP = CP + 1;                                                          SCAN
  387           END;                                                                     SCAN
  388           CP = CP - 1;                                                             SCAN
  389        END;                                                                        SCAN
  390                                                                                    SCAN CASE 2.
  391        /*  CASE 2  */                                                              SCAN
  392                                                                                    SCAN
  393    ;   /*  NOT USED IN SKELETON (BUT USED IN XCOM)  */                             SCAN
  394                                                                                    SCAN CASE 3.
  395        /*  CASE 3  */                                                              SCAN
  396                                                                                    SCAN
  397    ;   /*  NOT USED IN SKELETON (BUT USED IN XCOM)  */                             SCAN
  398                                                                                    SCAN CASE 4.
  399        /*  CASE 4  */                                                              SCAN
  400                                                                                    SCAN
  401        DO FOREVER;  /* A LETTER:  IDENTIFIERS AND RESERVED WORDS */                SCAN
  402           DO CP = CP + 1 TO TEXT_LIMIT;                                            SCAN
  403              IF NOT_LETTER_OR_DIGIT(BYTE(TEXT, CP)) THEN                           SCAN
  404                 DO;  /* END OF IDENTIFIER  */                                      SCAN
  405                    IF CP > 0 THEN BCD = BCD ^^ SUBSTR(TEXT, 0, CP);                SCAN
  406                    S1 = LENGTH(BCD);                                               SCAN
  407                    IF S1 > 1 THEN IF S1 <= RESERVED_LIMIT THEN                     SCAN
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 12
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  408                       /* CHECK FOR RESERVED WORDS */                               SCAN
  409                       DO I = V_INDEX(S1-1) TO V_INDEX(S1) - 1;                     SCAN
  410                          IF BCD = V(I) THEN                                        SCAN
  411                             DO;                                                    SCAN
  412                                TOKEN = I;                                          SCAN
  413                                RETURN;                                             SCAN
  414                             END;                                                   SCAN
  415                       END;                                                         SCAN
  416                    /*  RESERVED WORDS EXIT HIGHER: THEREFORE <IDENTIFIER>*/        SCAN
  417                    TOKEN = IDENT;                                                  SCAN
  418                    RETURN;                                                         SCAN
  419                 END;                                                               SCAN
  420           END;                                                                     SCAN
  421           /*  END OF CARD  */                                                      SCAN
  422           BCD = BCD ^^ TEXT;                                                       SCAN
  423           CALL GET_CARD;                                                           SCAN
  424           CP = -1;                                                                 SCAN
  425        END;                                                                        SCAN
  426                                                                                    SCAN CASE 5.
  427        /*  CASE 5  */                                                              SCAN
  428                                                                                    SCAN
  429        DO;      /*  DIGIT:  A NUMBER  */                                           SCAN
  430           TOKEN = NUMBER;                                                          SCAN
  431           DO FOREVER;                                                              SCAN
  432              DO CP = CP TO TEXT_LIMIT;                                             SCAN
  433                 S1 = BYTE(TEXT, CP);                                               SCAN
  434                 IF (S1 < 48) ^ (S1 > 57) THEN RETURN;                              SCAN
  435                 NUMBER_VALUE = 10*NUMBER_VALUE + S1 - 48;                          SCAN
  436              END;                                                                  SCAN
  437              CALL GET_CARD;                                                        SCAN
  438           END;                                                                     SCAN
  439        END;                                                                        SCAN
  440                                                                                    SCAN CASE 6.
  441        /*  CASE 6  */                                                              SCAN
  442                                                                                    SCAN
  443        DO;      /*  A /:  MAY BE DIVIDE OR START OF COMMENT  */                    SCAN
  444           CALL CHAR;                                                               SCAN
  445           IF BYTE(TEXT, CP) \= BYTE('*') THEN                                      SCAN
  446              DO;                                                                   SCAN
  447                 TOKEN = DIVIDE;                                                    SCAN
  448                 RETURN;                                                            SCAN
  449              END;                                                                  SCAN
  450           /* WE HAVE A COMMENT  */                                                 SCAN
  451           S1, S2 = BYTE(' ');                                                      SCAN
  452           DO WHILE S1 \= BYTE('*') ^ S2 \= BYTE('/');                              SCAN
  453              IF S1 = BYTE('$') THEN                                                SCAN
  454                 DO;  /* A CONTROL CHARACTER  */                                    SCAN
  455                    CONTROL(S2) = \ CONTROL(S2);                                    SCAN
  456                    IF S2 = BYTE('^') THEN                                          SCAN
  457                       IF CONTROL(S2) THEN                                          SCAN
  458                          MARGIN_CHOP = TEXT_LIMIT - CP + 1;                        SCAN
  459                       ELSE                                                         SCAN
  460                          MARGIN_CHOP = 0;                                          SCAN
  461                 END;                                                               SCAN
  462              S1 = S2;                                                              SCAN
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 13
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  463              CALL CHAR;                                                            SCAN
  464              S2 = BYTE(TEXT, CP);                                                  SCAN
  465           END;                                                                     SCAN
  466        END;                                                                        SCAN
  467                                                                                    SCAN CASE 7.
  468        /*  CASE 7  */                                                              SCAN
  469        DO;      /*  SPECIAL CHARACTERS  */                                         SCAN
  470           TOKEN = TX(BYTE(TEXT));                                                  SCAN
  471           CP = 1;                                                                  SCAN
  472           RETURN;                                                                  SCAN
  473        END;                                                                        SCAN
  474                                                                                    SCAN CASE 8.
  475        /*  CASE 8  */                                                              SCAN
  476    ;   /*  NOT USED IN SKELETON (BUT USED IN XCOM)  */                             SCAN
  477                                                                                    SCAN CASE 9.
  478     END;     /* OF CASE ON CHARTYPE  */                                            SCAN
  479     CP = CP + 1;  /* ADVANCE SCANNER AND RESUME SEARCH FOR TOKEN  */               SCAN
  480        END;                                                                        SCAN
  481     END SCAN;                                                                      SCAN

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
S1              FIXED      1315     DATA    358      13
S2              FIXED      1316     DATA    358       8
SCAN1           LABEL       615  PROGRAM    362       0 *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 14
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  482                                                                                   *
  483                                                                                   *
  484                                                                                   *
  485                                                                                   *
  486    /*                         TIME AND DATE                                 */    *
  487                                                                                   *
  488                                                                                   *
  489  PRINT_TIME:                                                                      *
  490     PROCEDURE (MESSAGE, T);                                                       *
  491        DECLARE MESSAGE CHARACTER, T FIXED;                                         PRINT_TIME
  492        MESSAGE = MESSAGE ^^ T/360000 ^^ ':' ^^ T MOD 360000 / 6000 ^^ ':'          PRINT_TIME
  493     ^^ T MOD 6000 / 100 ^^ '.';                                                    PRINT_TIME C6 = 360000
  494        T = T MOD 100;  /* DECIMAL FRACTION  */                                     PRINT_TIME
  495        IF T < 10 THEN MESSAGE = MESSAGE ^^ '0';                                    PRINT_TIME
  496        OUTPUT = MESSAGE ^^ T ^^ '.';                                               PRINT_TIME
  497     END PRINT_TIME;                                                                PRINT_TIME

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
MESSAGE         CHARACTER   178   STRING    490       5
T               FIXED      1327     DATA    490       7
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 15
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  498                                                                                   *
  499  PRINT_DATE_AND_TIME:                                                             *
  500     PROCEDURE (MESSAGE, D, T);                                                    *
  501        DECLARE MESSAGE CHARACTER, (D, T, YEAR, DAY, M) FIXED;                      PRINT_DATE_AND_TIME
  502        DECLARE MONTH(11) CHARACTER INITIAL ('JANUARY', 'FEBRUARY', 'MARCH',        PRINT_DATE_AND_TIME
  503     'APRIL', 'MAY', 'JUNE', 'JULY', 'AUGUST', 'SEPTEMBER', 'OCTOBER',              PRINT_DATE_AND_TIME
  504     'NOVEMBER', 'DECEMBER'),                                                       PRINT_DATE_AND_TIME
  505        DAYS(12) FIXED INITIAL (0, 31, 60, 91, 121, 152, 182, 213, 244, 274,        PRINT_DATE_AND_TIME
  506     305, 335, 366);                                                                PRINT_DATE_AND_TIME
  507        YEAR = D/1000 + 1900;                                                       PRINT_DATE_AND_TIME
  508        DAY = D MOD 1000;                                                           PRINT_DATE_AND_TIME
  509        IF (YEAR & "3") \= 0 THEN IF DAY > 59 THEN DAY = DAY + 1; /* NOT LEAP YEAR*/ PRINT_DATE_AND_TIME
  510        M = 1;                                                                      PRINT_DATE_AND_TIME
  511        DO WHILE DAY > DAYS(M);  M = M + 1;  END;                                   PRINT_DATE_AND_TIME
  512        CALL PRINT_TIME(MESSAGE ^^ MONTH(M-1) ^^ X1 ^^ DAY-DAYS(M-1) ^^  ', '       PRINT_DATE_AND_TIME
  513     ^^ YEAR ^^ '.  CLOCK TIME = ', T);                                             PRINT_DATE_AND_TIME
  514     END PRINT_DATE_AND_TIME;                                                       PRINT_DATE_AND_TIME

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
D               FIXED      1331     DATA    500       2
DAY             FIXED      1334     DATA    501       6
DAYS            FIXED      1355     DATA    505       2
M               FIXED      1335     DATA    501       6
MESSAGE         CHARACTER   184   STRING    500       1
MONTH           CHARACTER   185   STRING    502       1
T               FIXED      1332     DATA    500       1
YEAR            FIXED      1333     DATA    501       3
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 16
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  515                                                                                   *
  516    /*                         INITIALIZATION                                     */*
  517                                                                                   *
  518                                                                                   *
  519                                                                                   *
  520  INITIALIZATION:                                                                  *
  521     PROCEDURE;                                                                    *
  522     DECLARE FILEN CHARACTER, EXT FIXED;                                            INITIALIZATION
  523    OUTPUT(-2) = 'FILENAME: ';                                                      INITIALIZATION
  524    FILEN = INPUT(-1);                                                              INITIALIZATION
  525    IF FILEN = ' ' THEN FILEN = '';                                                 INITIALIZATION
  526    IF LENGTH(FILEN) = 0 THEN DO;                                                   INITIALIZATION
  527            FILENAME(0) = 'TTY:SKELTN.SKL';                                         INITIALIZATION
  528            FILENAME(1) = 'DSK:SKELTN.LST';                                         INITIALIZATION
  529            OUTPUT(-1) = 'INPUT PROGRAM FROM TTY:';                                 INITIALIZATION
  530            END;                                                                    INITIALIZATION
  531                                                                                    INITIALIZATION
  532    ELSE    DO;                                                                     INITIALIZATION
  533            EXT = 0;                                                                INITIALIZATION
  534            DO I = 0 TO LENGTH(FILEN)-1;                                            INITIALIZATION
  535                    IF BYTE(FILEN,I) = BYTE('.') THEN EXT = I;                      INITIALIZATION
  536                    END;                                                            INITIALIZATION
  537            IF EXT = 0 THEN DO;                                                     INITIALIZATION
  538                    FILENAME(0) = FILEN ^^ '.SKL';                                  INITIALIZATION
  539                    FILENAME(1) = FILEN ^^ '.LST';                                  INITIALIZATION
  540                    END;                                                            INITIALIZATION
  541            ELSE    DO;                                                             INITIALIZATION
  542                    FILENAME(0) = FILEN;                                            INITIALIZATION
  543                    FILENAME(1) = SUBSTR(FILEN,0,EXT+1)^^'.LST'^^                   INITIALIZATION
  544                                  SUBSTR(FILEN,EXT+4);                              INITIALIZATION
  545                    END;                                                            INITIALIZATION
  546            END;                                                                    INITIALIZATION
  547        EJECT_PAGE;                                                                 INITIALIZATION
  548     CALL PRINT_DATE_AND_TIME ('   SYNTAX CHECK -- UNIVERSITY OF LOUISVILLE -- III VERSION ', DATE, TIME); INITIALIZATION
  549        DOUBLE_SPACE;                                                               INITIALIZATION
  550        CALL PRINT_DATE_AND_TIME ('TODAY IS ', DATE, TIME);                         INITIALIZATION
  551        DOUBLE_SPACE;                                                               INITIALIZATION
  552        DO I = 1 TO NT;                                                             INITIALIZATION
  553     S = V(I);                                                                      INITIALIZATION C7 = 18
  554     IF S = '<NUMBER>' THEN NUMBER = I;  ELSE                                       INITIALIZATION
  555     IF S = '<IDENTIFIER>' THEN IDENT = I;  ELSE                                    INITIALIZATION
  556     IF S = '/' THEN DIVIDE = I;  ELSE                                              INITIALIZATION
  557     IF S = '_^_' THEN EOFILE = I;  ELSE                                            INITIALIZATION
  558     IF S = ';' THEN STOPIT(I) = TRUE;  ELSE                                        INITIALIZATION
  559     ;                                                                              INITIALIZATION
  560        END;                                                                        INITIALIZATION
  561        IF IDENT = NT THEN RESERVED_LIMIT = LENGTH(V(NT-1));                        INITIALIZATION
  562        ELSE RESERVED_LIMIT = LENGTH(V(NT));                                        INITIALIZATION
  563        V(EOFILE) = 'EOF';                                                          INITIALIZATION
  564        STOPIT(EOFILE) = TRUE;                                                      INITIALIZATION
  565        CHARTYPE(BYTE(' ')) = 1;                                                    INITIALIZATION
  566        CHARTYPE(9) = 1;     /* ASCII TAB CHARACTER */                              INITIALIZATION
  567        CHARTYPE(0) = 1;            /* DO SAME FOR NULL, WHICH POPS UP */           INITIALIZATION
  568        DO I = 0 TO 255;                                                            INITIALIZATION
  569     NOT_LETTER_OR_DIGIT(I) = TRUE;                                                 INITIALIZATION C8 = 255
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 17
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  570        END;                                                                        INITIALIZATION
  571        DO I = 0 TO LENGTH(ALPHABET) - 1;                                           INITIALIZATION
  572     J = BYTE(ALPHABET, I);                                                         INITIALIZATION
  573     TX(J) = I;                                                                     INITIALIZATION
  574     NOT_LETTER_OR_DIGIT(J) = FALSE;                                                INITIALIZATION
  575     CHARTYPE(J) = 4;                                                               INITIALIZATION
  576        END;                                                                        INITIALIZATION
  577        DO I = 0 TO 9;                                                              INITIALIZATION
  578     J = BYTE('0123456789', I);                                                     INITIALIZATION C9 = 9
  579     NOT_LETTER_OR_DIGIT(J) = FALSE;                                                INITIALIZATION
  580     CHARTYPE(J) = 5;                                                               INITIALIZATION
  581        END;                                                                        INITIALIZATION
  582        DO I = V_INDEX(0) TO V_INDEX(1) - 1;                                        INITIALIZATION
  583     J = BYTE(V(I));                                                                INITIALIZATION
  584     TX(J) = I;                                                                     INITIALIZATION
  585     CHARTYPE(J) = 7;                                                               INITIALIZATION
  586        END;                                                                        INITIALIZATION
  587        CHARTYPE(BYTE('/')) = 6;                                                    INITIALIZATION
  588        /* FIRST SET UP GLOBAL VARIABLES CONTROLLING SCAN, THEN CALL IT */          INITIALIZATION
  589        CP = 0;  TEXT_LIMIT = -1;                                                   INITIALIZATION
  590        TEXT = '';                                                                  INITIALIZATION
  591        CONTROL(BYTE('L')) = TRUE;                                                  INITIALIZATION
  592        CALL SCAN;                                                                  INITIALIZATION
  593                                                                                    INITIALIZATION
  594        /* INITIALIZE THE PARSE STACK */                                            INITIALIZATION
  595        SP = 1;      PARSE_STACK(SP) = EOFILE;                                      INITIALIZATION
  596                                                                                    INITIALIZATION
  597     END INITIALIZATION;                                                            INITIALIZATION

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
EXT             FIXED      1373     DATA    522       5
FILEN           CHARACTER   199   STRING    522      11
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 18
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  598                                                                                   *
  599                                                                                   *
  600                                                                                   *
  601                                                                                   *
  602                                                                                   *
  603                                                                                   *
  604  DUMPIT:                                                                          *
  605     PROCEDURE;      /* DUMP OUT THE STATISTICS COLLECTED DURING THIS RUN  */      *
  606        DOUBLE_SPACE;                                                               DUMPIT
  607        /*  PUT OUT THE ENTRY COUNT FOR IMPORTANT PROCEDURES */                     DUMPIT
  608                                                                                    DUMPIT
  609        OUTPUT = 'STACKING DECISIONS= ' ^^ CALLCOUNT(1);                            DUMPIT
  610        OUTPUT = 'SCAN                = ' ^^ CALLCOUNT(3);                          DUMPIT
  611        OUTPUT = 'FREE STRING AREA  = ' ^^ FREELIMIT - FREEBASE;                    DUMPIT
  612     END DUMPIT;                                                                    DUMPIT
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 19
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  613                                                                                   *
  614                                                                                   *
  615  STACK_DUMP:                                                                      *
  616     PROCEDURE;                                                                    *
  617        DECLARE LINE CHARACTER;                                                     STACK_DUMP
  618        LINE = 'PARTIAL PARSE TO THIS POINT IS: ';                                  STACK_DUMP
  619        DO I = 2 TO SP;                                                             STACK_DUMP
  620     IF LENGTH(LINE) > 105 THEN                                                     STACK_DUMP
  621        DO;                                                                         STACK_DUMP
  622           OUTPUT = LINE;                                                           STACK_DUMP
  623           LINE = X4;                                                               STACK_DUMP
  624        END;                                                                        STACK_DUMP
  625     LINE = LINE ^^ X1 ^^ V(PARSE_STACK(I));                                        STACK_DUMP
  626        END;                                                                        STACK_DUMP
  627        OUTPUT = LINE;                                                              STACK_DUMP
  628     END STACK_DUMP;                                                                STACK_DUMP

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
LINE            CHARACTER   220   STRING    617       7
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 20
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  629                                                                                   *
  630                                                                                   *
  631    /*                    THE SYNTHESIS ALGORITHM FOR XPL                      */  *
  632                                                                                   *
  633                                                                                   *
  634  SYNTHESIZE:                                                                      *
  635  PROCEDURE(PRODUCTION_NUMBER);                                                    *
  636     DECLARE PRODUCTION_NUMBER FIXED;                                               SYNTHESIZE
  637                                                                                    SYNTHESIZE
  638     /*  THIS PROCEDURE IS RESPONSIBLE FOR THE SEMANTICS (CODE SYNTHESIS), IF       SYNTHESIZE
  639        ANY, OF THE SKELETON COMPILER.  ITS ARGUMENT IS THE NUMBER OF THE           SYNTHESIZE
  640        PRODUCTION WHICH WILL BE APPLIED IN THE PENDING REDUCTION.  THE GLOBAL      SYNTHESIZE
  641        VARIABLES MP AND SP POINT TO THE BOUNDS IN THE STACKS OF THE RIGHT PART     SYNTHESIZE
  642        OF THIS PRODUCTION.                                                         SYNTHESIZE
  643         NORMALLY, THIS PROCEDURE WILL TAKE THE FORM OF A GIANT CASE STATEMENT      SYNTHESIZE
  644        ON PRODUCTION_NUMBER.  HOWEVER, THE SYNTAX CHECKER HAS SEMANTICS (THE       SYNTHESIZE
  645        TERMINATION OF CHECKING) ONLY FOR PRODUCTION 1.                       */    SYNTHESIZE
  646                                                                                    SYNTHESIZE
  647     IF PRODUCTION_NUMBER = 1 THEN                                                  SYNTHESIZE
  648                                                                                    SYNTHESIZE
  649   /*  <PROGRAM>    ::=  <STATEMENT LIST>    */                                     SYNTHESIZE
  650     DO;                                                                            SYNTHESIZE
  651        IF MP \= 2 THEN  /* WE DIDN'T GET HERE LEGITIMATELY  */                     SYNTHESIZE
  652     DO;                                                                            SYNTHESIZE
  653        CALL ERROR ('EOF AT INVALID POINT', 1);                                     SYNTHESIZE
  654        CALL STACK_DUMP;                                                            SYNTHESIZE
  655     END;                                                                           SYNTHESIZE
  656        COMPILING = FALSE;                                                          SYNTHESIZE
  657     END;                                                                           SYNTHESIZE
  658    ELSE DO;                                                                        SYNTHESIZE
  659    OUTPUT(-1)='SYNTHESIZE--PRODUCTION#: '^^PRODUCTION_NUMBER;                      SYNTHESIZE
  660    OUTPUT(-1)='SYNTHESIZE--TOKEN IS: '^^V(TOKEN);                                  SYNTHESIZE
  661    OUTPUT(-1) = 'SYNTHESIZE--SP: '^^SP^^' MP: '^^MP^^' PARSE_STACK IS:';           SYNTHESIZE
  662    DO I = 1 TO SP;                                                                 SYNTHESIZE
  663      OUTPUT(-1) = 'SYNTHESIZE--'^^I^^' '^^V(PARSE_STACK(I));                       SYNTHESIZE
  664            END;                                                                    SYNTHESIZE
  665    OUTPUT(-1)=' ';                                                                 SYNTHESIZE
  666    END;                                                                            SYNTHESIZE
  667  END SYNTHESIZE;                                                                   SYNTHESIZE

SYMBOL TABLE DUMP

SYMBOL            TYPE       LOC   SEGMENT DEFINED REF COUNT
PRODUCTION_NUMBER FIXED      1448     DATA    635       2
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 21
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  668                                                                                   *
  669                                                                                   *
  670                                                                                   *
  671                                                                                   *
  672    /*                SYNTACTIC PARSING FUNCTIONS                              */  *
  673                                                                                   *
  674                                                                                   *
  675  RIGHT_CONFLICT:                                                                  *
  676     PROCEDURE (LEFT) BIT(1);                                                      *
  677        DECLARE LEFT FIXED;                                                         RIGHT_CONFLICT
  678    DECLARE (BIT#,BYTE#,CHECK,CASE#) FIXED;                                         RIGHT_CONFLICT
  679        /*  THIS PROCEDURE IS TRUE IF TOKEN IS NOT A LEGAL RIGHT CONTEXT OF LEFT*/  RIGHT_CONFLICT
  680   /*    RETURN ("C0" & SHL(BYTE(C1(LEFT), SHR(TOKEN,2)), SHL(TOKEN,1)              RIGHT_CONFLICT
  681     & "06")) = 0;  */                                                              RIGHT_CONFLICT
  682    BIT# = SHL(TOKEN,1);                                                            RIGHT_CONFLICT
  683    BYTE# = BIT# / 9;                                                               RIGHT_CONFLICT
  684    CHECK = BIT# MOD 9;                                                             RIGHT_CONFLICT
  685    IF CHECK \= 8 THEN  /* EXTRACT DECISION FROM A BYTE */                          RIGHT_CONFLICT
  686            CASE# = SHR(BYTE(C1(PARSE_STACK(SP)),BYTE#),7-CHECK)&"3";               RIGHT_CONFLICT
  687    ELSE  /* EXTRACT DECISION FROM 2 BYTES (CROSSES BOUNDARY) */                    RIGHT_CONFLICT
  688    CASE# = SHL(BYTE(C1(PARSE_STACK(SP)),BYTE#)&1,1) +                              RIGHT_CONFLICT
  689                 SHR(BYTE(C1(PARSE_STACK(SP)),BYTE#+1),8);                          RIGHT_CONFLICT
  690    RETURN CASE#=0;                                                                 RIGHT_CONFLICT
  691     END RIGHT_CONFLICT;                                                            RIGHT_CONFLICT

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
BIT#            FIXED      1481     DATA    678       3
BYTE#           FIXED      1482     DATA    678       4
CASE#           FIXED      1484     DATA    678       3
CHECK           FIXED      1483     DATA    678       3
LEFT            FIXED      1480     DATA    676       0 *
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 22
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  692                                                                                   *
  693                                                                                   *
  694  RECOVER:                                                                         *
  695     PROCEDURE;                                                                    *
  696        /* IF THIS IS THE SECOND SUCCESSIVE CALL TO RECOVER, DISCARD ONE SYMBOL */  RECOVER
  697        IF \ FAILSOFT THEN CALL SCAN;                                               RECOVER
  698        FAILSOFT = FALSE;                                                           RECOVER
  699        DO WHILE \ STOPIT(TOKEN);                                                   RECOVER
  700     CALL SCAN;  /* TO FIND SOMETHING SOLID IN THE TEXT  */                         RECOVER
  701        END;                                                                        RECOVER
  702        DO WHILE RIGHT_CONFLICT (PARSE_STACK(SP));                                  RECOVER
  703     IF SP > 2 THEN SP = SP - 1;  /* AND IN THE STACK  */                           RECOVER
  704     ELSE CALL SCAN;  /* BUT DON'T GO TOO FAR  */                                   RECOVER
  705        END;                                                                        RECOVER
  706        OUTPUT = 'RESUME:' ^^ SUBSTR(POINTER, TEXT_LIMIT-CP+MARGIN_CHOP+7);         RECOVER
  707     END RECOVER;                                                                   RECOVER
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 23
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  708                                                                                   *
  709  STACKING:                                                                        *
  710     PROCEDURE BIT(1);  /* STACKING DECISION FUNCTION */                           *
  711    DECLARE (BIT#,BYTE#,CHECK,CASE#) FIXED;                                         STACKING
  712        CALLCOUNT(1) = CALLCOUNT(1) + 1;                                            STACKING
  713        DO FOREVER;    /* UNTIL RETURN  */                                          STACKING
  714        /* NOTE: THE DEC-10 IMPLEMENTATION HAS 9-BIT BYTES */                       STACKING
  715        BIT# = SHL(TOKEN,1);        /* (TOKEN * 2) */                               STACKING
  716        BYTE# = BIT#/9;                                                             STACKING
  717        CHECK = BIT# MOD 9;                                                         STACKING
  718        IF CHECK \= 8 THEN  /* EXTRACT DECISION FROM A BYTE */                      STACKING
  719           CASE# = SHR(BYTE(C1(PARSE_STACK(SP)),BYTE#),7-CHECK)&"3";                STACKING
  720        ELSE  /* EXTRACT DECISION FROM 2 BYTES (CROSSES BOUNDARY) */                STACKING
  721           CASE# = SHL(BYTE(C1(PARSE_STACK(SP)),BYTE#)&1,1) +                       STACKING
  722                 SHR(BYTE(C1(PARSE_STACK(SP)),BYTE#+1),8);                          STACKING
  723        DO CASE CASE#;                                                              STACKING
  724                                                                                    STACKING CASE 0.
  725        /*  CASE 0  */                                                              STACKING
  726        DO;    /* ILLEGAL SYMBOL PAIR  */                                           STACKING
  727           CALL ERROR('ILLEGAL SYMBOL PAIR: ' ^^ V(PARSE_STACK(SP)) ^^ X1 ^^        STACKING
  728              V(TOKEN), 1);                                                         STACKING
  729           CALL STACK_DUMP;                                                         STACKING
  730           CALL RECOVER;                                                            STACKING
  731        END;                                                                        STACKING
  732                                                                                    STACKING CASE 1.
  733    /* CASE 1 */                                                                    STACKING
  734    DO;                                                                             STACKING
  735        RETURN TRUE;      /*  STACK TOKEN  */                                       STACKING
  736        END;                                                                        STACKING
  737        /*  CASE 2  */                                                              STACKING CASE 2.
  738        DO;                                                                         STACKING
  739        RETURN FALSE;     /* DON'T STACK IT YET  */                                 STACKING
  740        END;                                                                        STACKING
  741        /*  CASE 3  */                                                              STACKING CASE 3.
  742                                                                                    STACKING
  743        DO;      /* MUST CHECK TRIPLES  */                                          STACKING
  744           J = SHL(PARSE_STACK(SP-1)&"FFFF",16)                                     STACKING
  745             + SHL(PARSE_STACK(SP)&"FFFFFF", 8) + TOKEN;                            STACKING
  746           I = -1;  K = NC1TRIPLES + 1;  /* BINARY SEARCH OF TRIPLES  */            STACKING C10 = 16777215
  747           DO WHILE I + 1 < K;                                                      STACKING
  748              L = SHR(I+K, 1);                                                      STACKING
  749              IF C1TRIPLES(L) > J THEN K = L;                                       STACKING
  750              ELSE IF C1TRIPLES(L) < J THEN I = L;                                  STACKING
  751              ELSE RETURN TRUE;  /* IT IS A VALID TRIPLE  */                        STACKING
  752           END;                                                                     STACKING
  753           RETURN FALSE;                                                            STACKING
  754        END;                                                                        STACKING
  755                                                                                    STACKING CASE 4.
  756     END;    /* OF DO CASE  */                                                      STACKING
  757        END;   /*  OF DO FOREVER */                                                 STACKING
  758     END STACKING;                                                                  STACKING

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 24
SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
 
BIT#            FIXED      1487     DATA    711       3
BYTE#           FIXED      1488     DATA    711       4
CASE#           FIXED      1490     DATA    711       3
CHECK           FIXED      1489     DATA    711       3
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 25
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  759                                                                                   *
  760  PR_OK:                                                                           *
  761     PROCEDURE(PRD) BIT(1);                                                        *
  762        /* DECISION PROCEDURE FOR CONTEXT CHECK OF EQUAL OR IMBEDDED RIGHT PARTS*/  PR_OK
  763        DECLARE (H, I, J, PRD) FIXED;                                               PR_OK
  764        DO CASE CONTEXT_CASE(PRD);                                                  PR_OK
  765                                                                                    PR_OK CASE 0.
  766     /*  CASE 0 -- NO CHECK REQUIRED  */                                            PR_OK
  767                                                                                    PR_OK
  768     RETURN TRUE;                                                                   PR_OK
  769                                                                                    PR_OK CASE 1.
  770     /*  CASE 1 -- RIGHT CONTEXT CHECK  */                                          PR_OK
  771                                                                                    PR_OK
  772     RETURN \ RIGHT_CONFLICT (HDTB(PRD));                                           PR_OK
  773                                                                                    PR_OK CASE 2.
  774     /*  CASE 2 -- LEFT CONTEXT CHECK  */                                           PR_OK
  775                                                                                    PR_OK
  776     DO;                                                                            PR_OK
  777        H = HDTB(PRD) - NT;                                                         PR_OK
  778        I = PARSE_STACK(SP - PRLENGTH(PRD));                                        PR_OK
  779        DO J = LEFT_INDEX(H-1) TO LEFT_INDEX(H) - 1;                                PR_OK
  780           IF LEFT_CONTEXT(J) = I THEN RETURN TRUE;                                 PR_OK
  781        END;                                                                        PR_OK
  782        RETURN FALSE;                                                               PR_OK
  783     END;                                                                           PR_OK
  784                                                                                    PR_OK CASE 3.
  785     /*  CASE 3 -- CHECK TRIPLES  */                                                PR_OK
  786                                                                                    PR_OK
  787     DO;                                                                            PR_OK
  788        H = HDTB(PRD) - NT;                                                         PR_OK
  789        I = SHL(PARSE_STACK(SP - PRLENGTH(PRD)), 8) + TOKEN;                        PR_OK
  790        DO J = TRIPLE_INDEX(H-1) TO TRIPLE_INDEX(H) - 1;                            PR_OK
  791           IF CONTEXT_TRIPLE(J) = I THEN RETURN TRUE;                               PR_OK
  792        END;                                                                        PR_OK
  793        RETURN FALSE;                                                               PR_OK
  794     END;                                                                           PR_OK
  795                                                                                    PR_OK CASE 4.
  796        END;  /* OF DO CASE  */                                                     PR_OK
  797     END PR_OK;                                                                     PR_OK

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
H               FIXED      1498     DATA    763       6
I               FIXED      1499     DATA    763       4
J               FIXED      1500     DATA    763       4
PRD             FIXED      1501     DATA    761       6
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 26
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  798                                                                                   *
  799                                                                                   *
  800    /*                       ANALYSIS ALGORITHM                                  */*
  801                                                                                   *
  802                                                                                   *
  803                                                                                   *
  804  REDUCE:                                                                          *
  805     PROCEDURE;                                                                    *
  806        DECLARE (I, J, PRD) FIXED;                                                  REDUCE
  807        /* PACK STACK TOP INTO ONE WORD */                                          REDUCE
  808        DO I = SP - 4 TO SP - 1;                                                    REDUCE
  809     J = SHL(J, 8) + PARSE_STACK(I);                                                REDUCE
  810        END;                                                                        REDUCE
  811                                                                                    REDUCE
  812        DO PRD = PR_INDEX(PARSE_STACK(SP)-1) TO PR_INDEX(PARSE_STACK(SP)) - 1;      REDUCE
  813     IF (PRMASK(PRLENGTH(PRD)) & J) = PRTB(PRD) THEN                                REDUCE
  814        IF PR_OK(PRD) THEN                                                          REDUCE
  815        DO;  /* AN ALLOWED REDUCTION */                                             REDUCE
  816           MP = SP - PRLENGTH(PRD) + 1; MPP1 = MP + 1;                              REDUCE
  817           CALL SYNTHESIZE(PRDTB(PRD));                                             REDUCE
  818           SP = MP;                                                                 REDUCE
  819           PARSE_STACK(SP) = HDTB(PRD);                                             REDUCE
  820           RETURN;                                                                  REDUCE
  821        END;                                                                        REDUCE
  822        END;                                                                        REDUCE
  823                                                                                    REDUCE
  824        /* LOOK UP HAS FAILED, ERROR CONDITION */                                   REDUCE
  825        CALL ERROR('NO PRODUCTION IS APPLICABLE',1);                                REDUCE
  826        CALL STACK_DUMP;                                                            REDUCE
  827        FAILSOFT = FALSE;                                                           REDUCE
  828        CALL RECOVER;                                                               REDUCE
  829     END REDUCE;                                                                    REDUCE

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      1504     DATA    806       2
J               FIXED      1505     DATA    806       3
PRD             FIXED      1506     DATA    806       7
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 27
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  830                                                                                   *
  831  COMPILATION_LOOP:                                                                *
  832     PROCEDURE;                                                                    *
  833                                                                                    COMPILATION_LOOP
  834        COMPILING = TRUE;                                                           COMPILATION_LOOP
  835        DO WHILE COMPILING;     /* ONCE AROUND FOR EACH PRODUCTION (REDUCTION)  */  COMPILATION_LOOP
  836     DO WHILE STACKING;                                                             COMPILATION_LOOP
  837        SP = SP + 1;                                                                COMPILATION_LOOP
  838        IF SP = STACKSIZE THEN                                                      COMPILATION_LOOP
  839           DO;                                                                      COMPILATION_LOOP
  840              CALL ERROR ('STACK OVERFLOW *** CHECKING ABORTED ***', 2);            COMPILATION_LOOP
  841              RETURN;   /* THUS ABORTING CHECKING */                                COMPILATION_LOOP
  842           END;                                                                     COMPILATION_LOOP
  843        PARSE_STACK(SP) = TOKEN;                                                    COMPILATION_LOOP
  844        VAR(SP) = BCD;                                                              COMPILATION_LOOP
  845        FIXV(SP) = NUMBER_VALUE;                                                    COMPILATION_LOOP
  846        CALL SCAN;                                                                  COMPILATION_LOOP
  847     END;                                                                           COMPILATION_LOOP
  848                                                                                    COMPILATION_LOOP
  849     CALL REDUCE;                                                                   COMPILATION_LOOP
  850        END;     /* OF DO WHILE COMPILING  */                                       COMPILATION_LOOP
  851     END COMPILATION_LOOP;                                                          COMPILATION_LOOP
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 28
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  852                                                                                   *
  853                                                                                   *
  854                                                                                   *
  855                                                                                   *
  856  PRINT_SUMMARY:                                                                   *
  857     PROCEDURE;                                                                    *
  858        DECLARE I FIXED;                                                            PRINT_SUMMARY
  859        CALL PRINT_DATE_AND_TIME ('END OF CHECKING ', DATE, TIME);                  PRINT_SUMMARY
  860        OUTPUT = '';                                                                PRINT_SUMMARY
  861        OUTPUT = CARD_COUNT ^^ ' CARDS WERE CHECKED.';                              PRINT_SUMMARY
  862        IF ERROR_COUNT = 0 THEN OUTPUT = 'NO ERRORS WERE DETECTED.';                PRINT_SUMMARY
  863        ELSE IF ERROR_COUNT > 1 THEN                                                PRINT_SUMMARY
  864     OUTPUT = ERROR_COUNT ^^ ' ERRORS (' ^^ SEVERE_ERRORS                           PRINT_SUMMARY
  865        ^^ ' SEVERE) WERE DETECTED.';                                               PRINT_SUMMARY
  866        ELSE IF SEVERE_ERRORS = 1 THEN OUTPUT = 'ONE SEVERE ERROR WAS DETECTED.';   PRINT_SUMMARY
  867     ELSE OUTPUT = 'ONE ERROR WAS DETECTED.';                                       PRINT_SUMMARY
  868        IF PREVIOUS_ERROR > 0 THEN                                                  PRINT_SUMMARY
  869     OUTPUT = 'THE LAST DETECTED ERROR WAS ON LINE ' ^^ PREVIOUS_ERROR              PRINT_SUMMARY
  870        ^^ PERIOD;                                                                  PRINT_SUMMARY
  871        IF CONTROL(BYTE('D')) THEN CALL DUMPIT;                                     PRINT_SUMMARY
  872        DOUBLE_SPACE;                                                               PRINT_SUMMARY
  873        CLOCK(3) = TIME;                                                            PRINT_SUMMARY
  874        DO I = 1 TO 3;   /* WATCH OUT FOR MIDNIGHT */                               PRINT_SUMMARY
  875     IF CLOCK(I) < CLOCK(I-1) THEN CLOCK(I) = CLOCK(I) +  8640000;                  PRINT_SUMMARY C11 = 3
  876        END;                                                                        PRINT_SUMMARY C12 = 8640000
  877        CALL PRINT_TIME ('TOTAL TIME IN CHECKER      ', CLOCK(3) - CLOCK(0));       PRINT_SUMMARY
  878        CALL PRINT_TIME ('SET UP TIME                ', CLOCK(1) - CLOCK(0));       PRINT_SUMMARY
  879        CALL PRINT_TIME ('ACTUAL CHECKING TIME       ', CLOCK(2) - CLOCK(1));       PRINT_SUMMARY
  880        CALL PRINT_TIME ('CLEAN-UP TIME AT END       ', CLOCK(3) - CLOCK(2));       PRINT_SUMMARY
  881        IF CLOCK(2) > CLOCK(1) THEN   /* WATCH OUT FOR CLOCK BEING OFF */           PRINT_SUMMARY
  882        OUTPUT = 'CHECKING RATE: ' ^^ 6000*CARD_COUNT/(CLOCK(2)-CLOCK(1))           PRINT_SUMMARY
  883     ^^ ' CARDS PER MINUTE.';                                                       PRINT_SUMMARY
  884     END PRINT_SUMMARY;                                                             PRINT_SUMMARY

SYMBOL TABLE DUMP

SYMBOL          TYPE       LOC   SEGMENT DEFINED REF COUNT
I               FIXED      1526     DATA    858       5
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 29
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  885                                                                                   *
  886  MAIN_PROCEDURE:                                                                  *
  887     PROCEDURE;                                                                    *
  888        CLOCK(0) = TIME;    /* KEEP TRACK OF TIME IN EXECUTION */                   MAIN_PROCEDURE
  889        CALL INITIALIZATION;                                                        MAIN_PROCEDURE
  890    OUTPUT(-1)='MAIN_PROCEDURE--INITIALIZATION FINISHED';                           MAIN_PROCEDURE
  891                                                                                    MAIN_PROCEDURE
  892        CLOCK(1) = TIME;                                                            MAIN_PROCEDURE
  893                                                                                    MAIN_PROCEDURE
  894        CALL COMPILATION_LOOP;                                                      MAIN_PROCEDURE
  895    OUTPUT(-1) = 'MAIN_PROCEDURE--COMPILATION_LOOP FINISHED';                       MAIN_PROCEDURE
  896                                                                                    MAIN_PROCEDURE
  897        CLOCK(2) = TIME;                                                            MAIN_PROCEDURE
  898                                                                                    MAIN_PROCEDURE
  899        /* CLOCK(3) GETS SET IN PRINT_SUMMARY */                                    MAIN_PROCEDURE
  900        CALL PRINT_SUMMARY;                                                         MAIN_PROCEDURE
  901                                                                                    MAIN_PROCEDURE
  902     END MAIN_PROCEDURE;                                                            MAIN_PROCEDURE
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 30
 LINE    SOURCE STATEMENT                                                               PROCEDURE AND COMPILER INFORMATION
 
  903                                                                                   *
  904                                                                                   *
  905  CALL MAIN_PROCEDURE;                                                             *
  906                                                                                   *
  907  EOF EOF EOF                                                                      *

SYMBOL TABLE DUMP

SYMBOL              TYPE       LOC   SEGMENT DEFINED REF COUNT
ALPHABET            CHARACTER    75   STRING    180       2
BCD                 CHARACTER    71   STRING    155       8
BUFFER              CHARACTER    76   STRING    190      13
C1                  CHARACTER    38   STRING     89       6
C1TRIPLES           FIXED       700     DATA    124       2
CALLCOUNT           FIXED      1132     DATA    225       6
CARD_COUNT          FIXED      1086     DATA    191       7
CHAR                PROCEDURE   594  PROGRAM    347       2
CHARTYPE            BIT (9)     821     DATA    175       9
CLOCK               FIXED      1153     DATA    229      20
COMPACTIFY          PROCEDURE   128  PROGRAM      0       1
COMPILATION_LOOP    PROCEDURE  2208  PROGRAM    831       1
COMPILING           BIT (9)    1122     DATA    211       4
CONTEXT_CASE        BIT (9)     771     DATA    136       1
CONTEXT_TRIPLE      FIXED       784     DATA    141       1
CONTROL             BIT (9)     949     DATA    176       8
COUNT_COMPACT       FIXED        33     DATA      0       2
CP                  FIXED       799     DATA    155      33
DIVIDE              FIXED      1093     DATA    200       2
DOUBLE              CHARACTER    73   STRING    159       4
DUMPIT              PROCEDURE  1469  PROGRAM    604       1
EOFILE              FIXED      1094     DATA    200       4
ERROR               PROCEDURE   403  PROGRAM    286       6
  PARAMETER  1      CHARACTER   161   STRING    287       7
  PARAMETER  2      FIXED      1267     DATA    287       6
ERROR_COUNT         FIXED      1087     DATA    191       5
FAILSOFT            BIT (9)    1121     DATA    211       4
FIXV                FIXED      1183     DATA    249       1
FREEBASE            FIXED        32     DATA      0       2
FREELIMIT           FIXED        11     DATA      0       2
GET_CARD            PROCEDURE   491  PROGRAM    316       4
HDTB                BIT (9)     755     DATA    132       4
I                   FIXED      1160     DATA    237      32
IDENT               FIXED      1091     DATA    200       3
INITIALIZATION      PROCEDURE  1073  PROGRAM    520       1
I_FORMAT            CHARACTER PROCEDURE   375  PROGRAM    276       2
  PARAMETER  1      FIXED      1264     DATA    277       3
  PARAMETER  2      FIXED      1265     DATA    277       4
J                   FIXED      1161     DATA    237      13
K                   FIXED      1162     DATA    237       4
L                   FIXED      1163     DATA    237       5
LEFT_CONTEXT        BIT (9)     779     DATA    138       1
LEFT_INDEX          BIT (9)     780     DATA    139       2
MAIN_PROCEDURE      PROCEDURE  2408  PROGRAM    886       1
MARGIN_CHOP         FIXED       820     DATA    165       6
MP                  FIXED      1260     DATA    255       5
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 31
SYMBOL              TYPE       LOC   SEGMENT DEFINED REF COUNT
 
MPP1                FIXED      1261     DATA    255       1
NOT_LETTER_OR_DIGIT BIT (9)    1013     DATA    176       4
NUMBER              FIXED      1092     DATA    200       2
NUMBER_VALUE        FIXED      1090     DATA    196       4
PAD                 CHARACTER PROCEDURE   351  PROGRAM    267       2
  PARAMETER  1      CHARACTER   159   STRING    268       5
  PARAMETER  2      FIXED      1262     DATA    268       4
PAGE                CHARACTER    72   STRING    159       1
PARSE_STACK         BIT (9)    1164     DATA    246      20
PERIOD              CHARACTER    82   STRING    234       1
POINTER             CHARACTER    79   STRING    223       2
PRDTB               BIT (9)     747     DATA    130       1
PREVIOUS_ERROR      FIXED      1089     DATA    191       4
PRINT_DATE_AND_TIME PROCEDURE  1005  PROGRAM    499       3
  PARAMETER  1      CHARACTER   184   STRING    500       4
  PARAMETER  2      FIXED      1331     DATA    500       5
  PARAMETER  3      FIXED      1332     DATA    500       4
PRINT_SUMMARY       PROCEDURE  2250  PROGRAM    856       1
PRINT_TIME          PROCEDURE   940  PROGRAM    489       5
  PARAMETER  1      CHARACTER   178   STRING    490      10
  PARAMETER  2      FIXED      1327     DATA    490      12
PRLENGTH            BIT (9)     763     DATA    134       4
PRMASK              FIXED      1123     DATA    217       1
PRTB                FIXED       718     DATA    127       1
PR_INDEX            BIT (9)     789     DATA    144       2
PR_OK               PROCEDURE  1952  PROGRAM    760       1
  PARAMETER  1      FIXED      1501     DATA    761       7
RECOVER             PROCEDURE  1731  PROGRAM    694       2
REDUCE              PROCEDURE  2091  PROGRAM    804       1
RESERVED_LIMIT      FIXED       819     DATA    165       3
RIGHT_CONFLICT      PROCEDURE  1661  PROGRAM    675       2
  PARAMETER  1      FIXED      1480     DATA    676       2
S                   CHARACTER    78   STRING    213       6
SCAN                PROCEDURE   604  PROGRAM    356       5
SEVERE_ERRORS       FIXED      1088     DATA    191       5
SP                  FIXED      1259     DATA    255      33
STACKING            PROCEDURE  1786  PROGRAM    709       1
STACK_DUMP          PROCEDURE  1501  PROGRAM    615       3
STOPIT              BIT (9)    1095     DATA    211       3
SYNTHESIZE          PROCEDURE  1541  PROGRAM    634       1
  PARAMETER  1      FIXED      1448     DATA    635       3
TEXT                CHARACTER    77   STRING    190      16
TEXT_LIMIT          FIXED      1085     DATA    191      12
TOKEN               FIXED       798     DATA    155      13
TRIPLE_INDEX        BIT (9)     785     DATA    142       2
TX                  BIT (9)     885     DATA    175       3
V                   CHARACTER     5   STRING     81      11
VAR                 CHARACTER    83   STRING    248       1
V_INDEX             FIXED       645     DATA     87       4
X1                  CHARACTER    80   STRING    233       3
X4                  CHARACTER    81   STRING    233       1
X70                 CHARACTER    74   STRING    161       2
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 32

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

907 LINES CONTAINING 350 STATEMENTS WERE COMPILED.
NO ERRORS WERE DETECTED.
2429 WORDS OF PROGRAM, 1625 WORDS OF DATA, AND 251 WORDS OF DESCRIPTORS.  TOTAL CORE REQUIREMENT 4305 WORDS.
TOTAL TIME IN COMPILER    = 0:7.463
INITIALIZATION TIME       = 0:0.199
ACTUAL COMPILATION TIME   = 0:6.610
POST-COMPILATION CLEAN-UP = 0:0.654

MACRO DEFINITIONS:
 
NAME          AT LINE REF COUNT LITERAL VALUE
NT                80        6    18
NSY               80        2    32
B32              259        0    &"FFFFFFFF"
TRUE             239       11    1
FALSE            239       10    0
DX_SIZE            0        2    500
FOREVER          239        4    WHILE 1
STACKSIZE        245        4    75
NC1TRIPLES       123        2    17
EJECT_PAGE       158        1    OUTPUT(1) = PAGE
DOUBLE_SPACE     160        4    OUTPUT(1) = DOUBLE
 
ID COMPARES       = 966
SYMBOL TABLE SIZE = 122
MACRO DEFINITIONS = 11
SCAN              = 4746
EMITINST          = 2627
FORCE ACCUMULATOR = 1067
ARITHEMIT         = 200
GENERATE STORE    = 238
FREE STRING AREA  = 14084
COMPACTIFICATIONS = 31
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 33
INSTRUCTION FREQUENCIES
 
.INIT.    1
.INPT.    2
.OUTP.    44
.EXIT.    3
.NAME.    6
CALLI     10
ILDB      3
LDB       67
IDPB      3
DPB       27
MOVE      561
MOVEI     38
MOVEM     383
MOVN      2
MOVM      1
IMULI     2
IDIV      3
IDIVI     11
ROT       4
LSH       129
LSHC      7
BLT       2
JRST      164
PUSHJ     146
PUSH      29
POP       29
POPJ      55
ADD       37
ADDI      93
ADDM      2
SUB       33
SUBI      33
CAIL      3
CAIE      15
CAIGE     1
CAIN      7
CAIG      13
CAML      5
CAME      3
CAMLE     25
CAMGE     4
CAMN      2
CAMG      6
JUMP      1
JUMPE     23
JUMPA     59
JUMPGE    1
JUMPN     2
SKIPE     8
AOSA      21
SOJG      3
SETZM     10
AND       25
ANDI      113
IOR       9
SKLTON.XPL  COMPILED 1-FEB-1981  AT 12:33:31 BY VERSION 4.0                              PAGE 34
INSTRUCTION FREQUENCIES
 
SETCA     5
HLL       5
HRLI      2
HRLM      1
HLRZ      1
HRREI     126