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