home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts.zip / pccts / antlr / antlr.c < prev    next >
C/C++ Source or Header  |  1994-03-31  |  38KB  |  1,786 lines
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.20b9
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    120b9
  11.  
  12. #ifdef __cplusplus
  13. #ifndef __STDC__
  14. #define __STDC__
  15. #endif
  16. #endif
  17. #include "set.h"
  18. #include <ctype.h>
  19. #include "syn.h"
  20. #include "hash.h"
  21. #include "generic.h"
  22. #define zzcr_attr(attr,tok,t)
  23. #define zzEOF_TOKEN 1
  24. #define zzSET_SIZE 16
  25. #include "antlr.h"
  26. #include "tokens.h"
  27. #include "dlgdef.h"
  28. #include "mode.h"
  29. ANTLR_INFO
  30.  
  31. #ifdef __STDC__
  32. static void chkToken(char *, char *, char *, int);
  33. #else
  34. static void chkToken();
  35. #endif
  36.  
  37. static int class_nest_level = 0;
  38.  
  39. void
  40. #ifdef __STDC__
  41. grammar(void)
  42. #else
  43. grammar()
  44. #endif
  45. {
  46.     zzRULE;
  47.     zzBLOCK(zztasp1);
  48.     zzMake0;
  49.     {
  50.     Graph g;  
  51.     {
  52.         zzBLOCK(zztasp2);
  53.         zzMake0;
  54.         {
  55.         while ( 1 ) {
  56.             if ( (LA(1)==80) ) {
  57.                 zzmatch(80); zzCONSUME;
  58.                 zzmatch(Action);
  59.                 
  60.                 if ( HdrAction==NULL ) {
  61.                     HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  62.                     require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  63.                     strcpy(HdrAction, LATEXT(1));
  64.                 }
  65.                 else warn("additional #header statement ignored");
  66.  zzCONSUME;
  67.             }
  68.             else {
  69.                 if ( (LA(1)==81) ) {
  70.                     zzmatch(81); zzCONSUME;
  71.                     zzmatch(QuotedTerm);
  72.                     
  73.                     if ( GenCC ) {
  74.                         warn("#parser meta-op incompatible with -CC; ignored");
  75.                     }
  76.                     else {
  77.                         if ( strcmp(ParserName,"zzparser")==0 ) {
  78.                             ParserName=StripQuotes(mystrdup(LATEXT(1)));
  79.                             if ( RulePrefix[0]!='\0' )
  80.                             {
  81.                                 warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  82.                                 RulePrefix[0]='\0';
  83.                             }
  84.                         }
  85.                         else warn("additional #parser statement ignored");
  86.                     }
  87.  zzCONSUME;
  88.                 }
  89.                 else {
  90.                     if ( (LA(1)==82) ) {
  91.                         zzmatch(82); zzCONSUME;
  92.                         zzmatch(QuotedTerm);
  93.                         {
  94.                             zzantlr_state st; FILE *f; struct zzdlg_state dst;
  95.                             UserTokenDefsFile = mystrdup(LATEXT(1));
  96.                             zzsave_antlr_state(&st);
  97.                             zzsave_dlg_state(&dst);
  98.                             f = fopen(StripQuotes(LATEXT(1)), "r");
  99.                             if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", LATEXT(1)+1));}
  100.                             else {
  101.                                 ANTLRm(enum_file(), f, PARSE_ENUM_FILE);
  102.                                 UserDefdTokens = 1;
  103.                             }
  104.                             zzrestore_antlr_state(&st);
  105.                             zzrestore_dlg_state(&dst);
  106.                         }  
  107.  zzCONSUME;
  108.                     }
  109.                     else break;
  110.                 }
  111.             }
  112.             zzLOOP(zztasp2);
  113.         }
  114.         zzEXIT(zztasp2);
  115.         }
  116.     }
  117.     {
  118.         zzBLOCK(zztasp2);
  119.         zzMake0;
  120.         {
  121.         char *a;  
  122.         while ( 1 ) {
  123.             if ( (LA(1)==Action) ) {
  124.                 zzmatch(Action);
  125.                 
  126.                 a = (char *) calloc(strlen(LATEXT(1))+1,
  127.                 sizeof(char));
  128.                 require(a!=NULL, "rule grammar: cannot allocate action");
  129.                 strcpy(a, LATEXT(1));
  130.                 if ( class_nest_level>0 ) list_add(&class_actions, a);
  131.                 else list_add(&BeforeActions, a);
  132.  zzCONSUME;
  133.             }
  134.             else {
  135.                 if ( (LA(1)==93) ) {
  136.                     laction();
  137.                 }
  138.                 else {
  139.                     if ( (LA(1)==94) ) {
  140.                         aLexclass();
  141.                     }
  142.                     else {
  143.                         if ( (LA(1)==97) ) {
  144.                             token();
  145.                         }
  146.                         else {
  147.                             if ( (LA(1)==95) ) {
  148.                                 error();
  149.                             }
  150.                             else {
  151.                                 if ( (LA(1)==96) ) {
  152.                                     tclass();
  153.                                 }
  154.                                 else {
  155.                                     if ( (LA(1)==84) ) {
  156.                                         class_def();
  157.                                     }
  158.                                     else {
  159.                                         if ( (LA(1)==83) ) {
  160.                                             zzmatch(83);
  161.                                             
  162.                                             if ( class_nest_level==0 )
  163.                                             warn("missing class definition for trailing '}'");
  164.                                             class_nest_level--;
  165.  zzCONSUME;
  166.                                         }
  167.                                         else break;
  168.                                     }
  169.                                 }
  170.                             }
  171.                         }
  172.                     }
  173.                 }
  174.             }
  175.             zzLOOP(zztasp2);
  176.         }
  177.         zzEXIT(zztasp2);
  178.         }
  179.     }
  180.     rule();
  181.     g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;  
  182.     {
  183.         zzBLOCK(zztasp2);
  184.         zzMake0;
  185.         {
  186.         while ( 1 ) {
  187.             if ( (LA(1)==NonTerminal) ) {
  188.                 rule();
  189.                 if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}  
  190.             }
  191.             else {
  192.                 if ( (LA(1)==94) ) {
  193.                     aLexclass();
  194.                 }
  195.                 else {
  196.                     if ( (LA(1)==97) ) {
  197.                         token();
  198.                     }
  199.                     else {
  200.                         if ( (LA(1)==95) ) {
  201.                             error();
  202.                         }
  203.                         else {
  204.                             if ( (LA(1)==96) ) {
  205.                                 tclass();
  206.                             }
  207.                             else {
  208.                                 if ( (LA(1)==84) ) {
  209.                                     class_def();
  210.                                 }
  211.                                 else {
  212.                                     if ( (LA(1)==83) ) {
  213.                                         zzmatch(83);
  214.                                         
  215.                                         if ( class_nest_level==0 )
  216.                                         warn("missing class definition for trailing '}'");
  217.                                         class_nest_level--;
  218.  zzCONSUME;
  219.                                     }
  220.                                     else break;
  221.                                 }
  222.                             }
  223.                         }
  224.                     }
  225.                 }
  226.             }
  227.             zzLOOP(zztasp2);
  228.         }
  229.         zzEXIT(zztasp2);
  230.         }
  231.     }
  232.     {
  233.         zzBLOCK(zztasp2);
  234.         zzMake0;
  235.         {
  236.         char *a;  
  237.         while ( 1 ) {
  238.             if ( (LA(1)==Action) ) {
  239.                 zzmatch(Action);
  240.                 
  241.                 a = (char *) calloc(strlen(LATEXT(1))+1,
  242.                 sizeof(char));
  243.                 require(a!=NULL, "rule grammar: cannot allocate action");
  244.                 strcpy(a, LATEXT(1));
  245.                 if ( class_nest_level>0 ) list_add(&class_actions, a);
  246.                 else list_add(&AfterActions, a);
  247.  zzCONSUME;
  248.             }
  249.             else {
  250.                 if ( (LA(1)==93) ) {
  251.                     laction();
  252.                 }
  253.                 else {
  254.                     if ( (LA(1)==95) ) {
  255.                         error();
  256.                     }
  257.                     else {
  258.                         if ( (LA(1)==96) ) {
  259.                             tclass();
  260.                         }
  261.                         else {
  262.                             if ( (LA(1)==84) ) {
  263.                                 class_def();
  264.                             }
  265.                             else {
  266.                                 if ( (LA(1)==83) ) {
  267.                                     zzmatch(83);
  268.                                     
  269.                                     if ( class_nest_level==0 )
  270.                                     warn("missing class definition for trailing '}'");
  271.                                     class_nest_level--;
  272.  zzCONSUME;
  273.                                 }
  274.                                 else break;
  275.                             }
  276.                         }
  277.                     }
  278.                 }
  279.             }
  280.             zzLOOP(zztasp2);
  281.         }
  282.         zzEXIT(zztasp2);
  283.         }
  284.     }
  285.     zzmatch(Eof); zzCONSUME;
  286.     zzEXIT(zztasp1);
  287.     return;
  288. fail:
  289.     zzEXIT(zztasp1);
  290.     CannotContinue=TRUE;  
  291.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  292.     zzresynch(setwd1, 0x1);
  293.     }
  294. }
  295.  
  296. void
  297. #ifdef __STDC__
  298. class_def(void)
  299. #else
  300. class_def()
  301. #endif
  302. {
  303.     zzRULE;
  304.     zzBLOCK(zztasp1);
  305.     zzMake0;
  306.     {
  307.     int go=1; char name[MaxRuleName+1];  
  308.     zzmatch(84); zzCONSUME;
  309.     {
  310.         zzBLOCK(zztasp2);
  311.         zzMake0;
  312.         {
  313.         if ( (LA(1)==NonTerminal) ) {
  314.             zzmatch(NonTerminal);
  315.             if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  316.  zzCONSUME;
  317.         }
  318.         else {
  319.             if ( (LA(1)==TokenTerm) ) {
  320.                 zzmatch(TokenTerm);
  321.                 if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  322.  zzCONSUME;
  323.             }
  324.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  325.         }
  326.         zzEXIT(zztasp2);
  327.         }
  328.     }
  329.     
  330.     if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
  331.     && GenCC ) {
  332.         err("only one grammar class allowed in this release");
  333.         go = 0;
  334.     }
  335.     else strcpy(CurrentClassName, name);
  336.     if ( !GenCC ) { err("class meta-op used without C++ option"); }  
  337.     zzmatch(87);
  338.     
  339.     no_classes_found = 0;
  340.     if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
  341.     else class_nest_level++;
  342.  zzCONSUME;
  343.     zzEXIT(zztasp1);
  344.     return;
  345. fail:
  346.     zzEXIT(zztasp1);
  347.     CannotContinue=TRUE;  
  348.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  349.     zzresynch(setwd1, 0x2);
  350.     }
  351. }
  352.  
  353. void
  354. #ifdef __STDC__
  355. rule(void)
  356. #else
  357. rule()
  358. #endif
  359. {
  360.     zzRULE;
  361.     zzBLOCK(zztasp1);
  362.     zzMake0;
  363.     {
  364.     
  365.     RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  366.     set toksrefd, rulesrefd;
  367.     char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  368.     zzmatch(NonTerminal);
  369.     q=NULL;
  370.     if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  371.         warn(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
  372.         CannotContinue=TRUE;
  373.     }
  374.     else
  375.     {
  376.         q = (RuleEntry *)hash_add(Rname,
  377.         LATEXT(1),
  378.         (Entry *)newRuleEntry(LATEXT(1)));
  379.         CurRule = q->str;
  380.     }
  381.     CurRuleNode = q;
  382.     f = CurFile; l = zzline;
  383.     NumRules++;
  384.  zzCONSUME;
  385.     {
  386.         zzBLOCK(zztasp2);
  387.         zzMake0;
  388.         {
  389.         if ( (LA(1)==88) ) {
  390.             zzmatch(88);
  391.             if ( q!=NULL ) q->noAST = TRUE;  
  392.  zzCONSUME;
  393.         }
  394.         zzEXIT(zztasp2);
  395.         }
  396.     }
  397.     {
  398.         zzBLOCK(zztasp2);
  399.         zzMake0;
  400.         {
  401.         ;  
  402.         if ( (setwd1[LA(1)]&0x4) ) {
  403.             {
  404.                 zzBLOCK(zztasp3);
  405.                 zzMake0;
  406.                 {
  407.                 if ( (LA(1)==89) ) {
  408.                     zzmatch(89); zzCONSUME;
  409.                 }
  410.                 zzEXIT(zztasp3);
  411.                 }
  412.             }
  413.             zzmatch(PassAction);
  414.             pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  415.             require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  416.             strcpy(pdecl, LATEXT(1));
  417.             CurParmDef = pdecl;
  418.  zzCONSUME;
  419.         }
  420.         zzEXIT(zztasp2);
  421.         }
  422.     }
  423.     {
  424.         zzBLOCK(zztasp2);
  425.         zzMake0;
  426.         {
  427.         if ( (LA(1)==90) ) {
  428.             zzmatch(90); zzCONSUME;
  429.             zzmatch(PassAction);
  430.             ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  431.             require(ret!=NULL, "rule rule: cannot allocate ret type");
  432.             strcpy(ret, LATEXT(1));
  433.             CurRetDef = ret;
  434.  zzCONSUME;
  435.         }
  436.         zzEXIT(zztasp2);
  437.         }
  438.     }
  439.     {
  440.         zzBLOCK(zztasp2);
  441.         zzMake0;
  442.         {
  443.         if ( (LA(1)==QuotedTerm) ) {
  444.             zzmatch(QuotedTerm);
  445.             if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));  
  446.  zzCONSUME;
  447.         }
  448.         zzEXIT(zztasp2);
  449.         }
  450.     }
  451.     
  452.     if ( GenEClasseForRules && q!=NULL ) {
  453.         e = newECnode;
  454.         require(e!=NULL, "cannot allocate error class node");
  455.         if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  456.         else a = q->egroup;
  457.         if ( Tnum( a ) == 0 )
  458.         {
  459.             e->tok = addTname( a );
  460.             list_add(&eclasses, (char *)e);
  461.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  462.             /* refers to itself */
  463.             list_add(&(e->elist), mystrdup(q->str));
  464.         }
  465.         else {
  466.             warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
  467.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  468.             free(e);
  469.         }
  470.     }
  471.     BlkLevel++;  
  472.     zzmatch(91); zzCONSUME;
  473.     block( &toksrefd, &rulesrefd );
  474.     r = makeBlk(zzaArg(zztasp1,7),0);
  475.     ((Junction *)r.left)->jtype = RuleBlk;
  476.     if ( q!=NULL ) ((Junction *)r.left)->rname = q->str;
  477.     ((Junction *)r.left)->file = f;
  478.     ((Junction *)r.left)->line = l;
  479.     ((Junction *)r.left)->pdecl = pdecl;
  480.     ((Junction *)r.left)->ret = ret;
  481.     ((Junction *)r.left)->lock = makelocks();
  482.     ((Junction *)r.left)->pred_lock = makelocks();
  483.     ((Junction *)r.left)->tokrefs = toksrefd;
  484.     ((Junction *)r.left)->rulerefs = rulesrefd;
  485.     p = newJunction();    /* add EndRule Node */
  486.     ((Junction *)r.right)->p1 = (Node *)p;
  487.     r.right = (Node *) p;
  488.     p->jtype = EndRule;
  489.     p->lock = makelocks();
  490.     p->pred_lock = makelocks();
  491.     ((Junction *)r.left)->end = p;
  492.     if ( q!=NULL ) q->rulenum = NumRules;
  493.     zzaArg(zztasp1,7) = r;
  494.     --BlkLevel;  
  495.     zzmatch(92); zzCONSUME;
  496.     {
  497.         zzBLOCK(zztasp2);
  498.         zzMake0;
  499.         {
  500.         if ( (LA(1)==Action) ) {
  501.             zzmatch(Action);
  502.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  503.             require(a!=NULL, "rule rule: cannot allocate error action");
  504.             strcpy(a, LATEXT(1));
  505.             ((Junction *)r.left)->erraction = a;
  506.  zzCONSUME;
  507.         }
  508.         zzEXIT(zztasp2);
  509.         }
  510.     }
  511.     if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);  
  512.     CurRuleNode = NULL;  
  513.     zzEXIT(zztasp1);
  514.     return;
  515. fail:
  516.     zzEXIT(zztasp1);
  517.     CannotContinue=TRUE;  
  518.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  519.     zzresynch(setwd1, 0x8);
  520.     }
  521. }
  522.  
  523. void
  524. #ifdef __STDC__
  525. laction(void)
  526. #else
  527. laction()
  528. #endif
  529. {
  530.     zzRULE;
  531.     zzBLOCK(zztasp1);
  532.     zzMake0;
  533.     {
  534.     char *a;  
  535.     zzmatch(93); zzCONSUME;
  536.     zzmatch(Action);
  537.     
  538.     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  539.     require(a!=NULL, "rule laction: cannot allocate action");
  540.     strcpy(a, LATEXT(1));
  541.     list_add(&LexActions, a);
  542.  zzCONSUME;
  543.     zzEXIT(zztasp1);
  544.     return;
  545. fail:
  546.     zzEXIT(zztasp1);
  547.     CannotContinue=TRUE;  
  548.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  549.     zzresynch(setwd1, 0x10);
  550.     }
  551. }
  552.  
  553. void
  554. #ifdef __STDC__
  555. aLexclass(void)
  556. #else
  557. aLexclass()
  558. #endif
  559. {
  560.     zzRULE;
  561.     zzBLOCK(zztasp1);
  562.     zzMake0;
  563.     {
  564.     zzmatch(94); zzCONSUME;
  565.     zzmatch(TokenTerm);
  566.     lexclass(mystrdup(LATEXT(1)));  
  567.  zzCONSUME;
  568.     zzEXIT(zztasp1);
  569.     return;
  570. fail:
  571.     zzEXIT(zztasp1);
  572.     CannotContinue=TRUE;  
  573.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  574.     zzresynch(setwd1, 0x20);
  575.     }
  576. }
  577.  
  578. void
  579. #ifdef __STDC__
  580. error(void)
  581. #else
  582. error()
  583. #endif
  584. {
  585.     zzRULE;
  586.     zzBLOCK(zztasp1);
  587.     zzMake0;
  588.     {
  589.     char *t=NULL; ECnode *e; int go=1; TermEntry *p;  
  590.     zzmatch(95); zzCONSUME;
  591.     {
  592.         zzBLOCK(zztasp2);
  593.         zzMake0;
  594.         {
  595.         ;  
  596.         if ( (LA(1)==TokenTerm) ) {
  597.             zzmatch(TokenTerm);
  598.             t=mystrdup(LATEXT(1));  
  599.  zzCONSUME;
  600.         }
  601.         else {
  602.             if ( (LA(1)==QuotedTerm) ) {
  603.                 zzmatch(QuotedTerm);
  604.                 t=mystrdup(LATEXT(1));  
  605.  zzCONSUME;
  606.             }
  607.             else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  608.         }
  609.         zzEXIT(zztasp2);
  610.         }
  611.     }
  612.     e = newECnode;
  613.     require(e!=NULL, "cannot allocate error class node");
  614.     e->lexclass = CurrentLexClass;
  615.     if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  616.     {
  617.         if ( hash_get(Texpr, t) != NULL )
  618.         warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  619.         e->tok = addTname( t );
  620.         set_orel(e->tok, &imag_tokens);
  621.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  622.         "hash table mechanism is broken");
  623.         p->classname = 1;    /* entry is errclass name, not token */
  624.         list_add(&eclasses, (char *)e);
  625.     }
  626.     else
  627.     {
  628.     warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
  629.     free( e );
  630.     go=0;
  631. }
  632.     zzmatch(87); zzCONSUME;
  633.     {
  634.         zzBLOCK(zztasp2);
  635.         zzMake0;
  636.         {
  637.         if ( (LA(1)==NonTerminal) ) {
  638.             zzmatch(NonTerminal);
  639.             if ( go ) t=mystrdup(LATEXT(1));  
  640.  zzCONSUME;
  641.         }
  642.         else {
  643.             if ( (LA(1)==TokenTerm) ) {
  644.                 zzmatch(TokenTerm);
  645.                 if ( go ) t=mystrdup(LATEXT(1));  
  646.  zzCONSUME;
  647.             }
  648.             else {
  649.                 if ( (LA(1)==QuotedTerm) ) {
  650.                     zzmatch(QuotedTerm);
  651.                     if ( go ) t=mystrdup(LATEXT(1));  
  652.  zzCONSUME;
  653.                 }
  654.                 else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  655.             }
  656.         }
  657.         zzEXIT(zztasp2);
  658.         }
  659.     }
  660.     if ( go ) list_add(&(e->elist), t);  
  661.     {
  662.         zzBLOCK(zztasp2);
  663.         zzMake0;
  664.         {
  665.         while ( (setwd1[LA(1)]&0x40) ) {
  666.             {
  667.                 zzBLOCK(zztasp3);
  668.                 zzMake0;
  669.                 {
  670.                 if ( (LA(1)==NonTerminal) ) {
  671.                     zzmatch(NonTerminal);
  672.                     if ( go ) t=mystrdup(LATEXT(1));  
  673.  zzCONSUME;
  674.                 }
  675.                 else {
  676.                     if ( (LA(1)==TokenTerm) ) {
  677.                         zzmatch(TokenTerm);
  678.                         if ( go ) t=mystrdup(LATEXT(1));  
  679.  zzCONSUME;
  680.                     }
  681.                     else {
  682.                         if ( (LA(1)==QuotedTerm) ) {
  683.                             zzmatch(QuotedTerm);
  684.                             if ( go ) t=mystrdup(LATEXT(1));  
  685.  zzCONSUME;
  686.                         }
  687.                         else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  688.                     }
  689.                 }
  690.                 zzEXIT(zztasp3);
  691.                 }
  692.             }
  693.             if ( go ) list_add(&(e->elist), t);  
  694.             zzLOOP(zztasp2);
  695.         }
  696.         zzEXIT(zztasp2);
  697.         }
  698.     }
  699.     zzmatch(83); zzCONSUME;
  700.     zzEXIT(zztasp1);
  701.     return;
  702. fail:
  703.     zzEXIT(zztasp1);
  704.     CannotContinue=TRUE;  
  705.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  706.     zzresynch(setwd1, 0x80);
  707.     }
  708. }
  709.  
  710. void
  711. #ifdef __STDC__
  712. tclass(void)
  713. #else
  714. tclass()
  715. #endif
  716. {
  717.     zzRULE;
  718.     zzBLOCK(zztasp1);
  719.     zzMake0;
  720.     {
  721.     char *t=NULL; TCnode *e; int go=1,tok; TermEntry *p, *term;  
  722.     zzmatch(96); zzCONSUME;
  723.     zzmatch(TokenTerm);
  724.     t=mystrdup(LATEXT(1));  
  725.  zzCONSUME;
  726.     e = newTCnode;
  727.     require(e!=NULL, "cannot allocate token class node");
  728.     e->lexclass = CurrentLexClass;
  729.     if ( Tnum( t ) == 0 )
  730.     {
  731.         e->tok = addTname( t );
  732.         set_orel(e->tok, &imag_tokens);
  733.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  734.         "hash table mechanism is broken");
  735.         p->classname = 1;    /* entry is class name, not token */
  736.         p->tclass = e;        /* save ptr to this tclass def */
  737.         list_add(&tclasses, (char *)e);
  738.     }
  739.     else
  740.     {
  741.     warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
  742.     free( e );
  743.     go=0;
  744. }
  745.     zzmatch(87); zzCONSUME;
  746.     {
  747.         zzBLOCK(zztasp2);
  748.         zzMake0;
  749.         {
  750.         while ( (setwd2[LA(1)]&0x1) ) {
  751.             {
  752.                 zzBLOCK(zztasp3);
  753.                 zzMake0;
  754.                 {
  755.                 if ( (LA(1)==TokenTerm) ) {
  756.                     zzmatch(TokenTerm);
  757.                     if ( go ) {
  758.                         term = (TermEntry *) hash_get(Tname, LATEXT(1));
  759.                         if ( term==NULL && UserDefdTokens ) {
  760.                             err("implicit token definition not allowed with #tokdefs");
  761.                             go = 0;
  762.                         }
  763.                         else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
  764.                     }  
  765.  zzCONSUME;
  766.                 }
  767.                 else {
  768.                     if ( (LA(1)==QuotedTerm) ) {
  769.                         zzmatch(QuotedTerm);
  770.                         if ( go ) {
  771.                             term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  772.                             if ( term==NULL && UserDefdTokens ) {
  773.                                 err("implicit token definition not allowed with #tokdefs");
  774.                                 go = 0;
  775.                             }
  776.                             else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
  777.                         }  
  778.  zzCONSUME;
  779.                     }
  780.                     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  781.                 }
  782.                 zzEXIT(zztasp3);
  783.                 }
  784.             }
  785.             if ( go ) list_add(&(e->tlist), t);  
  786.             zzLOOP(zztasp2);
  787.         }
  788.         zzEXIT(zztasp2);
  789.         }
  790.     }
  791.     zzmatch(83); zzCONSUME;
  792.     zzEXIT(zztasp1);
  793.     return;
  794. fail:
  795.     zzEXIT(zztasp1);
  796.     CannotContinue=TRUE;  
  797.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  798.     zzresynch(setwd2, 0x2);
  799.     }
  800. }
  801.  
  802. void
  803. #ifdef __STDC__
  804. token(void)
  805. #else
  806. token()
  807. #endif
  808. {
  809.     zzRULE;
  810.     zzBLOCK(zztasp1);
  811.     zzMake0;
  812.     {
  813.     char *t=NULL, *e=NULL, *a=NULL; int tnum=0;  
  814.     zzmatch(97); zzCONSUME;
  815.     {
  816.         zzBLOCK(zztasp2);
  817.         zzMake0;
  818.         {
  819.         if ( (LA(1)==TokenTerm) ) {
  820.             zzmatch(TokenTerm);
  821.             t=mystrdup(LATEXT(1));  
  822.  zzCONSUME;
  823.             {
  824.                 zzBLOCK(zztasp3);
  825.                 zzMake0;
  826.                 {
  827.                 if ( (LA(1)==98) ) {
  828.                     zzmatch(98); zzCONSUME;
  829.                     zzmatch(99);
  830.                     tnum = atoi(LATEXT(1));  
  831.  zzCONSUME;
  832.                 }
  833.                 zzEXIT(zztasp3);
  834.                 }
  835.             }
  836.         }
  837.         zzEXIT(zztasp2);
  838.         }
  839.     }
  840.     {
  841.         zzBLOCK(zztasp2);
  842.         zzMake0;
  843.         {
  844.         if ( (LA(1)==QuotedTerm) ) {
  845.             zzmatch(QuotedTerm);
  846.             e=mystrdup(LATEXT(1));  
  847.  zzCONSUME;
  848.         }
  849.         zzEXIT(zztasp2);
  850.         }
  851.     }
  852.     {
  853.         zzBLOCK(zztasp2);
  854.         zzMake0;
  855.         {
  856.         if ( (LA(1)==Action) ) {
  857.             zzmatch(Action);
  858.             
  859.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  860.             require(a!=NULL, "rule token: cannot allocate action");
  861.             strcpy(a, LATEXT(1));
  862.  zzCONSUME;
  863.         }
  864.         zzEXIT(zztasp2);
  865.         }
  866.     }
  867.     chkToken(t, e, a, tnum);  
  868.     zzEXIT(zztasp1);
  869.     return;
  870. fail:
  871.     zzEXIT(zztasp1);
  872.     CannotContinue=TRUE;  
  873.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  874.     zzresynch(setwd2, 0x4);
  875.     }
  876. }
  877.  
  878. void
  879. #ifdef __STDC__
  880. block( set *toksrefd, set *rulesrefd )
  881. #else
  882. block(toksrefd,rulesrefd)
  883.  set *toksrefd;
  884. set *rulesrefd ;
  885. #endif
  886. {
  887.     zzRULE;
  888.     zzBLOCK(zztasp1);
  889.     zzMake0;
  890.     {
  891.     
  892.     Graph g, b;
  893.     * toksrefd = empty;
  894.     * rulesrefd = empty;
  895.     set_clr(AST_nodes_refd_in_actions);
  896.     alt( toksrefd,rulesrefd );
  897.     b = g = zzaArg(zztasp1,1);  
  898.     
  899.     if ( ((Junction *)g.left)->p1->ntype == nAction )
  900.     {
  901.         if ( !((ActionNode *)(((Junction *)g.left)->p1))->is_predicate )
  902.         {
  903.             ((ActionNode *)(((Junction *)g.left)->p1))->init_action = TRUE;
  904.         }
  905.     }
  906.     {
  907.         zzBLOCK(zztasp2);
  908.         zzMake0;
  909.         {
  910.         while ( (LA(1)==100) ) {
  911.             zzmatch(100); zzCONSUME;
  912.             alt( toksrefd,rulesrefd );
  913.             g = Or(g, zzaArg(zztasp2,2));  
  914.             zzLOOP(zztasp2);
  915.         }
  916.         zzEXIT(zztasp2);
  917.         }
  918.     }
  919.     zzaArg(zztasp1,0) = b;  
  920.     zzEXIT(zztasp1);
  921.     return;
  922. fail:
  923.     zzEXIT(zztasp1);
  924.     CannotContinue=TRUE;  
  925.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  926.     zzresynch(setwd2, 0x8);
  927.     }
  928. }
  929.  
  930. void
  931. #ifdef __STDC__
  932. alt( set *toksrefd, set *rulesrefd )
  933. #else
  934. alt(toksrefd,rulesrefd)
  935.  set *toksrefd;
  936. set *rulesrefd ;
  937. #endif
  938. {
  939.     zzRULE;
  940.     zzBLOCK(zztasp1);
  941.     zzMake0;
  942.     {
  943.     int n=0,ne=0; Graph g; int e_num=0, not=0;
  944.     int first_on_line = 1; g.left=g.right=NULL;
  945.     {
  946.         zzBLOCK(zztasp2);
  947.         zzMake0;
  948.         {
  949.         int tok;  
  950.         while ( (setwd2[LA(1)]&0x10) ) {
  951.             tok = LA(1);  
  952.             {
  953.                 zzBLOCK(zztasp3);
  954.                 zzMake0;
  955.                 {
  956.                 not=0;  
  957.                 if ( (LA(1)==101) ) {
  958.                     zzmatch(101);
  959.                     not=1;  
  960.  zzCONSUME;
  961.                 }
  962.                 zzEXIT(zztasp3);
  963.                 }
  964.             }
  965.             element( not, first_on_line );
  966.             if ( tok!=Action && tok!=Pred ) first_on_line = 0;  
  967.             
  968.             if ( zzaArg(zztasp2,2 ).left!=NULL ) {
  969.                 g = Cat(g, zzaArg(zztasp2,2));
  970.                 n++;
  971.                 if ( tok!=Action && tok!=Pred ) e_num++;
  972.                 /* record record number of all rule and token refs */
  973.                 if ( tok==TokenTerm||tok==QuotedTerm||tok==WildCard ) {
  974.                     ((TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1)->elnum = e_num;
  975.                     set_orel(e_num,  toksrefd);
  976.                 }
  977.                 else if ( tok==NonTerminal ) {
  978.                     ((RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1)->elnum = e_num;
  979.                     set_orel(e_num,  rulesrefd);
  980.                 }
  981.             }
  982.             zzLOOP(zztasp2);
  983.         }
  984.         zzEXIT(zztasp2);
  985.         }
  986.     }
  987.     if ( n == 0 ) g = emptyAlt();
  988.     zzaArg(zztasp1,0) = g;
  989.     zzEXIT(zztasp1);
  990.     return;
  991. fail:
  992.     zzEXIT(zztasp1);
  993.     CannotContinue=TRUE;  
  994.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  995.     zzresynch(setwd2, 0x20);
  996.     }
  997. }
  998.  
  999. void
  1000. #ifdef __STDC__
  1001. element( int not, int first_on_line )
  1002. #else
  1003. element(not,first_on_line)
  1004.  int not;
  1005. int first_on_line ;
  1006. #endif
  1007. {
  1008.     zzRULE;
  1009.     zzBLOCK(zztasp1);
  1010.     zzMake0;
  1011.     {
  1012.     
  1013.     set toksrefd, rulesrefd;
  1014.     TermEntry *term;
  1015.     TokNode *p=NULL; RuleRefNode *q; int approx=0;
  1016.     if ( (LA(1)==TokenTerm) ) {
  1017.         zzmatch(TokenTerm);
  1018.         
  1019.         term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1020.         if ( term==NULL && UserDefdTokens ) {
  1021.             err("implicit token definition not allowed with #tokdefs");
  1022.             zzaArg(zztasp1,0 ).left = zzaArg(zztasp1,0 ).right = NULL;
  1023.         }
  1024.         else {
  1025.             zzaArg(zztasp1,0) = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);
  1026.             term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1027.             require( term!= NULL, "hash table mechanism is broken");
  1028.             p->tclass = term->tclass;
  1029.             p->complement =  not;
  1030.         }
  1031.  zzCONSUME;
  1032.         {
  1033.             zzBLOCK(zztasp2);
  1034.             zzMake0;
  1035.             {
  1036.             if ( (LA(1)==102) ) {
  1037.                 zzmatch(102); zzCONSUME;
  1038.                 {
  1039.                     zzBLOCK(zztasp3);
  1040.                     zzMake0;
  1041.                     {
  1042.                     if ( (LA(1)==QuotedTerm) ) {
  1043.                         zzmatch(QuotedTerm);
  1044.                         if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1045.  zzCONSUME;
  1046.                     }
  1047.                     else {
  1048.                         if ( (LA(1)==TokenTerm) ) {
  1049.                             zzmatch(TokenTerm);
  1050.                             if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1051.  zzCONSUME;
  1052.                         }
  1053.                         else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1054.                     }
  1055.                     zzEXIT(zztasp3);
  1056.                     }
  1057.                 }
  1058.             }
  1059.             zzEXIT(zztasp2);
  1060.             }
  1061.         }
  1062.         
  1063.         if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1064.         list_add(&MetaTokenNodes, (void *)p);
  1065.         {
  1066.             zzBLOCK(zztasp2);
  1067.             zzMake0;
  1068.             {
  1069.             if ( (LA(1)==103) ) {
  1070.                 zzmatch(103);
  1071.                 if ( p!=NULL ) p->astnode=ASTroot;  
  1072.  zzCONSUME;
  1073.             }
  1074.             else {
  1075.                 if ( (setwd2[LA(1)]&0x40) ) {
  1076.                     if ( p!=NULL ) p->astnode=ASTchild;  
  1077.                 }
  1078.                 else {
  1079.                     if ( (LA(1)==88) ) {
  1080.                         zzmatch(88);
  1081.                         if ( p!=NULL ) p->astnode=ASTexclude;  
  1082.  zzCONSUME;
  1083.                     }
  1084.                     else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1085.                 }
  1086.             }
  1087.             zzEXIT(zztasp2);
  1088.             }
  1089.         }
  1090.     }
  1091.     else {
  1092.         if ( (LA(1)==QuotedTerm) ) {
  1093.             zzmatch(QuotedTerm);
  1094.             
  1095.             term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1096.             if ( term==NULL && UserDefdTokens ) {
  1097.                 err("implicit token definition not allowed with #tokdefs");
  1098.                 zzaArg(zztasp1,0 ).left = zzaArg(zztasp1,0 ).right = NULL;
  1099.             }
  1100.             else {
  1101.                 zzaArg(zztasp1,0) = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);
  1102.                 p->complement =  not;
  1103.             }
  1104.  zzCONSUME;
  1105.             {
  1106.                 zzBLOCK(zztasp2);
  1107.                 zzMake0;
  1108.                 {
  1109.                 if ( (LA(1)==102) ) {
  1110.                     zzmatch(102); zzCONSUME;
  1111.                     {
  1112.                         zzBLOCK(zztasp3);
  1113.                         zzMake0;
  1114.                         {
  1115.                         if ( (LA(1)==QuotedTerm) ) {
  1116.                             zzmatch(QuotedTerm);
  1117.                             if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1118.  zzCONSUME;
  1119.                         }
  1120.                         else {
  1121.                             if ( (LA(1)==TokenTerm) ) {
  1122.                                 zzmatch(TokenTerm);
  1123.                                 if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1124.  zzCONSUME;
  1125.                             }
  1126.                             else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1127.                         }
  1128.                         zzEXIT(zztasp3);
  1129.                         }
  1130.                     }
  1131.                 }
  1132.                 zzEXIT(zztasp2);
  1133.                 }
  1134.             }
  1135.             {
  1136.                 zzBLOCK(zztasp2);
  1137.                 zzMake0;
  1138.                 {
  1139.                 if ( (LA(1)==103) ) {
  1140.                     zzmatch(103);
  1141.                     if ( p!=NULL ) p->astnode=ASTroot;  
  1142.  zzCONSUME;
  1143.                 }
  1144.                 else {
  1145.                     if ( (setwd2[LA(1)]&0x80) ) {
  1146.                         if ( p!=NULL ) p->astnode=ASTchild;  
  1147.                     }
  1148.                     else {
  1149.                         if ( (LA(1)==88) ) {
  1150.                             zzmatch(88);
  1151.                             if ( p!=NULL ) p->astnode=ASTexclude;  
  1152.  zzCONSUME;
  1153.                         }
  1154.                         else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1155.                     }
  1156.                 }
  1157.                 zzEXIT(zztasp2);
  1158.                 }
  1159.             }
  1160.             
  1161.             if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1162.             list_add(&MetaTokenNodes, (void *)p);
  1163.         }
  1164.         else {
  1165.             if ( (LA(1)==WildCard) ) {
  1166.                 if (  not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");  
  1167.                 zzmatch(WildCard);
  1168.                 zzaArg(zztasp1,0) = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);  
  1169.  zzCONSUME;
  1170.                 {
  1171.                     zzBLOCK(zztasp2);
  1172.                     zzMake0;
  1173.                     {
  1174.                     if ( (LA(1)==103) ) {
  1175.                         zzmatch(103);
  1176.                         p->astnode=ASTroot;  
  1177.  zzCONSUME;
  1178.                     }
  1179.                     else {
  1180.                         if ( (setwd3[LA(1)]&0x1) ) {
  1181.                             p->astnode=ASTchild;  
  1182.                         }
  1183.                         else {
  1184.                             if ( (LA(1)==88) ) {
  1185.                                 zzmatch(88);
  1186.                                 p->astnode=ASTexclude;  
  1187.  zzCONSUME;
  1188.                             }
  1189.                             else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1190.                         }
  1191.                     }
  1192.                     zzEXIT(zztasp2);
  1193.                     }
  1194.                 }
  1195.                 list_add(&MetaTokenNodes, (void *)p);  
  1196.             }
  1197.             else {
  1198.                 if ( (LA(1)==NonTerminal) ) {
  1199.                     if (  not ) warn("~ NONTERMINAL is an undefined operation");  
  1200.                     zzmatch(NonTerminal);
  1201.                     zzaArg(zztasp1,0) = buildRuleRef(LATEXT(1));  
  1202.  zzCONSUME;
  1203.                     {
  1204.                         zzBLOCK(zztasp2);
  1205.                         zzMake0;
  1206.                         {
  1207.                         if ( (LA(1)==88) ) {
  1208.                             zzmatch(88);
  1209.                             q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  1210.                             q->astnode=ASTexclude;  
  1211.  zzCONSUME;
  1212.                         }
  1213.                         zzEXIT(zztasp2);
  1214.                         }
  1215.                     }
  1216.                     {
  1217.                         zzBLOCK(zztasp2);
  1218.                         zzMake0;
  1219.                         {
  1220.                         if ( (setwd3[LA(1)]&0x2) ) {
  1221.                             {
  1222.                                 zzBLOCK(zztasp3);
  1223.                                 zzMake0;
  1224.                                 {
  1225.                                 if ( (LA(1)==89) ) {
  1226.                                     zzmatch(89); zzCONSUME;
  1227.                                 }
  1228.                                 zzEXIT(zztasp3);
  1229.                                 }
  1230.                             }
  1231.                             zzmatch(PassAction);
  1232.                             addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1233.  zzCONSUME;
  1234.                         }
  1235.                         zzEXIT(zztasp2);
  1236.                         }
  1237.                     }
  1238.                     {
  1239.                         zzBLOCK(zztasp2);
  1240.                         zzMake0;
  1241.                         {
  1242.                         char *a; RuleRefNode *rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  1243.                         if ( (LA(1)==90) ) {
  1244.                             zzmatch(90); zzCONSUME;
  1245.                             zzmatch(PassAction);
  1246.                             
  1247.                             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1248.                             require(a!=NULL, "rule element: cannot allocate assignment");
  1249.                             strcpy(a, LATEXT(1));
  1250.                             rr->assign = a;
  1251.  zzCONSUME;
  1252.                         }
  1253.                         zzEXIT(zztasp2);
  1254.                         }
  1255.                     }
  1256.                 }
  1257.                 else {
  1258.                     if ( (LA(1)==Action) ) {
  1259.                         if (  not )    warn("~ ACTION is an undefined operation");  
  1260.                         zzmatch(Action);
  1261.                         zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);  
  1262.  zzCONSUME;
  1263.                     }
  1264.                     else {
  1265.                         if ( (LA(1)==Pred) ) {
  1266.                             if (  not )    warn("~ SEMANTIC-PREDICATE is an undefined operation");  
  1267.                             zzmatch(Pred);
  1268.                             zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);  
  1269.  zzCONSUME;
  1270.                             {
  1271.                                 zzBLOCK(zztasp2);
  1272.                                 zzMake0;
  1273.                                 {
  1274.                                 char *a; ActionNode *act = (ActionNode *) ((Junction *)zzaRet.left)->p1;  
  1275.                                 if ( (LA(1)==PassAction) ) {
  1276.                                     zzmatch(PassAction);
  1277.                                     
  1278.                                     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1279.                                     require(a!=NULL, "rule element: cannot allocate predicate fail action");
  1280.                                     strcpy(a, LATEXT(1));
  1281.                                     act->pred_fail = a;
  1282.  zzCONSUME;
  1283.                                 }
  1284.                                 zzEXIT(zztasp2);
  1285.                                 }
  1286.                             }
  1287.                             
  1288.                             if ( DemandLookahead )
  1289.                             {
  1290.                                 warn("-gk incompatible with <<..>>? predicate usage; -gk turned off");
  1291.                                 DemandLookahead = 0;
  1292.                             }
  1293.                         }
  1294.                         else {
  1295.                             if ( (setwd3[LA(1)]&0x4) ) {
  1296.                                 if (  not )    warn("~ BLOCK is an undefined operation");  
  1297.                                 BlkLevel++;  
  1298.                                 {
  1299.                                     zzBLOCK(zztasp2);
  1300.                                     zzMake0;
  1301.                                     {
  1302.                                     if ( (LA(1)==104) ) {
  1303.                                         zzmatch(104); zzCONSUME;
  1304.                                         {
  1305.                                             zzBLOCK(zztasp3);
  1306.                                             zzMake0;
  1307.                                             {
  1308.                                             if ( (LA(1)==105) ) {
  1309.                                                 zzmatch(105);
  1310.                                                 approx=LL_k;  
  1311.  zzCONSUME;
  1312.                                             }
  1313.                                             else {
  1314.                                                 if ( (LA(1)==106) ) {
  1315.                                                     zzmatch(106);
  1316.                                                     approx = 1;  
  1317.  zzCONSUME;
  1318.                                                 }
  1319.                                                 else {
  1320.                                                     if ( (LA(1)==107) ) {
  1321.                                                         zzmatch(107);
  1322.                                                         approx = 2;  
  1323.  zzCONSUME;
  1324.                                                     }
  1325.                                                     else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1326.                                                 }
  1327.                                             }
  1328.                                             zzEXIT(zztasp3);
  1329.                                             }
  1330.                                         }
  1331.                                     }
  1332.                                     zzEXIT(zztasp2);
  1333.                                     }
  1334.                                 }
  1335.                                 {
  1336.                                     zzBLOCK(zztasp2);
  1337.                                     zzMake0;
  1338.                                     {
  1339.                                     if ( (LA(1)==108) ) {
  1340.                                         zzmatch(108); zzCONSUME;
  1341.                                         block( &toksrefd,&rulesrefd );
  1342.                                         zzaRet = zzaArg(zztasp2,2); --BlkLevel;  
  1343.                                         zzmatch(109); zzCONSUME;
  1344.                                         {
  1345.                                             zzBLOCK(zztasp3);
  1346.                                             zzMake0;
  1347.                                             {
  1348.                                             if ( (LA(1)==110) ) {
  1349.                                                 zzmatch(110);
  1350.                                                 zzaRet = makeLoop(zzaRet,approx);  
  1351.  zzCONSUME;
  1352.                                             }
  1353.                                             else {
  1354.                                                 if ( (LA(1)==111) ) {
  1355.                                                     zzmatch(111);
  1356.                                                     zzaRet = makePlus(zzaRet,approx);  
  1357.  zzCONSUME;
  1358.                                                 }
  1359.                                                 else {
  1360.                                                     if ( (LA(1)==112) ) {
  1361.                                                         zzmatch(112);
  1362.                                                         zzaRet = makeBlk(zzaRet,approx);
  1363.                                                         FoundGuessBlk = 1;
  1364.                                                         ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
  1365.                                                         if ( ! first_on_line ) {
  1366.                                                             err("(...)? predicate must be first element of production");
  1367.                                                         }
  1368.  zzCONSUME;
  1369.                                                     }
  1370.                                                     else {
  1371.                                                         if ( (setwd3[LA(1)]&0x8) ) {
  1372.                                                             zzaRet = makeBlk(zzaRet,approx);  
  1373.                                                         }
  1374.                                                         else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1375.                                                     }
  1376.                                                 }
  1377.                                             }
  1378.                                             zzEXIT(zztasp3);
  1379.                                             }
  1380.                                         }
  1381.                                         
  1382.                                         ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1383.                                         ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1384.                                         {
  1385.                                             zzBLOCK(zztasp3);
  1386.                                             zzMake0;
  1387.                                             {
  1388.                                             if ( (LA(1)==PassAction) ) {
  1389.                                                 zzmatch(PassAction);
  1390.                                                 addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1391.  zzCONSUME;
  1392.                                             }
  1393.                                             zzEXIT(zztasp3);
  1394.                                             }
  1395.                                         }
  1396.                                     }
  1397.                                     else {
  1398.                                         if ( (LA(1)==87) ) {
  1399.                                             zzmatch(87); zzCONSUME;
  1400.                                             block( &toksrefd,&rulesrefd );
  1401.                                             zzaRet = makeOpt(zzaArg(zztasp2,2),approx); --BlkLevel;  
  1402.                                             zzmatch(83);
  1403.                                             
  1404.                                             ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1405.                                             ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1406.  zzCONSUME;
  1407.                                             {
  1408.                                                 zzBLOCK(zztasp3);
  1409.                                                 zzMake0;
  1410.                                                 {
  1411.                                                 if ( (LA(1)==PassAction) ) {
  1412.                                                     zzmatch(PassAction);
  1413.                                                     addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1414.  zzCONSUME;
  1415.                                                 }
  1416.                                                 zzEXIT(zztasp3);
  1417.                                                 }
  1418.                                             }
  1419.                                         }
  1420.                                         else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1421.                                     }
  1422.                                     zzEXIT(zztasp2);
  1423.                                     }
  1424.                                 }
  1425.                             }
  1426.                             else {
  1427.                                 if ( (LA(1)==91) ) {
  1428.                                     zzmatch(91);
  1429.                                     warn(eMsg1("missing ';' on rule %s", CurRule));
  1430.                                     CannotContinue=TRUE;  
  1431.  zzCONSUME;
  1432.                                 }
  1433.                                 else {
  1434.                                     if ( (LA(1)==110) ) {
  1435.                                         zzmatch(110);
  1436.                                         warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;  
  1437.  zzCONSUME;
  1438.                                     }
  1439.                                     else {
  1440.                                         if ( (LA(1)==111) ) {
  1441.                                             zzmatch(111);
  1442.                                             warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;  
  1443.  zzCONSUME;
  1444.                                         }
  1445.                                         else {
  1446.                                             if ( (LA(1)==90) ) {
  1447.                                                 zzmatch(90);
  1448.                                                 warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;  
  1449.  zzCONSUME;
  1450.                                             }
  1451.                                             else {
  1452.                                                 if ( (LA(1)==PassAction) ) {
  1453.                                                     zzmatch(PassAction);
  1454.                                                     warn("[...] out of context 'rule > [...]'");
  1455.                                                     CannotContinue=TRUE;  
  1456.  zzCONSUME;
  1457.                                                 }
  1458.                                                 else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1459.                                             }
  1460.                                         }
  1461.                                     }
  1462.                                 }
  1463.                             }
  1464.                         }
  1465.                     }
  1466.                 }
  1467.             }
  1468.         }
  1469.     }
  1470.     zzEXIT(zztasp1);
  1471.     return;
  1472. fail:
  1473.     zzEXIT(zztasp1);
  1474.     CannotContinue=TRUE;  
  1475.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1476.     zzresynch(setwd3, 0x10);
  1477.     }
  1478. }
  1479.  
  1480. void
  1481. #ifdef __STDC__
  1482. enum_file(void)
  1483. #else
  1484. enum_file()
  1485. #endif
  1486. {
  1487.     zzRULE;
  1488.     zzBLOCK(zztasp1);
  1489.     zzMake0;
  1490.     {
  1491.     if ( (setwd3[LA(1)]&0x20) ) {
  1492.         {
  1493.             zzBLOCK(zztasp2);
  1494.             zzMake0;
  1495.             {
  1496.             while ( (LA(1)==121) ) {
  1497.                 enum_def();
  1498.                 zzLOOP(zztasp2);
  1499.             }
  1500.             zzEXIT(zztasp2);
  1501.             }
  1502.         }
  1503.     }
  1504.     else {
  1505.         if ( (setwd3[LA(1)]&0x40) ) {
  1506.             defines();
  1507.         }
  1508.         else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1509.     }
  1510.     zzEXIT(zztasp1);
  1511.     return;
  1512. fail:
  1513.     zzEXIT(zztasp1);
  1514.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1515.     zzresynch(setwd3, 0x80);
  1516.     }
  1517. }
  1518.  
  1519. void
  1520. #ifdef __STDC__
  1521. defines(void)
  1522. #else
  1523. defines()
  1524. #endif
  1525. {
  1526.     zzRULE;
  1527.     zzBLOCK(zztasp1);
  1528.     zzMake0;
  1529.     {
  1530.     int v,maxt= -1; char *t;  
  1531.     {
  1532.         zzBLOCK(zztasp2);
  1533.         zzMake0;
  1534.         {
  1535.         while ( (LA(1)==118) ) {
  1536.             zzmatch(118); zzCONSUME;
  1537.             zzmatch(ID);
  1538.             t = mystrdup(LATEXT(1));  
  1539.  zzCONSUME;
  1540.             zzmatch(INT);
  1541.             
  1542.             v = atoi(LATEXT(1));
  1543.             /*            fprintf(stderr, "#token %s=%d\n", t, v); */
  1544.             TokenNum = v;
  1545.             if ( v>maxt ) maxt=v;
  1546.             if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1547.             else {
  1548.                 warn(eMsg1("redefinition of token %s; ignored",t));
  1549.             }
  1550.  zzCONSUME;
  1551.             zzLOOP(zztasp2);
  1552.         }
  1553.         zzEXIT(zztasp2);
  1554.         }
  1555.     }
  1556.     TokenNum = maxt + 1;  
  1557.     zzEXIT(zztasp1);
  1558.     return;
  1559. fail:
  1560.     zzEXIT(zztasp1);
  1561.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1562.     zzresynch(setwd4, 0x1);
  1563.     }
  1564. }
  1565.  
  1566. void
  1567. #ifdef __STDC__
  1568. enum_def(void)
  1569. #else
  1570. enum_def()
  1571. #endif
  1572. {
  1573.     zzRULE;
  1574.     zzBLOCK(zztasp1);
  1575.     zzMake0;
  1576.     {
  1577.     int v= -1; char *t;  
  1578.     zzmatch(121); zzCONSUME;
  1579.     zzmatch(ID); zzCONSUME;
  1580.     zzmatch(122); zzCONSUME;
  1581.     zzmatch(ID);
  1582.     t = mystrdup(LATEXT(1));  
  1583.  zzCONSUME;
  1584.     {
  1585.         zzBLOCK(zztasp2);
  1586.         zzMake0;
  1587.         {
  1588.         if ( (LA(1)==123) ) {
  1589.             zzmatch(123); zzCONSUME;
  1590.             zzmatch(INT);
  1591.             v=atoi(LATEXT(1));  
  1592.  zzCONSUME;
  1593.         }
  1594.         else {
  1595.             if ( (setwd4[LA(1)]&0x2) ) {
  1596.                 v++;  
  1597.             }
  1598.             else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1599.         }
  1600.         zzEXIT(zztasp2);
  1601.         }
  1602.     }
  1603.     
  1604.     /*            fprintf(stderr, "#token %s=%d\n", t, v);*/
  1605.     TokenNum = v;
  1606.     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1607.     else {
  1608.         warn(eMsg1("redefinition of token %s; ignored",t));
  1609.     }
  1610.     {
  1611.         zzBLOCK(zztasp2);
  1612.         zzMake0;
  1613.         {
  1614.         while ( (LA(1)==124) ) {
  1615.             zzmatch(124); zzCONSUME;
  1616.             {
  1617.                 zzBLOCK(zztasp3);
  1618.                 zzMake0;
  1619.                 {
  1620.                 if ( (LA(1)==ID) ) {
  1621.                     zzmatch(ID);
  1622.                     t = mystrdup(LATEXT(1));  
  1623.  zzCONSUME;
  1624.                     {
  1625.                         zzBLOCK(zztasp4);
  1626.                         zzMake0;
  1627.                         {
  1628.                         if ( (LA(1)==123) ) {
  1629.                             zzmatch(123); zzCONSUME;
  1630.                             zzmatch(INT);
  1631.                             v=atoi(LATEXT(1));  
  1632.  zzCONSUME;
  1633.                         }
  1634.                         else {
  1635.                             if ( (setwd4[LA(1)]&0x4) ) {
  1636.                                 v++;  
  1637.                             }
  1638.                             else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1639.                         }
  1640.                         zzEXIT(zztasp4);
  1641.                         }
  1642.                     }
  1643.                     
  1644.                     /*                    fprintf(stderr, "#token %s=%d\n", t, v);*/
  1645.                     TokenNum = v;
  1646.                     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1647.                     else {
  1648.                         warn(eMsg1("redefinition of token %s; ignored",t));
  1649.                     }
  1650.                 }
  1651.                 zzEXIT(zztasp3);
  1652.                 }
  1653.             }
  1654.             zzLOOP(zztasp2);
  1655.         }
  1656.         zzEXIT(zztasp2);
  1657.         }
  1658.     }
  1659.     zzmatch(125); zzCONSUME;
  1660.     zzmatch(126);
  1661.     TokenNum++;  
  1662.  zzCONSUME;
  1663.     zzEXIT(zztasp1);
  1664.     return;
  1665. fail:
  1666.     zzEXIT(zztasp1);
  1667.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1668.     zzresynch(setwd4, 0x8);
  1669.     }
  1670. }
  1671.  
  1672. /* semantics of #token */
  1673. static void
  1674. #ifdef __STDC__
  1675. chkToken(char *t, char *e, char *a, int tnum)
  1676. #else
  1677. chkToken(t,e,a,tnum)
  1678. char *t, *e, *a;
  1679. int tnum;
  1680. #endif
  1681. {
  1682.     TermEntry *p;
  1683.     
  1684.     /* check to see that they don't try to redefine a token as a token class */
  1685.     if ( t!=NULL ) {
  1686.     p = (TermEntry *) hash_get(Tname, t);
  1687.     if ( p!=NULL && p->classname ) {
  1688.     err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
  1689.     if ( a!=NULL ) free(a);
  1690.     return;
  1691. }
  1692. }
  1693.  
  1694.     if ( t==NULL && e==NULL ) {            /* none found */
  1695. err("#token requires at least token name or rexpr");
  1696. }
  1697. else if ( t!=NULL && e!=NULL ) {    /* both found */
  1698. if ( UserDefdTokens ) {            /* if #tokdefs, must not define new */
  1699. p = (TermEntry *) hash_get(Tname, t);
  1700. if ( p==NULL ) {
  1701. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  1702. return;
  1703. }
  1704. }
  1705. Tklink(t, e);
  1706. if ( a!=NULL ) {
  1707. if ( hasAction(e) ) {
  1708. err(eMsg1("redefinition of action for %s; ignored",e));
  1709. }
  1710. else setHasAction(e, a);
  1711. }
  1712. }
  1713. else if ( t!=NULL ) {                /* only one found */
  1714. if ( UserDefdTokens ) {
  1715. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  1716. return;
  1717. }
  1718. if ( Tnum( t ) == 0 ) addTname( t );
  1719. else {
  1720. err(eMsg1("redefinition of token %s; ignored",t));
  1721. }
  1722. if ( a!=NULL ) {
  1723. err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  1724. free(a);
  1725. }
  1726. }
  1727. else if ( e!=NULL ) {
  1728. if ( Tnum( e ) == 0 ) addTexpr( e );
  1729. else {
  1730. if ( hasAction(e) ) {
  1731. err(eMsg1("redefinition of action for expr %s; ignored",e));
  1732. }
  1733. else if ( a==NULL ) {
  1734. err(eMsg1("redefinition of expr %s; ignored",e));
  1735. }
  1736. }
  1737. if ( a!=NULL ) setHasAction(e, a);
  1738. }
  1739.  
  1740.     /* if a token type number was specified, then add the token ID and 'tnum'
  1741. * pair to the ForcedTokens list.  (only applies if an id was given)
  1742. */
  1743. if ( t!=NULL && tnum>0 )
  1744. {
  1745. if ( set_el(tnum, reserved_positions) )
  1746. {
  1747. err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
  1748. }
  1749. else
  1750. {
  1751. list_add(&ForcedTokens, newForcedToken(t,tnum));
  1752. set_orel(tnum, &reserved_positions);
  1753. }
  1754. }
  1755. }
  1756.  
  1757. /* ANTLR-specific syntax error message generator 
  1758. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  1759. */
  1760. void
  1761. #ifdef __STDC__
  1762. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  1763. #else
  1764. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  1765. char *text, *egroup, *bad_text;
  1766. int tok;
  1767. int etok;
  1768. int k;
  1769. SetWordType *eset;
  1770. #endif
  1771. {
  1772. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  1773. fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
  1774. if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
  1775. if ( k==1 ) fprintf(stderr, " missing");
  1776. else
  1777. {
  1778. fprintf(stderr, "; \"%s\" not", bad_text);
  1779. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  1780. }
  1781. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  1782. else fprintf(stderr, " %s", zztokens[etok]);
  1783. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  1784. fprintf(stderr, "\n");
  1785. }
  1786.