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-2001
5  * Purdue University Electrical Engineering
6  * With AHPCRC, University of Minnesota
7  * ANTLR Version 1.33MR33
8  *
9  *   ..\bin\antlr dlg_p.g -gh
10  *
11  */
12 
13 #define ANTLR_VERSION	13333
14 #include "pcctscfg.h"
15 #include "pccts_stdio.h"
16 
17 #include <ctype.h>
18 #include "dlg.h"
19 #define zzSET_SIZE 8
20 #include "antlr.h"
21 #include "tokens.h"
22 #include "dlgdef.h"
23 #include "mode.h"
24 
25 /* MR23 In order to remove calls to PURIFY use the antlr -nopurify option */
26 
27 #ifndef PCCTS_PURIFY
28 #define PCCTS_PURIFY(r,s) memset((char *) &(r),'\0',(s));
29 #endif
30 
31 ANTLR_INFO
32 
33 
34 /* MR20 G. Hobbelt
35 Fix for Borland C++ 4.x & 5.x compiling with ALL warnings enabled
36 */
37 
38 #ifdef __TURBOC__
39 #pragma warn -aus  /* unused assignment of 'xxx' */
40 #endif
41 
42 int	action_no = 0;	   /* keep track of actions outputed */
43 int	nfa_allocated = 0; /* keeps track of number of nfa nodes */
44 nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
45 nfa_node nfa_model_node;   /* model to initialize new nodes */
46 set	used_chars;	   /* used to label trans. arcs */
47 set	used_classes;	   /* classes or chars used to label trans. arcs */
48 set	normal_chars;	   /* mask to get rid elements that aren't used
49 in set */
50 int	flag_paren = FALSE;
51 int	flag_brace = FALSE;
52 int	mode_counter = 0;  /* keep track of number of %%names */
53 
54 
55 
56 void
57 #ifdef __USE_PROTOS
grammar(void)58 grammar(void)
59 #else
60 grammar()
61 #endif
62 {
63   zzRULE;
64   zzBLOCK(zztasp1);
65   zzMake0;
66   {
67   p_head(); p_class_hdr(); func_action = FALSE;
68   {
69     zzBLOCK(zztasp2);
70     zzMake0;
71     {
72     while ( (setwd1[LA(1)]&0x1) ) {
73       {
74         zzBLOCK(zztasp3);
75         zzMake0;
76         {
77         if ( (LA(1)==LEXACTION) ) {
78           zzmatch(LEXACTION); zzCONSUME;
79         }
80         else {
81           if ( (LA(1)==LEXMEMBER) ) {
82             zzmatch(LEXMEMBER); zzCONSUME;
83           }
84           else {
85             if ( (LA(1)==LEXPREFIX) ) {
86               zzmatch(LEXPREFIX); zzCONSUME;
87             }
88             else {
89               if ( (LA(1)==PARSERCLASS) ) {
90                 zzmatch(PARSERCLASS); zzCONSUME;
91               }
92               else {
93                 if ( (LA(1)==ACTION) ) {
94                 }
95                 else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
96               }
97             }
98           }
99         }
100         zzEXIT(zztasp3);
101         }
102       }
103       zzmatch(ACTION); zzCONSUME;
104       zzLOOP(zztasp2);
105     }
106     zzEXIT(zztasp2);
107     }
108   }
109   if ( gen_cpp ) p_includes();
110   start_states();
111   func_action = FALSE; p_tables(); p_tail();
112   {
113     zzBLOCK(zztasp2);
114     zzMake0;
115     {
116     while ( (LA(1)==ACTION) ) {
117       zzmatch(ACTION); zzCONSUME;
118       zzLOOP(zztasp2);
119     }
120     zzEXIT(zztasp2);
121     }
122   }
123   zzmatch(1);
124   if (firstLexMember != 0) p_class_def1();
125  zzCONSUME;
126 
127   zzEXIT(zztasp1);
128   return;
129 fail:
130   zzEXIT(zztasp1);
131   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
132   zzresynch(setwd1, 0x2);
133   }
134 }
135 
136 void
137 #ifdef __USE_PROTOS
start_states(void)138 start_states(void)
139 #else
140 start_states()
141 #endif
142 {
143   zzRULE;
144   zzBLOCK(zztasp1);
145   zzMake0;
146   {
147   {
148     zzBLOCK(zztasp2);
149     zzMake0;
150     {
151     if ( (LA(1)==PER_PER) ) {
152       zzmatch(PER_PER); zzCONSUME;
153       do_conversion();
154     }
155     else {
156       if ( (LA(1)==NAME_PER_PER) ) {
157         zzmatch(NAME_PER_PER); zzCONSUME;
158         do_conversion();
159         {
160           zzBLOCK(zztasp3);
161           zzMake0;
162           {
163           while ( (LA(1)==NAME_PER_PER) ) {
164             zzmatch(NAME_PER_PER); zzCONSUME;
165             do_conversion();
166             zzLOOP(zztasp3);
167           }
168           zzEXIT(zztasp3);
169           }
170         }
171       }
172       else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
173     }
174     zzEXIT(zztasp2);
175     }
176   }
177   zzmatch(PER_PER); zzCONSUME;
178   zzEXIT(zztasp1);
179   return;
180 fail:
181   zzEXIT(zztasp1);
182   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
183   zzresynch(setwd1, 0x4);
184   }
185 }
186 
187 void
188 #ifdef __USE_PROTOS
do_conversion(void)189 do_conversion(void)
190 #else
191 do_conversion()
192 #endif
193 {
194   zzRULE;
195   zzBLOCK(zztasp1);
196   zzMake0;
197   {
198   new_automaton_mode(); func_action = TRUE;
199   rule_list();
200 
201   dfa_class_nop[mode_counter] =
202   relabel(zzaArg(zztasp1,1 ).l,comp_level);
203   if (comp_level)
204   p_shift_table(mode_counter);
205   dfa_basep[mode_counter] = dfa_allocated+1;
206   make_dfa_model_node(dfa_class_nop[mode_counter]);
207   nfa_to_dfa(zzaArg(zztasp1,1 ).l);
208   ++mode_counter;
209   func_action = FALSE;
210 #ifdef HASH_STAT
211   fprint_hash_stats(stderr);
212 #endif
213   zzEXIT(zztasp1);
214   return;
215 fail:
216   zzEXIT(zztasp1);
217   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
218   zzresynch(setwd1, 0x8);
219   }
220 }
221 
222 void
223 #ifdef __USE_PROTOS
rule_list(void)224 rule_list(void)
225 #else
226 rule_list()
227 #endif
228 {
229   zzRULE;
230   zzBLOCK(zztasp1);
231   zzMake0;
232   {
233   if ( (setwd1[LA(1)]&0x10) ) {
234     rule();
235     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
236     {
237       zzBLOCK(zztasp2);
238       zzMake0;
239       {
240       while ( (setwd1[LA(1)]&0x20) ) {
241         rule();
242         {nfa_node *t1;
243           t1 = new_nfa_node();
244           (t1)->trans[0]=zzaRet.l;
245           (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
246           /* all accept nodes "dead ends" */
247           zzaRet.l=t1; zzaRet.r=NULL;
248         }
249         zzLOOP(zztasp2);
250       }
251       zzEXIT(zztasp2);
252       }
253     }
254   }
255   else {
256     if ( (setwd1[LA(1)]&0x40) ) {
257       zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
258       warning("no regular expressions", zzline);
259     }
260     else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
261   }
262   zzEXIT(zztasp1);
263   return;
264 fail:
265   zzEXIT(zztasp1);
266   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
267   zzresynch(setwd1, 0x80);
268   }
269 }
270 
271 void
272 #ifdef __USE_PROTOS
rule(void)273 rule(void)
274 #else
275 rule()
276 #endif
277 {
278   zzRULE;
279   zzBLOCK(zztasp1);
280   zzMake0;
281   {
282   if ( (setwd2[LA(1)]&0x1) ) {
283     reg_expr();
284     zzmatch(ACTION);
285     if (zzaArg(zztasp1,1 ).r != NULL) {
286       zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;
287     }
288  zzCONSUME;
289 
290   }
291   else {
292     if ( (LA(1)==ACTION) ) {
293       zzmatch(ACTION);
294       zzaRet.l = NULL; zzaRet.r = NULL;
295       error("no expression for action  ", zzline);
296  zzCONSUME;
297 
298     }
299     else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
300   }
301   zzEXIT(zztasp1);
302   return;
303 fail:
304   zzEXIT(zztasp1);
305   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
306   zzresynch(setwd2, 0x2);
307   }
308 }
309 
310 void
311 #ifdef __USE_PROTOS
reg_expr(void)312 reg_expr(void)
313 #else
314 reg_expr()
315 #endif
316 {
317   zzRULE;
318   zzBLOCK(zztasp1);
319   zzMake0;
320   {
321   and_expr();
322   zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
323   {
324     zzBLOCK(zztasp2);
325     zzMake0;
326     {
327     while ( (LA(1)==OR) ) {
328       zzmatch(OR); zzCONSUME;
329       and_expr();
330       {nfa_node *t1, *t2;
331         t1 = new_nfa_node(); t2 = new_nfa_node();
332         (t1)->trans[0]=zzaRet.l;
333         (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
334         /* MR23 */		   if (zzaRet.r != NULL) (zzaRet.r)->trans[1]=t2;
335         if (zzaArg(zztasp2,2 ).r) {
336           (zzaArg(zztasp2,2 ).r)->trans[1]=t2;     /* MR20 */
337         }
338         zzaRet.l=t1; zzaRet.r=t2;
339       }
340       zzLOOP(zztasp2);
341     }
342     zzEXIT(zztasp2);
343     }
344   }
345   zzEXIT(zztasp1);
346   return;
347 fail:
348   zzEXIT(zztasp1);
349   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
350   zzresynch(setwd2, 0x4);
351   }
352 }
353 
354 void
355 #ifdef __USE_PROTOS
and_expr(void)356 and_expr(void)
357 #else
358 and_expr()
359 #endif
360 {
361   zzRULE;
362   zzBLOCK(zztasp1);
363   zzMake0;
364   {
365   repeat_expr();
366 
367   zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
368   {
369     zzBLOCK(zztasp2);
370     zzMake0;
371     {
372     while ( (setwd2[LA(1)]&0x8) ) {
373       repeat_expr();
374       if (zzaRet.r != NULL) {
375         (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l;
376         zzaRet.r=zzaArg(zztasp2,1 ).r;
377       }
378       zzLOOP(zztasp2);
379     }
380     zzEXIT(zztasp2);
381     }
382   }
383   zzEXIT(zztasp1);
384   return;
385 fail:
386   zzEXIT(zztasp1);
387   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
388   zzresynch(setwd2, 0x10);
389   }
390 }
391 
392 void
393 #ifdef __USE_PROTOS
repeat_expr(void)394 repeat_expr(void)
395 #else
396 repeat_expr()
397 #endif
398 {
399   zzRULE;
400   zzBLOCK(zztasp1);
401   zzMake0;
402   {
403   if ( (setwd2[LA(1)]&0x20) ) {
404     expr();
405     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
406     {
407       zzBLOCK(zztasp2);
408       zzMake0;
409       {
410       if ( (LA(1)==ZERO_MORE) ) {
411         zzmatch(ZERO_MORE);
412         {	nfa_node *t1,*t2;
413           /* MR23 */		if (zzaRet.r != NULL) (zzaRet.r)->trans[0] = zzaRet.l;
414           t1 = new_nfa_node(); t2 = new_nfa_node();
415           t1->trans[0]=zzaRet.l;
416           t1->trans[1]=t2;
417           /* MR23 */		if (zzaRet.r != NULL) (zzaRet.r)->trans[1]=t2;
418           zzaRet.l=t1;zzaRet.r=t2;
419         }
420  zzCONSUME;
421 
422       }
423       else {
424         if ( (LA(1)==ONE_MORE) ) {
425           zzmatch(ONE_MORE);
426           if (zzaRet.r != NULL) (zzaRet.r)->trans[0] = zzaRet.l;
427  zzCONSUME;
428 
429         }
430         else {
431           if ( (setwd2[LA(1)]&0x40) ) {
432           }
433           else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
434         }
435       }
436       zzEXIT(zztasp2);
437       }
438     }
439   }
440   else {
441     if ( (LA(1)==ZERO_MORE) ) {
442       zzmatch(ZERO_MORE);
443       error("no expression for *", zzline);
444  zzCONSUME;
445 
446     }
447     else {
448       if ( (LA(1)==ONE_MORE) ) {
449         zzmatch(ONE_MORE);
450         error("no expression for +", zzline);
451  zzCONSUME;
452 
453       }
454       else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
455     }
456   }
457   zzEXIT(zztasp1);
458   return;
459 fail:
460   zzEXIT(zztasp1);
461   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
462   zzresynch(setwd2, 0x80);
463   }
464 }
465 
466 void
467 #ifdef __USE_PROTOS
expr(void)468 expr(void)
469 #else
470 expr()
471 #endif
472 {
473   zzRULE;
474   zzBLOCK(zztasp1);
475   zzMake0;
476   {
477   zzaRet.l = new_nfa_node();
478   zzaRet.r = new_nfa_node();
479   if ( (LA(1)==L_BRACK) ) {
480     zzmatch(L_BRACK); zzCONSUME;
481     atom_list();
482     zzmatch(R_BRACK);
483 
484     /* MR23 */		if (zzaRet.l != NULL) {
485       (zzaRet.l)->trans[0] = zzaRet.r;
486       (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
487       set_orin(&used_chars,(zzaRet.l)->label);
488     }
489  zzCONSUME;
490 
491   }
492   else {
493     if ( (LA(1)==NOT) ) {
494       zzmatch(NOT); zzCONSUME;
495       zzmatch(L_BRACK); zzCONSUME;
496       atom_list();
497       zzmatch(R_BRACK);
498 
499       /* MR23 */		if (zzaRet.l != NULL) {
500         (zzaRet.l)->trans[0] = zzaRet.r;
501         (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
502         set_orin(&used_chars,(zzaRet.l)->label);
503       }
504  zzCONSUME;
505 
506     }
507     else {
508       if ( (LA(1)==L_PAR) ) {
509         zzmatch(L_PAR); zzCONSUME;
510         reg_expr();
511         zzmatch(R_PAR);
512 
513         /* MR23 */		if (zzaRet.l != NULL) {
514           (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
515           if (zzaArg(zztasp1,2 ).r) {
516             (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;    /* MR20 */
517           }
518         }
519  zzCONSUME;
520 
521       }
522       else {
523         if ( (LA(1)==L_BRACE) ) {
524           zzmatch(L_BRACE); zzCONSUME;
525           reg_expr();
526           zzmatch(R_BRACE);
527 
528           /* MR23 */		if (zzaRet.l != NULL) {
529             (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
530             (zzaRet.l)->trans[1] = zzaRet.r;
531             if (zzaArg(zztasp1,2 ).r) {
532               (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;    /* MR20 */
533             }
534           }
535  zzCONSUME;
536 
537         }
538         else {
539           if ( (setwd3[LA(1)]&0x1) ) {
540             atom();
541 
542             /* MR23 */		if (zzaRet.l != NULL) {
543               (zzaRet.l)->trans[0] = zzaRet.r;
544               (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
545               set_orin(&used_chars,(zzaRet.l)->label);
546             }
547           }
548           else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
549         }
550       }
551     }
552   }
553   zzEXIT(zztasp1);
554   return;
555 fail:
556   zzEXIT(zztasp1);
557   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
558   zzresynch(setwd3, 0x2);
559   }
560 }
561 
562 void
563 #ifdef __USE_PROTOS
atom_list(void)564 atom_list(void)
565 #else
566 atom_list()
567 #endif
568 {
569   zzRULE;
570   zzBLOCK(zztasp1);
571   zzMake0;
572   {
573   set_free(zzaRet.label);
574   {
575     zzBLOCK(zztasp2);
576     zzMake0;
577     {
578     while ( (setwd3[LA(1)]&0x4) ) {
579       near_atom();
580       set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);
581       zzLOOP(zztasp2);
582     }
583     zzEXIT(zztasp2);
584     }
585   }
586   zzEXIT(zztasp1);
587   return;
588 fail:
589   zzEXIT(zztasp1);
590   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
591   zzresynch(setwd3, 0x8);
592   }
593 }
594 
595 void
596 #ifdef __USE_PROTOS
near_atom(void)597 near_atom(void)
598 #else
599 near_atom()
600 #endif
601 {
602   zzRULE;
603   zzBLOCK(zztasp1);
604   zzMake0;
605   {
606   register int i;
607   register int i_prime;
608   anychar();
609   zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
610   i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
611   if (case_insensitive && islower(i_prime))
612   set_orel(toupper(i_prime)-MIN_CHAR,
613   &(zzaRet.label));
614   if (case_insensitive && isupper(i_prime))
615   set_orel(tolower(i_prime)-MIN_CHAR,
616   &(zzaRet.label));
617   {
618     zzBLOCK(zztasp2);
619     zzMake0;
620     {
621     if ( (LA(1)==RANGE) ) {
622       zzmatch(RANGE); zzCONSUME;
623       anychar();
624       if (case_insensitive){
625         i_prime = zzaRet.letter+MIN_CHAR;
626         zzaRet.letter = (islower(i_prime) ?
627         toupper(i_prime) : i_prime)-MIN_CHAR;
628         i_prime = zzaArg(zztasp2,2 ).letter+MIN_CHAR;
629         zzaArg(zztasp2,2 ).letter = (islower(i_prime) ?
630         toupper(i_prime) : i_prime)-MIN_CHAR;
631       }
632       /* check to see if range okay */
633       {
634         int debugLetter1 = zzaRet.letter;
635         int debugLetter2 = zzaArg(zztasp2,2 ).letter;
636       }
637       if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
638       && zzaArg(zztasp2,2 ).letter != 0xff){       /* MR16 */
639         error("invalid range  ", zzline);
640       }
641       for (i=zzaRet.letter; i<= (int)zzaArg(zztasp2,2 ).letter; ++i){
642         set_orel(i,&(zzaRet.label));
643         i_prime = i+MIN_CHAR;
644         if (case_insensitive && islower(i_prime))
645         set_orel(toupper(i_prime)-MIN_CHAR,
646         &(zzaRet.label));
647         if (case_insensitive && isupper(i_prime))
648         set_orel(tolower(i_prime)-MIN_CHAR,
649         &(zzaRet.label));
650       }
651     }
652     else {
653       if ( (setwd3[LA(1)]&0x10) ) {
654       }
655       else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
656     }
657     zzEXIT(zztasp2);
658     }
659   }
660   zzEXIT(zztasp1);
661   return;
662 fail:
663   zzEXIT(zztasp1);
664   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
665   zzresynch(setwd3, 0x20);
666   }
667 }
668 
669 void
670 #ifdef __USE_PROTOS
atom(void)671 atom(void)
672 #else
673 atom()
674 #endif
675 {
676   zzRULE;
677   zzBLOCK(zztasp1);
678   zzMake0;
679   {
680   register int i_prime;
681   anychar();
682   zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
683   i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
684   if (case_insensitive && islower(i_prime))
685   set_orel(toupper(i_prime)-MIN_CHAR,
686   &(zzaRet.label));
687   if (case_insensitive && isupper(i_prime))
688   set_orel(tolower(i_prime)-MIN_CHAR,
689   &(zzaRet.label));
690   zzEXIT(zztasp1);
691   return;
692 fail:
693   zzEXIT(zztasp1);
694   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
695   zzresynch(setwd3, 0x40);
696   }
697 }
698 
699 void
700 #ifdef __USE_PROTOS
anychar(void)701 anychar(void)
702 #else
703 anychar()
704 #endif
705 {
706   zzRULE;
707   zzBLOCK(zztasp1);
708   zzMake0;
709   {
710   if ( (LA(1)==REGCHAR) ) {
711     zzmatch(REGCHAR);
712     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
713  zzCONSUME;
714 
715   }
716   else {
717     if ( (LA(1)==OCTAL_VALUE) ) {
718       zzmatch(OCTAL_VALUE);
719       zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
720  zzCONSUME;
721 
722     }
723     else {
724       if ( (LA(1)==HEX_VALUE) ) {
725         zzmatch(HEX_VALUE);
726         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
727  zzCONSUME;
728 
729       }
730       else {
731         if ( (LA(1)==DEC_VALUE) ) {
732           zzmatch(DEC_VALUE);
733           zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
734  zzCONSUME;
735 
736         }
737         else {
738           if ( (LA(1)==TAB) ) {
739             zzmatch(TAB);
740             zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
741  zzCONSUME;
742 
743           }
744           else {
745             if ( (LA(1)==NL) ) {
746               zzmatch(NL);
747               zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
748  zzCONSUME;
749 
750             }
751             else {
752               if ( (LA(1)==CR) ) {
753                 zzmatch(CR);
754                 zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
755  zzCONSUME;
756 
757               }
758               else {
759                 if ( (LA(1)==BS) ) {
760                   zzmatch(BS);
761                   zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
762  zzCONSUME;
763 
764                 }
765                 else {
766                   if ( (LA(1)==LIT) ) {
767                     zzmatch(LIT);
768                     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
769  zzCONSUME;
770 
771                   }
772                   else {
773                     if ( (LA(1)==L_EOF) ) {
774                       zzmatch(L_EOF);
775                       zzaRet.letter = 0;
776  zzCONSUME;
777 
778                     }
779                     else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
780                   }
781                 }
782               }
783             }
784           }
785         }
786       }
787     }
788   }
789   zzEXIT(zztasp1);
790   return;
791 fail:
792   zzEXIT(zztasp1);
793   /* empty action */
794   zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
795   zzresynch(setwd3, 0x80);
796   }
797 }
798 
799 /* adds a new nfa to the binary tree and returns a pointer to it */
800 nfa_node *
801 #ifdef __USE_PROTOS
new_nfa_node(void)802 new_nfa_node(void)
803 #else
804 new_nfa_node()
805 #endif
806 {
807   register nfa_node *t;
808   static int nfa_size=0;	/* elements nfa_array[] can hold */
809 
810 	++nfa_allocated;
811   if (nfa_size<=nfa_allocated){
812     /* need to redo array */
813     if (!nfa_array){
814       /* need some to do inital allocation */
815       nfa_size=nfa_allocated+NFA_MIN;
816       nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
817       nfa_size);
818     }else{
819       /* need more space */
820       nfa_size=2*(nfa_allocated+1);
821       nfa_array=(nfa_node **) realloc(nfa_array,
822       sizeof(nfa_node*)*nfa_size);
823     }
824   }
825   /* fill out entry in array */
826   t = (nfa_node*) malloc(sizeof(nfa_node));
827   nfa_array[nfa_allocated] = t;
828   *t = nfa_model_node;
829   t->node_no = nfa_allocated;
830   return t;
831 }
832 
833 
834 /* initialize the model node used to fill in newly made nfa_nodes */
835 void
836 #ifdef __USE_PROTOS
make_nfa_model_node(void)837 make_nfa_model_node(void)
838 #else
839 make_nfa_model_node()
840 #endif
841 {
842   nfa_model_node.node_no = -1; /* impossible value for real nfa node */
843   nfa_model_node.nfa_set = 0;
844   nfa_model_node.accept = 0;   /* error state default*/
845   nfa_model_node.trans[0] = NULL;
846   nfa_model_node.trans[1] = NULL;
847   nfa_model_node.label = empty;
848 }
849 
850 #if defined(DEBUG) || defined(_DEBUG)
851 
852 /* print out the pointer value and the node_number */
853 void
854 #ifdef __USE_PROTOS
fprint_dfa_pair(FILE * f,nfa_node * p)855 fprint_dfa_pair(FILE *f, nfa_node *p)
856 #else
857 fprint_dfa_pair(f, p)
858 FILE *f;
859 nfa_node *p;
860 #endif
861 {
862   if (p){
863     fprintf(f, "%x (%d)", p, p->node_no);
864   }else{
865     fprintf(f, "(nil)");
866   }
867 }
868 
869 /* print out interest information on a set */
870 void
871 #ifdef __USE_PROTOS
fprint_set(FILE * f,set s)872 fprint_set(FILE *f, set s)
873 #else
874 fprint_set(f,s)
875 FILE *f;
876 set s;
877 #endif
878 {
879   unsigned int *x;
880 
881 	fprintf(f, "n = %d,", s.n);
882   if (s.setword){
883     fprintf(f, "setword = %x,   ", s.setword);
884     /* print out all the elements in the set */
885     x = set_pdq(s);
886     while (*x!=nil){
887       fprintf(f, "%d ", *x);
888       ++x;
889     }
890   }else{
891     fprintf(f, "setword = (nil)");
892   }
893 }
894 
895 /* code to be able to dump out the nfas
896 return 0 if okay dump
897 return 1 if screwed up
898 */
899 int
900 #ifdef __USE_PROTOS
dump_nfas(int first_node,int last_node)901 dump_nfas(int first_node, int last_node)
902 #else
903 dump_nfas(first_node, last_node)
904 int first_node;
905 int last_node;
906 #endif
907 {
908   register int i;
909   nfa_node *t;
910 
911 	for (i=first_node; i<=last_node; ++i){
912     t = NFA(i);
913     if (!t) break;
914     fprintf(stderr, "nfa_node %d {\n", t->node_no);
915     fprintf(stderr, "\n\tnfa_set = %d\n", t->nfa_set);
916     fprintf(stderr, "\taccept\t=\t%d\n", t->accept);
917     fprintf(stderr, "\ttrans\t=\t(");
918     fprint_dfa_pair(stderr, t->trans[0]);
919     fprintf(stderr, ",");
920     fprint_dfa_pair(stderr, t->trans[1]);
921     fprintf(stderr, ")\n");
922     fprintf(stderr, "\tlabel\t=\t{ ");
923     fprint_set(stderr, t->label);
924     fprintf(stderr, "\t}\n");
925     fprintf(stderr, "}\n\n");
926   }
927   return 0;
928 }
929 #endif
930 
931 /* DLG-specific syntax error message generator
932 * (define USER_ZZSYN when compiling so don't get 2 definitions)
933 */
934 void
935 #ifdef __USE_PROTOS
zzsyn(char * text,int tok,char * egroup,SetWordType * eset,int etok,int k,char * bad_text)936 zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
937 #else
938 zzsyn(text, tok, egroup, eset, etok, k, bad_text)
939 char *text, *egroup, *bad_text;
940 int tok;
941 int etok;
942 int k;
943 SetWordType *eset;
944 #endif
945 {
946 fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
947 fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
948 if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
949 if ( k==1 ) fprintf(stderr, " missing");
950 else
951 {
952 fprintf(stderr, "; \"%s\" not", bad_text);
953 if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
954 }
955 if ( zzset_deg(eset)>0 ) zzedecode(eset);
956 else fprintf(stderr, " %s", zztokens[etok]);
957 if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
958 fprintf(stderr, "\n");
959 }
960