home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts1.zip / ANTLR / ANTLR.C < prev    next >
C/C++ Source or Header  |  1993-09-02  |  22KB  |  1,114 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, Hank Dietz and Will Cohen: 1989-1993
  5.  * Purdue University Electrical Engineering
  6.  * ANTLR Version 1.10
  7.  */
  8. #include <stdio.h>
  9. #define ANTLR_VERSION    110
  10.  
  11. #ifdef __cplusplus
  12. #ifndef __STDC__
  13. #define __STDC__
  14. #endif
  15. #endif
  16. #include "set.h"
  17. #include <ctype.h>
  18. #include "syn.h"
  19. #include "hash.h"
  20. #include "generic.h"
  21. #define zzcr_attr(attr,tok,t)
  22. #define zzEOF_TOKEN 1
  23. #define zzSET_SIZE 12
  24. #include "antlr.h"
  25. #include "tokens.h"
  26. #include "dlgdef.h"
  27. #include "mode.h"
  28. ANTLR_INFO
  29.  
  30. #ifdef __STDC__
  31. static void chkToken(char *, char *, char *);
  32. #else
  33. static void chkToken();
  34. #endif
  35.  
  36. #ifdef __STDC__
  37. void
  38. grammar()
  39. #else
  40. grammar()
  41. #endif
  42. {
  43.     zzRULE;
  44.     zzBLOCK(zztasp1);
  45.     zzMake0;
  46.     {
  47.     Graph g;  
  48.     {
  49.         zzBLOCK(zztasp2);
  50.         zzMake0;
  51.         {
  52.         if ( (LA(1)==71) ) {
  53.             zzmatch(71); zzCONSUME;
  54.             zzmatch(Action);
  55.             
  56.             HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  57.             require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  58.             strcpy(HdrAction, LATEXT(1));
  59.              zzCONSUME;
  60.         }
  61.         zzEXIT(zztasp2);
  62.         }
  63.     }
  64.     {
  65.         zzBLOCK(zztasp2);
  66.         zzMake0;
  67.         {
  68.         if ( (LA(1)==72) ) {
  69.             zzmatch(72); zzCONSUME;
  70.             zzmatch(QuotedTerm);
  71.             
  72.             ParserName=StripQuotes(mystrdup(LATEXT(1)));
  73.             if ( RulePrefix[0]!='\0' )
  74.             {
  75.                 warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  76.                 RulePrefix[0]='\0';
  77.             }
  78.              zzCONSUME;
  79.         }
  80.         zzEXIT(zztasp2);
  81.         }
  82.     }
  83.     {
  84.         zzBLOCK(zztasp2);
  85.         zzMake0;
  86.         {
  87.         char *a;  
  88.         while ( 1 ) {
  89.             if ( (LA(1)==Action) ) {
  90.                 zzmatch(Action);
  91.                 
  92.                 a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  93.                 require(a!=NULL, "rule grammar: cannot allocate action");
  94.                 strcpy(a, LATEXT(1));
  95.                 list_add(&BeforeActions, a);
  96.                  zzCONSUME;
  97.             }
  98.             else {
  99.                 if ( (LA(1)==79) ) {
  100.                     laction();
  101.                 }
  102.                 else {
  103.                     if ( (LA(1)==80) ) {
  104.                         aLexclass();
  105.                     }
  106.                     else {
  107.                         if ( (LA(1)==85) ) {
  108.                             token();
  109.                         }
  110.                         else {
  111.                             if ( (LA(1)==82) ) {
  112.                                 error();
  113.                             }
  114.                             else break;
  115.                         }
  116.                     }
  117.                 }
  118.             }
  119.             zzLOOP(zztasp2);
  120.         }
  121.         zzEXIT(zztasp2);
  122.         }
  123.     }
  124.     rule();
  125.     zzNON_GUESS_MODE {
  126.     g=zzaArg(zztasp1,4); SynDiag = (Junction *) zzaArg(zztasp1,4 ).left;  
  127.     }
  128.     {
  129.         zzBLOCK(zztasp2);
  130.         zzMake0;
  131.         {
  132.         while ( 1 ) {
  133.             if ( (LA(1)==NonTerminal) ) {
  134.                 rule();
  135.                 zzNON_GUESS_MODE {
  136.                 if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}  
  137.                 }
  138.             }
  139.             else {
  140.                 if ( (LA(1)==80) ) {
  141.                     aLexclass();
  142.                 }
  143.                 else {
  144.                     if ( (LA(1)==85) ) {
  145.                         token();
  146.                     }
  147.                     else {
  148.                         if ( (LA(1)==82) ) {
  149.                             error();
  150.                         }
  151.                         else break;
  152.                     }
  153.                 }
  154.             }
  155.             zzLOOP(zztasp2);
  156.         }
  157.         zzEXIT(zztasp2);
  158.         }
  159.     }
  160.     {
  161.         zzBLOCK(zztasp2);
  162.         zzMake0;
  163.         {
  164.         char *a;  
  165.         while ( 1 ) {
  166.             if ( (LA(1)==Action) ) {
  167.                 zzmatch(Action);
  168.                 
  169.                 a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  170.                 require(a!=NULL, "rule grammar: cannot allocate action");
  171.                 strcpy(a, LATEXT(1));
  172.                 list_add(&AfterActions, a);
  173.                  zzCONSUME;
  174.             }
  175.             else {
  176.                 if ( (LA(1)==79) ) {
  177.                     laction();
  178.                 }
  179.                 else {
  180.                     if ( (LA(1)==82) ) {
  181.                         error();
  182.                     }
  183.                     else break;
  184.                 }
  185.             }
  186.             zzLOOP(zztasp2);
  187.         }
  188.         zzEXIT(zztasp2);
  189.         }
  190.     }
  191.     zzmatch(Eof); zzCONSUME;
  192.     zzEXIT(zztasp1);
  193.     return;
  194. fail:
  195.     zzEXIT(zztasp1);
  196.     CannotContinue=TRUE;  
  197.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  198.     zzresynch(setwd1, 0x1);
  199.     }
  200. }
  201.  
  202. #ifdef __STDC__
  203. void
  204. rule()
  205. #else
  206. rule()
  207. #endif
  208. {
  209.     zzRULE;
  210.     zzBLOCK(zztasp1);
  211.     zzMake0;
  212.     {
  213.     RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  214.     char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  215.     zzmatch(NonTerminal);
  216.     q=NULL;
  217.     if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  218.         warn(eMsg1("duplicate rule definition: '%s'",LATEXT(1)))
  219.         CannotContinue=TRUE;
  220.     }
  221.     else
  222.     {
  223.         q = (RuleEntry *)hash_add(Rname,
  224.         LATEXT(1),
  225.         (Entry *)newRuleEntry(LATEXT(1)));
  226.         CurRule = q->str;
  227.     }
  228.     CurRuleNode = q;
  229.     f = CurFile; l = zzline;
  230.     NumRules++;
  231.      zzCONSUME;
  232.     {
  233.         zzBLOCK(zztasp2);
  234.         zzMake0;
  235.         {
  236.         if ( (LA(1)==74) ) {
  237.             zzmatch(74);
  238.             if ( q!=NULL ) q->noAST = TRUE;  
  239.              zzCONSUME;
  240.         }
  241.         zzEXIT(zztasp2);
  242.         }
  243.     }
  244.     {
  245.         zzBLOCK(zztasp2);
  246.         zzMake0;
  247.         {
  248.         ;  
  249.         if ( (setwd1[LA(1)]&0x2) ) {
  250.             {
  251.                 zzBLOCK(zztasp3);
  252.                 zzMake0;
  253.                 {
  254.                 if ( (LA(1)==75) ) {
  255.                     zzmatch(75); zzCONSUME;
  256.                 }
  257.                 zzEXIT(zztasp3);
  258.                 }
  259.             }
  260.             zzmatch(PassAction);
  261.             pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  262.             require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  263.             strcpy(pdecl, LATEXT(1));
  264.             CurParmDef = pdecl;
  265.              zzCONSUME;
  266.         }
  267.         zzEXIT(zztasp2);
  268.         }
  269.     }
  270.     {
  271.         zzBLOCK(zztasp2);
  272.         zzMake0;
  273.         {
  274.         if ( (LA(1)==76) ) {
  275.             zzmatch(76); zzCONSUME;
  276.             zzmatch(PassAction);
  277.             ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  278.             require(ret!=NULL, "rule rule: cannot allocate ret type");
  279.             strcpy(ret, LATEXT(1));
  280.             CurRetDef = ret;
  281.              zzCONSUME;
  282.         }
  283.         zzEXIT(zztasp2);
  284.         }
  285.     }
  286.     {
  287.         zzBLOCK(zztasp2);
  288.         zzMake0;
  289.         {
  290.         if ( (LA(1)==QuotedTerm) ) {
  291.             zzmatch(QuotedTerm);
  292.             if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));  
  293.              zzCONSUME;
  294.         }
  295.         zzEXIT(zztasp2);
  296.         }
  297.     }
  298.     zzNON_GUESS_MODE {
  299.     
  300.     if ( GenEClasseForRules && q!=NULL ) {
  301.         e = newECnode;
  302.         require(e!=NULL, "cannot allocate error class node");
  303.         if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  304.         else a = q->egroup;
  305.         if ( Tnum( a ) == 0 )
  306.         {
  307.             e->tok = addTname( a );
  308.             list_add(&eclasses, (char *)e);
  309.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  310.             /* refers to itself */
  311.             list_add(&(e->elist), mystrdup(q->str));
  312.         }
  313.         else {
  314.             warn(eMsg1("default errclass for '%s' would conflict with token/errclass",a));
  315.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  316.             free(e);
  317.         }
  318.     }
  319.     }
  320.     zzNON_GUESS_MODE {
  321.     BlkLevel++;  
  322.     }
  323.     zzmatch(77); zzCONSUME;
  324.     block();
  325.     zzNON_GUESS_MODE {
  326.     r = makeBlk(zzaArg(zztasp1,7));
  327.     ((Junction *)r.left)->jtype = RuleBlk;
  328.     if ( q!=NULL ) ((Junction *)r.left)->rname = q->str;
  329.     ((Junction *)r.left)->file = f;
  330.     ((Junction *)r.left)->line = l;
  331.     ((Junction *)r.left)->pdecl = pdecl;
  332.     ((Junction *)r.left)->ret = ret;
  333.     ((Junction *)r.left)->lock = makelocks();
  334.     ((Junction *)r.left)->pred_lock = makelocks();
  335.     p = newJunction();    /* add EndRule Node */
  336.     ((Junction *)r.right)->p1 = (Node *)p;
  337.     r.right = (Node *) p;
  338.     p->jtype = EndRule;
  339.     p->lock = makelocks();
  340.     p->pred_lock = makelocks();
  341.     ((Junction *)r.left)->end = p;
  342.     if ( q!=NULL ) q->rulenum = NumRules;
  343.     zzaArg(zztasp1,7) = r;
  344.     }
  345.     zzNON_GUESS_MODE {
  346.     --BlkLevel;  
  347.     }
  348.     zzmatch(78); zzCONSUME;
  349.     {
  350.         zzBLOCK(zztasp2);
  351.         zzMake0;
  352.         {
  353.         if ( (LA(1)==Action) ) {
  354.             zzmatch(Action);
  355.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  356.             require(a!=NULL, "rule rule: cannot allocate error action");
  357.             strcpy(a, LATEXT(1));
  358.             ((Junction *)r.left)->erraction = a;
  359.              zzCONSUME;
  360.         }
  361.         zzEXIT(zztasp2);
  362.         }
  363.     }
  364.     zzNON_GUESS_MODE {
  365.     if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);  
  366.     }
  367.     zzNON_GUESS_MODE {
  368.     CurRuleNode = NULL;  
  369.     }
  370.     zzEXIT(zztasp1);
  371.     return;
  372. fail:
  373.     zzEXIT(zztasp1);
  374.     CannotContinue=TRUE;  
  375.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  376.     zzresynch(setwd1, 0x4);
  377.     }
  378. }
  379.  
  380. #ifdef __STDC__
  381. void
  382. laction()
  383. #else
  384. laction()
  385. #endif
  386. {
  387.     zzRULE;
  388.     zzBLOCK(zztasp1);
  389.     zzMake0;
  390.     {
  391.     char *a;  
  392.     zzmatch(79); zzCONSUME;
  393.     zzmatch(Action);
  394.     
  395.     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  396.     require(a!=NULL, "rule laction: cannot allocate action");
  397.     strcpy(a, LATEXT(1));
  398.     list_add(&LexActions, a);
  399.      zzCONSUME;
  400.     zzEXIT(zztasp1);
  401.     return;
  402. fail:
  403.     zzEXIT(zztasp1);
  404.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  405.     zzresynch(setwd1, 0x8);
  406.     }
  407. }
  408.  
  409. #ifdef __STDC__
  410. void
  411. aLexclass()
  412. #else
  413. aLexclass()
  414. #endif
  415. {
  416.     zzRULE;
  417.     zzBLOCK(zztasp1);
  418.     zzMake0;
  419.     {
  420.     zzmatch(80); zzCONSUME;
  421.     zzmatch(TokenTerm);
  422.     lexclass(mystrdup(LATEXT(1)));  
  423.      zzCONSUME;
  424.     zzEXIT(zztasp1);
  425.     return;
  426. fail:
  427.     zzEXIT(zztasp1);
  428.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  429.     zzresynch(setwd1, 0x10);
  430.     }
  431. }
  432.  
  433. #ifdef __STDC__
  434. void
  435. error()
  436. #else
  437. error()
  438. #endif
  439. {
  440.     zzRULE;
  441.     zzBLOCK(zztasp1);
  442.     zzMake0;
  443.     {
  444.     char *t=NULL; ECnode *e; int go=1; TermEntry *p;  
  445.     zzmatch(82); zzCONSUME;
  446.     {
  447.         zzBLOCK(zztasp2);
  448.         zzMake0;
  449.         {
  450.         ;  
  451.         if ( (LA(1)==TokenTerm) ) {
  452.             zzmatch(TokenTerm);
  453.             t=mystrdup(LATEXT(1));  
  454.              zzCONSUME;
  455.         }
  456.         else {
  457.             if ( (LA(1)==QuotedTerm) ) {
  458.                 zzmatch(QuotedTerm);
  459.                 t=mystrdup(LATEXT(1));  
  460.                  zzCONSUME;
  461.             }
  462.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  463.         }
  464.         zzEXIT(zztasp2);
  465.         }
  466.     }
  467.     zzNON_GUESS_MODE {
  468.     e = newECnode;
  469.     require(e!=NULL, "cannot allocate error class node");
  470.     e->lexclass = CurrentLexClass;
  471.     if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  472.     {
  473.         if ( hash_get(Texpr, t) != NULL )
  474.         warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  475.         e->tok = addTname( t );
  476.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  477.         "hash table mechanism is broken");
  478.         p->errclassname = 1;    /* entry is errclass name, not token */
  479.         list_add(&eclasses, (char *)e);
  480.     }
  481.     else
  482.     {
  483.     warn(eMsg1("redefinition of errclass or conflict w/token '%s'; ignored",t));
  484.     free( e );
  485.     go=0;
  486. }
  487.     }
  488.     zzmatch(83); zzCONSUME;
  489.     {
  490.         zzBLOCK(zztasp2);
  491.         zzMake0;
  492.         {
  493.         if ( (LA(1)==NonTerminal) ) {
  494.             zzmatch(NonTerminal);
  495.             if ( go ) t=mystrdup(LATEXT(1));  
  496.              zzCONSUME;
  497.         }
  498.         else {
  499.             if ( (LA(1)==TokenTerm) ) {
  500.                 zzmatch(TokenTerm);
  501.                 if ( go ) t=mystrdup(LATEXT(1));  
  502.                  zzCONSUME;
  503.             }
  504.             else {
  505.                 if ( (LA(1)==QuotedTerm) ) {
  506.                     zzmatch(QuotedTerm);
  507.                     if ( go ) t=mystrdup(LATEXT(1));  
  508.                      zzCONSUME;
  509.                 }
  510.                 else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  511.             }
  512.         }
  513.         zzEXIT(zztasp2);
  514.         }
  515.     }
  516.     zzNON_GUESS_MODE {
  517.     if ( go ) list_add(&(e->elist), t);  
  518.     }
  519.     {
  520.         zzBLOCK(zztasp2);
  521.         zzMake0;
  522.         {
  523.         while ( (setwd1[LA(1)]&0x20) ) {
  524.             {
  525.                 zzBLOCK(zztasp3);
  526.                 zzMake0;
  527.                 {
  528.                 if ( (LA(1)==NonTerminal) ) {
  529.                     zzmatch(NonTerminal);
  530.                     if ( go ) t=mystrdup(LATEXT(1));  
  531.                      zzCONSUME;
  532.                 }
  533.                 else {
  534.                     if ( (LA(1)==TokenTerm) ) {
  535.                         zzmatch(TokenTerm);
  536.                         if ( go ) t=mystrdup(LATEXT(1));  
  537.                          zzCONSUME;
  538.                     }
  539.                     else {
  540.                         if ( (LA(1)==QuotedTerm) ) {
  541.                             zzmatch(QuotedTerm);
  542.                             if ( go ) t=mystrdup(LATEXT(1));  
  543.                              zzCONSUME;
  544.                         }
  545.                         else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  546.                     }
  547.                 }
  548.                 zzEXIT(zztasp3);
  549.                 }
  550.             }
  551.             zzNON_GUESS_MODE {
  552.             if ( go ) list_add(&(e->elist), t);  
  553.             }
  554.             zzLOOP(zztasp2);
  555.         }
  556.         zzEXIT(zztasp2);
  557.         }
  558.     }
  559.     zzmatch(84); zzCONSUME;
  560.     zzEXIT(zztasp1);
  561.     return;
  562. fail:
  563.     zzEXIT(zztasp1);
  564.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  565.     zzresynch(setwd1, 0x40);
  566.     }
  567. }
  568.  
  569. #ifdef __STDC__
  570. void
  571. token()
  572. #else
  573. token()
  574. #endif
  575. {
  576.     zzRULE;
  577.     zzBLOCK(zztasp1);
  578.     zzMake0;
  579.     {
  580.     char *t=NULL, *e=NULL, *a=NULL;  
  581.     zzmatch(85); zzCONSUME;
  582.     {
  583.         zzBLOCK(zztasp2);
  584.         zzMake0;
  585.         {
  586.         if ( (LA(1)==TokenTerm) ) {
  587.             zzmatch(TokenTerm);
  588.             t=mystrdup(LATEXT(1));  
  589.              zzCONSUME;
  590.         }
  591.         zzEXIT(zztasp2);
  592.         }
  593.     }
  594.     {
  595.         zzBLOCK(zztasp2);
  596.         zzMake0;
  597.         {
  598.         if ( (LA(1)==QuotedTerm) ) {
  599.             zzmatch(QuotedTerm);
  600.             e=mystrdup(LATEXT(1));  
  601.              zzCONSUME;
  602.         }
  603.         zzEXIT(zztasp2);
  604.         }
  605.     }
  606.     {
  607.         zzBLOCK(zztasp2);
  608.         zzMake0;
  609.         {
  610.         if ( (LA(1)==Action) ) {
  611.             zzmatch(Action);
  612.             
  613.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  614.             require(a!=NULL, "rule token: cannot allocate action");
  615.             strcpy(a, LATEXT(1));
  616.              zzCONSUME;
  617.         }
  618.         zzEXIT(zztasp2);
  619.         }
  620.     }
  621.     zzNON_GUESS_MODE {
  622.     chkToken(t, e, a);  
  623.     }
  624.     zzEXIT(zztasp1);
  625.     return;
  626. fail:
  627.     zzEXIT(zztasp1);
  628.     CannotContinue=TRUE;  
  629.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  630.     zzresynch(setwd1, 0x80);
  631.     }
  632. }
  633.  
  634. #ifdef __STDC__
  635. void
  636. block()
  637. #else
  638. block()
  639. #endif
  640. {
  641.     zzRULE;
  642.     zzBLOCK(zztasp1);
  643.     zzMake0;
  644.     {
  645.     
  646.     Graph g, b;
  647.     alt();
  648.     zzNON_GUESS_MODE {
  649.     b = g = zzaArg(zztasp1,1);  
  650.     }
  651.     zzNON_GUESS_MODE {
  652.     
  653.     if ( ((Junction *)g.left)->p1->ntype == nAction )
  654.     {
  655.         if ( !((ActionNode *)(((Junction *)g.left)->p1))->is_predicate )
  656.         {
  657.             ((ActionNode *)(((Junction *)g.left)->p1))->init_action = TRUE;
  658.         }
  659.     }
  660.     }
  661.     {
  662.         zzBLOCK(zztasp2);
  663.         zzMake0;
  664.         {
  665.         while ( (LA(1)==86) ) {
  666.             zzmatch(86); zzCONSUME;
  667.             alt();
  668.             zzNON_GUESS_MODE {
  669.             g = Or(g, zzaArg(zztasp2,2));  
  670.             }
  671.             zzLOOP(zztasp2);
  672.         }
  673.         zzEXIT(zztasp2);
  674.         }
  675.     }
  676.     zzNON_GUESS_MODE {
  677.     zzaArg(zztasp1,0) = b;  
  678.     }
  679.     zzEXIT(zztasp1);
  680.     return;
  681. fail:
  682.     zzEXIT(zztasp1);
  683.     CannotContinue=TRUE;  
  684.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  685.     zzresynch(setwd2, 0x1);
  686.     }
  687. }
  688.  
  689. #ifdef __STDC__
  690. void
  691. alt()
  692. #else
  693. alt()
  694. #endif
  695. {
  696.     zzRULE;
  697.     zzBLOCK(zztasp1);
  698.     zzMake0;
  699.     {
  700.     int n=0; Graph g; g.left=g.right=NULL;  
  701.     {
  702.         zzBLOCK(zztasp2);
  703.         zzMake0;
  704.         {
  705.         while ( (setwd2[LA(1)]&0x2) ) {
  706.             element();
  707.             zzNON_GUESS_MODE {
  708.             n++; g = Cat(g, zzaArg(zztasp2,1));  
  709.             }
  710.             zzLOOP(zztasp2);
  711.         }
  712.         zzEXIT(zztasp2);
  713.         }
  714.     }
  715.     zzNON_GUESS_MODE {
  716.     if ( n == 0 ) g = emptyAlt();
  717.     zzaArg(zztasp1,0) = g;
  718.     }
  719.     zzEXIT(zztasp1);
  720.     return;
  721. fail:
  722.     zzEXIT(zztasp1);
  723.     CannotContinue=TRUE;  
  724.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  725.     zzresynch(setwd2, 0x4);
  726.     }
  727. }
  728.  
  729. #ifdef __STDC__
  730. void
  731. element()
  732. #else
  733. element()
  734. #endif
  735. {
  736.     zzRULE;
  737.     zzBLOCK(zztasp1);
  738.     zzMake0;
  739.     {
  740.     TokNode *p; RuleRefNode *q;  
  741.     if ( (LA(1)==TokenTerm) ) {
  742.         zzmatch(TokenTerm);
  743.         zzaArg(zztasp1,0) = buildToken(LATEXT(1));  
  744.          zzCONSUME;
  745.         {
  746.             zzBLOCK(zztasp2);
  747.             zzMake0;
  748.             {
  749.             p = (TokNode *) ((Junction *)zzaRet.left)->p1;  
  750.             if ( (LA(1)==87) ) {
  751.                 zzmatch(87);
  752.                 p->astnode=ASTroot;  
  753.                  zzCONSUME;
  754.             }
  755.             else {
  756.                 if ( (setwd2[LA(1)]&0x8) ) {
  757.                     zzNON_GUESS_MODE {
  758.                     p->astnode=ASTchild;  
  759.                     }
  760.                 }
  761.                 else {
  762.                     if ( (LA(1)==74) ) {
  763.                         zzmatch(74);
  764.                         p->astnode=ASTexclude;  
  765.                          zzCONSUME;
  766.                     }
  767.                     else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  768.                 }
  769.             }
  770.             zzEXIT(zztasp2);
  771.             }
  772.         }
  773.     }
  774.     else {
  775.         if ( (LA(1)==QuotedTerm) ) {
  776.             zzmatch(QuotedTerm);
  777.             zzaArg(zztasp1,0) = buildToken(LATEXT(1));  
  778.              zzCONSUME;
  779.             {
  780.                 zzBLOCK(zztasp2);
  781.                 zzMake0;
  782.                 {
  783.                 p = (TokNode *) ((Junction *)zzaRet.left)->p1;  
  784.                 if ( (LA(1)==87) ) {
  785.                     zzmatch(87);
  786.                     p->astnode=ASTroot;  
  787.                      zzCONSUME;
  788.                 }
  789.                 else {
  790.                     if ( (setwd2[LA(1)]&0x10) ) {
  791.                         zzNON_GUESS_MODE {
  792.                         p->astnode=ASTchild;  
  793.                         }
  794.                     }
  795.                     else {
  796.                         if ( (LA(1)==74) ) {
  797.                             zzmatch(74);
  798.                             p->astnode=ASTexclude;  
  799.                              zzCONSUME;
  800.                         }
  801.                         else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  802.                     }
  803.                 }
  804.                 zzEXIT(zztasp2);
  805.                 }
  806.             }
  807.         }
  808.         else {
  809.             if ( (LA(1)==NonTerminal) ) {
  810.                 zzmatch(NonTerminal);
  811.                 zzaArg(zztasp1,0) = buildRuleRef(LATEXT(1));  
  812.                  zzCONSUME;
  813.                 {
  814.                     zzBLOCK(zztasp2);
  815.                     zzMake0;
  816.                     {
  817.                     if ( (LA(1)==74) ) {
  818.                         zzmatch(74);
  819.                         q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  820.                         q->astnode=ASTexclude;  
  821.                          zzCONSUME;
  822.                     }
  823.                     zzEXIT(zztasp2);
  824.                     }
  825.                 }
  826.                 {
  827.                     zzBLOCK(zztasp2);
  828.                     zzMake0;
  829.                     {
  830.                     if ( (setwd2[LA(1)]&0x20) ) {
  831.                         {
  832.                             zzBLOCK(zztasp3);
  833.                             zzMake0;
  834.                             {
  835.                             if ( (LA(1)==75) ) {
  836.                                 zzmatch(75); zzCONSUME;
  837.                             }
  838.                             zzEXIT(zztasp3);
  839.                             }
  840.                         }
  841.                         zzmatch(PassAction);
  842.                         addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  843.                          zzCONSUME;
  844.                     }
  845.                     zzEXIT(zztasp2);
  846.                     }
  847.                 }
  848.                 {
  849.                     zzBLOCK(zztasp2);
  850.                     zzMake0;
  851.                     {
  852.                     char *a; RuleRefNode *rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  853.                     if ( (LA(1)==76) ) {
  854.                         zzmatch(76); zzCONSUME;
  855.                         zzmatch(PassAction);
  856.                         
  857.                         a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  858.                         require(a!=NULL, "rule element: cannot allocate assignment");
  859.                         strcpy(a, LATEXT(1));
  860.                         rr->assign = a;
  861.                          zzCONSUME;
  862.                     }
  863.                     zzEXIT(zztasp2);
  864.                     }
  865.                 }
  866.             }
  867.             else {
  868.                 if ( (LA(1)==Action) ) {
  869.                     zzmatch(Action);
  870.                     zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);  
  871.                      zzCONSUME;
  872.                 }
  873.                 else {
  874.                     if ( (LA(1)==Pred) ) {
  875.                         zzmatch(Pred);
  876.                         zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);  
  877.                          zzCONSUME;
  878.                         {
  879.                             zzBLOCK(zztasp2);
  880.                             zzMake0;
  881.                             {
  882.                             char *a; ActionNode *act = (ActionNode *) ((Junction *)zzaRet.left)->p1;  
  883.                             if ( (LA(1)==PassAction) ) {
  884.                                 zzmatch(PassAction);
  885.                                 
  886.                                 a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  887.                                 require(a!=NULL, "rule element: cannot allocate predicate fail action");
  888.                                 strcpy(a, LATEXT(1));
  889.                                 act->pred_fail = a;
  890.                                  zzCONSUME;
  891.                             }
  892.                             zzEXIT(zztasp2);
  893.                             }
  894.                         }
  895.                     }
  896.                     else {
  897.                         if ( (LA(1)==88) ) {
  898.                             zzNON_GUESS_MODE {
  899.                             BlkLevel++;  
  900.                             }
  901.                             zzmatch(88); zzCONSUME;
  902.                             block();
  903.                             zzNON_GUESS_MODE {
  904.                             zzaArg(zztasp1,0) = zzaArg(zztasp1,2); --BlkLevel;  
  905.                             }
  906.                             zzmatch(89); zzCONSUME;
  907.                             {
  908.                                 zzBLOCK(zztasp2);
  909.                                 zzMake0;
  910.                                 {
  911.                                 if ( (LA(1)==90) ) {
  912.                                     zzmatch(90);
  913.                                     zzaRet = makeLoop(zzaRet);  
  914.                                      zzCONSUME;
  915.                                 }
  916.                                 else {
  917.                                     if ( (LA(1)==91) ) {
  918.                                         zzmatch(91);
  919.                                         zzaRet = makePlus(zzaRet);  
  920.                                          zzCONSUME;
  921.                                     }
  922.                                     else {
  923.                                         if ( (LA(1)==92) ) {
  924.                                             zzmatch(92);
  925.                                             zzaRet = makeBlk(zzaRet);
  926.                                             FoundGuessBlk = 1;
  927.                                             ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
  928.                                              zzCONSUME;
  929.                                         }
  930.                                         else {
  931.                                             if ( (setwd2[LA(1)]&0x40) ) {
  932.                                                 zzNON_GUESS_MODE {
  933.                                                 zzaRet = makeBlk(zzaRet);  
  934.                                                 }
  935.                                             }
  936.                                             else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  937.                                         }
  938.                                     }
  939.                                 }
  940.                                 zzEXIT(zztasp2);
  941.                                 }
  942.                             }
  943.                             {
  944.                                 zzBLOCK(zztasp2);
  945.                                 zzMake0;
  946.                                 {
  947.                                 if ( (LA(1)==PassAction) ) {
  948.                                     zzmatch(PassAction);
  949.                                     addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  950.                                      zzCONSUME;
  951.                                 }
  952.                                 zzEXIT(zztasp2);
  953.                                 }
  954.                             }
  955.                         }
  956.                         else {
  957.                             if ( (LA(1)==83) ) {
  958.                                 zzNON_GUESS_MODE {
  959.                                 BlkLevel++;  
  960.                                 }
  961.                                 zzmatch(83); zzCONSUME;
  962.                                 block();
  963.                                 zzNON_GUESS_MODE {
  964.                                 zzaArg(zztasp1,0) = makeOpt(zzaArg(zztasp1,2)); --BlkLevel;  
  965.                                 }
  966.                                 zzmatch(84); zzCONSUME;
  967.                                 {
  968.                                     zzBLOCK(zztasp2);
  969.                                     zzMake0;
  970.                                     {
  971.                                     if ( (LA(1)==PassAction) ) {
  972.                                         zzmatch(PassAction);
  973.                                         addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  974.                                          zzCONSUME;
  975.                                     }
  976.                                     zzEXIT(zztasp2);
  977.                                     }
  978.                                 }
  979.                             }
  980.                             else {
  981.                                 if ( (LA(1)==77) ) {
  982.                                     zzmatch(77);
  983.                                     warn(eMsg1("missing ';' on rule %s", CurRule));
  984.                                     CannotContinue=TRUE;  
  985.                                      zzCONSUME;
  986.                                 }
  987.                                 else {
  988.                                     if ( (LA(1)==90) ) {
  989.                                         zzmatch(90);
  990.                                         warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;  
  991.                                          zzCONSUME;
  992.                                     }
  993.                                     else {
  994.                                         if ( (LA(1)==91) ) {
  995.                                             zzmatch(91);
  996.                                             warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;  
  997.                                              zzCONSUME;
  998.                                         }
  999.                                         else {
  1000.                                             if ( (LA(1)==76) ) {
  1001.                                                 zzmatch(76);
  1002.                                                 warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;  
  1003.                                                  zzCONSUME;
  1004.                                             }
  1005.                                             else {
  1006.                                                 if ( (LA(1)==PassAction) ) {
  1007.                                                     zzmatch(PassAction);
  1008.                                                     warn("[...] out of context 'rule > [...]'");
  1009.                                                     CannotContinue=TRUE;  
  1010.                                                      zzCONSUME;
  1011.                                                 }
  1012.                                                 else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1013.                                             }
  1014.                                         }
  1015.                                     }
  1016.                                 }
  1017.                             }
  1018.                         }
  1019.                     }
  1020.                 }
  1021.             }
  1022.         }
  1023.     }
  1024.     zzEXIT(zztasp1);
  1025.     return;
  1026. fail:
  1027.     zzEXIT(zztasp1);
  1028.     CannotContinue=TRUE;  
  1029.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1030.     zzresynch(setwd2, 0x80);
  1031.     }
  1032. }
  1033.  
  1034. /* semantics of #token */
  1035. static void
  1036. #ifdef __STDC__
  1037. chkToken(char *t, char *e, char *a)
  1038. #else
  1039. chkToken(t,e,a)
  1040. char *t, *e, *a;
  1041. #endif
  1042. {
  1043.     if ( t==NULL && e==NULL ) {            /* none found */
  1044.         warn("#token requires at least token name or rexpr");
  1045.     }
  1046.     else if ( t!=NULL && e!=NULL ) {    /* both found */
  1047.         Tklink(t, e);
  1048.         if ( a!=NULL ) {
  1049.             if ( hasAction(e) ) {
  1050.                 warn(eMsg1("redefinition of action for %s; ignored",e));
  1051.             }
  1052.             else setHasAction(e, a);
  1053.         }
  1054.     }
  1055.     else if ( t!=NULL ) {                /* only one found */
  1056.         if ( Tnum( t ) == 0 ) addTname( t );
  1057.         else {
  1058.             warn(eMsg1("redefinition of token %s; ignored",t));
  1059.         }
  1060.         if ( a!=NULL ) {
  1061.             warn(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  1062.             free(a);
  1063.         }
  1064.     }
  1065.     else if ( e!=NULL ) {
  1066.         if ( Tnum( e ) == 0 ) addTexpr( e );
  1067.         else {
  1068.             if ( hasAction(e) ) {
  1069.                 warn(eMsg1("redefinition of action for %s; ignored",e));
  1070.             }
  1071.             else if ( a==NULL ) {
  1072.                 warn(eMsg1("redefinition of expr %s; ignored",e));
  1073.             }
  1074.         }
  1075.         if ( a!=NULL ) setHasAction(e, a);
  1076.     }
  1077. }
  1078.  
  1079. /* This is designed for use with 1.10, but if created with 1.06,
  1080. * must define SetWordType.  Also define EOF for 1.06.
  1081. #define zzEOF_TOKEN 1
  1082. typedef unsigned SetWordType;
  1083. */
  1084.  
  1085. /* ANTLR-specific syntax error message generator 
  1086. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  1087. */
  1088. void
  1089. #ifdef __STDC__
  1090. zzsyn(char *text, unsigned tok, char *egroup, SetWordType *eset, unsigned etok, int k, char *bad_text)
  1091. #else
  1092. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  1093. char *text, *egroup, *bad_text;
  1094. unsigned tok;
  1095. unsigned etok;
  1096. int k;
  1097. SetWordType *eset;
  1098. #endif
  1099. {
  1100. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  1101. fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
  1102. if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
  1103. if ( k==1 ) fprintf(stderr, " missing");
  1104. else
  1105. {
  1106. fprintf(stderr, "; \"%s\" not", bad_text);
  1107. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  1108. }
  1109. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  1110. else fprintf(stderr, " %s", zztokens[etok]);
  1111. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  1112. fprintf(stderr, "\n");
  1113. }
  1114.