home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts1.zip / ANTLR / SYN.H < prev    next >
C/C++ Source or Header  |  1993-09-02  |  7KB  |  234 lines
  1. /*
  2.  * syn.h
  3.  *
  4.  * $Id: syn.h,v 1.8 1993/08/10 17:10:00 pccts Exp pccts $
  5.  * $Revision: 1.8 $
  6.  *
  7.  * This file includes definitions and macros associated with syntax diagrams
  8.  *
  9.  * SOFTWARE RIGHTS
  10.  *
  11.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  12.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  13.  * company may do whatever they wish with source code distributed with
  14.  * PCCTS or the code generated by PCCTS, including the incorporation of
  15.  * PCCTS, or its output, into commerical software.
  16.  * 
  17.  * We encourage users to develop software with PCCTS.  However, we do ask
  18.  * that credit is given to us for developing PCCTS.  By "credit",
  19.  * we mean that if you incorporate our source code into one of your
  20.  * programs (commercial product, research project, or otherwise) that you
  21.  * acknowledge this fact somewhere in the documentation, research report,
  22.  * etc...  If you like PCCTS and have developed a nice tool with the
  23.  * output, please mention that you developed it using PCCTS.  In
  24.  * addition, we ask that this header remain intact in our source code.
  25.  * As long as these guidelines are kept, we expect to continue enhancing
  26.  * this system and expect to make other tools available as they are
  27.  * completed.
  28.  *
  29.  * ANTLR 1.10
  30.  * Terence Parr
  31.  * Purdue University
  32.  * 1989-1993
  33.  */
  34.  
  35. #define NumNodeTypes    4
  36. #define NumJuncTypes    9
  37.  
  38. /* List the different node types */
  39. #define nJunction        1
  40. #define nRuleRef        2
  41. #define nToken            3
  42. #define nAction            4
  43.  
  44. /* Different types of junctions */
  45. #define aSubBlk            1
  46. #define aOptBlk            2
  47. #define aLoopBlk        3
  48. #define EndBlk            4
  49. #define RuleBlk            5
  50. #define Generic            6    /* just a junction--no unusual characteristics */
  51. #define EndRule            7
  52. #define aPlusBlk        8
  53. #define aLoopBegin        9
  54.  
  55. typedef int NodeType;
  56.  
  57. #define TreeBlockAllocSize        500
  58. #define JunctionBlockAllocSize    200
  59. #define ActionBlockAllocSize    50
  60. #define RRefBlockAllocSize        100
  61. #define TokenBlockAllocSize        100
  62.  
  63. /* note that 'right' is used by the tree node allocator as a ptr for linked list */
  64. typedef struct _tree {
  65.             struct _tree *down, *right;
  66.             int token;
  67.             union {
  68.                 int rk;    /* if token==EpToken, => how many more tokens req'd */
  69.                 struct _tree *tref;    /* if token==TREE_REF */
  70.                 set sref;            /* if token==SET */
  71.             } v;
  72.         } Tree;
  73.  
  74. /* a predicate is defined to be a predicate action and a token tree with context info */
  75. /* later, this struct may include the "hoisting distance" when we hoist past tokens. */
  76. typedef struct _Predicate {
  77.     char *expr;
  78.     Tree *tcontext;    /* used if lookahead depth of > one is needed (tree) */
  79.     set completion;    /* which lookahead depths are required to complete tcontext? */
  80.     set scontext[2];/* used if lookahead depth of one is needed (set) */
  81.                     /* scontext[0] is not used; only needed so genExprSets()
  82.                        routine works (it expects an array)
  83.                      */
  84.     struct _Predicate *next;
  85. } Predicate;
  86.  
  87.                 /* M e s s a g e  P a s s i n g  T o  N o d e s */
  88.  
  89. /*
  90.  * assumes a 'Junction *r' exists.  This macro calls a function with
  91.  * the pointer to the node to operate on and a pointer to the rule
  92.  * in which it is enclosed.
  93.  */
  94. #define TRANS(p)    {if ( (p)==NULL ) fatal("TRANS: NULL object");        \
  95.                     if ( (p)->ntype == nJunction ) (*(fpJTrans[((Junction *)(p))->jtype]))( p );\
  96.                     else (*(fpTrans[(p)->ntype]))( p );}
  97.  
  98. #define PRINT(p)    {if ( (p)==NULL ) fatal("PRINT: NULL object");\
  99.                     (*(fpPrint[(p)->ntype]))( p );}
  100.  
  101. #define REACH(p,k,rk,a) {if ( (p)==NULL ) fatal("REACH: NULL object");\
  102.                     (a) = (*(fpReach[(p)->ntype]))( p, k, rk );}
  103.  
  104. #define TRAV(p,k,rk,a) {if ( (p)==NULL ) fatal("TRAV: NULL object");\
  105.                     (a) = (*(fpTraverse[(p)->ntype]))( p, k, rk );}
  106.  
  107. /* All syntax diagram nodes derive from Node -- superclass
  108.  */
  109. #ifdef __cplusplus
  110. class Node {
  111. public:
  112.             NodeType ntype;
  113.         };
  114. #else
  115. typedef struct _node {
  116.             NodeType ntype;
  117.         } Node;
  118. #endif
  119.  
  120. #ifdef __cplusplus
  121. class ActionNode : public Node {
  122. public:
  123. #else
  124. typedef struct _anode {
  125.             NodeType ntype;
  126. #endif
  127.             Node *next;
  128.             char *action;
  129.             int file;            /* index in FileStr (name of file with action) */
  130.             int line;            /* line number that action occurs on */
  131.             int is_predicate;    /* true if action is a <<...>>? predicate action */
  132.             int done;            /* don't dump if action dumped (used for predicates) */
  133.             int init_action;    /* is this the 1st action of 1st prod of block? */
  134.             char *pred_fail;    /* what to do/print when predicate fails */
  135. #ifdef __cplusplus
  136.         };
  137. #else
  138.         } ActionNode;
  139. #endif
  140.  
  141. #ifdef __cplusplus
  142. class TokNode : public Node {
  143. public:
  144. #else
  145. typedef struct _toknode {
  146.             NodeType ntype;
  147. #endif
  148.             Node *next;
  149.             char *rname;        /* name of rule it's in */
  150.             int file;            /* index in FileStr (name of file with rule) */
  151.             int line;            /* line number that token occurs on */
  152.             int token;
  153.             int label;            /* token label or expression ? */
  154.             int astnode;        /* leaf/root/excluded (used to build AST's) */
  155. #ifdef __cplusplus
  156.         };
  157. #else
  158.         } TokNode;
  159. #endif
  160.  
  161. #ifdef __cplusplus
  162. class RuleRefNode : public Node {
  163. public:
  164. #else
  165. typedef struct _rrnode {
  166.             NodeType ntype;
  167. #endif
  168.             Node *next;
  169.             char *rname;        /* name of rule it's in */
  170.             int file;            /* index in FileStr (name of file with rule)
  171.                                    it's in */
  172.             int line;            /* line number that rule ref occurs on */
  173.             char *text;            /* reference to which rule */
  174.             char *parms;        /* point to parameters of rule invocation
  175.                                    (if present) */
  176.             char *assign;        /* point to left-hand-side of assignment
  177.                                    (if any) */
  178.             int linked;            /* Has a FoLink already been established? */
  179.             int astnode;        /* excluded? (used to build AST's) */
  180. #ifdef __cplusplus
  181.         };
  182. #else
  183.         } RuleRefNode;
  184. #endif
  185.  
  186. #ifdef __cplusplus
  187. class Junction : public Node {
  188. public:
  189. #else
  190. typedef struct _junct {
  191.             NodeType ntype;
  192. #endif
  193.             int visited;        /* used by recursive routines to avoid
  194.                                    infinite recursion */
  195.             int pvisited;        /* used by print routines to avoid
  196.                                    infinite recursion */
  197.             char *lock;            /* used by REACH to track infinite recursion */
  198.             char *pred_lock;    /* used by find_predicates to track infinite recursion */
  199.             int altnum;            /* used in subblocks. altnum==0 means not an
  200.                                    alt of subrule */
  201.             int jtype;            /* annotation for code-gen/FIRST/FOLLOW.
  202.                                    Junction type */
  203. #ifdef __cplusplus
  204.             Junction *end;        /* pointer to node with EndBlk in it
  205.                                    if blk == a block type */
  206. #else
  207.             struct _junct *end;    /* pointer to node with EndBlk in it
  208.                                    if blk == a block type */
  209. #endif
  210.             Node *p1, *p2;
  211.             char *rname;        /* name of rule junction is in */
  212.             int file;            /* index in FileStr (name of file with rule)
  213.                                    if blk == RuleBlk */
  214.             int line;            /* line number that rule occurs on */
  215.             int halt;            /* never move past a junction with halt==TRUE */
  216.             char *pdecl;        /* point to declaration of parameters on rule
  217.                                    (if present) */
  218.             char *parm;            /* point to parameter of block invocation
  219.                                    (if present) */
  220.             char *ret;            /* point to return type of rule (if present) */
  221.             char *erraction;    /* point to error action (if present) */
  222.             int blockid;        /* if start of block, then this is a unique ID */
  223.             set *fset;            /* used for code generation */
  224.             Tree *ftree;        /* used for code generation */
  225.             Predicate *predicate;/* predicate that can be used to disambiguate */
  226.             int guess;            /* true if (...)? block */
  227. #ifdef __cplusplus
  228.         };
  229. #else
  230.         } Junction;
  231. #endif
  232.  
  233. typedef struct { Node *left, *right; } Graph;
  234.