BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c

   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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 inital 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
 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
 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
 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
 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
 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 }