auto commit for import

diff --git a/antlr/hash.h b/antlr/hash.h
new file mode 100755 (executable)
index 0000000..60a3417
--- /dev/null
+++ b/antlr/hash.h
@@ -0,0 +1,62 @@
+/*
+ * hash.h -- define hash table entries, sizes, hash function...
+ *
+ * $Id: hash.h,v 1.2 95/06/15 18:06:57 parrt Exp $
+ * $Revision: 1.2 $
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ * 
+ * We encourage users to develop software with PCCTS.  However, we do ask
+ * that credit is given to us for developing PCCTS.  By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc...  If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS.  In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-1995
+ */
+
+                               /* H a s h  T a b l e  S t u f f */
+
+#ifndef HashTableSize
+#define HashTableSize  553
+#endif
+#ifndef StrTableSize
+#define StrTableSize   1000000
+#endif
+
+typedef struct _entry {                /* Minimum hash table entry -- superclass */
+                       char *str;
+                       struct _entry *next;
+               } Entry;
+
+/* Hash 's' using 'size', place into h (s is modified) */
+#define Hash(s,h,size)                                                         \
+       {while ( *s != '\0' ) h = (h<<1) + *s++;                \
+       h %= size;}
+
+#ifdef __STDC__
+Entry  *hash_get(Entry **, char *),
+               **newHashTable(void),
+               *hash_add(Entry **, char *, Entry *);
+
+void   killHashTable(Entry **);
+
+#else
+Entry *hash_get(), **newHashTable(), *hash_add();
+#endif

