home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts.zip / pccts / dlg / dlg_p.c < prev    next >
C/C++ Source or Header  |  1994-03-31  |  16KB  |  798 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.20b6
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    120b6
  11.  
  12. #include <ctype.h>
  13. #include "dlg.h"
  14. #ifdef MEMCHK
  15. #include "trax.h"
  16. #endif
  17. #define zzEOF_TOKEN 1
  18. #define zzSET_SIZE 8
  19. #include "antlr.h"
  20. #include "tokens.h"
  21. #include "dlgdef.h"
  22. #include "mode.h"
  23. ANTLR_INFO
  24.  
  25. int    action_no = 0;       /* keep track of actions outputed */
  26. int    nfa_allocated = 0; /* keeps track of number of nfa nodes */
  27. nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
  28. nfa_node nfa_model_node;   /* model to initialize new nodes */
  29. set    used_chars;       /* used to label trans. arcs */
  30. set    used_classes;       /* classes or chars used to label trans. arcs */
  31. set    normal_chars;       /* mask to get rid elements that aren't used
  32. in set */
  33. int    flag_paren = FALSE;
  34. int    flag_brace = FALSE;
  35. int    mode_counter = 0;  /* keep track of number of %%names */
  36.  
  37.   
  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.     p_head(); p_class_hdr(); func_action = FALSE;  
  51.     {
  52.         zzBLOCK(zztasp2);
  53.         zzMake0;
  54.         {
  55.         while ( (LA(1)==ACTION) ) {
  56.             zzmatch(ACTION); zzCONSUME;
  57.             zzLOOP(zztasp2);
  58.         }
  59.         zzEXIT(zztasp2);
  60.         }
  61.     }
  62.     if ( gen_cpp ) p_includes();  
  63.     start_states();
  64.     func_action = FALSE; p_tables(); p_tail();   
  65.     {
  66.         zzBLOCK(zztasp2);
  67.         zzMake0;
  68.         {
  69.         while ( (LA(1)==ACTION) ) {
  70.             zzmatch(ACTION); zzCONSUME;
  71.             zzLOOP(zztasp2);
  72.         }
  73.         zzEXIT(zztasp2);
  74.         }
  75.     }
  76.     zzmatch(1); zzCONSUME;
  77.     zzEXIT(zztasp1);
  78.     return;
  79. fail:
  80.     zzEXIT(zztasp1);
  81.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  82.     zzresynch(setwd1, 0x1);
  83.     }
  84. }
  85.  
  86. void
  87. #ifdef __STDC__
  88. start_states(void)
  89. #else
  90. start_states()
  91. #endif
  92. {
  93.     zzRULE;
  94.     zzBLOCK(zztasp1);
  95.     zzMake0;
  96.     {
  97.     {
  98.         zzBLOCK(zztasp2);
  99.         zzMake0;
  100.         {
  101.         if ( (LA(1)==PER_PER) ) {
  102.             zzmatch(PER_PER); zzCONSUME;
  103.             do_conversion();
  104.         }
  105.         else {
  106.             if ( (LA(1)==NAME_PER_PER) ) {
  107.                 zzmatch(NAME_PER_PER); zzCONSUME;
  108.                 do_conversion();
  109.                 {
  110.                     zzBLOCK(zztasp3);
  111.                     zzMake0;
  112.                     {
  113.                     while ( (LA(1)==NAME_PER_PER) ) {
  114.                         zzmatch(NAME_PER_PER); zzCONSUME;
  115.                         do_conversion();
  116.                         zzLOOP(zztasp3);
  117.                     }
  118.                     zzEXIT(zztasp3);
  119.                     }
  120.                 }
  121.             }
  122.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  123.         }
  124.         zzEXIT(zztasp2);
  125.         }
  126.     }
  127.     zzmatch(PER_PER); zzCONSUME;
  128.     zzEXIT(zztasp1);
  129.     return;
  130. fail:
  131.     zzEXIT(zztasp1);
  132.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  133.     zzresynch(setwd1, 0x2);
  134.     }
  135. }
  136.  
  137. void
  138. #ifdef __STDC__
  139. do_conversion(void)
  140. #else
  141. do_conversion()
  142. #endif
  143. {
  144.     zzRULE;
  145.     zzBLOCK(zztasp1);
  146.     zzMake0;
  147.     {
  148.     new_automaton_mode(); func_action = TRUE;  
  149.     rule_list();
  150.     
  151.     dfa_class_nop[mode_counter] =
  152.     relabel(zzaArg(zztasp1,1 ).l,comp_level);
  153.     if (comp_level)
  154.     p_shift_table(mode_counter);
  155.     dfa_basep[mode_counter] = dfa_allocated+1;
  156.     make_dfa_model_node(dfa_class_nop[mode_counter]);
  157.     nfa_to_dfa(zzaArg(zztasp1,1 ).l);
  158.     ++mode_counter;
  159.     func_action = FALSE;
  160. #ifdef HASH_STAT
  161.     fprint_hash_stats(stderr);
  162. #endif
  163.     zzEXIT(zztasp1);
  164.     return;
  165. fail:
  166.     zzEXIT(zztasp1);
  167.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  168.     zzresynch(setwd1, 0x4);
  169.     }
  170. }
  171.  
  172. void
  173. #ifdef __STDC__
  174. rule_list(void)
  175. #else
  176. rule_list()
  177. #endif
  178. {
  179.     zzRULE;
  180.     zzBLOCK(zztasp1);
  181.     zzMake0;
  182.     {
  183.     if ( (setwd1[LA(1)]&0x8) ) {
  184.         rule();
  185.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  186.         {
  187.             zzBLOCK(zztasp2);
  188.             zzMake0;
  189.             {
  190.             while ( (setwd1[LA(1)]&0x10) ) {
  191.                 rule();
  192.                 {nfa_node *t1;
  193.                     t1 = new_nfa_node();
  194.                     (t1)->trans[0]=zzaRet.l;
  195.                     (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
  196.                     /* all accept nodes "dead ends" */
  197.                     zzaRet.l=t1; zzaRet.r=NULL;
  198.                 }
  199.                 zzLOOP(zztasp2);
  200.             }
  201.             zzEXIT(zztasp2);
  202.             }
  203.         }
  204.     }
  205.     else {
  206.         if ( (setwd1[LA(1)]&0x20) ) {
  207.             zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
  208.             warning("no regular expressions", zzline);
  209.         }
  210.         else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  211.     }
  212.     zzEXIT(zztasp1);
  213.     return;
  214. fail:
  215.     zzEXIT(zztasp1);
  216.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  217.     zzresynch(setwd1, 0x40);
  218.     }
  219. }
  220.  
  221. void
  222. #ifdef __STDC__
  223. rule(void)
  224. #else
  225. rule()
  226. #endif
  227. {
  228.     zzRULE;
  229.     zzBLOCK(zztasp1);
  230.     zzMake0;
  231.     {
  232.     if ( (setwd1[LA(1)]&0x80) ) {
  233.         reg_expr();
  234.         zzmatch(ACTION);
  235.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;  
  236.  zzCONSUME;
  237.     }
  238.     else {
  239.         if ( (LA(1)==ACTION) ) {
  240.             zzmatch(ACTION);
  241.             zzaRet.l = NULL; zzaRet.r = NULL;
  242.             error("no expression for action  ", zzline);
  243.  zzCONSUME;
  244.         }
  245.         else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  246.     }
  247.     zzEXIT(zztasp1);
  248.     return;
  249. fail:
  250.     zzEXIT(zztasp1);
  251.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  252.     zzresynch(setwd2, 0x1);
  253.     }
  254. }
  255.  
  256. void
  257. #ifdef __STDC__
  258. reg_expr(void)
  259. #else
  260. reg_expr()
  261. #endif
  262. {
  263.     zzRULE;
  264.     zzBLOCK(zztasp1);
  265.     zzMake0;
  266.     {
  267.     and_expr();
  268.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  269.     {
  270.         zzBLOCK(zztasp2);
  271.         zzMake0;
  272.         {
  273.         while ( (LA(1)==OR) ) {
  274.             zzmatch(OR); zzCONSUME;
  275.             and_expr();
  276.             {nfa_node *t1, *t2;
  277.                 t1 = new_nfa_node(); t2 = new_nfa_node();
  278.                 (t1)->trans[0]=zzaRet.l;
  279.                 (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
  280.                 (zzaRet.r)->trans[1]=t2;
  281.                 (zzaArg(zztasp2,2 ).r)->trans[1]=t2;
  282.                 zzaRet.l=t1; zzaRet.r=t2;
  283.             }
  284.             zzLOOP(zztasp2);
  285.         }
  286.         zzEXIT(zztasp2);
  287.         }
  288.     }
  289.     zzEXIT(zztasp1);
  290.     return;
  291. fail:
  292.     zzEXIT(zztasp1);
  293.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  294.     zzresynch(setwd2, 0x2);
  295.     }
  296. }
  297.  
  298. void
  299. #ifdef __STDC__
  300. and_expr(void)
  301. #else
  302. and_expr()
  303. #endif
  304. {
  305.     zzRULE;
  306.     zzBLOCK(zztasp1);
  307.     zzMake0;
  308.     {
  309.     repeat_expr();
  310.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  311.     {
  312.         zzBLOCK(zztasp2);
  313.         zzMake0;
  314.         {
  315.         while ( (setwd2[LA(1)]&0x4) ) {
  316.             repeat_expr();
  317.             (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l; zzaRet.r=zzaArg(zztasp2,1 ).r;  
  318.             zzLOOP(zztasp2);
  319.         }
  320.         zzEXIT(zztasp2);
  321.         }
  322.     }
  323.     zzEXIT(zztasp1);
  324.     return;
  325. fail:
  326.     zzEXIT(zztasp1);
  327.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  328.     zzresynch(setwd2, 0x8);
  329.     }
  330. }
  331.  
  332. void
  333. #ifdef __STDC__
  334. repeat_expr(void)
  335. #else
  336. repeat_expr()
  337. #endif
  338. {
  339.     zzRULE;
  340.     zzBLOCK(zztasp1);
  341.     zzMake0;
  342.     {
  343.     if ( (setwd2[LA(1)]&0x10) ) {
  344.         expr();
  345.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  346.         {
  347.             zzBLOCK(zztasp2);
  348.             zzMake0;
  349.             {
  350.             if ( (LA(1)==ZERO_MORE) ) {
  351.                 zzmatch(ZERO_MORE);
  352.                 {    nfa_node *t1,*t2;
  353.                     (zzaRet.r)->trans[0] = zzaRet.l;
  354.                     t1 = new_nfa_node(); t2 = new_nfa_node();
  355.                     t1->trans[0]=zzaRet.l;
  356.                     t1->trans[1]=t2;
  357.                     (zzaRet.r)->trans[1]=t2;
  358.                     zzaRet.l=t1;zzaRet.r=t2;
  359.                 }
  360.  zzCONSUME;
  361.             }
  362.             else {
  363.                 if ( (LA(1)==ONE_MORE) ) {
  364.                     zzmatch(ONE_MORE);
  365.                     (zzaRet.r)->trans[0] = zzaRet.l;  
  366.  zzCONSUME;
  367.                 }
  368.             }
  369.             zzEXIT(zztasp2);
  370.             }
  371.         }
  372.     }
  373.     else {
  374.         if ( (LA(1)==ZERO_MORE) ) {
  375.             zzmatch(ZERO_MORE);
  376.             error("no expression for *", zzline);  
  377.  zzCONSUME;
  378.         }
  379.         else {
  380.             if ( (LA(1)==ONE_MORE) ) {
  381.                 zzmatch(ONE_MORE);
  382.                 error("no expression for +", zzline);  
  383.  zzCONSUME;
  384.             }
  385.             else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  386.         }
  387.     }
  388.     zzEXIT(zztasp1);
  389.     return;
  390. fail:
  391.     zzEXIT(zztasp1);
  392.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  393.     zzresynch(setwd2, 0x20);
  394.     }
  395. }
  396.  
  397. void
  398. #ifdef __STDC__
  399. expr(void)
  400. #else
  401. expr()
  402. #endif
  403. {
  404.     zzRULE;
  405.     zzBLOCK(zztasp1);
  406.     zzMake0;
  407.     {
  408.     zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();   
  409.     if ( (LA(1)==L_BRACK) ) {
  410.         zzmatch(L_BRACK); zzCONSUME;
  411.         atom_list();
  412.         zzmatch(R_BRACK);
  413.         
  414.         (zzaRet.l)->trans[0] = zzaRet.r;
  415.         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
  416.         set_orin(&used_chars,(zzaRet.l)->label);
  417.  zzCONSUME;
  418.     }
  419.     else {
  420.         if ( (LA(1)==NOT) ) {
  421.             zzmatch(NOT); zzCONSUME;
  422.             zzmatch(L_BRACK); zzCONSUME;
  423.             atom_list();
  424.             zzmatch(R_BRACK);
  425.             
  426.             (zzaRet.l)->trans[0] = zzaRet.r;
  427.             (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
  428.             set_orin(&used_chars,(zzaRet.l)->label);
  429.  zzCONSUME;
  430.         }
  431.         else {
  432.             if ( (LA(1)==L_PAR) ) {
  433.                 zzmatch(L_PAR); zzCONSUME;
  434.                 reg_expr();
  435.                 zzmatch(R_PAR);
  436.                 
  437.                 (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  438.                 (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  439.  zzCONSUME;
  440.             }
  441.             else {
  442.                 if ( (LA(1)==L_BRACE) ) {
  443.                     zzmatch(L_BRACE); zzCONSUME;
  444.                     reg_expr();
  445.                     zzmatch(R_BRACE);
  446.                     
  447.                     (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  448.                     (zzaRet.l)->trans[1] = zzaRet.r;
  449.                     (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  450.  zzCONSUME;
  451.                 }
  452.                 else {
  453.                     if ( (setwd2[LA(1)]&0x40) ) {
  454.                         atom();
  455.                         
  456.                         (zzaRet.l)->trans[0] = zzaRet.r;
  457.                         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
  458.                         set_orin(&used_chars,(zzaRet.l)->label);
  459.                     }
  460.                     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  461.                 }
  462.             }
  463.         }
  464.     }
  465.     zzEXIT(zztasp1);
  466.     return;
  467. fail:
  468.     zzEXIT(zztasp1);
  469.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  470.     zzresynch(setwd2, 0x80);
  471.     }
  472. }
  473.  
  474. void
  475. #ifdef __STDC__
  476. atom_list(void)
  477. #else
  478. atom_list()
  479. #endif
  480. {
  481.     zzRULE;
  482.     zzBLOCK(zztasp1);
  483.     zzMake0;
  484.     {
  485.     set_free(zzaRet.label);   
  486.     {
  487.         zzBLOCK(zztasp2);
  488.         zzMake0;
  489.         {
  490.         while ( (setwd3[LA(1)]&0x1) ) {
  491.             near_atom();
  492.             set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);  
  493.             zzLOOP(zztasp2);
  494.         }
  495.         zzEXIT(zztasp2);
  496.         }
  497.     }
  498.     zzEXIT(zztasp1);
  499.     return;
  500. fail:
  501.     zzEXIT(zztasp1);
  502.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  503.     zzresynch(setwd3, 0x2);
  504.     }
  505. }
  506.  
  507. void
  508. #ifdef __STDC__
  509. near_atom(void)
  510. #else
  511. near_atom()
  512. #endif
  513. {
  514.     zzRULE;
  515.     zzBLOCK(zztasp1);
  516.     zzMake0;
  517.     {
  518.     register int i;
  519.     register int i_prime;
  520.     anychar();
  521.     zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
  522.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  523.     if (case_insensitive && islower(i_prime))
  524.     set_orel(toupper(i_prime)-MIN_CHAR,
  525.     &(zzaRet.label));
  526.     if (case_insensitive && isupper(i_prime))
  527.     set_orel(tolower(i_prime)-MIN_CHAR,
  528.     &(zzaRet.label));
  529.     {
  530.         zzBLOCK(zztasp2);
  531.         zzMake0;
  532.         {
  533.         if ( (LA(1)==RANGE) ) {
  534.             zzmatch(RANGE); zzCONSUME;
  535.             anychar();
  536.             if (case_insensitive){
  537.                 i_prime = zzaRet.letter+MIN_CHAR;
  538.                 zzaRet.letter = (islower(i_prime) ?
  539.                 toupper(i_prime) : i_prime)-MIN_CHAR;
  540.                 i_prime = zzaArg(zztasp2,2 ).letter+MIN_CHAR;
  541.                 zzaArg(zztasp2,2 ).letter = (islower(i_prime) ?
  542.                 toupper(i_prime) : i_prime)-MIN_CHAR;
  543.             }
  544.             /* check to see if range okay */
  545.             if (zzaRet.letter > zzaArg(zztasp2,2 ).letter){
  546.                 error("invalid range  ", zzline);
  547.             }
  548.             for (i=zzaRet.letter; i<= zzaArg(zztasp2,2 ).letter; ++i){
  549.                 set_orel(i,&(zzaRet.label));
  550.                 i_prime = i+MIN_CHAR;
  551.                 if (case_insensitive && islower(i_prime))
  552.                 set_orel(toupper(i_prime)-MIN_CHAR,
  553.                 &(zzaRet.label));
  554.                 if (case_insensitive && isupper(i_prime))
  555.                 set_orel(tolower(i_prime)-MIN_CHAR,
  556.                 &(zzaRet.label));
  557.             }
  558.         }
  559.         zzEXIT(zztasp2);
  560.         }
  561.     }
  562.     zzEXIT(zztasp1);
  563.     return;
  564. fail:
  565.     zzEXIT(zztasp1);
  566.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  567.     zzresynch(setwd3, 0x4);
  568.     }
  569. }
  570.  
  571. void
  572. #ifdef __STDC__
  573. atom(void)
  574. #else
  575. atom()
  576. #endif
  577. {
  578.     zzRULE;
  579.     zzBLOCK(zztasp1);
  580.     zzMake0;
  581.     {
  582.     register int i_prime;  
  583.     anychar();
  584.     zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
  585.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  586.     if (case_insensitive && islower(i_prime))
  587.     set_orel(toupper(i_prime)-MIN_CHAR,
  588.     &(zzaRet.label));
  589.     if (case_insensitive && isupper(i_prime))
  590.     set_orel(tolower(i_prime)-MIN_CHAR,
  591.     &(zzaRet.label));
  592.     zzEXIT(zztasp1);
  593.     return;
  594. fail:
  595.     zzEXIT(zztasp1);
  596.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  597.     zzresynch(setwd3, 0x8);
  598.     }
  599. }
  600.  
  601. void
  602. #ifdef __STDC__
  603. anychar(void)
  604. #else
  605. anychar()
  606. #endif
  607. {
  608.     zzRULE;
  609.     zzBLOCK(zztasp1);
  610.     zzMake0;
  611.     {
  612.     if ( (LA(1)==REGCHAR) ) {
  613.         zzmatch(REGCHAR);
  614.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  615.  zzCONSUME;
  616.     }
  617.     else {
  618.         if ( (LA(1)==OCTAL_VALUE) ) {
  619.             zzmatch(OCTAL_VALUE);
  620.             zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  621.  zzCONSUME;
  622.         }
  623.         else {
  624.             if ( (LA(1)==HEX_VALUE) ) {
  625.                 zzmatch(HEX_VALUE);
  626.                 zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  627.  zzCONSUME;
  628.             }
  629.             else {
  630.                 if ( (LA(1)==DEC_VALUE) ) {
  631.                     zzmatch(DEC_VALUE);
  632.                     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  633.  zzCONSUME;
  634.                 }
  635.                 else {
  636.                     if ( (LA(1)==TAB) ) {
  637.                         zzmatch(TAB);
  638.                         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  639.  zzCONSUME;
  640.                     }
  641.                     else {
  642.                         if ( (LA(1)==NL) ) {
  643.                             zzmatch(NL);
  644.                             zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  645.  zzCONSUME;
  646.                         }
  647.                         else {
  648.                             if ( (LA(1)==CR) ) {
  649.                                 zzmatch(CR);
  650.                                 zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  651.  zzCONSUME;
  652.                             }
  653.                             else {
  654.                                 if ( (LA(1)==BS) ) {
  655.                                     zzmatch(BS);
  656.                                     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  657.  zzCONSUME;
  658.                                 }
  659.                                 else {
  660.                                     if ( (LA(1)==LIT) ) {
  661.                                         zzmatch(LIT);
  662.                                         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  663.  zzCONSUME;
  664.                                     }
  665.                                     else {
  666.                                         if ( (LA(1)==L_EOF) ) {
  667.                                             zzmatch(L_EOF);
  668.                                             zzaRet.letter = 0;  
  669.  zzCONSUME;
  670.                                         }
  671.                                         else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  672.                                     }
  673.                                 }
  674.                             }
  675.                         }
  676.                     }
  677.                 }
  678.             }
  679.         }
  680.     }
  681.     zzEXIT(zztasp1);
  682.     return;
  683. fail:
  684.     zzEXIT(zztasp1);
  685.     /* empty action */  
  686.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  687.     zzresynch(setwd3, 0x10);
  688.     }
  689. }
  690.  
  691. /* adds a new nfa to the binary tree and returns a pointer to it */
  692. nfa_node *new_nfa_node()
  693. {
  694.     register nfa_node *t;
  695.     static int nfa_size=0;    /* elements nfa_array[] can hold */
  696.     
  697.     ++nfa_allocated;
  698.     if (nfa_size<=nfa_allocated){
  699.         /* need to redo array */
  700.         if (!nfa_array){
  701.             /* need some to do inital allocation */
  702.             nfa_size=nfa_allocated+NFA_MIN;
  703.             nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
  704.             nfa_size);
  705.         }else{
  706.             /* need more space */
  707.             nfa_size=2*(nfa_allocated+1);
  708.             nfa_array=(nfa_node **) realloc(nfa_array, 
  709.             sizeof(nfa_node*)*nfa_size);
  710.         }
  711.     }
  712.     /* fill out entry in array */
  713.     t = (nfa_node*) malloc(sizeof(nfa_node));
  714.     nfa_array[nfa_allocated] = t;
  715.     *t = nfa_model_node;
  716.     t->node_no = nfa_allocated;
  717.     return t;
  718. }
  719.  
  720.  
  721. /* initialize the model node used to fill in newly made nfa_nodes */
  722. void
  723. make_nfa_model_node()
  724. {
  725.     nfa_model_node.node_no = -1; /* impossible value for real nfa node */
  726.     nfa_model_node.nfa_set = 0;
  727.     nfa_model_node.accept = 0;   /* error state default*/
  728.     nfa_model_node.trans[0] = NULL;
  729.     nfa_model_node.trans[1] = NULL;
  730.     nfa_model_node.label = empty;
  731. }
  732.  
  733. #ifdef DEBUG
  734.  
  735. /* print out the pointer value and the node_number */
  736. fprint_dfa_pair(f, p)
  737. FILE *f;
  738. nfa_node *p;
  739. {
  740.     if (p){
  741.         fprintf(f, "%x (%d)", p, p->node_no);
  742.     }else{
  743.         fprintf(f, "(nil)");
  744.     }
  745. }
  746.  
  747. /* print out interest information on a set */
  748. fprint_set(f,s)
  749. FILE *f;
  750. set s;
  751. {
  752.     unsigned int *x;
  753.     
  754.     fprintf(f, "n = %d,", s.n);
  755.     if (s.setword){
  756.         fprintf(f, "setword = %x,   ", s.setword);
  757.         /* print out all the elements in the set */
  758.         x = set_pdq(s);
  759.         while (*x!=nil){
  760.             fprintf(f, "%d ", *x);
  761.             ++x;
  762.         }
  763.     }else{
  764.         fprintf(f, "setword = (nil)");
  765.     }
  766. }
  767.  
  768. /* code to be able to dump out the nfas
  769. return 0 if okay dump
  770. return 1 if screwed up
  771. */
  772. int dump_nfas(first_node, last_node)
  773. int first_node;
  774. int last_node;
  775. {
  776.     register int i;
  777.     nfa_node *t;
  778.     
  779.     for (i=first_node; i<=last_node; ++i){
  780.         t = NFA(i);
  781.         if (!t) break;
  782.         fprintf(stderr, "nfa_node %d {\n", t->node_no);
  783.         fprintf(stderr, "\n\tnfa_set = %d\n", t->nfa_set);
  784.         fprintf(stderr, "\taccept\t=\t%d\n", t->accept);
  785.         fprintf(stderr, "\ttrans\t=\t(");
  786.         fprint_dfa_pair(stderr, t->trans[0]);
  787.         fprintf(stderr, ",");
  788.         fprint_dfa_pair(stderr, t->trans[1]);
  789.         fprintf(stderr, ")\n");
  790.         fprintf(stderr, "\tlabel\t=\t{ ");
  791.         fprint_set(stderr, t->label);
  792.         fprintf(stderr, "\t}\n");
  793.         fprintf(stderr, "}\n\n");
  794.     }
  795.     return 0;
  796. }
  797. #endif
  798.