+/* bits.c -- manage creation and output of bit sets used by the parser.\r
+ *\r
+ * SOFTWARE RIGHTS\r
+ *\r
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool\r
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or\r
+ * company may do whatever they wish with source code distributed with\r
+ * PCCTS or the code generated by PCCTS, including the incorporation of\r
+ * PCCTS, or its output, into commerical software.\r
+ *\r
+ * We encourage users to develop software with PCCTS. However, we do ask\r
+ * that credit is given to us for developing PCCTS. By "credit",\r
+ * we mean that if you incorporate our source code into one of your\r
+ * programs (commercial product, research project, or otherwise) that you\r
+ * acknowledge this fact somewhere in the documentation, research report,\r
+ * etc... If you like PCCTS and have developed a nice tool with the\r
+ * output, please mention that you developed it using PCCTS. In\r
+ * addition, we ask that this header remain intact in our source code.\r
+ * As long as these guidelines are kept, we expect to continue enhancing\r
+ * this system and expect to make other tools available as they are\r
+ * completed.\r
+ *\r
+ * ANTLR 1.33\r
+ * Terence Parr\r
+ * Parr Research Corporation\r
+ * with Purdue University and AHPCRC, University of Minnesota\r
+ * 1989-2001\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <ctype.h>\r
+#include <assert.h>\r
+#include "pcctscfg.h"\r
+#include "set.h"\r
+#include "syn.h"\r
+#include "hash.h"\r
+#include "generic.h"\r
+#include "dlgdef.h"\r
+\r
+/* char is only thing that is pretty much always known == 8 bits\r
+ * This allows output of antlr (set stuff, anyway) to be androgynous (portable)\r
+ */\r
+typedef unsigned char SetWordType;\r
+#define BitsPerByte 8\r
+#define BitsPerWord BitsPerByte*sizeof(SetWordType)\r
+\r
+static SetWordType *setwd = NULL;\r
+int setnum = -1;\r
+int wordnum = 0;\r
+\r
+int esetnum = 0;\r
+\r
+/* Used to convert native wordsize, which ANTLR uses (via set.c) to manipulate sets,\r
+ to bytes that are most portable size-wise.\r
+ */\r
+void\r
+#ifdef __USE_PROTOS\r
+DumpIntAsChars( FILE *f, char *format, unsigned wd )\r
+#else\r
+DumpIntAsChars( f, format, wd )\r
+FILE *f;\r
+char *format;\r
+unsigned wd;\r
+#endif\r
+{\r
+ int i;\r
+ /* uses max of 32 bit unsigned integer for the moment */\r
+ static unsigned long byte_mask[sizeof(unsigned long)] =\r
+ { 0xFF, 0xFF00UL, 0xFF0000UL, 0xFF000000UL }; /* MR20 G. Hobbelt */\r
+/* 0xFF00000000, 0xFF0000000000, 0xFF000000000000, 0xFF00000000000000 };*/\r
+\r
+ /* for each byte in the word */\r
+ assert(sizeof(unsigned) <= 4); /* M20 G. Hobbelt Sanity check */\r
+ for (i=0; i<sizeof(unsigned); i++)\r
+ {\r
+ /* mask out the ith byte and shift down to the first 8 bits */\r
+ fprintf(f, format, (wd&byte_mask[i])>>(i*BitsPerByte));\r
+ if ( i<sizeof(unsigned)-1) fprintf(f, ",");\r
+ }\r
+}\r
+\r
+/* Create a new setwd (ignoring [Ep] token on end) */\r
+void\r
+#ifdef __USE_PROTOS\r
+NewSetWd( void )\r
+#else\r
+NewSetWd( )\r
+#endif\r
+{\r
+ SetWordType *p;\r
+\r
+ if ( setwd == NULL )\r
+ {\r
+ setwd = (SetWordType *) calloc(TokenNum, sizeof(SetWordType));\r
+ require(setwd!=NULL, "NewSetWd: cannot alloc set wd\n");\r
+ }\r
+ for (p = setwd; p<&(setwd[TokenNum]); p++) {*p=0;}\r
+ wordnum++;\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+DumpSetWd( void )\r
+#else\r
+DumpSetWd( )\r
+#endif\r
+{\r
+ if ( GenCC ) DumpSetWdForCC();\r
+ else DumpSetWdForC();\r
+}\r
+\r
+/* Dump the current setwd to ErrFile. 0..MaxTokenVal */\r
+void\r
+#ifdef __USE_PROTOS\r
+DumpSetWdForC( void )\r
+#else\r
+DumpSetWdForC( )\r
+#endif\r
+{\r
+ int i,c=1;\r
+\r
+ if ( setwd==NULL ) return;\r
+ fprintf(DefFile, "extern SetWordType setwd%d[];\n", wordnum);\r
+ fprintf(ErrFile,\r
+ "SetWordType setwd%d[%d] = {", wordnum, TokenNum-1);\r
+ for (i=0; i<TokenNum-1; i++)\r
+ {\r
+ DAWDLE;\r
+ if ( i!=0 ) fprintf(ErrFile, ",");\r
+ if ( c == 8 ) {fprintf(ErrFile, "\n\t"); c=1;} else c++;\r
+ fprintf(ErrFile, "0x%x", setwd[i]);\r
+ }\r
+ fprintf(ErrFile, "};\n");\r
+}\r
+\r
+/* Dump the current setwd to Parser.C file. 0..MaxTokenVal;\r
+ * Only used if -CC on.\r
+ */\r
+void\r
+#ifdef __USE_PROTOS\r
+DumpSetWdForCC( void )\r
+#else\r
+DumpSetWdForCC( )\r
+#endif\r
+{\r
+ int i,c=1;\r
+\r
+ if ( setwd==NULL ) return;\r
+ fprintf(Parser_h, "\tstatic SetWordType setwd%d[%d];\n", wordnum, TokenNum-1);\r
+ fprintf(Parser_c,\r
+ "SetWordType %s::setwd%d[%d] = {", CurrentClassName, wordnum,\r
+ TokenNum-1);\r
+ for (i=0; i<TokenNum-1; i++)\r
+ {\r
+ DAWDLE;\r
+ if ( i!=0 ) fprintf(Parser_c, ",");\r
+ if ( c == 8 ) {fprintf(Parser_c, "\n\t"); c=1;} else c++;\r
+ fprintf(Parser_c, "0x%x", setwd[i]);\r
+ }\r
+ fprintf(Parser_c, "};\n");\r
+}\r
+\r
+/* Make a new set. Dump old setwd and create new setwd if current setwd is full */\r
+void\r
+#ifdef __USE_PROTOS\r
+NewSet( void )\r
+#else\r
+NewSet( )\r
+#endif\r
+{\r
+ setnum++;\r
+ if ( setnum==BitsPerWord ) /* is current setwd full? */\r
+ {\r
+ DumpSetWd(); NewSetWd(); setnum = 0;\r
+ }\r
+}\r
+\r
+/* s is a set of tokens. Turn on bit at each token position in set 'setnum' */\r
+void\r
+#ifdef __USE_PROTOS\r
+FillSet( set s )\r
+#else\r
+FillSet( s )\r
+set s;\r
+#endif\r
+{\r
+ SetWordType mask=(((unsigned)1)<<setnum);\r
+ unsigned int e;\r
+\r
+ while ( !set_nil(s) )\r
+ {\r
+ e = set_int(s);\r
+ set_rm(e, s);\r
+ setwd[e] |= mask;\r
+ }\r
+}\r
+\r
+ /* E r r o r C l a s s S t u f f */\r
+\r
+/* compute the FIRST of a rule for the error class stuff */\r
+static set\r
+#ifdef __USE_PROTOS\r
+Efirst( char *rule, ECnode *eclass )\r
+#else\r
+Efirst( rule, eclass )\r
+char *rule;\r
+ECnode *eclass;\r
+#endif\r
+{\r
+ set rk, a;\r
+ Junction *r;\r
+ RuleEntry *q = (RuleEntry *) hash_get(Rname, rule);\r
+\r
+ if ( q == NULL )\r
+ {\r
+ warnNoFL(eMsg2("undefined rule '%s' referenced in errclass '%s'; ignored",\r
+ rule, TokenString(eclass->tok)));\r
+ return empty;\r
+ }\r
+ r = RulePtr[q->rulenum];\r
+ r->end->halt = TRUE; /* don't let reach fall off end of rule here */\r
+ rk = empty;\r
+ REACH(r, 1, &rk, a);\r
+ r->end->halt = FALSE;\r
+ return a;\r
+}\r
+\r
+/*\r
+ * scan the list of tokens/eclasses/nonterminals filling the new eclass\r
+ * with the set described by the list. Note that an eclass can be\r
+ * quoted to allow spaces etc... However, an eclass must not conflict\r
+ * with a reg expr found elsewhere. The reg expr will be taken over\r
+ * the eclass name.\r
+ */\r
+static void\r
+#ifdef __USE_PROTOS\r
+doEclass( char *eclass )\r
+#else\r
+doEclass( eclass )\r
+char *eclass;\r
+#endif\r
+{\r
+ TermEntry *q;\r
+ ECnode *p;\r
+ TCnode *tcnode;\r
+ ListNode *e;\r
+ unsigned int t;\r
+ unsigned deg=0;\r
+ set a;\r
+ require(eclass!=NULL, "doEclass: NULL eset");\r
+ \r
+ p = (ECnode *) eclass;\r
+ lexmode(p->lexclass); /* switch to lexclass where errclass is defined */\r
+ p->eset = empty;\r
+ for (e = (p->elist)->next; e!=NULL; e=e->next)\r
+ {\r
+ q = NULL; /* MR23 */\r
+\r
+ if ( islower( *((char *)e->elem) ) ) /* is it a rule ref? (alias FIRST request) */\r
+ {\r
+ a = Efirst((char *)e->elem, p);\r
+ set_orin(&p->eset, a);\r
+ deg += set_deg(a);\r
+ set_free( a );\r
+ continue;\r
+ }\r
+ else if ( *((char *)e->elem)=='"' )\r
+ {\r
+ t = 0;\r
+ q = (TermEntry *) hash_get(Texpr, (char *) e->elem);\r
+ if ( q == NULL )\r
+ {\r
+ /* if quoted and not an expr look for eclass name */\r
+ q = (TermEntry *) hash_get(Tname, *((char **)&(e->elem))=StripQuotes((char *)e->elem));\r
+ if ( q != NULL ) t = q->token;\r
+ }\r
+ else t = q->token;\r
+ }\r
+ else /* labelled token/eclass/tokclass */\r
+ {\r
+ q = (TermEntry *) hash_get(Tname, (char *)e->elem);\r
+ if ( q != NULL )\r
+ {\r
+ if ( strcmp((char *)e->elem, TokenString(p->tok))==0 )\r
+ {\r
+ warnNoFL(eMsg1("self-referential error class '%s'; ignored",\r
+ (char *)e->elem));\r
+ continue;\r
+ }\r
+ else\r
+ t = q->token;\r
+ }\r
+ else t=0;\r
+ }\r
+ if ( t!=0 )\r
+ {\r
+ if (isTermEntryTokClass(q)) { /* MR23 */\r
+ tcnode = q->tclass; /* MR23 */\r
+ set_orin(&p->eset, tcnode->tset); /* MR23 */\r
+ deg = set_deg(p->eset); /* MR23 */\r
+ } /* MR23 */\r
+ else {\r
+ set_orel(t, &p->eset);\r
+ deg++;\r
+ }\r
+ }\r
+ else warnNoFL(eMsg2("undefined token '%s' referenced in errclass '%s'; ignored",\r
+ (char *)e->elem, TokenString(p->tok)));\r
+ }\r
+ p->setdeg = deg;\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+ComputeErrorSets( void )\r
+#else\r
+ComputeErrorSets( )\r
+#endif\r
+{\r
+#ifdef __cplusplus\r
+ list_apply(eclasses, (void (*)(void *)) doEclass);\r
+#else\r
+#ifdef __USE_PROTOS\r
+ list_apply(eclasses, (void (*)(void *)) doEclass);\r
+#else\r
+ list_apply(eclasses, doEclass);\r
+#endif\r
+#endif\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+ComputeTokSets( void )\r
+#else\r
+ComputeTokSets( )\r
+#endif\r
+{\r
+ ListNode *t, *e = NULL, *e1, *e2;\r
+ int something_changed;\r
+ int i;\r
+ TCnode *p;\r
+ TermEntry *q, *q1, *q2;\r
+\r
+ if ( tclasses == NULL ) return;\r
+\r
+ /* turn lists of token/tokclass references into sets */\r
+ for (t = tclasses->next; t!=NULL; t=t->next)\r
+ {\r
+ p = (TCnode *) t->elem;\r
+\r
+ /* if wild card, then won't have entries in tclass, assume all_tokens */\r
+ if ( p->tok == WildCardToken )\r
+ {\r
+ p->tset = set_dup(all_tokens);\r
+ continue;\r
+ }\r
+\r
+ lexmode(p->lexclass); /* switch to lexclass where tokclass is defined */\r
+ p->tset = empty;\r
+\r
+ /* instantiate all tokens/token_classes into the tset */\r
+ for (e = (p->tlist)->next; e!=NULL; e=e->next)\r
+ {\r
+ char *tokstr;\r
+ tokstr = (char *)e->elem;\r
+ if ( *tokstr == '"' ) {\r
+ q = (TermEntry *) hash_get(Texpr, tokstr);\r
+ require(q!=NULL, "ComputeTokSets: no token def");\r
+ set_orel(q->token, &p->tset);\r
+ } else if (tokstr[0] == '.') {\r
+ e1=e->next;\r
+ e2=e1->next;\r
+ e=e2;\r
+ q1= (TermEntry *) hash_get(Tname, (char *)e1->elem);\r
+ require(q1!=NULL, "ComputeTokSets: no token def");\r
+ q2= (TermEntry *) hash_get(Tname, (char *)e2->elem);\r
+ require(q2!=NULL, "ComputeTokSets: no token def");\r
+\r
+ if (set_el(q1->token,imag_tokens)) {\r
+errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",\r
+ TokenString(p->tok),(char *)e1->elem) );\r
+ }\r
+ if (set_el(q2->token,imag_tokens)) {\r
+errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",\r
+ TokenString(p->tok),(char *)e2->elem) );\r
+ }\r
+ if (q1->token > q2->token) {\r
+errNoFL(eMsg3("for #tokclass %s %s..%s - first token number > second token number",\r
+ TokenString(p->tok),(char *)e1->elem,(char *)e2->elem) );\r
+ for (i=q2->token; i<=q1->token; i++) { set_orel(i, &p->tset); }\r
+ } else {\r
+ for (i=q1->token; i<=q2->token; i++) { set_orel(i, &p->tset); }\r
+ }\r
+ } else {\r
+ q = (TermEntry *) hash_get(Tname, tokstr);\r
+ require(q!=NULL, "ComputeTokSets: no token def");\r
+ set_orel(q->token, &p->tset);\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Go thru list of tokclasses again looking for tokclasses in sets */\r
+again:\r
+ something_changed = 0;\r
+ for (t = tclasses->next; t!=NULL; t=t->next)\r
+ {\r
+ set tcl;\r
+ p = (TCnode *) t->elem;\r
+ tcl = set_and(p->tset, tokclasses);\r
+ if ( !set_nil(tcl) )\r
+ {\r
+ int tk;\r
+ /* replace refs to tokclasses with the associated set of tokens */\r
+ something_changed = 1;\r
+ while ( !set_nil(tcl) )\r
+ {\r
+ tk = set_int(tcl); /* grab one of the tok class refs */\r
+ set_rm(tk, tcl);\r
+ if ( p->tok != tk ) /* tokclass ref to yourself? */\r
+ {\r
+ q = (TermEntry *) hash_get(Tname, TokenString(tk));\r
+ require(q!=NULL, "#tokclass not in hash table");\r
+ set_orin(&p->tset, q->tclass->tset);\r
+ }\r
+ set_rm(tk, p->tset); /* remove ref that we replaced */\r
+ }\r
+ }\r
+ set_free(tcl);\r
+ }\r
+ if ( something_changed ) goto again;\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+DumpRemainingTokSets(void)\r
+#else\r
+DumpRemainingTokSets()\r
+#endif\r
+{\r
+ TCnode *p;\r
+ ListNode *t;\r
+\r
+ /* Go thru tclasses (for the last time) and dump the sets not dumped\r
+ * during code gen; yes, this is a bogus way to do this, but ComputeTokSets()\r
+ * can't dump the defs as the error file and tok file has not been created\r
+ * yet etc...\r
+ */\r
+ if ( tclasses==NULL ) return;\r
+ for (t = tclasses->next; t!=NULL; t=t->next)\r
+ {\r
+ unsigned e;\r
+ p = (TCnode *) t->elem;\r
+ if ( p->dumped ) continue;\r
+ e = DefErrSet(&(p->tset), 0, TokenString(p->tok));\r
+ p->dumped = 1;\r
+ p->setnum = e;\r
+ }\r
+}\r
+\r
+\r
+/* replace a subset of an error set with an error class name if a subset is found\r
+ * repeat process until no replacements made\r
+ */\r
+void\r
+#ifdef __USE_PROTOS\r
+SubstErrorClass( set *f )\r
+#else\r
+SubstErrorClass( f )\r
+set *f;\r
+#endif\r
+{\r
+ int max, done = 0;\r
+ ListNode *p;\r
+ ECnode *ec, *maxclass = NULL;\r
+ set a;\r
+ require(f!=NULL, "SubstErrorClass: NULL eset");\r
+\r
+ if ( eclasses == NULL ) return;\r
+ while ( !done )\r
+ {\r
+ max = 0;\r
+ maxclass = NULL;\r
+ for (p=eclasses->next; p!=NULL; p=p->next) /* chk all error classes */\r
+ {\r
+ ec = (ECnode *) p->elem;\r
+ if ( ec->setdeg > max )\r
+ {\r
+ if ( set_sub(ec->eset, *f) || set_equ(ec->eset, *f) )\r
+ {maxclass = ec; max=ec->setdeg;}\r
+ }\r
+ }\r
+ if ( maxclass != NULL ) /* if subset found, replace with token */\r
+ {\r
+ a = set_dif(*f, maxclass->eset);\r
+ set_orel((unsigned)maxclass->tok, &a);\r
+ set_free(*f);\r
+ *f = a;\r
+ }\r
+ else done = 1;\r
+ }\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSet1(int nilOK, set *f, int subst, char *name )\r
+#else\r
+DefErrSet1(nilOK, f, subst, name )\r
+int nilOK;\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+#endif\r
+{\r
+ if ( GenCC ) return DefErrSetForCC1(nilOK, f, subst, name, "_set");\r
+ else return DefErrSetForC1(nilOK, f, subst, name, "_set");\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSet( set *f, int subst, char *name )\r
+#else\r
+DefErrSet( f, subst, name )\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+#endif\r
+{\r
+ return DefErrSet1(0,f,subst,name);\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSetWithSuffix(int nilOK, set *f, int subst, char *name, const char* suffix)\r
+#else\r
+DefErrSetWithSuffix(nilOK, f, subst, name, suffix )\r
+int nilOK;\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+char *suffix;\r
+#endif\r
+{\r
+ if ( GenCC ) return DefErrSetForCC1(nilOK, f, subst, name, suffix );\r
+ else return DefErrSetForC1(nilOK, f, subst, name, suffix);\r
+}\r
+\r
+/* Define a new error set. WARNING...set-implementation dependent.\r
+ */\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSetForC1(int nilOK, set *f, int subst, char * name, const char * suffix)\r
+#else\r
+DefErrSetForC1(nilOK, f, subst, name, suffix)\r
+int nilOK; /* MR13 */\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+const char *suffix;\r
+#endif\r
+{\r
+ unsigned *p, *endp;\r
+ int e=1;\r
+\r
+ if (!nilOK) require(!set_nil(*f), "DefErrSetForC1: nil set to dump?");\r
+\r
+ if ( subst ) SubstErrorClass(f);\r
+ p = f->setword;\r
+ endp = &(f->setword[f->n]);\r
+ esetnum++;\r
+ if ( name!=NULL )\r
+ fprintf(DefFile, "extern SetWordType %s%s[];\n", name, suffix);\r
+ else\r
+ fprintf(DefFile, "extern SetWordType zzerr%d[];\n", esetnum);\r
+ if ( name!=NULL ) {\r
+ fprintf(ErrFile, "SetWordType %s%s[%d] = {",\r
+ name,\r
+ suffix,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ }\r
+ else {\r
+ fprintf(ErrFile, "SetWordType zzerr%d[%d] = {",\r
+ esetnum,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ }\r
+ while ( p < endp )\r
+ {\r
+ if ( e > 1 ) fprintf(ErrFile, ", ");\r
+ DumpIntAsChars(ErrFile, "0x%x", *p++);\r
+ if ( e == 3 )\r
+ {\r
+ DAWDLE;\r
+ if ( p < endp ) fprintf(ErrFile, ",");\r
+ fprintf(ErrFile, "\n\t");\r
+ e=1;\r
+ }\r
+ else e++;\r
+ }\r
+ fprintf(ErrFile, "};\n");\r
+\r
+ return esetnum;\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSetForC( set *f, int subst, char *name )\r
+#else\r
+DefErrSetForC( f, subst, name )\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+#endif\r
+{\r
+ return DefErrSetForC1(0,f,subst,name, "_set");\r
+}\r
+\r
+/* Define a new error set. WARNING...set-implementation dependent;\r
+ * Only used when -CC on.\r
+ */\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSetForCC1(int nilOK, set *f, int subst, char *name, const char *suffix )\r
+#else\r
+DefErrSetForCC1(nilOK, f, subst, name, suffix )\r
+int nilOK; /* MR13 */\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+const char *suffix;\r
+#endif\r
+{\r
+ unsigned *p, *endp;\r
+ int e=1;\r
+\r
+ if (!nilOK) require(!set_nil(*f), "DefErrSetForCC1: nil set to dump?");\r
+\r
+ if ( subst ) SubstErrorClass(f);\r
+ p = f->setword;\r
+ endp = &(f->setword[f->n]);\r
+ esetnum++;\r
+\r
+ if ( name!=NULL ) {\r
+ fprintf(Parser_h, "\tstatic SetWordType %s%s[%d];\n", name, suffix,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ fprintf(Parser_c, "SetWordType %s::%s%s[%d] = {",\r
+ CurrentClassName,\r
+ name,\r
+ suffix,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ }\r
+ else {\r
+ fprintf(Parser_c, "SetWordType %s::err%d[%d] = {",\r
+ CurrentClassName,\r
+ esetnum,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ fprintf(Parser_h, "\tstatic SetWordType err%d[%d];\n", esetnum,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ }\r
+\r
+ while ( p < endp )\r
+ {\r
+ if ( e > 1 ) fprintf(Parser_c, ", ");\r
+ DumpIntAsChars(Parser_c, "0x%x", *p++);\r
+ if ( e == 3 )\r
+ {\r
+ if ( p < endp ) fprintf(Parser_c, ",");\r
+ fprintf(Parser_c, "\n\t");\r
+ e=1;\r
+ }\r
+ else e++;\r
+ }\r
+ fprintf(Parser_c, "};\n");\r
+\r
+ return esetnum;\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+DefErrSetForCC( set *f, int subst, char *name )\r
+#else\r
+DefErrSetForCC( f, subst, name )\r
+set *f;\r
+int subst; /* should be substitute error classes? */\r
+char *name;\r
+#endif\r
+{\r
+ return DefErrSetForCC1(0,f,subst,name, "_set");\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+GenParser_c_Hdr(void)\r
+#else\r
+GenParser_c_Hdr()\r
+#endif\r
+{\r
+ int i,j;\r
+ TermEntry *te;\r
+ char * hasAkaName = NULL; /* MR23 */\r
+\r
+ hasAkaName = (char *) malloc(TokenNum+1); /* MR23 */\r
+ require(hasAkaName!=NULL, "Cannot alloc hasAkaName\n"); /* MR23 */\r
+ for (i = 0; i < TokenNum; i++) hasAkaName[i]='0'; /* MR23 */\r
+ hasAkaName[TokenNum] = 0; /* MR23 */\r
+\r
+ fprintf(Parser_c, "/*\n");\r
+ fprintf(Parser_c, " * %s: P a r s e r S u p p o r t\n", CurrentClassName);\r
+ fprintf(Parser_c, " *\n");\r
+ fprintf(Parser_c, " * Generated from:");\r
+ for (i=0; i<NumFiles; i++) fprintf(Parser_c, " %s", FileStr[i]);\r
+ fprintf(Parser_c, "\n");\r
+ fprintf(Parser_c, " *\n");\r
+ fprintf(Parser_c, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");\r
+ fprintf(Parser_c, " * Parr Research Corporation\n");\r
+ fprintf(Parser_c, " * with Purdue University Electrical Engineering\n");\r
+ fprintf(Parser_c, " * with AHPCRC, University of Minnesota\n");\r
+ fprintf(Parser_c, " * ANTLR Version %s\n", Version);\r
+ fprintf(Parser_c, " */\n\n");\r
+ \r
+ if ( FirstAction != NULL ) dumpAction(FirstAction,Parser_c, 0, -1, 0, 1); /* MR11 MR15b */\r
+\r
+ fprintf(Parser_c, "#define ANTLR_VERSION %s\n", VersionDef);\r
+\r
+ fprintf(Parser_c, "#include \"pcctscfg.h\"\n");\r
+ fprintf(Parser_c, "#include \"pccts_stdio.h\"\n");\r
+ fprintf(Parser_c, "#define ANTLR_SUPPORT_CODE\n");\r
+ if ( UserTokenDefsFile != NULL )\r
+ fprintf(Parser_c, "#include %s\n", UserTokenDefsFile);\r
+ else\r
+ fprintf(Parser_c, "#include \"%s\"\n", DefFileName);\r
+\r
+ fprintf(Parser_c, "#include \"%s.h\"\n\n", CurrentClassName);\r
+\r
+ fprintf(Parser_c, "const ANTLRChar *%s::tokenName(int tok) ", /* MR1 */\r
+ CurrentClassName); /* MR1 */\r
+ fprintf(Parser_c, " { return _token_tbl[tok]; }\n"); /* MR1 */ /* MR10 */\r
+ /* Dump a Parser::tokens for each automaton */\r
+ fprintf(Parser_c, "\nconst ANTLRChar *%s::_token_tbl[]={\n",\r
+ CurrentClassName); /* MR20 */\r
+ fprintf(Parser_c, "\t/* 00 */\t\"Invalid\"");\r
+\r
+ for (i=1; i<TokenNum-1; i++)\r
+ {\r
+ DAWDLE;\r
+ if ( i == EpToken ) continue;\r
+ /* remapped to invalid token? */\r
+ if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )\r
+ {\r
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"invalid\"", i);\r
+ continue;\r
+ }\r
+ if ( TokenString(i) != NULL ) {\r
+ te=(TermEntry *) hash_get(Tname,TokenString(i)); /* MR11 */\r
+ if (te == NULL || te->akaString == NULL) { /* MR11 */\r
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"%s\"", i, TokenString(i));\r
+ } else {\r
+ hasAkaName[i] = '1'; /* MR23 */\r
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"%s\"", i, te->akaString); /* MR11 */\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* look in all lexclasses for the reg expr */\r
+ for (j=0; j<NumLexClasses; j++)\r
+ {\r
+ lexmode(j);\r
+ if ( ExprString(i) != NULL )\r
+ {\r
+ fprintf(Parser_c, ",\n\t/* %02d */\t", i);\r
+ dumpExpr(Parser_c, ExprString(i));\r
+ break;\r
+ }\r
+ }\r
+ if ( j>=NumLexClasses )\r
+ {\r
+ if ( UserDefdTokens )\r
+ {\r
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"\"", i);\r
+ }\r
+ else\r
+ fatal_internal(eMsgd("No label or expr for token %d",i));\r
+ }\r
+ }\r
+ }\r
+ fprintf(Parser_c, "\n};\n");\r
+\r
+ /* Build constructors */\r
+ fprintf(Parser_c, "\n%s::", CurrentClassName);\r
+ fprintf(Parser_c, "%s(ANTLRTokenBuffer *input) : %s(input,%d,%d,%d,%d)\n",\r
+ CurrentClassName,\r
+ (BaseClassName == NULL ? "ANTLRParser" : BaseClassName),\r
+ OutputLL_k,\r
+ FoundGuessBlk,\r
+ DemandLookahead,\r
+ NumWords(TokenNum-1)*sizeof(unsigned));\r
+ fprintf(Parser_c, "{\n");\r
+ fprintf(Parser_c, "\ttoken_tbl = _token_tbl;\n");\r
+ if (TraceGen) {\r
+ fprintf(Parser_c, "\ttraceOptionValueDefault=1;\t\t// MR10 turn trace ON\n");\r
+ } else {\r
+ fprintf(Parser_c, "\ttraceOptionValueDefault=0;\t\t// MR10 turn trace OFF\n");\r
+ };\r
+ fprintf(Parser_c, "}\n\n");\r
+ free ( (void *) hasAkaName);\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+GenParser_h_Hdr(void)\r
+#else\r
+GenParser_h_Hdr()\r
+#endif\r
+{\r
+ int i;\r
+\r
+ fprintf(Parser_h, "/*\n");\r
+ fprintf(Parser_h, " * %s: P a r s e r H e a d e r \n", CurrentClassName);\r
+ fprintf(Parser_h, " *\n");\r
+ fprintf(Parser_h, " * Generated from:");\r
+ for (i=0; i<NumFiles; i++) fprintf(Parser_h, " %s", FileStr[i]);\r
+ fprintf(Parser_h, "\n");\r
+ fprintf(Parser_h, " *\n");\r
+ fprintf(Parser_h, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");\r
+ fprintf(Parser_h, " * Parr Research Corporation\n");\r
+ fprintf(Parser_h, " * with Purdue University Electrical Engineering\n");\r
+ fprintf(Parser_h, " * with AHPCRC, University of Minnesota\n");\r
+ fprintf(Parser_h, " * ANTLR Version %s\n", Version);\r
+ fprintf(Parser_h, " */\n\n");\r
+\r
+ if ( FirstAction != NULL ) dumpAction( FirstAction, Parser_h, 0, -1, 0, 1); /* MR11 MR15b */\r
+\r
+ fprintf(Parser_h, "#ifndef %s_h\n", CurrentClassName);\r
+ fprintf(Parser_h, "#define %s_h\n\n", CurrentClassName);\r
+\r
+ fprintf(Parser_h, "#ifndef ANTLR_VERSION\n");\r
+ fprintf(Parser_h, "#define ANTLR_VERSION %s\n",VersionDef);\r
+ fprintf(Parser_h, "#endif\n\n");\r
+\r
+ if ( GenAST ) fprintf(Parser_h, "class ASTBase;\n");\r
+ if (TraceGen) {\r
+ fprintf(Parser_h,"#ifndef zzTRACE_RULES\n"); /* MR20 */\r
+ fprintf(Parser_h,"#define zzTRACE_RULES\n"); /* MR20 */\r
+ fprintf(Parser_h,"#endif\n"); /* MR22 */\r
+ };\r
+ fprintf(Parser_h, "#include \"%s\"\n\n", APARSER_H);\r
+\r
+ if ( HdrAction != NULL ) dumpAction( HdrAction, Parser_h, 0, -1, 0, 1);\r
+ \r
+/* MR10 */ if (ClassDeclStuff == NULL) {\r
+/* MR10 */ fprintf(Parser_h, "class %s : public ANTLRParser {\n", CurrentClassName);\r
+/* MR10 */ } else {\r
+/* MR10 */ fprintf(Parser_h, "class %s %s {\n",CurrentClassName,ClassDeclStuff);\r
+/* MR10 */ };\r
+\r
+ fprintf(Parser_h, "public:\n"); /* MR1 */\r
+ fprintf(Parser_h, "\tstatic const ANTLRChar *tokenName(int tk);\n");/* MR1 */\r
+ fprintf(Parser_h, "\tenum { SET_SIZE = %i };\n",TokenNum-1); /* MR21 */\r
+ fprintf(Parser_h, "protected:\n");\r
+ fprintf(Parser_h, "\tstatic const ANTLRChar *_token_tbl[];\n"); /* MR20 */\r
+ fprintf(Parser_h, "private:\n");\r
+}\r
+\r
+/* Currently, this is only used in !GenCC mode */\r
+void\r
+#ifdef __USE_PROTOS\r
+GenErrHdr( void )\r
+#else\r
+GenErrHdr( )\r
+#endif\r
+{\r
+ int i, j;\r
+ TermEntry *te;\r
+\r
+ fprintf(ErrFile, "/*\n");\r
+ fprintf(ErrFile, " * A n t l r S e t s / E r r o r F i l e H e a d e r\n");\r
+ fprintf(ErrFile, " *\n");\r
+ fprintf(ErrFile, " * Generated from:");\r
+ for (i=0; i<NumFiles; i++) fprintf(ErrFile, " %s", FileStr[i]);\r
+ fprintf(ErrFile, "\n");\r
+ fprintf(ErrFile, " *\n");\r
+ fprintf(ErrFile, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");\r
+ fprintf(ErrFile, " * Parr Research Corporation\n");\r
+ fprintf(ErrFile, " * with Purdue University Electrical Engineering\n");\r
+ fprintf(ErrFile, " * With AHPCRC, University of Minnesota\n");\r
+ fprintf(ErrFile, " * ANTLR Version %s\n", Version);\r
+ fprintf(ErrFile, " */\n\n");\r
+\r
+ if ( FirstAction != NULL ) dumpAction( FirstAction, ErrFile, 0, -1, 0, 1); /* MR11 MR15b */\r
+ \r
+ fprintf(ErrFile, "#define ANTLR_VERSION %s\n", VersionDef);\r
+\r
+ fprintf(ErrFile, "#include \"pcctscfg.h\"\n");\r
+ fprintf(ErrFile, "#include \"pccts_stdio.h\"\n");\r
+ if ( strcmp(ParserName, DefaultParserName)!=0 )\r
+ fprintf(ErrFile, "#define %s %s\n", DefaultParserName, ParserName);\r
+ if ( strcmp(ParserName, DefaultParserName)!=0 )\r
+ fprintf(ErrFile, "#include \"%s\"\n", RemapFileName);\r
+ if ( HdrAction != NULL ) dumpAction( HdrAction, ErrFile, 0, -1, 0, 1 );\r
+ if ( FoundGuessBlk )\r
+ {\r
+ fprintf(ErrFile, "#define ZZCAN_GUESS\n");\r
+ fprintf(ErrFile, "#include \"pccts_setjmp.h\"\n");\r
+ }\r
+ if (TraceGen) {\r
+ fprintf(ErrFile,"#ifndef zzTRACE_RULES\n"); /* MR20 */\r
+ fprintf(ErrFile,"#define zzTRACE_RULES\n"); /* MR20 */\r
+ fprintf(ErrFile,"#endif\n"); /* MR22 */\r
+ };\r
+\r
+ if ( OutputLL_k > 1 ) fprintf(ErrFile, "#define LL_K %d\n", OutputLL_k);\r
+#ifdef DUM\r
+ if ( LexGen ) fprintf(ErrFile, "#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));\r
+#endif\r
+ fprintf(ErrFile, "#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));\r
+ if ( DemandLookahead ) fprintf(ErrFile, "#define DEMAND_LOOK\n");\r
+ fprintf(ErrFile, "#include \"antlr.h\"\n");\r
+ if ( GenAST ) fprintf(ErrFile, "#include \"ast.h\"\n");\r
+ \r
+ if ( UserDefdTokens ) fprintf(ErrFile, "#include %s\n", UserTokenDefsFile);\r
+ /* still need this one as it has the func prototypes */\r
+ fprintf(ErrFile, "#include \"%s\"\n", DefFileName);\r
+ fprintf(ErrFile, "#include \"dlgdef.h\"\n");\r
+ fprintf(ErrFile, "#include \"err.h\"\n\n");\r
+\r
+ /* Dump a zztokens for each automaton */\r
+ if ( strcmp(ParserName, DefaultParserName)!=0 )\r
+ {\r
+ fprintf(ErrFile, "ANTLRChar *%s_zztokens[%d]={\n", ParserName, TokenNum-1);\r
+ }\r
+ else\r
+ {\r
+ fprintf(ErrFile, "ANTLRChar *zztokens[%d]={\n", TokenNum-1);\r
+ }\r
+ fprintf(ErrFile, "\t/* 00 */\t\"Invalid\"");\r
+ for (i=1; i<TokenNum-1; i++)\r
+ {\r
+ DAWDLE;\r
+ if ( i == EpToken ) continue;\r
+ /* remapped to invalid token? */\r
+ if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )\r
+ {\r
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"invalid\"", i);\r
+ continue;\r
+ }\r
+ if ( TokenString(i) != NULL ) {\r
+ te=(TermEntry *) hash_get(Tname,TokenString(i)); /* MR11 */\r
+ if (te == NULL || te->akaString == NULL) { /* MR11 */\r
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"%s\"", i, TokenString(i));\r
+ } else {\r
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"%s\"", i, te->akaString); /* MR11 */\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* look in all lexclasses for the reg expr */\r
+ for (j=0; j<NumLexClasses; j++)\r
+ {\r
+ lexmode(j);\r
+ if ( ExprString(i) != NULL )\r
+ {\r
+ fprintf(ErrFile, ",\n\t/* %02d */\t", i);\r
+ dumpExpr(ErrFile, ExprString(i));\r
+ break;\r
+ }\r
+ }\r
+ if ( j>=NumLexClasses )\r
+ {\r
+ if ( UserDefdTokens )\r
+ {\r
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"\"", i);\r
+ }\r
+ else\r
+ fatal_internal(eMsgd("No label or expr for token %d",i));\r
+ }\r
+ }\r
+ }\r
+ fprintf(ErrFile, "\n};\n");\r
+}\r
+\r
+void\r
+#ifdef __USE_PROTOS\r
+dumpExpr( FILE *f, char *e )\r
+#else\r
+dumpExpr( f, e )\r
+FILE *f;\r
+char *e;\r
+#endif\r
+{\r
+ while ( *e!='\0' )\r
+ {\r
+ if ( *e=='\\' && *(e+1)=='\\' )\r
+ {putc('\\', f); putc('\\', f); e+=2;}\r
+ else if ( *e=='\\' && *(e+1)=='"' )\r
+ {putc('\\', f); putc('"', f); e+=2;}\r
+ else if ( *e=='\\' ) {putc('\\', f); putc('\\', f); e++;}\r
+ else {putc(*e, f); e++;}\r
+ }\r
+}\r
+\r
+int\r
+#ifdef __USE_PROTOS\r
+isTermEntryTokClass(TermEntry *te)\r
+#else\r
+isTermEntryTokClass(te)\r
+TermEntry *te;\r
+#endif\r
+{\r
+ ListNode *t;\r
+ TCnode *p;\r
+ TermEntry *q;\r
+ char *tokstr;\r
+\r
+ if (tclasses == NULL) return 0;\r
+\r
+ for (t = tclasses->next; t!=NULL; t=t->next)\r
+ {\r
+ p = (TCnode *) t->elem;\r
+ tokstr = TokenString(p->tok);\r
+ lexmode(p->lexclass); /* switch to lexclass where tokclass is defined */\r
+ q = (TermEntry *) hash_get(Tname, tokstr);\r
+ if (q == te) return 1;\r
+ }\r
+ return 0;\r
+}\r