home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / sigm / vols000 / vol039 / ll1p20.pli < prev    next >
Text File  |  1984-04-29  |  7KB  |  233 lines
  1. LL1P20: PROC;
  2. /****************************************************************
  3. *              LL(1) GRAMMAR ANALYZER - PHASE 2            *
  4. *PURPOSE:                                                       *
  5. *    THIS PROGRAM SORTS THE VOCABULARY AND PRINTS THE INTERNAL  *
  6. *    FORM OF THE LANGUAGE IN A BNF FORMAT.            *
  7. *INPUT:                                                         *
  8. *OUTPUT:                                                        *
  9. *OUTLINE:                                                       *
  10. *REMARKS:                                                       *
  11. ****************************************************************/
  12.  
  13. /****************************************************************
  14. * * * * * * * * * * * COMMON DATA DEFINITIONS * * * * * * * * * *
  15. ****************************************************************/
  16.  
  17. /*    * * *  COMMON REPLACEMENTS  * * *    */
  18. %REPLACE TRUE BY '1'B;
  19. %REPLACE FALSE BY '0'B;
  20.  
  21. %INCLUDE 'LL1CMN.DCL';    /* GET COMMON AREAS. */
  22.  
  23. /****************************************************************
  24. * * * * * * * * * * * COMMON PROCUDURES * * * * * * * * * * * * *
  25. ****************************************************************/
  26.  
  27.  
  28. %INCLUDE 'LL1PRC.DCL';
  29.  
  30.  
  31. /****************************************************************
  32. * * * * * * * * * * * GRAMMAR PRINT PROCUDURES * * * * * * * * **
  33. ****************************************************************/
  34.  
  35. PRINT_PRODUCTIONS: PROC;
  36. /*THIS ROUTINE IS RESPONSIBLE FOR PRINTING THE VOCABULARY. */
  37.     DCL I BIN(15);        /* INDEXES */
  38.     DCL J BIN(15);
  39.     DCL NUM_LINES BIN(15);    /* MAXIMUM NUMBER OF LINES */
  40.     DCL LHS_ENT CHAR(10) VARYING;
  41.     DCL RHS_ENT(5) CHAR(10) VARYING;
  42.  
  43. /* OUTPUT THE HEADING. */
  44.     ON ENDPAGE(LSTFIL)
  45.        BEGIN;
  46.           PUT FILE(LSTFIL) PAGE;
  47.           PUT FILE(LSTFIL) SKIP(3) 
  48.           EDIT('*** PRODUCTION LISTING ***','PAGE',
  49.             PAGENO(LSTFIL)-1)
  50.           (X(20),A(26),X(10),A(4),F(4));
  51.           PUT FILE(LSTFIL) SKIP(1);
  52.        END;
  53.     SIGNAL ENDPAGE(LSTFIL);
  54.  
  55. /* PRINT THE REPORT LINES. */
  56.     PUT FILE(LSTFIL) SKIP(1)
  57.           EDIT('STARTING SYMBOL: ',VOC(CHRNUM(STRSYM)))
  58.           (X(14),A(17),A(10));
  59.     DO I=1 TO NUMPRD;
  60.        LHS_ENT=VOC(CHRNUM(LHS(I)));
  61.        DO J=1 TO 5;
  62.           IF J>LENGTH(RHS(I)) THEN
  63.              RHS_ENT(J)='';
  64.           ELSE
  65.              RHS_ENT(J)=VOC(CHRNUM(SUBSTR(RHS(I),J,1)));
  66.        END;
  67.        PUT FILE(LSTFIL) SKIP(1)
  68.            EDIT(I,LHS_ENT,' -> ',(RHS_ENT(J) DO J=1 TO 5),';')
  69.           (F(4),X(01),A,A(04),5(A,X(01)),A(1));
  70.     END;
  71.  
  72.         END  PRINT_PRODUCTIONS;
  73.  
  74.  
  75. PRINT_VOCABULARY: PROC;
  76. /*THIS ROUTINE IS RESPONSIBLE FOR PRINTING THE VOCABULARY. */
  77.     DCL I BIN(15);        /* INDEXES */
  78.     DCL J BIN(15);
  79.     DCL NUM_LINES BIN(15);    /* MAXIMUM NUMBER OF LINES */
  80.     DCL TRM_ENT CHAR(10) VARYING;
  81.     DCL NTRM_ENT CHAR(10) VARYING;
  82.  
  83. /* DETERMINE MAX LENGTH FOR LOOP. */
  84.     IF LENGTH(TRM)>LENGTH(NTRM) THEN
  85.        NUM_LINES=LENGTH(TRM);
  86.     ELSE
  87.        NUM_LINES=LENGTH(NTRM);
  88.  
  89. /* OUTPUT THE HEADING. */
  90.     ON ENDPAGE(LSTFIL)
  91.        BEGIN;
  92.           PUT FILE(LSTFIL) PAGE;
  93.           PUT FILE(LSTFIL) SKIP(3) 
  94.           EDIT('*** VOCABULARY LISTING ***','PAGE',
  95.             PAGENO(LSTFIL)-1)
  96.           (X(20),A(26),X(10),A(4),F(4));
  97.           PUT FILE(LSTFIL) SKIP(1)
  98.           EDIT('TERMINALS','NON-TERMINALS')
  99.           (X(19),A(10),X(05),A(13));
  100.           PUT FILE(LSTFIL) SKIP(1);
  101.        END;
  102.     SIGNAL ENDPAGE(LSTFIL);
  103.  
  104. /* PRINT THE REPORT LINES. */
  105.     DO I=1 TO NUM_LINES;
  106.        IF I>LENGTH(TRM) THEN    /* GET TERMINAL ENTRY.*/
  107.           TRM_ENT='';
  108.        ELSE
  109.           TRM_ENT=VOC(CHRNUM(SUBSTR(TRM,I,1)));
  110.        IF I>LENGTH(NTRM) THEN    /* GET NON-TERMINAL ENTRY.*/
  111.           NTRM_ENT='';
  112.        ELSE
  113.           NTRM_ENT=VOC(CHRNUM(SUBSTR(NTRM,I,1)));
  114.           PUT FILE(LSTFIL) SKIP(1)
  115.           EDIT(I,TRM_ENT,NTRM_ENT)
  116.           (X(14),F(4),X(01),A(10),X(05),A(10));
  117.     END;
  118.  
  119.           END  PRINT_VOCABULARY;
  120.  
  121.  
  122. SORT_VOCABULARY: PROC;
  123. /*THIS ROUTINE IS RESPONSIBLE FOR SORTING THE VOCABULARY. */
  124. /*IT SORTS:
  125.         1) NON-TERMINAL VS TERMINAL
  126.            2) SYMBOL
  127. /*THEN IT UPDATES ALL THE TABLES TO REFLECT THE NEW ORDER. */
  128.  
  129.     DCL I BIN(15);        /* INDEXES */
  130.     DCL J BIN(15);
  131.     DCL SORT_FLAG BIT(1);
  132.     DCL 1 VOC_INDEX(254),    /* SORT INDEX FOR VOCABULARY */
  133.         2 TRM_IND BIT(1),    /* 0=NON-TERMINAL 1=TERMINAL */
  134.         2 SYM_LEN BIN(7),   /* SYMBOL LENGTH */
  135.         2 ORIG CHAR;    /* ORIGINAL ORDER */
  136.     DCL 1 TMP_INDEX,    /* TEMP AREA FOR BUBBLE SORT */
  137.         2 TRM_IND BIT(1),    /* 0=NON-TERMINAL 1=TERMINAL */
  138.         2 SYM_LEN BIN(7),   /* SYMBOL LENGTH */
  139.         2 ORIG CHAR;    /* ORIGINAL ORDER */
  140.     DCL TMP_VOC(254) CHAR(10) VARYING;
  141.     DCL TMP_REORG(254) BIN(15);
  142.  
  143. /* BUILD SORT INDEX. */
  144.     STRSYM=SUBSTR(NTRM,1,1); /*STARTING SYMBOL*/
  145.     DO I=1 TO NUMVOC;
  146.        VOC_INDEX.TRM_IND(I)=ISTRM(NUMCHR(I));
  147.        VOC_INDEX.SYM_LEN(I)=LENGTH(VOC(I));
  148.        VOC_INDEX.ORIG(I)=NUMCHR(I);
  149.     END;
  150.  
  151. /* BUBBLE SORT THE INDEX. */
  152.     SORT_FLAG=TRUE;
  153.     DO WHILE(SORT_FLAG=TRUE);
  154.        SORT_FLAG=FALSE;
  155.        DO I=1 TO NUMVOC-1;
  156.           IF VOC_INDEX.TRM_IND(I)=TRUE &
  157.          VOC_INDEX.TRM_IND(I+1)=FALSE THEN
  158.              DO;
  159.             TMP_INDEX=VOC_INDEX(I);
  160.             VOC_INDEX(I)=VOC_INDEX(I+1);
  161.             VOC_INDEX(I+1)=TMP_INDEX;
  162.             SORT_FLAG=TRUE;
  163.          END;
  164.           ELSE
  165.          IF VOC_INDEX.TRM_IND(I)=VOC_INDEX.TRM_IND(I+1) THEN
  166.             IF VOC(CHRNUM(VOC_INDEX.ORIG(I))) >
  167.             VOC(CHRNUM(VOC_INDEX.ORIG(I+1))) THEN
  168.                    DO;
  169.                   TMP_INDEX=VOC_INDEX(I);
  170.                   VOC_INDEX(I)=VOC_INDEX(I+1);
  171.                   VOC_INDEX(I+1)=TMP_INDEX;
  172.                   SORT_FLAG=TRUE;
  173.                END;
  174.        END;
  175.     END;
  176.  
  177. /* PUT THE VOCABULARY TABLE IN ORDER SPECIFIED BY THE SORT. */
  178.     DO I=1 TO NUMVOC;
  179.        TMP_VOC(I)=VOC(CHRNUM(VOC_INDEX.ORIG(I)));
  180.     END;
  181.     DO I=1 TO NUMVOC;
  182.        VOC(I)=TMP_VOC(I);
  183.     END;
  184.  
  185.  
  186. /* PUT THE NON-TERMINAL TABLE IN ORDER SPECIFIED BY THE SORT. */
  187.     NTRM='';
  188.     DO I=1 TO NUMVOC;
  189.        IF VOC_INDEX.TRM_IND(I)=FALSE THEN
  190.           NTRM=NTRM || NUMCHR(I);
  191.     END;
  192.  
  193. /* PUT THE TERMINAL TABLE IN ORDER SPECIFIED BY THE SORT. */
  194.     TRM='';
  195.     DO I=1 TO NUMVOC;
  196.        IF VOC_INDEX.TRM_IND(I)=TRUE THEN
  197.           TRM=TRM || NUMCHR(I);
  198.     END;
  199.  
  200. /* TRANSLATE THE PRODUCTIONS ARRAY TO THE NEW INDEX. */
  201.     DO I=1 TO NUMVOC;
  202.        TMP_REORG(CHRNUM(VOC_INDEX.ORIG(I)))=I;
  203.     END;
  204.     DO I=1 TO NUMPRD;
  205.        LHS(I)=NUMCHR(TMP_REORG(CHRNUM(LHS(I))));
  206.        IF LENGTH(RHS(I))>0 THEN
  207.           DO J=1 TO LENGTH(RHS(I));
  208.          SUBSTR(RHS(I),J,1)=NUMCHR(TMP_REORG(CHRNUM(
  209.                     SUBSTR(RHS(I),J,1))));
  210.           END;
  211.     END;
  212.     STRSYM=NUMCHR(TMP_REORG(CHRNUM(STRSYM))); /*STARTING SYMBOL*/
  213.  
  214. /* RETURN TO CALLER. */
  215.           END  SORT_VOCABULARY;
  216.  
  217.  
  218. /****************************************************************
  219. * * * * * * * * * * * MAIN LINE PROCEDURE * * * * * * * * * * * *
  220. ****************************************************************/
  221.  
  222. /* DO INITIALIZATION. */
  223.       PUT SKIP LIST('BEGINNING PHASE 2 PROCESSING.');
  224.  
  225. /* PRINT THE GRAMMAR. */
  226.      CALL SORT_VOCABULARY;
  227.      CALL PRINT_VOCABULARY;    /* PRINT THE VOCABULARY. */
  228.      CALL PRINT_PRODUCTIONS;   /* PRINT THE PRODUCTIONS. */
  229.  
  230. /* RETURN TO CALLER. */
  231.      PUT SKIP LIST('PHASE 2 PROCESSING COMPLETE - NO ERRORS.');
  232.      END LL1P20;
  233.