home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts.zip / pccts / lang / Pascal / pascal.g < prev    next >
Text File  |  1994-03-31  |  6KB  |  307 lines
  1. /*
  2.  * File: pascal.g
  3.  *
  4.  * P a s c a l  G r a m m a r
  5.  *
  6.  * Some of the grammar could be more readable if it were spread out.  However,
  7.  * to show the concise nature of ANTLR, I am squishing it (show off).
  8.  * Theoretically, it would be possible to put the entire grammar into one
  9.  * rule with lots-o-parenthesis and duplicate subrules.
  10.  *
  11.  * This grammar is considered Public Domain and is distributed as is.
  12.  *
  13.  * Terence Parr 1990
  14.  * Purdue University
  15.  * January 1990
  16.  *
  17.  * Modified by Will Cohen 12/17/90
  18.  * Fixed {..} , (..)* bug in expressions, 11-92
  19.  */
  20. #header <<
  21.  
  22. #include "sym.h"
  23. #include "pascal.h"
  24. extern Sym *CurSym;
  25.  
  26. >>
  27.  
  28. <<
  29. Sym *CurSym;
  30. static int level = 0;
  31. >>
  32.  
  33. /* made special tokens for key words to simplify lexical analyser */
  34. #token And
  35. #token Array
  36. #token Begin
  37. #token Case
  38. #token Const
  39. #token Div
  40. #token Do
  41. #token Downto
  42. #token Else
  43. #token End
  44. #token File
  45. #token For
  46. #token Forward
  47. #token Function
  48. #token Goto
  49. #token If
  50. #token In
  51. #token Label
  52. #token Mod
  53. #token Nil
  54. #token Not
  55. #token Of
  56. #token Or
  57. #token Packed
  58. #token Procedure
  59. #token Program
  60. #token Record
  61. #token Repeat
  62. #token Set
  63. #token Then
  64. #token To
  65. #token Type
  66. #token Until
  67. #token Var
  68. #token While
  69. #token With
  70.  
  71. /* things to specify identifiers */
  72. #token TypeID
  73. #token UTypeID
  74. #token VarID
  75. #token ProcID
  76. #token ProgID
  77. #token FuncID
  78. #token ConstID
  79.  
  80. /* white space */
  81. #token "[\t\ ]"            << zzskip(); >>
  82. #token "[\n\r]"            << zzline++; zzskip(); >>
  83.  
  84. /* signal start of a comment */
  85. #token "\{"            << zzmode(COMMENT); zzskip();>>
  86. #token "\(\*"            << zzmode(COMMENT); zzskip();>>
  87.  
  88. /* G r o s s  S y n t a x  C o n t r o l */
  89.  
  90.  
  91. program    :    <<Sym *globals=NULL, *p;>>
  92.         Program nonReserved    
  93.         <<make_special_entry(ProgID,$2);
  94.           printf("program %s level %d:\n\n", $2->symbol, level);
  95.            zzs_scope(&globals);
  96.         >>
  97.         "\(" idList "\)"    <<addlist($4,VarID,level);>>
  98.         ";"
  99.         block "."
  100.         <<
  101.           p = zzs_rmscope(&globals);
  102.           printf("global (level %d) symbols:", level);
  103.           for (; p != NULL; p=p->scope)
  104.             printf(" %s", p->symbol);
  105.           printf("\n\n");
  106.         >>
  107.         "@"
  108.     ;
  109.  
  110. block    :    <<Sym **oldscope = zzs_scope(NULL); >>
  111.         decl 
  112.         ( routine <<zzs_scope(oldscope);>> )*
  113.         Begin
  114.             slist
  115.         End
  116.     ;
  117.  
  118. routine    : <<int tok; Sym *p,*locals=NULL;>>
  119.         ( Procedure <<tok=ProcID;>> | Function <<tok=FuncID;>>)
  120.         nonReserved << $2 = make_special_entry(tok,$2);>>
  121.         <<zzs_scope(&locals); level++; >>
  122.         {"\(" parmGroup (";" parmGroup)* "\)"}
  123.         { ":" (TypeID | UTypeID) }
  124.         ";"
  125.         block ";"
  126.         <<
  127.           p = zzs_rmscope(&locals);
  128.           printf("subprogram %s level %d:\n", $2->symbol, --level);
  129.           printf("local (level %d) symbols:", level+1);
  130.           for (; p != NULL; p=p->scope) printf(" %s", p->symbol);
  131.           printf("\n\n");
  132.         >>
  133.     ;
  134.  
  135. parmGroup : {Var} idList ":" (TypeID | UTypeID) <<addlist($2,VarID,level);>> ;
  136.  
  137. slist    : label ( ";" label )* ;
  138.  
  139. label    : {UINT ":"} statement ;
  140.  
  141. statement    : (var | FuncID ) ":=" expr
  142.         | ProcID { "\(" expr ("," expr)* "\)" }
  143.         | Begin slist End
  144.  
  145.         | If expr Then statement { Else statement}
  146.         | Case expr Of
  147.             (constant ("," constant)* ":" statement ";")*
  148.             End
  149.         | While expr Do statement
  150.         | Repeat slist Until expr
  151.         | For VarID ":=" expr ( To| Downto ) expr Do statement
  152.         | With var ( "," var )* Do statement
  153.         | Goto UINT
  154.         | /* empty statement */
  155.         ;
  156.  
  157.  
  158. /* D e c l a r a t i o n  S e c t i o n */
  159.  
  160.  
  161. decl    : ( LABEL UINT ( "," UINT )* ";")*
  162.         { Const nonReserved "=" constant
  163.             <<make_special_entry(ConstID,$2);>>
  164.             ";"
  165.             ( nonReserved "=" constant
  166.                 <<make_special_entry(ConstID,$1);>>
  167.                 ";"
  168.             )*
  169.         }
  170.         { Type nonReserved "=" type
  171.             <<make_special_entry(UTypeID,$2);>>
  172.             ";"
  173.             ( nonReserved "=" type
  174.                 <<make_special_entry(UTypeID,$1);>>
  175.                 ";"
  176.             )*
  177.         }
  178.         { Var idList ":" type ";"    <<addlist($2,VarID,level);>>
  179.             ( idList ":" type ";"    <<addlist($1,VarID,level);>>
  180.             )*
  181.         }
  182.     ;
  183.  
  184. /* tokens than can be redefined in a new scope */
  185. nonReserved    : UTypeID    << $0 = $1; >>
  186.         | VarID        << $0 = $1; >>
  187.         | ProcID    << $0 = $1; >>
  188.         | ProgID    << $0 = $1; >>
  189.         | FuncID    << $0 = $1; >>
  190.         | ConstID    << $0 = $1; >>
  191.         | WORD        << $0 = $1; >>
  192.         ;
  193.  
  194. simpleType    : (TypeID | UTypeID)
  195.         | "\(" wordList <<addlist($2,ConstID,level);>> "\)"
  196.         | constant ".." constant
  197.         ;
  198.  
  199. type        : simpleType
  200.         /* since pointers to types can be defined before actual type*/
  201.         | "^" (TypeID | nonReserved)
  202.         | {Packed} structType
  203.         ;
  204.  
  205. structType    : Array "\[" simpleType ("," simpleType)* "\]" Of type
  206.         | File Of type
  207.         | Set Of simpleType
  208.         | Record fixedPart {";"} (fixedPart {";"} )* {variantPart} End
  209.         ;
  210.  
  211. fixedPart    : idList ":" type
  212.         ;
  213.  
  214. variantPart    : Case {WORD ":"}
  215.             (TypeID | UTypeID) Of variant {";"} (variant {";"})*
  216.         ;
  217.  
  218. variant        : constant ( "," constant )* ":"
  219.             "\(" fixedPart {";"} (fixedPart {";"})* 
  220.             {variantPart} "\)"
  221.         ;
  222.  
  223. /* Use 'link' field of symbol rec to link elements together into idlist */
  224. idList    : <<Sym *list=NULL;>>    /* Return list of id's */
  225.         nonReserved        << $1->link = list; list = $1; >>
  226.         ( "," nonReserved    << $2->link = list; list = $2; >>
  227.         )*
  228.         <<$0 = list;>>
  229.     ;
  230.  
  231. wordList: <<Sym *list=NULL;>>            /* Return list of words */
  232.         WORD        <<$1->link = list; list=$1;>>
  233.         ( "," WORD    <<$2->link = list; list=$2;>>
  234.         )*
  235.                 <<$0 = list;>>
  236.     ;
  237.  
  238. constant : {"\+"|"\-"} (ConstID | UINT { "." UINT {"E" {"\+"|"\-"} UINT}})
  239.     | Nil
  240.     | LITERAL
  241.     ;
  242.  
  243. uconstant : ConstID
  244.     /* floating point number */
  245.     | UINT { "." UINT {"E" {"\+"|"\-"} UINT}}
  246.     | Nil
  247.     | LITERAL
  248.     ;
  249.             
  250.  
  251. /* E x p r e s s i o n  S e c t i o n */
  252.  
  253.  
  254. expr    : simpleExpr (("="|"\<"|"\>"|"\<\>"|"\<="|"\>="| In ) simpleExpr)* ;
  255.  
  256. simpleExpr    : {"\+"|"\-"} term (("\+"|"\-"| Or ) term)* ;
  257.  
  258. term    : factor (("\*"|"/"| Div | Mod | And ) factor)* ;
  259.  
  260. factor    : uconstant
  261.     | var
  262.     | FuncID { "\(" expr ("," expr)* "\)" }
  263.     | "\(" expr "\)"
  264.     | Not factor
  265.     | "\[" {expr {".." expr}} ("," expr {".." expr})* "\]"
  266.     ;
  267.  
  268. var    : VarID ref
  269.     | WORD ref    <</* NOTE error if not defined before use */>>
  270.     ;
  271.  
  272. ref    : "\[" expr ("," expr)* "\]" ref
  273.     | "^" ref
  274.     | "." (WORD <</*NOTE error*/>>|VarID) ref
  275.     |
  276.     ;
  277.  
  278. #token LITERAL "' ~[\0-\31']* '"
  279. #token UINT "[0-9]+"
  280. #token WORD "[a-zA-Z] [a-zA-Z0-9]*"
  281.         <<
  282.         {
  283.             register Sym *p;
  284.  
  285.             p = zzs_get(zzlextext);
  286.             if ( p == NULL ){
  287.                 p = zzs_newadd(zzlextext);
  288.                 p->token = WORD;
  289.             }else{ 
  290.                 NLA = p->token;
  291.             }
  292.             CurSym = p;
  293.         }
  294.         >>
  295.  
  296. /* special automaton to skip over comments */
  297. #lexclass COMMENT
  298. /* ends of comments */
  299. #token "\*\)"            << zzmode(START); zzskip(); >>
  300. #token "\}"            << zzmode(START); zzskip(); >>
  301.  
  302. #token "[\n\r]"            << zzline++; zzskip(); >>
  303.  
  304. #token "\*"            << zzskip(); >>
  305. #token "~[\*\}\n\r]+"        << zzskip(); >>
  306.  
  307.