home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBOPAS / PASUTIL1.ZIP / PARTB.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-12-28  |  16.7 KB  |  465 lines

  1.       LETTER      : GETIDENTIFIER(
  2.                                    (* UPDATING *)  CURRCHAR,
  3.                                                    NEXTCHAR,
  4.                                    (* RETURNING *) NAME,
  5.                                                    VALYOO,
  6.                                                    LENGTH    );
  7.       DIGIT       : GETNUMBER(
  8.                                (* UPDATING *)  CURRCHAR,
  9.                                                NEXTCHAR,
  10.                                (* RETURNING *) NAME,
  11.                                                VALYOO,
  12.                                                LENGTH    );
  13.       QUOTE       : GETCHARLITERAL(
  14.                                     (* UPDATING *)  CURRCHAR,
  15.                                                     NEXTCHAR,
  16.                                     (* RETURNING *) NAME,
  17.                                                     VALYOO,
  18.                                                     LENGTH    );
  19.       OTHERCHAR   : BEGIN
  20.                                GETSPECIALCHAR(
  21.                                        (* UPDATING *)  CURRCHAR,
  22.                                                        NEXTCHAR,
  23.                                        (* RETURNING *) NAME,
  24.                                                        VALYOO,
  25.                                                        LENGTH    );
  26.                        IF NAME = OPENCOMMENT
  27.                           THEN
  28.                              GETCOMMENT(
  29.                                          (* UPDATING *) CURRCHAR,
  30.                                                         NEXTCHAR,
  31.                                                         NAME,
  32.                                                         VALYOO,
  33.                                                         LENGTH    )
  34.                     END;
  35.       FILEMARK    : NAME := ENDOFFILE
  36.    END (* CASE *)
  37. END; (* GETNEXTSYMBOL *)
  38. PROCEDURE GETSYMBOL(
  39.                      (* UPDATING *)  VAR NEXTSYM   : SYMBOLINFO;
  40.                      (* RETURNING *) VAR CURRSYM   : SYMBOLINFO );
  41. VAR
  42.     DUMMY: SYMBOLINFO;
  43. BEGIN (* GETSYMBOL *)
  44.    DUMMY   := CURRSYM;
  45.    CURRSYM := NEXTSYM;
  46.    NEXTSYM := DUMMY  ;
  47.    WITH NEXTSYM^ DO
  48.       BEGIN
  49.          SKIPSPACES(
  50.                      (* UPDATING *)  CURRCHAR,
  51.                                      NEXTCHAR,
  52.                      (* RETURNING *) SPACESBEFORE,
  53.                                      CRSBEFORE     );
  54.          LENGTH := 0;
  55.          IF CURRSYM^.NAME = OPENCOMMENT
  56.             THEN
  57.                GETCOMMENT(
  58.                            (* UPDATING *)  CURRCHAR,
  59.                                            NEXTCHAR,
  60.                            (* RETURNING *) NAME,
  61.                                            VALYOO,
  62.                                            LENGTH    )
  63.             ELSE
  64.                GETNEXTSYMBOL(
  65.                               (* UPDATING *)  CURRCHAR,
  66.                                               NEXTCHAR,
  67.                               (* RETURNING *) NAME,
  68.                                                         VALYOO,
  69.                                               LENGTH    )
  70.       END (* WITH *)
  71. END; (* GETSYMBOL *)
  72.  PROCEDURE INT2 ( VAR TOPOFSTACK : INTEGER;
  73.  VAR CURRLINEPOS,
  74.      CURRMARGIN : INTEGER;
  75.  VAR KEYWORD    : KEYWORDTABLE;
  76.  VAR DBLCHARS   : DBLCHRSET;
  77.  VAR DBLCHAR    : DBLCHARTABLE;
  78.  VAR SGLCHAR    : SGLCHARTABLE;
  79.  VAR RECORDSEEN : BOOLEAN;
  80.  VAR CURRCHAR,
  81.      NEXTCHAR   : CHARINFO;
  82.  VAR CURRSYM,
  83.      NEXTSYM    : SYMBOLINFO;
  84.  VAR PPOPTION   : OPTIONTABLE );
  85.  
  86. BEGIN
  87.    WITH PPOPTION [ OFSYM ] DO
  88.       BEGIN
  89.          OPTIONSSELECTED   := [ CRSUPPRESS,
  90.                                 SPACEBEFORE ];
  91.          DINDENTSYMBOLS    := [];
  92.          GOBBLETERMINATORS := []
  93.       END;
  94.    WITH PPOPTION [ FORSYM ] DO
  95.       BEGIN
  96.          OPTIONSSELECTED   := [ SPACEAFTER,
  97.                                 INDENTBYTAB,
  98.                                 GOBBLESYMBOLS,
  99.                                 CRAFTER ];
  100.          DINDENTSYMBOLS    := [];
  101.                                   GOBBLETERMINATORS := [ DOSYM ]
  102.       END;
  103.    WITH PPOPTION [ WHILESYM ] DO
  104.       BEGIN
  105.          OPTIONSSELECTED   := [ SPACEAFTER,
  106.                                 INDENTBYTAB,
  107.                                 GOBBLESYMBOLS,
  108.                                 CRAFTER ];
  109.          DINDENTSYMBOLS    := [];
  110.          GOBBLETERMINATORS := [ DOSYM ]
  111.       END;
  112.    WITH PPOPTION [ WITHSYM ] DO
  113.       BEGIN
  114.          OPTIONSSELECTED   := [ SPACEAFTER,
  115.                                 INDENTBYTAB,
  116.                                 GOBBLESYMBOLS,
  117.                                 CRAFTER ];
  118.          DINDENTSYMBOLS    := [];
  119.          GOBBLETERMINATORS := [ DOSYM ]
  120.       END;
  121.    WITH PPOPTION [ DOSYM ] DO
  122.       BEGIN
  123.          OPTIONSSELECTED   := [ CRSUPPRESS,
  124.                                 SPACEBEFORE ];
  125.          DINDENTSYMBOLS    := [];
  126.          GOBBLETERMINATORS := []
  127.       END;
  128.    WITH PPOPTION [ IFSYM ] DO
  129.       BEGIN
  130.          OPTIONSSELECTED   := [ SPACEAFTER,
  131.                                 INDENTBYTAB,
  132.                                              GOBBLESYMBOLS,
  133.                                 CRAFTER ];
  134.          DINDENTSYMBOLS    := [];
  135.          GOBBLETERMINATORS := [ THENSYM ]
  136.       END;
  137.    WITH PPOPTION [ THENSYM ] DO
  138.       BEGIN
  139.          OPTIONSSELECTED   := [ INDENTBYTAB, CRAFTER ];
  140.          DINDENTSYMBOLS    := [];
  141.          GOBBLETERMINATORS := []
  142.       END;
  143.    WITH PPOPTION [ ELSESYM ] DO
  144.       BEGIN
  145.          OPTIONSSELECTED   := [ CRBEFORE,
  146.                                 DINDENTONKEYS,
  147.                                 DINDENT,
  148.                                 INDENTBYTAB,
  149.                                 CRAFTER ];
  150.          DINDENTSYMBOLS    := [ IFSYM,
  151.                                 ELSESYM ];
  152.          GOBBLETERMINATORS := []
  153.       END;
  154.    WITH PPOPTION [ ENDSYM ] DO
  155.       BEGIN
  156.          OPTIONSSELECTED   := [ CRBEFORE,
  157.                                 DINDENTONKEYS,
  158.                                 DINDENT,
  159.                                 CRAFTER ];
  160.          DINDENTSYMBOLS    := [ IFSYM,
  161.                                 THENSYM,
  162.                                 ELSESYM,
  163.                                 FORSYM,
  164.                                 WHILESYM,
  165.                                 WITHSYM,
  166.                                 CASEVARSYM,
  167.                                 COLON,
  168.                                 EQUALS ];
  169.          GOBBLETERMINATORS := []
  170.       END;
  171.    WITH PPOPTION [ UNTILSYM ] DO
  172.       BEGIN
  173.          OPTIONSSELECTED   := [ CRBEFORE,
  174.                                 DINDENTONKEYS,
  175.                                 DINDENT,
  176.                                 SPACEAFTER,
  177.                                 GOBBLESYMBOLS,
  178.                                 CRAFTER ];
  179.          DINDENTSYMBOLS    := [ IFSYM,
  180.                                 THENSYM,
  181.                                 ELSESYM,
  182.                                 FORSYM,
  183.                                 WHILESYM,
  184.                                 WITHSYM,
  185.                                 COLON,
  186.                                 EQUALS ];
  187.          GOBBLETERMINATORS := [ ENDSYM,
  188.                                 UNTILSYM,
  189.                                 ELSESYM,
  190.                                 SEMICOLON ];
  191.       END;
  192.    WITH PPOPTION [ BECOMES ] DO
  193.       BEGIN
  194.          OPTIONSSELECTED   := [ SPACEBEFORE,
  195.                                 SPACEAFTER,
  196.                                 GOBBLESYMBOLS ];
  197.          DINDENTSYMBOLS    := [];
  198.          GOBBLETERMINATORS := [ ENDSYM,
  199.                                 UNTILSYM,
  200.                                 ELSESYM,
  201.                                 SEMICOLON ]
  202.       END;
  203.    WITH PPOPTION [ OPENCOMMENT ] DO
  204.       BEGIN
  205.          OPTIONSSELECTED   := [ CRSUPPRESS ];
  206.          DINDENTSYMBOLS    := [];
  207.           GOBBLETERMINATORS := []
  208.       END;
  209.    WITH PPOPTION [ CLOSECOMMENT ] DO
  210.       BEGIN
  211.          OPTIONSSELECTED   := [ CRSUPPRESS ];
  212.          DINDENTSYMBOLS    := [];
  213.          GOBBLETERMINATORS := []
  214.       END;
  215.    WITH PPOPTION [ SEMICOLON ] DO
  216.       BEGIN
  217.          OPTIONSSELECTED   := [ CRSUPPRESS,
  218.                                 DINDENTONKEYS,
  219.                                 CRAFTER ];
  220.          DINDENTSYMBOLS    := [ IFSYM,
  221.                                 THENSYM,
  222.                                 ELSESYM,
  223.                                 FORSYM,
  224.                                 WHILESYM,
  225.                                 WITHSYM,
  226.                                 COLON,
  227.                                 EQUALS ];
  228.          GOBBLETERMINATORS := []
  229.       END;
  230.    WITH PPOPTION [ COLON ] DO
  231.       BEGIN
  232.          OPTIONSSELECTED   := [ SPACEAFTER, 
  233.                                 INDENTTOCLP ];
  234.          DINDENTSYMBOLS    := [];
  235.          GOBBLETERMINATORS := []
  236.       END;
  237.    WITH PPOPTION [ EQUALS ] DO
  238.       BEGIN
  239.          OPTIONSSELECTED   := [ SPACEBEFORE,
  240.                                 SPACEAFTER,
  241.                                 INDENTTOCLP ];
  242.          DINDENTSYMBOLS    := [];
  243.          GOBBLETERMINATORS := []
  244.       END;
  245.    WITH PPOPTION [ OPENPAREN ] DO
  246.       BEGIN
  247.          OPTIONSSELECTED   := [ GOBBLESYMBOLS ];
  248.          DINDENTSYMBOLS    := [];
  249.          GOBBLETERMINATORS := [ CLOSEPAREN ]
  250.       END;
  251.    WITH PPOPTION [ CLOSEPAREN ] DO
  252.       BEGIN
  253.          OPTIONSSELECTED   := [];
  254.          DINDENTSYMBOLS    := [];
  255.          GOBBLETERMINATORS := []
  256.       END;
  257.    WITH PPOPTION [ PERIOD ] DO
  258.       BEGIN
  259.          OPTIONSSELECTED   := [ CRSUPPRESS ];
  260.          DINDENTSYMBOLS    := [];
  261.          GOBBLETERMINATORS := []
  262.       END;
  263.    WITH PPOPTION [ ENDOFFILE ] DO
  264.       BEGIN
  265.          OPTIONSSELECTED   := [];
  266.          DINDENTSYMBOLS    := [];
  267.          GOBBLETERMINATORS := []
  268.       END;
  269.    WITH PPOPTION [ OTHERSYM ] DO
  270.       BEGIN
  271.          OPTIONSSELECTED   := [];
  272.          DINDENTSYMBOLS    := [];
  273.          GOBBLETERMINATORS := []
  274.       END
  275. END; (* INITIALIZE2 *)
  276. PROCEDURE INITIALIZE( (* RETURNING *)
  277.                           VAR TOPOFSTACK  : INTEGER;
  278.                           VAR CURRLINEPOS,
  279.                               CURRMARGIN  : INTEGER;
  280.                           VAR KEYWORD     : KEYWORDTABLE;
  281.                           VAR DBLCHARS    : DBLCHRSET;
  282.                           VAR DBLCHAR     : DBLCHARTABLE;
  283.                           VAR SGLCHAR     : SGLCHARTABLE;
  284.                           VAR RECORDSEEN  : BOOLEAN;
  285.                           VAR CURRCHAR,
  286.                               NEXTCHAR    : CHARINFO;
  287.                           VAR CURRSYM,
  288.                               NEXTSYM     : SYMBOLINFO;
  289.                           VAR PPOPTION    : OPTIONTABLE   );
  290. BEGIN (* INITIALIZE *)
  291.    TOPOFSTACK  := 0;
  292.    CURRLINEPOS := 0;
  293.    CURRMARGIN  := 0;
  294.    KEYWORD [ PROGSYM    ] := 'PROGRAM   ' ;
  295.    KEYWORD [ FUNCSYM    ] := 'FUNCTION  ' ;
  296.    KEYWORD [ PROCSYM    ] := 'PROCEDURE ' ;
  297.    KEYWORD [ LABELSYM   ] := 'LABEL     ' ;
  298.    KEYWORD [ CONSTSYM   ] := 'CONST     ' ;
  299.    KEYWORD [ TYPESYM    ] := 'TYPE      ' ;
  300.    KEYWORD [ VARSYM     ] := 'VAR       ' ;
  301.    KEYWORD [ BEGINSYM   ] := 'BEGIN     ' ;
  302.    KEYWORD [ REPEATSYM  ] := 'REPEAT    ' ;
  303.    KEYWORD [ RECORDSYM  ] := 'RECORD    ' ;
  304.    KEYWORD [ CASESYM    ] := 'CASE      ' ;
  305.    KEYWORD [ CASEVARSYM ] := 'CASE      ' ;
  306.    KEYWORD [ OFSYM      ] := 'OF        ' ;
  307.    KEYWORD [ FORSYM     ] := 'FOR       ' ;
  308.    KEYWORD [ WHILESYM   ] := 'WHILE     ' ;
  309.    KEYWORD [ WITHSYM    ] := 'WITH      ' ;
  310.    KEYWORD [ DOSYM      ] := 'DO        ' ;
  311.    KEYWORD [ IFSYM      ] := 'IF        ' ;
  312.    KEYWORD [ THENSYM    ] := 'THEN      ' ;
  313.    KEYWORD [ ELSESYM    ] := 'ELSE      ' ;
  314.    KEYWORD [ ENDSYM     ] := 'END       ' ;
  315.    KEYWORD [ UNTILSYM   ] := 'UNTIL     ' ;
  316.    DBLCHARS := [ BECOMES, OPENCOMMENT ];
  317.    DBLCHAR [ BECOMES     ]  := ':=' ;
  318.    DBLCHAR [ OPENCOMMENT ]  := '(*' ;
  319.    SGLCHAR [ SEMICOLON  ]   := ';' ;
  320.    SGLCHAR [ COLON      ]   := ':' ;
  321.    SGLCHAR [ EQUALS     ]   := '=' ;
  322.    SGLCHAR [ OPENPAREN  ]   := '(' ;
  323.    SGLCHAR [ CLOSEPAREN ]   := ')' ;
  324.    SGLCHAR [ PERIOD     ]   := '.' ;
  325.    RECORDSEEN := FALSE;
  326.  SAWCOMOPEN := FALSE;
  327.  SAWCOMCLOSE := FALSE;
  328.  INACOMMENT := FALSE;
  329.  SAWQUOTEDSTRING := FALSE;
  330.    GETCHAR(
  331.             (* UPDATING *)  NEXTCHAR,
  332.             (* RETURNING *) CURRCHAR  );
  333.    NEW(CURRSYM);
  334.    NEW(NEXTSYM);
  335.    GETSYMBOL(
  336.               (* UPDATING *)  NEXTSYM,
  337.               (* RETURNING *) CURRSYM  );
  338.    WITH PPOPTION [ PROGSYM ] DO
  339.       BEGIN
  340.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  341.                                 SPACEAFTER ];
  342.          DINDENTSYMBOLS    := [];
  343.          GOBBLETERMINATORS := []
  344.       END;
  345.    WITH PPOPTION [ FUNCSYM ] DO
  346.       BEGIN
  347.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  348.                                 DINDENTONKEYS,
  349.                                 SPACEAFTER ];
  350.          DINDENTSYMBOLS    := [ LABELSYM,
  351.                                 CONSTSYM,
  352.                                 TYPESYM,
  353.                                 VARSYM ];
  354.          GOBBLETERMINATORS := []
  355.       END;
  356.    WITH PPOPTION [ PROCSYM ] DO
  357.       BEGIN
  358.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  359.                                 DINDENTONKEYS,
  360.                                 SPACEAFTER ];
  361.          DINDENTSYMBOLS    := [ LABELSYM,
  362.                                 CONSTSYM,
  363.                                 TYPESYM,
  364.                                 VARSYM ];
  365.          GOBBLETERMINATORS := []
  366.       END;
  367.    WITH PPOPTION [ LABELSYM ] DO
  368.       BEGIN
  369.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  370.                                 SPACEAFTER,
  371.                                 INDENTTOCLP,
  372.                                 CRAFTER ];
  373.          DINDENTSYMBOLS    := [];
  374.          GOBBLETERMINATORS := []
  375.       END;
  376.    WITH PPOPTION [ CONSTSYM ] DO
  377.       BEGIN
  378.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  379.                                 DINDENTONKEYS,
  380.                                 SPACEAFTER,
  381.                                 INDENTTOCLP,
  382.                                 CRAFTER ];
  383.          DINDENTSYMBOLS    := [ LABELSYM ];
  384.          GOBBLETERMINATORS := []
  385.       END;
  386.    WITH PPOPTION [ TYPESYM ] DO
  387.       BEGIN
  388.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  389.                                 DINDENTONKEYS,
  390.                                 SPACEAFTER,
  391.                                 INDENTTOCLP,
  392.                                 CRAFTER ];
  393.          DINDENTSYMBOLS    := [ LABELSYM,
  394.                                 CONSTSYM ];
  395.          GOBBLETERMINATORS := []
  396.       END;
  397.    WITH PPOPTION [ VARSYM ] DO
  398.       BEGIN
  399.          OPTIONSSELECTED   := [ BLANKLINEBEFORE,
  400.                                 DINDENTONKEYS,
  401.                                 SPACEAFTER,
  402.                                 INDENTTOCLP,
  403.                                 CRAFTER  ];
  404.          DINDENTSYMBOLS    := [ LABELSYM,
  405.                                 CONSTSYM,
  406.                                 TYPESYM ];
  407.          GOBBLETERMINATORS := []
  408.       END;
  409.    WITH PPOPTION [ BEGINSYM ] DO
  410.       BEGIN
  411.          OPTIONSSELECTED   := [ DINDENTONKEYS,
  412.                                 INDENTBYTAB,
  413.                                 CRAFTER ];
  414.          DINDENTSYMBOLS    := [ LABELSYM,
  415.                                 CONSTSYM,
  416.                                 TYPESYM,
  417.                                 VARSYM ];
  418.          GOBBLETERMINATORS := []
  419.       END;
  420.    WITH PPOPTION [ REPEATSYM ] DO
  421.       BEGIN
  422.          OPTIONSSELECTED   := [ INDENTBYTAB,
  423.                                 CRAFTER ];
  424.          DINDENTSYMBOLS    := [];
  425.          GOBBLETERMINATORS := []
  426.       END;
  427.    WITH PPOPTION [ RECORDSYM ] DO
  428.       BEGIN
  429.          OPTIONSSELECTED   := [ INDENTBYTAB,
  430.                                 CRAFTER ];
  431.          DINDENTSYMBOLS    := [];
  432.          GOBBLETERMINATORS := []
  433.       END;
  434.    WITH PPOPTION [ CASESYM ] DO
  435.       BEGIN
  436.          OPTIONSSELECTED   := [ SPACEAFTER,
  437.                                 INDENTBYTAB,
  438.                                 GOBBLESYMBOLS,
  439.                                 CRAFTER ];
  440.          DINDENTSYMBOLS    := [];
  441.          GOBBLETERMINATORS := [ OFSYM ]
  442.       END;
  443.    WITH PPOPTION [ CASEVARSYM ] DO
  444.       BEGIN
  445.          OPTIONSSELECTED   := [ SPACEAFTER,
  446.                                 INDENTBYTAB,
  447.                                 GOBBLESYMBOLS,
  448.                                 CRAFTER ];
  449.          DINDENTSYMBOLS    := [];
  450.          GOBBLETERMINATORS := [ OFSYM ]
  451.       END;
  452.  INT2 ( TOPOFSTACK, CURRLINEPOS, CURRMARGIN, KEYWORD, DBLCHARS, DBLCHAR,
  453.  SGLCHAR, RECORDSEEN, CURRCHAR, NEXTCHAR, CURRSYM, NEXTSYM, PPOPTION );
  454.  END;
  455.  (*    ******** M I S S I N G   D A T A   ***********          *)
  456.  (*
  457.   
  458.       BLCHAR,
  459.       SGLCHAR,
  460.       RECORDSEEN,
  461.       CURRCHAR,
  462.       NEXTCHAR, CURRSYM, NEXTSYM, PPOPTION );
  463.  END;
  464.   *)
  465.