diff --git a/antlr/proto.h b/antlr/proto.h
new file mode 100755 (executable)
index 0000000..5bfa428
--- /dev/null
+++ b/antlr/proto.h
@@ -0,0 +1,543 @@
+/*
+ * proto.h -- function prototypes
+ *
+ * $Id: proto.h,v 1.7 95/10/05 11:56:59 parrt Exp $
+ * $Revision: 1.7 $
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ * 
+ * We encourage users to develop software with PCCTS.  However, we do ask
+ * that credit is given to us for developing PCCTS.  By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc...  If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS.  In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-1995
+ */
+
+                           /* V a r i a b l e s */
+
+extern int tp;
+extern Junction *SynDiag;
+extern char Version[];
+extern char VersionDef[];
+#ifdef __cplusplus
+extern void (*fpPrint[])(...);
+#else
+extern void (*fpPrint[])();
+#endif
+#ifdef __cplusplus
+extern struct _set (*fpReach[])(...);
+#else
+extern struct _set (*fpReach[])();
+#endif
+#ifdef __cplusplus
+extern struct _tree *(*fpTraverse[])(...);
+#else
+extern struct _tree *(*fpTraverse[])();
+#endif
+#ifdef __cplusplus
+extern void (**fpTrans)(...);
+#else
+extern void (**fpTrans)();
+#endif
+#ifdef __cplusplus
+extern void (**fpJTrans)(...);
+#else
+extern void (**fpJTrans)();
+#endif
+#ifdef __cplusplus
+extern void (*C_Trans[NumNodeTypes+1])(...);
+#else
+extern void (*C_Trans[])();
+#endif
+#ifdef __cplusplus
+extern void (*C_JTrans[NumJuncTypes+1])(...);
+#else
+extern void (*C_JTrans[])();
+#endif
+extern int BlkLevel;
+extern int CurFile;
+extern char *CurRule;
+extern Junction *CurRuleBlk;
+extern RuleEntry *CurRuleNode;
+extern ListNode *CurElementLabels;
+extern char *FileStr[];
+extern int NumFiles;
+extern int EpToken;
+extern int WildCardToken;
+extern Entry   **Tname,
+                               **Texpr,
+                               **Rname,
+                               **Fcache,
+                               **Tcache,
+                               **Elabel,
+                               **Sname;
+extern ListNode *ExprOrder;
+extern ListNode **Cycles;
+extern int TokenNum;
+extern int LastTokenCounted;
+extern ListNode *BeforeActions, *AfterActions, *LexActions;
+extern ListNode *eclasses, *tclasses;
+extern char    *HdrAction;
+extern FILE    *ErrFile;
+extern char *RemapFileName;
+extern char *ErrFileName;
+extern char *DlgFileName;
+extern char *DefFileName;
+extern char *ModeFileName;
+extern int NumRules;
+extern Junction **RulePtr;
+extern int LL_k;
+extern int CLL_k;
+extern char *decodeJType[];
+extern int PrintOut;
+extern int PrintAnnotate;
+extern int CodeGen;
+extern int LexGen;
+extern int esetnum;
+extern int setnum;
+extern int wordnum;
+extern int GenAST;
+extern int GenANSI;
+extern int **FoStack;
+extern int **FoTOS;
+extern int GenExprSets;
+extern FILE *DefFile;
+extern int CannotContinue;
+extern int GenCR;
+extern int GenLineInfo;
+extern int action_file, action_line;
+extern int TraceGen;
+extern int CurAmbigAlt1, CurAmbigAlt2, CurAmbigline, CurAmbigfile;
+extern char *CurAmbigbtype;
+extern int elevel;
+extern int GenEClasseForRules;
+extern FILE *input, *output;
+extern char **TokenStr, **ExprStr;
+extern int CurrentLexClass, NumLexClasses;
+extern LClass lclass[];
+extern char LexStartSymbol[];
+extern char    *CurRetDef;
+extern char    *CurParmDef;
+extern int OutputLL_k;
+extern int TreeResourceLimit;
+extern int DemandLookahead;
+extern char *RulePrefix;
+extern int GenStdPccts;
+extern char *stdpccts;
+extern int ParseWithPredicates;
+extern int ConstrainSearch;
+extern int FoundGuessBlk;
+extern int FoundException;
+extern int WarningLevel;
+extern int pLevel;
+extern int pAlt1;
+extern int pAlt2;
+extern int AImode;
+extern int HoistPredicateContext;
+extern int GenCC;
+extern char *ParserName;
+extern char *StandardSymbols[];
+extern char *ASTSymbols[];
+extern set reserved_positions;
+extern set all_tokens;
+extern set imag_tokens;
+extern set tokclasses;
+extern ListNode *ForcedTokens;
+extern int *TokenInd;
+extern FILE *Parser_h, *Parser_c;
+extern char CurrentClassName[];
+extern int no_classes_found;
+extern char Parser_h_Name[];
+extern char Parser_c_Name[];
+extern ListNode *class_before_actions, *class_after_actions;
+extern char *UserTokenDefsFile;
+extern int UserDefdTokens;
+extern ListNode *MetaTokenNodes;
+extern char *OutputDirectory;
+extern int DontCopyTokens;
+extern set AST_nodes_refd_in_actions;
+extern ListNode *CurExGroups;
+extern int CurBlockID;
+extern int CurAltNum;
+extern Junction *CurAltStart;
+extern ExceptionGroup *DefaultExGroup;
+extern int NumSignals;
+extern int ContextGuardTRAV;
+
+
+
+#ifdef __USE_PROTOS
+extern void istackreset(void);
+extern int istacksize(void);
+extern void pushint(int);
+extern int popint( void );
+extern int istackempty( void );
+extern int topint( void );
+extern void NewSetWd( void );
+extern void DumpSetWd( void );
+extern void DumpSetWdForC( void );
+extern void DumpSetWdForCC( void );
+extern void NewSet( void );
+extern void FillSet( set );
+extern void ComputeErrorSets( void );
+extern void ComputeTokSets( void );
+extern void SubstErrorClass( set * );
+extern int DefErrSet( set *, int, char * );
+extern int DefErrSetForC( set *, int, char * );
+extern int DefErrSetForCC( set *, int, char * );
+extern void GenErrHdr( void );
+extern void dumpExpr( FILE *, char * );
+extern void addParm( Node *, char * );
+extern Graph buildAction( char *, int, int, int );
+extern Graph buildToken( char * );
+extern Graph buildWildCard( char * );
+extern Graph buildRuleRef( char * );
+extern Graph Or( Graph, Graph );
+extern Graph Cat( Graph, Graph );
+extern Graph makeOpt( Graph, int );
+extern Graph makeBlk( Graph, int );
+extern Graph makeLoop( Graph, int );
+extern Graph makePlus( Graph, int );
+extern Graph emptyAlt( void );
+extern TokNode * newTokNode( void );
+extern RuleRefNode * newRNode( void );
+extern Junction * newJunction( void );
+extern ActionNode * newActionNode( void );
+extern char * makelocks( void );
+extern void preorder( Tree * );
+extern Tree * tnode( int );
+extern void _Tfree( Tree * );
+extern Tree * tdup( Tree * );
+extern int is_single_tuple( Tree * );
+extern Tree * tappend( Tree *, Tree * );
+extern void Tfree( Tree * );
+extern Tree * tlink( Tree *, Tree *, int );
+extern Tree * tshrink( Tree * );
+extern Tree * tflatten( Tree * );
+extern Tree * tJunc( Junction *, int, set * );
+extern Tree * tRuleRef( RuleRefNode *, int, set * );
+extern Tree * tToken( TokNode *, int, set * );
+extern Tree * tAction( ActionNode *, int, set * );
+extern int tmember( Tree *, Tree * );
+extern int tmember_constrained( Tree *, Tree * );
+extern Tree * tleft_factor( Tree * );
+extern Tree * trm_perm( Tree *, Tree * );
+extern void tcvt( set *, Tree * );
+extern Tree * permute( int, int );
+extern Tree * VerifyAmbig( Junction *, Junction *, unsigned **, set *, Tree **, Tree **, int * );
+extern set rJunc( Junction *, int, set * );
+extern set rRuleRef( RuleRefNode *, int, set * );
+extern set rToken( TokNode *, int, set * );
+extern set rAction( ActionNode *, int, set * );
+extern void HandleAmbiguity( Junction *, Junction *, Junction *, int );
+extern set First( Junction *, int, int, int * );
+extern void freeBlkFsets( Junction * );
+extern void genAction( ActionNode * );
+extern void genRuleRef( RuleRefNode * );
+extern void genToken( TokNode * );
+extern void genOptBlk( Junction * );
+extern void genLoopBlk( Junction *, Junction *, Junction *, int );
+extern void genLoopBegin( Junction * );
+extern void genPlusBlk( Junction * );
+extern void genSubBlk( Junction * );
+extern void genRule( Junction * );
+extern void genJunction( Junction * );
+extern void genEndBlk( Junction * );
+extern void genEndRule( Junction * );
+extern void genHdr( int );
+extern void genHdr1( int );
+extern void dumpAction( char *, FILE *, int, int, int, int );
+extern Entry ** newHashTable( void );
+extern Entry * hash_add( Entry **, char *, Entry * );
+extern Entry * hash_get( Entry **, char * );
+extern void hashStat( Entry ** );
+extern char * mystrdup( char * );
+extern void genLexDescr( void );
+extern void dumpLexClasses( FILE * );
+extern void genDefFile( void );
+extern void DumpListOfParmNames( char *, FILE * );
+extern int DumpNextNameInDef( char **, FILE * );
+extern void DumpOldStyleParms( char *, FILE * );
+extern void DumpType( char *, FILE * );
+extern int strmember( char *, char * );
+extern int HasComma( char * );
+extern void DumpRetValStruct( FILE *, char *, int );
+extern char * StripQuotes( char * );
+extern int main( int, char *[] );
+extern void readDescr( void );
+extern FILE * NextFile( void );
+extern char * outname( char * );
+extern void fatalFL( char *, char *, int );
+extern void fatal_intern( char *, char *, int );
+extern void cleanUp( void );
+extern char * eMsg3( char *, char *, char *, char * );
+extern char * eMsgd( char *, int );
+extern void s_fprT( FILE *, set );
+extern char * TerminalString( int );
+extern void lexclass( char * );
+extern void lexmode( int );
+extern int LexClassIndex( char * );
+extern int hasAction( char * );
+extern void setHasAction( char *, char * );
+extern int addTname( char * );
+extern int addTexpr( char * );
+extern int Tnum( char * );
+extern void Tklink( char *, char * );
+extern Entry * newEntry( char *, int );
+extern void list_add( ListNode **, void * );
+extern void list_apply( ListNode *, void (*)(void *) );
+extern char * Fkey( char *, int, int );
+extern void FoPush( char *, int );
+extern void FoPop( int );
+extern void RegisterCycle( char *, int );
+extern void ResolveFoCycles( int );
+extern void pJunc( Junction * );
+extern void pRuleRef( RuleRefNode * );
+extern void pToken( TokNode * );
+extern void pAction( ActionNode * );
+extern void FoLink( Node * );
+extern void addFoLink( Node *, char *, Junction * );
+extern void GenCrossRef( Junction * );
+extern void defErr( char *, long, long, long, long, long, long );
+extern void genStdPCCTSIncludeFile(FILE *);
+extern Predicate *find_predicates(Node *);
+extern void GenRulePrototypes(FILE *, Junction *);
+extern Junction *first_item_is_guess_block(Junction *);
+extern Junction *analysis_point(Junction *);
+extern Tree *make_tree_from_sets(set *, set *);
+extern Tree *tdup_chain(Tree *);
+extern Tree *tdif(Tree *, Predicate *, set *, set *);
+extern set covered_set(Predicate *);
+extern void AmbiguityDialog(Junction *, int, Junction *, Junction *, int *, int *);
+extern void dumpAmbigMsg(set *, FILE *, int);
+extern void GenRuleFuncRedefs(FILE *, Junction *);
+extern void GenPredefinedSymbolRedefs(FILE *);
+extern void GenASTSymbolRedefs(FILE *);
+extern void GenRemapFile(void);
+extern void GenSetRedefs(FILE *);
+extern ForcedToken *newForcedToken(char *, int);
+extern void RemapForcedTokens(void);
+extern char *TokenOrExpr(int);
+extern void setUpperRange(TokNode *, char *);
+extern void GenParser_c_Hdr(void);
+extern void GenParser_h_Hdr(void);
+extern void GenRuleMemberDeclarationsForCC(FILE *, Junction *);
+extern int addForcedTname( char *, int );
+extern char *OutMetaName(char *);
+extern void warnNoFL(char *err);
+extern void warnFL(char *err,char *f,int l);
+extern void warn(char *err);
+extern void warnNoCR( char *err );
+extern void errNoFL(char *err);
+extern void errFL(char *err,char *f,int l);
+extern void err(char *err);
+extern void errNoCR( char *err );
+extern Tree *tmake(Tree *root, ...);
+extern void genPredTree( Predicate *p, Node *j, int );
+extern UserAction *newUserAction(char *);
+extern char *gate_symbol(char *name);
+extern char *makeAltID(int blockid, int altnum);
+extern void DumpRemainingTokSets();
+extern void DumpANSIFunctionArgDef(FILE *f, Junction *q);
+extern Predicate *computePredicateFromContextGuard(Graph);
+extern Predicate *new_pred(void);
+extern void chkGTFlag(void);
+#else
+extern void istackreset();
+extern int istacksize();
+extern void pushint();
+extern int popint();
+extern int istackempty();
+extern int topint();
+extern void NewSetWd();
+extern void DumpSetWd();
+extern void DumpSetWdForC();
+extern void DumpSetWdForCC();
+extern void NewSet();
+extern void FillSet();
+extern void ComputeErrorSets();
+extern void ComputeTokSets();
+extern void SubstErrorClass();
+extern int DefErrSet();
+extern int DefErrSetForC();
+extern int DefErrSetForCC();
+extern void GenErrHdr();
+extern void dumpExpr();
+extern void addParm();
+extern Graph buildAction();
+extern Graph buildToken();
+extern Graph buildWildCard();
+extern Graph buildRuleRef();
+extern Graph Or();
+extern Graph Cat();
+extern Graph makeOpt();
+extern Graph makeBlk();
+extern Graph makeLoop();
+extern Graph makePlus();
+extern Graph emptyAlt();
+extern TokNode * newTokNode();
+extern RuleRefNode * newRNode();
+extern Junction * newJunction();
+extern ActionNode * newActionNode();
+extern char * makelocks();
+extern void preorder();
+extern Tree * tnode();
+extern void _Tfree();
+extern Tree * tdup();
+extern int is_single_tuple();
+extern Tree * tappend();
+extern void Tfree();
+extern Tree * tlink();
+extern Tree * tshrink();
+extern Tree * tflatten();
+extern Tree * tJunc();
+extern Tree * tRuleRef();
+extern Tree * tToken();
+extern Tree * tAction();
+extern int tmember();
+extern int tmember_constrained();
+extern Tree * tleft_factor();
+extern Tree * trm_perm();
+extern void tcvt();
+extern Tree * permute();
+extern Tree * VerifyAmbig();
+extern set rJunc();
+extern set rRuleRef();
+extern set rToken();
+extern set rAction();
+extern void HandleAmbiguity();
+extern set First();
+extern void freeBlkFsets();
+extern void genAction();
+extern void genRuleRef();
+extern void genToken();
+extern void genOptBlk();
+extern void genLoopBlk();
+extern void genLoopBegin();
+extern void genPlusBlk();
+extern void genSubBlk();
+extern void genRule();
+extern void genJunction();
+extern void genEndBlk();
+extern void genEndRule();
+extern void genHdr();
+extern void genHdr1();
+extern void dumpAction();
+extern Entry ** newHashTable();
+extern Entry * hash_add();
+extern Entry * hash_get();
+extern void hashStat();
+extern char * mystrdup();
+extern void genLexDescr();
+extern void dumpLexClasses();
+extern void genDefFile();
+extern void DumpListOfParmNames();
+extern int DumpNextNameInDef();
+extern void DumpOldStyleParms();
+extern void DumpType();
+extern int strmember();
+extern int HasComma();
+extern void DumpRetValStruct();
+extern char * StripQuotes();
+extern int main();
+extern void readDescr();
+extern FILE * NextFile();
+extern char * outname();
+extern void fatalFL();
+extern void fatal_intern();
+extern void cleanUp();
+extern char * eMsg3();
+extern char * eMsgd();
+extern void s_fprT();
+extern char * TerminalString();
+extern void lexclass();
+extern void lexmode();
+extern int LexClassIndex();
+extern int hasAction();
+extern void setHasAction();
+extern int addTname();
+extern int addTexpr();
+extern int Tnum();
+extern void Tklink();
+extern Entry * newEntry();
+extern void list_add();
+extern void list_apply();
+extern char * Fkey();
+extern void FoPush();
+extern void FoPop();
+extern void RegisterCycle();
+extern void ResolveFoCycles();
+extern void pJunc();
+extern void pRuleRef();
+extern void pToken();
+extern void pAction();
+extern void FoLink();
+extern void addFoLink();
+extern void GenCrossRef();
+extern void defErr();
+extern void genStdPCCTSIncludeFile();
+extern Predicate *find_predicates();
+extern void GenRulePrototypes();
+extern Junction *first_item_is_guess_block();
+extern Junction *analysis_point();
+extern Tree *make_tree_from_sets();
+extern Tree *tdup_chain();
+extern Tree *tdif();
+extern set covered_set();
+extern void AmbiguityDialog();
+extern void dumpAmbigMsg();
+extern void GenRuleFuncRedefs();
+extern void GenPredefinedSymbolRedefs();
+extern void GenASTSymbolRedefs();
+extern void GenRemapFile();
+extern void GenSetRedefs();
+extern ForcedToken *newForcedToken();
+extern void RemapForcedTokens();
+extern char *TokenOrExpr();
+extern void setUpperRange();
+extern void GenParser_c_Hdr();
+extern void GenParser_h_Hdr();
+extern void GenRuleMemberDeclarationsForCC();
+extern int addForcedTname();
+extern char *OutMetaName();
+extern void warnNoFL();
+extern void warnFL();
+extern void warn();
+extern void warnNoCR();
+extern void errNoFL();
+extern void errFL();
+extern void err();
+extern void errNoCR();
+extern Tree *tmake();
+extern void genPredTree();
+extern UserAction *newUserAction();
+extern char *gate_symbol();
+extern char *makeAltID();
+extern void DumpRemainingTokSets();
+extern void DumpANSIFunctionArgDef();
+extern Predicate *computePredicateFromContextGuard();
+extern Predicate *new_pred();
+extern void chkGTFlag();
+#endif
+
+#ifdef __USE_PROTOS
+#include <stdlib.h>
+#endif

