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