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