diff --git a/antlr/syn.h b/antlr/syn.h
new file mode 100755 (executable)
index 0000000..c0a5aec
--- /dev/null
+++ b/antlr/syn.h
@@ -0,0 +1,344 @@
+/*
+ * syn.h
+ *
+ * $Id: syn.h,v 1.6 95/09/26 12:58:32 parrt Exp $
+ * $Revision: 1.6 $
+ *
+ * This file includes definitions and macros associated with syntax diagrams
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ * 
+ * We encourage users to develop software with PCCTS.  However, we do ask
+ * that credit is given to us for developing PCCTS.  By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc...  If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS.  In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-1995
+ */
+
+#define NumNodeTypes   4
+#define NumJuncTypes   9
+
+/* List the different node types */
+#define nJunction              1
+#define nRuleRef               2
+#define nToken                 3
+#define nAction                        4
+
+/* Different types of junctions */
+#define aSubBlk                        1
+#define aOptBlk                        2
+#define aLoopBlk               3
+#define EndBlk                 4
+#define RuleBlk                        5
+#define Generic                        6       /* just a junction--no unusual characteristics */
+#define EndRule                        7
+#define aPlusBlk               8
+#define aLoopBegin             9
+
+typedef int NodeType;
+
+#define TreeBlockAllocSize             500
+#define JunctionBlockAllocSize 200
+#define ActionBlockAllocSize   50
+#define RRefBlockAllocSize             100
+#define TokenBlockAllocSize            100
+
+#ifdef __cplusplus
+class ActionNode;
+class Junction;
+#endif
+
+/* note that 'right' is used by the tree node allocator as a ptr for linked list */
+typedef struct _tree {
+                       struct _tree *down, *right;
+                       int token;
+                       union {
+                               int rk; /* if token==EpToken, => how many more tokens req'd */
+                               struct _tree *tref;     /* if token==TREE_REF */
+                               set sref;                       /* if token==SET */
+                       } v;
+#ifdef TREE_DEBUG
+                       int in_use;
+#endif
+               } Tree;
+
+/* a predicate is defined to be a predicate action and a token tree with
+ * context info (if used); later, this struct may include the
+ * "hoisting distance" when we hoist past tokens.
+ *
+ * A tree is used to indicate && vs ||
+ *
+ *    p
+ *    |
+ *    q--r
+ *
+ * indicates p && (q||r).
+ *
+ * If expr is PRED_AND_LIST or PRED_OR_LIST, then it's an operation node
+ * and indicates the start of an && or || list.
+ */
+
+typedef struct _Predicate {
+       struct _Predicate *down, *right;        /* these have to be first */
+       struct _Predicate *up, *left;           /* doubly-link me */
+       char *expr;
+       Tree *tcontext; /* used if lookahead depth of > one is needed (tree) */
+       int k;                  /* lookahead depth for this tcontext */
+       set scontext[2];/* used if lookahead depth of one is needed (set) */
+                                       /* scontext[0] is not used; only needed so genExprSets()
+                                          routine works (it expects an array)
+                                        */
+       set completion; /* which lookahead depths are required to complete tcontext? */
+#ifdef __cplusplus
+       ActionNode *source;     /* where did this predicate come from? */
+#else
+       struct _anode *source;  /* where did this predicate come from? */
+#endif
+} Predicate;
+
+typedef struct _ExceptionHandler {
+                       char *signalname;
+                       char *action;
+               } ExceptionHandler;
+
+typedef struct _ExceptionGroup {
+                       struct _ListNode *handlers; /* list of ExceptionHandler's */
+                       char *label;            /* label==""; implies not attached to any
+                                                                * particular rule ref.
+                                                                */
+                       char *altID;            /* which alt did it come from (blk#:alt#) */
+               } ExceptionGroup ;
+
+
+#define TokenString(_i)                        ((TokenInd!=NULL)?TokenStr[TokenInd[_i]]:TokenStr[_i])
+#define ExprString(_i)                 ((TokenInd!=NULL)?ExprStr[TokenInd[_i]]:ExprStr[_i])
+
+
+                               /* M e s s a g e  P a s s i n g  T o  N o d e s */
+
+/*
+ * assumes a 'Junction *r' exists.  This macro calls a function with
+ * the pointer to the node to operate on and a pointer to the rule
+ * in which it is enclosed.
+ */
+#define TRANS(p)       {if ( (p)==NULL ) fatal("TRANS: NULL object");          \
+                                       if ( (p)->ntype == nJunction ) (*(fpJTrans[((Junction *)(p))->jtype]))( p );\
+                                       else (*(fpTrans[(p)->ntype]))( p );}
+
+#define PRINT(p)       {if ( (p)==NULL ) fatal("PRINT: NULL object");\
+                                       (*(fpPrint[(p)->ntype]))( p );}
+
+#define REACH(p,k,rk,a) {if ( (p)==NULL ) fatal("REACH: NULL object");\
+                                       (a) = (*(fpReach[(p)->ntype]))( p, k, rk );}
+
+#define TRAV(p,k,rk,a) {if ( (p)==NULL ) {\
+                                         if ( ContextGuardTRAV ) (a)=NULL; \
+                                         else fatal("TRAV: NULL object");\
+                                   } \
+                                       else (a) = (*(fpTraverse[(p)->ntype]))( p, k, rk );}
+
+/*
+#define TRAV(p,k,rk,a) {if ( (p)==NULL ) fatal("TRAV: NULL object");\
+                                       (a) = (*(fpTraverse[(p)->ntype]))( p, k, rk );}
+*/
+
+/* All syntax diagram nodes derive from Node -- superclass
+ */
+#ifdef __cplusplus
+class Node {
+public:
+                       NodeType ntype;
+                       char *rname;            /* what rule does this element live in? */
+                       int file;                       /* index in FileStr */
+                       int line;                       /* line number that element occurs on */
+               };
+#else
+typedef struct _node {
+                       NodeType ntype;
+                       char *rname;            /* what rule does this element live in? */
+                       int file;                       /* index in FileStr */
+                       int line;                       /* line number that element occurs on */
+               } Node;
+#endif
+
+#ifdef __cplusplus
+class ActionNode : public Node {
+public:
+#else
+typedef struct _anode {
+                       NodeType ntype;
+                       char *rname;            /* what rule does this action live in? */
+                       int file;                       /* index in FileStr (name of file with action) */
+                       int line;                       /* line number that action occurs on */
+#endif
+                       Node *next;
+                       char *action;
+                       int is_predicate;       /* true if action is a <<...>>? predicate action */
+                       int done;                       /* don't dump if action dumped (used for predicates) */
+                       int init_action;        /* is this the 1st action of 1st prod of block? */
+                       char *pred_fail;        /* what to do/print when predicate fails */
+                       Predicate *guardpred;   /* if '(context)? =>' was present, already done */
+                       unsigned char frmwarned;/* have we dumped a warning for pred yet? */
+                       unsigned char ctxwarned;/* have we dumped a warning for pred yet? */
+#ifdef __cplusplus
+               };
+#else
+               } ActionNode;
+#endif
+
+#ifdef __cplusplus
+class TokNode : public Node {
+public:
+#else
+typedef struct _toknode {
+                       NodeType ntype;
+                       char *rname;            /* name of rule it's in */
+                       int file;                       /* index in FileStr (name of file with rule) */
+                       int line;                       /* line number that token occurs on */
+#endif
+                       Node *next;
+                       int token;
+                       int astnode;            /* leaf/root/excluded (used to build AST's) */
+                       unsigned char label;/* token label or expression ? */
+                       unsigned char remapped;
+                                                               /* used if token id's are forced to certain positions;
+                                                                * a function walks the tree reassigning token numbers */
+                       unsigned char upper_range;
+                                                               /* used only if Token is of type T1..T2; in this case,
+                                                                * use token..upper_range as the range; else
+                                                                * upper_range must be 0 */
+                       unsigned char wild_card;
+                                                               /* indicates that the token is the "." wild-card;
+                                                                * field token is ignored if wild_card is set
+                                                                */
+                       unsigned int elnum; /* element number within the alternative */
+#ifdef __cplusplus
+                       Junction *altstart;     /* pointer to node that starts alt */
+#else
+                       struct _junct *altstart;        /* pointer to node that starts alt */
+#endif
+                       struct _TCnode *tclass;         /* token class if tokclass ref */
+                       set tset;                       /* set of tokens represented by meta token */
+                       char *el_label;         /* el_label:toknode */
+                       unsigned char complement;       /* complement the set? */
+                       ExceptionGroup *ex_group;       /* any exception[el_label] attached? */
+            unsigned char use_def_MT_handler;
+#ifdef __cplusplus
+               };
+#else
+               } TokNode;
+#endif
+
+#ifdef __cplusplus
+class RuleRefNode : public Node {
+public:
+#else
+typedef struct _rrnode {
+                       NodeType ntype;
+                       char *rname;            /* name of rule it's in */
+                       int file;                       /* index in FileStr (name of file with rule)
+                                                                  it's in */
+                       int line;                       /* line number that rule ref occurs on */
+#endif
+                       Node *next;
+                       char *text;                     /* reference to which rule */
+                       char *parms;            /* point to parameters of rule invocation
+                                                                  (if present) */
+                       char *assign;           /* point to left-hand-side of assignment
+                                                                  (if any) */
+                       int linked;                     /* Has a FoLink already been established? */
+                       int astnode;            /* excluded? (used to build AST's) */
+                       unsigned int elnum; /* element number within the alternative */
+#ifdef __cplusplus
+                       Junction *altstart;
+#else
+                       struct _junct *altstart;
+#endif
+                       char *el_label;         /* el_label:rrnode */
+                       ExceptionGroup *ex_group;       /* any exception[el_label] attached? */
+#ifdef __cplusplus
+               };
+#else
+               } RuleRefNode;
+#endif
+
+#ifdef __cplusplus
+class Junction : public Node {
+public:
+#else
+typedef struct _junct {
+                       NodeType ntype;
+                       char *rname;            /* name of rule junction is in */
+                       int file;                       /* index in FileStr (name of file with rule)
+                                                                  if blk == RuleBlk */
+                       int line;                       /* line number that rule occurs on */
+#endif
+                       char ignore;            /* used by FIRST computation to ignore
+                                                                  empty alt added for the (...)+ blks */
+                       char visited;           /* used by recursive routines to avoid
+                                                                  infinite recursion */
+                       char pvisited;          /* used by print routines to avoid
+                                                                  infinite recursion */
+                       char fvisited;          /* used by FoLink() to avoid
+                                                                  infinite recursion */
+                       char *lock;                     /* used by REACH to track infinite recursion */
+                       char *pred_lock;        /* used by find_predicates to track infinite recursion */
+                       int altnum;                     /* used in subblocks. altnum==0 means not an
+                                                                  alt of subrule */
+                       int jtype;                      /* annotation for code-gen/FIRST/FOLLOW.
+                                                                  Junction type */
+#ifdef __cplusplus
+                       Junction *end;          /* pointer to node with EndBlk in it
+                                                                  if blk == a block type */
+#else
+                       struct _junct *end;     /* pointer to node with EndBlk in it
+                                                                  if blk == a block type */
+#endif
+                       Node *p1, *p2;
+                       int halt;                       /* never move past a junction with halt==TRUE */
+                       char *pdecl;            /* point to declaration of parameters on rule
+                                                                  (if present) */
+                       char *parm;                     /* point to parameter of block invocation
+                                                                  (if present) */
+                       int predparm;           /* indicates that the 'parm' is a predicate
+                                                                * to be used in the while loop generated
+                                                                * for blocks */
+                       char *ret;                      /* point to return type of rule (if present) */
+                       char *erraction;        /* point to error action (if present) */
+                       int blockid;            /* this is a unique ID */
+                       char *exception_label;  /* goto label for this alt */
+                       set *fset;                      /* used for code generation */
+                       Tree *ftree;            /* used for code generation */
+                       Predicate *predicate;/* predicate that can be used to disambiguate */
+                       char guess;                     /* true if (...)? block */
+                       char approx;            /* limit block to use linear approx lookahead? */
+                       set tokrefs;            /* if ith element of alt is tokref then i is member */
+                       set rulerefs;           /* if ith element of alt is rule ref then i is member */
+                       struct _ListNode *exceptions; /* list of exceptions groups for rule */
+                       struct _ListNode *el_labels;  /* list of element labels for rule */
+#ifdef __cplusplus
+               };
+#else
+               } Junction;
+#endif
+
+typedef struct { Node *left, *right; } Graph;
+