home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / SIMTEL / CPMUG / CPMUG030.ARK / BUILD.PLM < prev    next >
Text File  |  1984-04-29  |  16KB  |  427 lines
  1. BASBUILD:
  2. DO; /* ORIGINALLY ORG'ED AT 2D00H ABOVE INTERP */
  3.    /*
  4.          ********************************************************
  5.          *                                                      *
  6.          *               BASIC-E BUILD PROGRAM                  *
  7.          *                                                      *
  8.          *          U. S. NAVY POSTGRADUATE SCHOOL              *
  9.          *               MONTEREY, CALIFORNIA                   *
  10.          *                                                      *
  11.          *          WRITTEN BY GORDON EUBANKS, JR.              *
  12.          *                                                      *
  13.          *                 CPM VERSION 1.3                      *
  14.          *                                                      *
  15.          *                  DECEMBER 1976                       *
  16.          *                                                      *
  17.          ********************************************************
  18.     */
  19.     /*
  20.          ********************************************************
  21.          *                                                      *
  22.          *      THE BUILD PROGRAM GAINS CONTROL WHEN THE        *
  23.          *      RUN TIME MONITOR IS EXECUTED.  THE INT FILE     *
  24.          *      FOR THE PROGRAM TO BE EXECUTED IS OPENED        *
  25.          *      AND THE BASIC-E MACHINE IS BUILT.               *
  26.          *                                                      *
  27.          *      BUILD PERFORMS THE FOLLOWING FUNCTIONS:         *
  28.          *                                                      *
  29.          *      (1) THE NUMERIC CONSTANTS ARE READ FROM         *
  30.          *      THE INT FILE, CONVERTED TO INTERNAL REP-        *
  31.          *      RESENTATION, AND STORED IN THE FSA.             *
  32.          *                                                      *
  33.          *      (2) THE SIZE OF THE CODE AREA, DATA AREA        *
  34.          *      AND NUMBER OF PRT ENTRIES ARE READ FROM         *
  35.          *      THE INT FILE. BUILD THEN DETERMINES THE         *
  36.          *      ABSOLUTE ADDRESS OF EACH SECTION OF THE         *
  37.          *      BASIC-E MACHINE. THESE ADDRESSES ARE            *
  38.          *      PASSED TO THE INTERP PROGRAM VIA FIXED          *
  39.          *      ADDRESSES IN THE FLOATING POINT SCRATCH         *
  40.          *      PAD.                                            *
  41.          *                                                      *
  42.          *      (3) FINALLY INSTRUCTIONS ARE READ FROM          *
  43.          *      THE FILE AND PLACED IN EITHER THE DATA          *
  44.          *      AREA OR THE CODE AREA. IN THE CASE OF BRS       *
  45.          *      BRC, PRO, CON, AND DEF OPERATORS THE            *
  46.          *      ADDRESS FOLLOWING THE INSTRUCTION IS RE-        *
  47.          *      LOCATED TO REFLECT ACTUAL MACHINE ADDRESSES     *
  48.          *      (MINUS 1 BECAUSE PROGRAM COUNTER GETS           *
  49.          *      INCREMENTED PRIOR TO USE (EXCEPT FOR CON)!!)    *
  50.          *      AFTER (REPEAT AFTER) THE MACHINE HAS BEEN       *
  51.          *      REPOSITIONED BY INTERP. THE END OF THE INT      *
  52.          *      FILE IS INDICATED BY A MACHINE INSTRUCTION      *
  53.          *      7FH.                                            *
  54.          *      REPOSITIONED BY INTERP.                         *
  55.          *                                                      *
  56.          ********************************************************
  57.     */
  58.     /*
  59.          ********************************************************
  60.          *                                                      *
  61.          *                    GLOBAL LITERALS                   *
  62.          *                                                      *
  63.          ********************************************************
  64.     */
  65. DECLARE
  66.         LIT       LITERALLY    'LITERALLY',
  67.         TRUE      LIT                  '1',
  68.         FALSE     LIT                  '0',
  69.         CR        LIT                '0DH',
  70.         LF        LIT                '0AH';
  71.     /*
  72.          ********************************************************
  73.          *                                                      *
  74.          *            SYSTEM PARAMETERS WHICH MAY               *
  75.          *            REQUIRE MODIFICATION BY USERS             *
  76.          *                                                      *
  77.          ********************************************************
  78.     */
  79. DECLARE
  80.         /* OP CODES FOR BASIC-E MACHINE INSTRUCTIONS */
  81.         DAT         LIT      '51',
  82.         ILS         LIT      '28',
  83.         DEF         LIT      '94',
  84.         BRS         LIT      '54',
  85.         BRC         LIT      '55',
  86.         PRO         LIT      '30',
  87.         CON         LIT      '46';
  88.     /*
  89.          ********************************************************
  90.          *                                                      *
  91.          *               EXTERNAL ENTRY POINTS                  *
  92.          *    THESE ENTRY POINTS ALLOW INTERFACEING WITH CP/M   *
  93.          *                                                      *
  94.          ********************************************************
  95.     */
  96. DECLARE
  97.         BDOSBEGIN    ADDRESS INITIAL(06H), /* PTR TO BOTTOM CP/M */
  98.         MAX          BASED   BDOSBEGIN   ADDRESS,
  99.         
  100.         /* OFFSET IS THE SIZE OF THIS MODULE */
  101.         OFFSET       ADDRESS EXTERNAL, /* INITIALIZED BELOW */
  102.         /* START IS THE ADDRESS TO START INTERPRETATION */
  103.         START      LABEL EXTERNAL,
  104.         /* BEGIN HOLDS THE VALUE OF .MEMORY FOR INTERP */
  105.         BEGIN     ADDRESS EXTERNAL,
  106.         /* PARAMETER PASSING LOCATIONS */
  107.  
  108.         PARAM1       ADDRESS EXTERNAL ,
  109.         PARAM2       ADDRESS EXTERNAL ,
  110.         PARAM3       ADDRESS EXTERNAL ,
  111.         PARAM4       ADDRESS EXTERNAL ;
  112.          /*
  113.          ********************************************************
  114.          *                                                      *
  115.          *                GLOBAL VARIABLES                      *
  116.          *                                                      *
  117.          ********************************************************
  118.         */
  119. DECLARE
  120.         MCD       LIT       'PARAM1',
  121.         MDA       LIT       'PARAM2',
  122.         MPR       LIT       'PARAM3',
  123.         SB        LIT       'PARAM4',
  124.         MBASE     ADDRESS, /* PTR TO NEXT POSTION IN DATA AREA */
  125.         MF        BASED     MBASE      BYTE,
  126.         BASE      ADDRESS, /* PTR TO NEXT POSITION IN CODE AREA */
  127.         CURCHAR   BYTE, /* HOLDS CHAR BEING ANALYZED */
  128.         B         BASED     BASE BYTE,
  129.         BV        BASED     BASE(1) BYTE,  /* VECTOR VERSION OF B */
  130.         A         BASED     BASE ADDRESS,
  131.         AP        BYTE, /* ACCUMULATOR INDEX */
  132.         ACCUM(16) BYTE, /* HOLDS CONSTANTS PRIOR TO CONV */
  133.         TEMP      ADDRESS,
  134.         T         BASED     TEMP BYTE;
  135.     /*
  136.          ********************************************************
  137.          *                                                      *
  138.          *         FLOATING POINT INTERFACE ROUTINES            *
  139.          *                                                      *
  140.          ********************************************************
  141.     */
  142. FLTOP: PROCEDURE(FUNCTION,LOCATION) EXTERNAL;
  143.     DECLARE FUNCTION BYTE, LOCATION ADDRESS;
  144.     END FLTOP;
  145.  
  146. DECLARE FPN LITERALLY 'FLTOP';
  147.  
  148. FLTRET: PROCEDURE(FUNCTION,LOCATION) EXTERNAL;
  149.     DECLARE FUNCTION BYTE, LOCATION ADDRESS;
  150.     END FLTRET;
  151.  
  152. DECLARE FP LITERALLY 'FLTRET';
  153.  
  154. FLTINP: PROCEDURE(COUNT,LOCATION) EXTERNAL;
  155.     DECLARE COUNT BYTE, LOCATION ADDRESS;
  156.     END FLTINP;
  157.  
  158. DECLARE FPINP LITERALLY 'FLTINP';
  159.  
  160.  
  161.  
  162.     /*
  163.          ********************************************************
  164.          *                                                      *
  165.          *                CP/M INTERFACE ROUTINES               *
  166.          *                                                      *
  167.          ********************************************************
  168.     */
  169. DECLARE
  170.         DISKBUFFLOC LIT     '80H',
  171.         FCBLOC      LIT     '5CH',
  172.         DISKBUFFEND LIT    '100H',
  173.       /* IF OPERATING SYSTEM READS VARIABLE LENGTH RECORDS
  174.          THIS MUST BE ADDRESS OF ACTUAL END OF RECORD */
  175.         BUFF      ADDRESS   INITIAL(DISKBUFFEND), /* INPUT BUFFER */
  176.         CHAR      BASED     BUFF       BYTE,     /* INPUTBUFF POINTER */
  177.         FILENAME  ADDRESS   INITIAL   (FCBLOC),
  178.         FNP       BASED     FILENAME(33)  BYTE; /* FILE CONTROL BLK */
  179.  
  180.  
  181. MON1:PROCEDURE(FUNCTION,PARAMETER) EXTERNAL;
  182.     DECLARE
  183.             FUNCTION  BYTE,
  184.             PARAMETER   ADDRESS;
  185. END MON1;
  186.  
  187. MON2: PROCEDURE(FUNCTION,PARAMETER) BYTE EXTERNAL;
  188.     DECLARE
  189.             FUNCTION    BYTE,
  190.             PARAMETER   ADDRESS;
  191. END MON2;
  192.  
  193.  
  194. MON3: PROCEDURE EXTERNAL;
  195. END MON3;
  196.  
  197.  
  198. PRINTCHAR: PROCEDURE(CHAR) EXTERNAL;
  199.     DECLARE CHAR BYTE;
  200. END PRINTCHAR;
  201.  
  202.  
  203. PRINT: PROCEDURE(BUFFER) EXTERNAL;
  204.      /*
  205.          PRINT A LINE ON CONSOLE FOLLOWED BY A
  206.          CARRIAGE RETURN AND LINEFEED
  207.      */
  208.     DECLARE
  209.             BUFFER ADDRESS;
  210. END PRINT;
  211.  
  212. PRINTF: PROCEDURE(BUFFER);
  213.     DECLARE BUFFER ADDRESS;
  214.     CALL PRINT(BUFFER);
  215.     CALL PRINTCHAR(CR); CALL PRINTCHAR(LF);
  216.     END PRINTF;
  217.  
  218. OPEN$INT$FILE: PROCEDURE;
  219.     FNP(9) = 'I';
  220.     FNP(10) = 'N';
  221.     FNP(11) = 'T';
  222.     IF MON2(15,FILENAME) = 255 THEN
  223.          DO;
  224.               CALL PRINTF(.('NI   $'));
  225.               CALL MON3;
  226.          END;
  227. END OPEN$INT$FILE;
  228.  
  229.  
  230. READ$INT$FILE: PROCEDURE BYTE;
  231.      /*
  232.         NEXT RECORD IS READ FROM INT FILE
  233.         DISKBUFFEND MUST REFLECT THE ADDRESS
  234.         OF THE END OF THE RECORD PLUS ONE
  235.         FOR FIXED SIZE RECORDS THIS IS A CONSTANT
  236.         RETURNS ZERO IF READ IS SAT, AND 1 IF EOF
  237.      */
  238.     RETURN MON2(20,FILENAME);
  239. END READ$INT$FILE;
  240.     /*
  241.          ********************************************************
  242.          *                                                      *
  243.          *                  GLOBAL PROCEDURES                   *
  244.          *                                                      *
  245.          ********************************************************
  246.     */
  247.  
  248.  
  249. INCBUF: PROCEDURE;
  250.     IF(BUFF := BUFF + 1) >= DISKBUFFEND THEN
  251.          DO;
  252.               BUFF = DISKBUFFLOC;
  253.               IF READ$INT$FILE <> 0 THEN
  254.                    CHAR = 7FH;
  255.          END;
  256. END INCBUF;
  257.  
  258.  
  259. STO$CHAR$INC: PROCEDURE;
  260.      /*
  261.         GET NEXT CHAR FROM INT FILE AND
  262.         PLACE IN CODE AREA. THEN INCREMENT
  263.         PTR INTO CODE AREA.
  264.      */
  265.     B=CHAR;
  266.     BASE=BASE+1;
  267. END STO$CHAR$INC;
  268.  
  269.  
  270. NEXT$CHAR: PROCEDURE BYTE;
  271.     CALL INCBUF;
  272.     RETURN CURCHAR := CHAR;
  273. END NEXT$CHAR;
  274.  
  275.  
  276. GET$TWO$BYTES: PROCEDURE;
  277.     /*
  278.       GET NEXT TWO BYTES FROM THE INT FILE
  279.       AND PLACE THEM IN THE CODE AREA IN REVERSE ORDER. 
  280.     */
  281.     BV(1) = NEXT$CHAR;
  282.     B = NEXT$CHAR;
  283.     RETURN;
  284. END GET$TWO$BYTES;
  285.  
  286.  
  287. INC$BASE$TWO: PROCEDURE;
  288.     BASE = BASE + 1 + 1;
  289.     RETURN;
  290. END INC$BASE$TWO;
  291.  
  292.  
  293. GETPARM: PROCEDURE ADDRESS;
  294.      /*
  295.         READ A 16 BIT PARAMETER FROM INT FILE
  296.         AND CONVERT IT TO AN 8080 ADDRESS QUANTITY
  297.      */
  298.     RETURN SHL(DOUBLE(NEXT$CHAR),8) + NEXT$CHAR;
  299. END GETPARM;
  300.  
  301.     /*
  302.          ********************************************************
  303.          *                                                      *
  304.          *              EXECUTION BEGINS HERE                   *
  305.          *                                                      *
  306.          ********************************************************
  307.     */
  308. BUILD:
  309. CALL PRINTF(.('BASIC-E INTERPRETER - VER 2.2$'));
  310. CALL OPEN$INT$FILE;
  311.  
  312. BASE = (.MEMORY + 100H) AND 0FF00H; /*  BEGINNING OF MACHINE AND FDA */
  313. OFFSET = BASE - BEGIN; /* SIZE OF THE BUILD MODULE */
  314.  
  315. CALL FPN(0,0); /* INITIALIZE FLOATING POINT PACKAGE */
  316.       /*
  317.           PROCESS CONSTANTS
  318.           EACH CONSTANT IS SEPARATED BY A $
  319.           LAST CONSTANT FOLLOWED BY A *
  320.       */
  321. DO WHILE(ACCUM(0) := NEXT$CHAR) <> '*'; /* * INDICATES END OF CONST */
  322.     AP = 0;   /* COUNTER FOR LENGTH OF THIS CONSTANT */
  323.     DO WHILE(ACCUM(AP:=AP+1) := NEXT$CHAR) <> '$';
  324.           /* GET CONSTANT INTO THE ACCUM */
  325.          END;
  326.     CALL FPINP(AP,.ACCUM); /* CONVERT IT TO INTERNAL FORM */
  327.     CALL FP(9,BASE);  /* LOAD INTO FDA FROM F/P ACCUM */
  328.     BASE = BASE + 4; /* NEXT LOCATION */
  329.     END;    /* OF LOOKING FOR *  */
  330.  
  331.       /*
  332.           SETUP MACHINE ADDRESS
  333.           BASE WILL NOW BE NEXT POSITION IN CODE AREA
  334.           MBASE WILL BE NEXT POSTION IN DATA AREA
  335.       
  336.           ACTUAL ADDRESSES OF CODE AREA, DATA AREA
  337.           PRT, AND STACK ARE PASSED TO INTERPRETER
  338.           USING FIXED LOCATIONS
  339.       */
  340. MBASE = GETPARM + BASE;
  341.  
  342. MDA = MBASE - OFFSET; /* ACTUAL DATA AREA ADDR */
  343. MCD = BASE - OFFSET; /* ACTUAL CODE AREA ADDR */
  344. MPR = GETPARM + MDA;  /* ACTUAL BEGINNING OF PRT */
  345. IF MPR >= MAX THEN /* INSURE THERE IS ENOUGH MEMORY */
  346.     DO;
  347.          CALL PRINTF(.('NM  $'));
  348.          CALL MON3;
  349.     END;
  350. SB = SHL(GETPARM,2) + MPR; /* NUMBER OF ENTRIES IN PRT * 4=SIZE PRT */
  351.  
  352.       /*
  353.           BUILD MACHINE - ATLAST 
  354.           AS OPCODES ARE READ THEY MAY BE:
  355.              (1) DAT - WHICH MEANS ALL CHARACTERS
  356.              FOLLOWING DAT GO INTO DATA AREA UNTIL
  357.              A BINARY ZERO IS INCOUNTERED
  358.  
  359.              (2) GREATER THAN 127 - WHICH IS A LIT
  360.              OR A LIT. TREAT THIS AS 16 BIT OPCODE
  361.              AND PUT IN CODE AREA IN ORDER THEY ARE
  362.              ON INT FILE
  363.  
  364.              (3) ILS - WHICH MEANS ALL CHARACTERS
  365.              FOLLOWING GO INTO CODE AREA UNTIL A 
  366.              BINARY ZERO IS INCOUNTERED - BUT FIRST
  367.              PUT A ILS IN CODE AREA AND THE NEXT 
  368.              BYTE IS SET TO ZERO AND INCREMENTED
  369.              FOR EACH CHARACTER IN THE STRING. IE
  370.              A STRING CONSTANT IS A ILS OPCODE,
  371.              A LENGTH AND THE STRING.
  372.      
  373.              (4) A NORMAL OP CODE - PUT IN CODE
  374.              AREA - BUT IF IT IS A BRS OR BRC OR
  375.              DEF OR PRO THEN THE NEXT TWO BYTES
  376.              ARE AN ADDRESS WHICH MUST BE RELOCATED
  377.              TO THE ACTUAL CODE AREA MINUS 1;
  378.              OR IT COULD BE A CON WHICH IS
  379.              RELOCATED TO THE FDA.
  380.         */
  381.  
  382. DO WHILE NEXT$CHAR <> 7FH; /* BUILD MACHINE */
  383.     IF CURCHAR = DAT THEN /* PROCESS DATA STATEMENT */
  384.          DO WHILE(MF := NEXT$CHAR) <> 0; /* LOOK FOR END */
  385.               MBASE = MBASE + 1;
  386.               END;
  387.          ELSE
  388.               IF CURCHAR >= 128 THEN /* PROCESS LIT OR LID */
  389.                    DO;
  390.                         CALL STO$CHAR$INC;
  391.                         CALL INCBUF;
  392.                         CALL STO$CHAR$INC;
  393.                    END;
  394.               ELSE
  395.                    IF CURCHAR = ILS THEN /* PROCESS INLINE STRING */
  396.                         DO;
  397.                              CALL STO$CHAR$INC;
  398.                              TEMP = BASE;
  399.                              CHAR = 0; /* TO SET LENGTH TO 0 INITIAL */
  400.                              CALL STO$CHAR$INC;
  401.                              DO WHILE NEXT$CHAR <> 0;
  402.                                   CALL STO$CHAR$INC;
  403.                                   T = T + 1;
  404.                                   END;
  405.                          END;
  406.                     ELSE
  407.                          DO;
  408.                              CALL STO$CHAR$INC;
  409.                              IF (CURCHAR = BRS) OR (CURCHAR = BRC) OR
  410.                                 (CURCHAR = DEF) OR (CURCHAR = PRO) THEN
  411.                                   DO;
  412.                                       CALL GET$TWO$BYTES;
  413.                                       A = A + MCD - 1;
  414.                                       CALL INC$BASE$TWO;
  415.                                   END;
  416.                              ELSE
  417.                                 IF CURCHAR = CON THEN
  418.                                   DO;
  419.                                     CALL GET$TWO$BYTES;
  420.                                     A = SHL(A,2) + BEGIN;
  421.                                     CALL INC$BASE$TWO;
  422.                                   END;
  423.                         END;
  424. END;   /* LOOKING FOR 7FH */
  425. GO TO START; /* RETURNS TO BASE MODULE FOR FURTHER PROCESSING */
  426. END;
  427.