pd.if.org Git - pccts/blob - h/err.h

   1 /*
   2  * err.h
   3  *
   4  * Standard error handling mechanism
   5  *
   6  * SOFTWARE RIGHTS
   7  *
   8  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
   9  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  10  * company may do whatever they wish with source code distributed with
  11  * PCCTS or the code generated by PCCTS, including the incorporation of
  12  * PCCTS, or its output, into commerical software.
  13  *
  14  * We encourage users to develop software with PCCTS.  However, we do ask
  15  * that credit is given to us for developing PCCTS.  By "credit",
  16  * we mean that if you incorporate our source code into one of your
  17  * programs (commercial product, research project, or otherwise) that you
  18  * acknowledge this fact somewhere in the documentation, research report,
  19  * etc...  If you like PCCTS and have developed a nice tool with the
  20  * output, please mention that you developed it using PCCTS.  In
  21  * addition, we ask that this header remain intact in our source code.
  22  * As long as these guidelines are kept, we expect to continue enhancing
  23  * this system and expect to make other tools available as they are
  24  * completed.
  25  *
  26  * Has grown to hold all kinds of stuff (err.h is increasingly misnamed)
  27  *
  28  * ANTLR 1.33
  29  * Terence Parr
  30  * Parr Research Corporation
  31  * with Purdue University and AHPCRC, University of Minnesota
  32  * 1989-1995
  33  */
  34
  35 #ifndef ERR_H
  36 #define ERR_H
  37
  38 #include "config.h"
  39
  40 #include <string.h>
  41 #ifdef __STDC__
  42 #include <stdarg.h>
  43 #else
  44 #include <varargs.h>
  45 #endif
  46
  47 #ifdef DUM
  48 /* Define usable bits per unsigned int word (used for set stuff) */
  49 #ifdef PC
  50 #define BSETWORDSIZE 16
  51 #define BSETLOGWORDSIZE 4
  52 #else
  53 #define BSETWORDSIZE 32
  54 #define BSETLOGWORDSIZE 5
  55 #endif
  56 #endif
  57
  58 #define BSETWORDSIZE 8
  59 #define BSETLOGWORDSIZE 3               /* SetWordType is 8bits */
  60
  61 #define BSETMODWORD(x) ((x) & (BSETWORDSIZE-1))         /* x % BSETWORDSIZE */
  62 #define BSETDIVWORD(x) ((x) >> BSETLOGWORDSIZE)         /* x / BSETWORDSIZE */
  63
  64 /* This is not put into the global pccts_parser structure because it is
  65  * hidden and does not need to be saved during a "save state" operation
  66  */
  67 /* maximum of 32 bits/unsigned int and must be 8 bits/byte */
  68 static SetWordType bitmask[] = {
  69         0x00000001, 0x00000002, 0x00000004, 0x00000008,
  70         0x00000010, 0x00000020, 0x00000040, 0x00000080
  71 };
  72
  73 void
  74 #ifdef __USE_PROTOS
  75 zzresynch(SetWordType *wd,SetWordType mask)
  76 #else
  77 zzresynch(wd,mask)
  78 SetWordType *wd, mask;
  79 #endif
  80 {
  81         static int consumed = 1;
  82
  83         /* if you enter here without having consumed a token from last resynch
  84          * force a token consumption.
  85          */
  86         if ( !consumed ) {zzCONSUME; return;}
  87
  88         /* if current token is in resynch set, we've got what we wanted */
  89         if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
  90
  91         /* scan until we find something in the resynch set */
  92         while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
  93         consumed=1;
  94 }
  95
  96 void
  97 #ifdef __USE_PROTOS
  98 zzconsumeUntil(SetWordType *st)
  99 #else
 100 zzconsumeUntil(st)
 101 SetWordType *st;
 102 #endif
 103 {
 104         while ( !zzset_el(LA(1), st) ) { zzCONSUME; }
 105 }
 106
 107 void
 108 #ifdef __USE_PROTOS
 109 zzconsumeUntilToken(int t)
 110 #else
 111 zzconsumeUntilToken(t)
 112 int t;
 113 #endif
 114 {
 115         while ( LA(1)!=t ) { zzCONSUME; }
 116 }
 117
 118 /* input looks like:
 119  *              zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText)
 120  * where the zzMiss stuff is set here to the token that did not match
 121  * (and which set wasn't it a member of).
 122  */
 123 void
 124 #ifdef __USE_PROTOS
 125 zzFAIL(int k, ...)
 126 #else
 127 zzFAIL(va_alist)
 128 va_dcl
 129 #endif
 130 {
 131 #ifdef LL_K
 132         static char text[LL_K*ZZLEXBUFSIZE+1];
 133         SetWordType *f[LL_K];
 134 #else
 135         static char text[ZZLEXBUFSIZE+1];
 136         SetWordType *f[1];
 137 #endif
 138         SetWordType **miss_set;
 139         char **miss_text;
 140         int *bad_tok;
 141         char **bad_text;
 142         int *err_k;
 143         int i;
 144         va_list ap;
 145 #ifndef __USE_PROTOS
 146         int k;
 147 #endif
 148 #ifdef __USE_PROTOS
 149         va_start(ap, k);
 150 #else
 151         va_start(ap);
 152         k = va_arg(ap, int);    /* how many lookahead sets? */
 153 #endif
 154         text[0] = '\0';
 155         for (i=1; i<=k; i++)    /* collect all lookahead sets */
 156         {
 157                 f[i-1] = va_arg(ap, SetWordType *);
 158         }
 159         for (i=1; i<=k; i++)    /* look for offending token */
 160         {
 161                 if ( i>1 ) strcat(text, " ");
 162                 strcat(text, LATEXT(i));
 163                 if ( !zzset_el((unsigned)LA(i), f[i-1]) ) break;
 164         }
 165         miss_set = va_arg(ap, SetWordType **);
 166         miss_text = va_arg(ap, char **);
 167         bad_tok = va_arg(ap, int *);
 168         bad_text = va_arg(ap, char **);
 169         err_k = va_arg(ap, int *);
 170         if ( i>k )
 171         {
 172                 /* bad; lookahead is permutation that cannot be matched,
 173                  * but, the ith token of lookahead is valid at the ith position
 174                  * (The old LL sub 1 (k) versus LL(k) parsing technique)
 175                  */
 176                 *miss_set = NULL;
 177                 *miss_text = zzlextext;
 178                 *bad_tok = LA(1);
 179                 *bad_text = LATEXT(1);
 180                 *err_k = k;
 181                 return;
 182         }
 183 /*      fprintf(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/
 184         *miss_set = f[i-1];
 185         *miss_text = text;
 186         *bad_tok = LA(i);
 187         *bad_text = LATEXT(i);
 188         if ( i==1 ) *err_k = 1;
 189         else *err_k = k;
 190 }
 191
 192 void
 193 #ifdef __USE_PROTOS
 194 zzsave_antlr_state(zzantlr_state *buf)
 195 #else
 196 zzsave_antlr_state(buf)
 197 zzantlr_state *buf;
 198 #endif
 199 {
 200 #ifdef LL_K
 201         int i;
 202 #endif
 203
 204 #ifdef ZZCAN_GUESS
 205         buf->guess_start = zzguess_start;
 206         buf->guessing = zzguessing;
 207 #endif
 208         buf->asp = zzasp;
 209 #ifdef GENAST
 210         buf->ast_sp = zzast_sp;
 211 #endif
 212 #ifdef ZZINF_LOOK
 213         buf->inf_labase = zzinf_labase;
 214         buf->inf_last = zzinf_last;
 215 #endif
 216 #ifdef DEMAND_LOOK
 217         buf->dirty = zzdirty;
 218 #endif
 219 #ifdef LL_K
 220         for (i=0; i<LL_K; i++) buf->tokenLA[i] = zztokenLA[i];
 221         for (i=0; i<LL_K; i++) strcpy(buf->textLA[i], zztextLA[i]);
 222         buf->lap = zzlap;
 223         buf->labase = zzlabase;
 224 #else
 225         buf->token = zztoken;
 226         strcpy(buf->text, zzlextext);
 227 #endif
 228 }
 229
 230 void
 231 #ifdef __USE_PROTOS
 232 zzrestore_antlr_state(zzantlr_state *buf)
 233 #else
 234 zzrestore_antlr_state(buf)
 235 zzantlr_state *buf;
 236 #endif
 237 {
 238 #ifdef LL_K
 239         int i;
 240 #endif
 241
 242 #ifdef ZZCAN_GUESS
 243         zzguess_start = buf->guess_start;
 244         zzguessing = buf->guessing;
 245 #endif
 246         zzasp = buf->asp;
 247 #ifdef GENAST
 248         zzast_sp = buf->ast_sp;
 249 #endif
 250 #ifdef ZZINF_LOOK
 251         zzinf_labase = buf->inf_labase;
 252         zzinf_last = buf->inf_last;
 253 #endif
 254 #ifdef DEMAND_LOOK
 255         zzdirty = buf->dirty;
 256 #endif
 257 #ifdef LL_K
 258         for (i=0; i<LL_K; i++) zztokenLA[i] = buf->tokenLA[i];
 259         for (i=0; i<LL_K; i++) strcpy(zztextLA[i], buf->textLA[i]);
 260         zzlap = buf->lap;
 261         zzlabase = buf->labase;
 262 #else
 263         zztoken = buf->token;
 264         strcpy(zzlextext, buf->text);
 265 #endif
 266 }
 267
 268 void
 269 #ifdef __USE_PROTOS
 270 zzedecode(SetWordType *a)
 271 #else
 272 zzedecode(a)
 273 SetWordType *a;
 274 #endif
 275 {
 276         register SetWordType *p = a;
 277         register SetWordType *endp = &(p[zzSET_SIZE]);
 278         register unsigned e = 0;
 279
 280         if ( zzset_deg(a)>1 ) fprintf(stderr, " {");
 281         do {
 282                 register SetWordType t = *p;
 283                 register SetWordType *b = &(bitmask[0]);
 284                 do {
 285                         if ( t & *b ) fprintf(stderr, " %s", zztokens[e]);
 286                         e++;
 287                 } while (++b < &(bitmask[sizeof(SetWordType)*8]));
 288         } while (++p < endp);
 289         if ( zzset_deg(a)>1 ) fprintf(stderr, " }");
 290 }
 291
 292 #ifndef USER_ZZSYN
 293 /* standard error reporting function */
 294 void
 295 #ifdef __USE_PROTOS
 296 zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
 297 #else
 298 zzsyn(text, tok, egroup, eset, etok, k, bad_text)
 299 char *text, *egroup, *bad_text;
 300 int tok;
 301 int etok;
 302 int k;
 303 SetWordType *eset;
 304 #endif
 305 {
 306
 307         fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
 308         if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
 309         if ( k==1 ) fprintf(stderr, " missing");
 310         else
 311         {
 312                 fprintf(stderr, "; \"%s\" not", bad_text);
 313                 if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
 314         }
 315         if ( zzset_deg(eset)>0 ) zzedecode(eset);
 316         else fprintf(stderr, " %s", zztokens[etok]);
 317         if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
 318         fprintf(stderr, "\n");
 319 }
 320 #endif
 321
 322 /* is b an element of set p? */
 323 int
 324 #ifdef __USE_PROTOS
 325 zzset_el(unsigned b, SetWordType *p)
 326 #else
 327 zzset_el(b,p)
 328 unsigned b;
 329 SetWordType *p;
 330 #endif
 331 {
 332         return( p[BSETDIVWORD(b)] & bitmask[BSETMODWORD(b)] );
 333 }
 334
 335 int
 336 #ifdef __USE_PROTOS
 337 zzset_deg(SetWordType *a)
 338 #else
 339 zzset_deg(a)
 340 SetWordType *a;
 341 #endif
 342 {
 343         /* Fast compute degree of a set... the number
 344            of elements present in the set.  Assumes
 345            that all word bits are used in the set
 346         */
 347         register SetWordType *p = a;
 348         register SetWordType *endp = &(a[zzSET_SIZE]);
 349         register int degree = 0;
 350
 351         if ( a == NULL ) return 0;
 352         while ( p < endp )
 353         {
 354                 register SetWordType t = *p;
 355                 register SetWordType *b = &(bitmask[0]);
 356                 do {
 357                         if (t & *b) ++degree;
 358                 } while (++b < &(bitmask[sizeof(SetWordType)*8]));
 359                 p++;
 360         }
 361
 362         return(degree);
 363 }
 364
 365 #ifdef DEMAND_LOOK
 366
 367 #ifdef LL_K
 368 int
 369 #ifdef __USE_PROTOS
 370 _zzmatch(int _t, char **zzBadText, char **zzMissText,
 371                 int *zzMissTok, int *zzBadTok,
 372                 SetWordType **zzMissSet)
 373 #else
 374 _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
 375 int _t;
 376 char **zzBadText;
 377 char **zzMissText;
 378 int *zzMissTok, *zzBadTok;
 379 SetWordType **zzMissSet;
 380 #endif
 381 {
 382         if ( zzdirty==LL_K ) {
 383                 zzCONSUME;
 384         }
 385         if ( LA(1)!=_t ) {
 386                 *zzBadText = *zzMissText=LATEXT(1);
 387                 *zzMissTok= _t; *zzBadTok=LA(1);
 388                 *zzMissSet=NULL;
 389                 return 0;
 390         }
 391         zzMakeAttr
 392         zzdirty++;
 393         zzlabase++;
 394         return 1;
 395 }
 396
 397 int
 398 #ifdef __USE_PROTOS
 399 _zzmatch_wsig(int _t)
 400 #else
 401 _zzmatch_wsig(_t)
 402 int _t;
 403 #endif
 404 {
 405         if ( zzdirty==LL_K ) {
 406                 zzCONSUME;
 407         }
 408         if ( LA(1)!=_t ) {
 409                 return 0;
 410         }
 411         zzMakeAttr
 412         zzdirty++;
 413         zzlabase++;
 414         return 1;
 415 }
 416
 417 #else
 418
 419 int
 420 #ifdef __USE_PROTOS
 421 _zzmatch(int _t, char **zzBadText, char **zzMissText,
 422                  int *zzMissTok, int *zzBadTok, SetWordType **zzMissSet)
 423 #else
 424 _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
 425 int _t;
 426 char **zzBadText;
 427 char **zzMissText;
 428 int *zzMissTok, *zzBadTok;
 429 SetWordType **zzMissSet;
 430 #endif
 431 {
 432         if ( zzdirty ) {zzCONSUME;}
 433         if ( LA(1)!=_t ) {
 434                 *zzBadText = *zzMissText=LATEXT(1);
 435                 *zzMissTok= _t; *zzBadTok=LA(1);
 436                 *zzMissSet=NULL;
 437                 return 0;
 438         }
 439         zzdirty = 1;
 440         zzMakeAttr
 441         return 1;
 442 }
 443
 444 int
 445 #ifdef __USE_PROTOS
 446 _zzmatch_wsig(int _t)
 447 #else
 448 _zzmatch_wsig(_t)
 449 int _t;
 450 #endif
 451 {
 452         if ( zzdirty ) {zzCONSUME;}
 453         if ( LA(1)!=_t ) {
 454                 return 0;
 455         }
 456         zzdirty = 1;
 457         zzMakeAttr
 458         return 1;
 459 }
 460
 461 #endif /*LL_K*/
 462
 463 #else
 464
 465 int
 466 #ifdef __USE_PROTOS
 467 _zzmatch(int _t, char **zzBadText, char **zzMissText,
 468                 int *zzMissTok, int *zzBadTok,
 469                 SetWordType **zzMissSet)
 470 #else
 471 _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
 472 int _t;
 473 char **zzBadText;
 474 char **zzMissText;
 475 int *zzMissTok, *zzBadTok;
 476 SetWordType **zzMissSet;
 477 #endif
 478 {
 479         if ( LA(1)!=_t ) {
 480                 *zzBadText = *zzMissText=LATEXT(1);
 481                 *zzMissTok= _t; *zzBadTok=LA(1);
 482                 *zzMissSet=NULL;
 483                 return 0;
 484         }
 485         zzMakeAttr
 486         return 1;
 487 }
 488
 489 int
 490 #ifdef __USE_PROTOS
 491 _zzmatch_wsig(int _t)
 492 #else
 493 _zzmatch_wsig(_t)
 494 int _t;
 495 #endif
 496 {
 497         if ( LA(1)!=_t ) return 0;
 498         zzMakeAttr
 499         return 1;
 500 }
 501
 502 #endif /*DEMAND_LOOK*/
 503
 504 #ifdef ZZINF_LOOK
 505 void
 506 #ifdef __USE_PROTOS
 507 _inf_zzgettok(void)
 508 #else
 509 _inf_zzgettok()
 510 #endif
 511 {
 512         if ( zzinf_labase >= zzinf_last )
 513                 {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
 514         else {
 515                 NLA = zzinf_tokens[zzinf_labase];
 516                 zzline = zzinf_line[zzinf_labase];      /* wrong in 1.21 */
 517                 strcpy(NLATEXT, zzinf_text[zzinf_labase]);
 518                 zzinf_labase++;
 519         }
 520 }
 521 #endif
 522
 523 #ifdef ZZINF_LOOK
 524 /* allocate default size text,token and line arrays;
 525  * then, read all of the input reallocing the arrays as needed.
 526  * Once the number of total tokens is known, the LATEXT(i) array (zzinf_text)
 527  * is allocated and it's pointers are set to the tokens in zzinf_text_buffer.
 528  */
 529 void
 530 #ifdef __USE_PROTOS
 531 zzfill_inf_look(void)
 532 #else
 533 zzfill_inf_look()
 534 #endif
 535 {
 536         int tok, line;
 537         int zzinf_token_buffer_size = ZZINF_DEF_TOKEN_BUFFER_SIZE;
 538         int zzinf_text_buffer_size = ZZINF_DEF_TEXT_BUFFER_SIZE;
 539         int zzinf_text_buffer_index = 0;
 540         int zzinf_lap = 0;
 541
 542         /* allocate text/token buffers */
 543         zzinf_text_buffer = (char *) malloc(zzinf_text_buffer_size);
 544         if ( zzinf_text_buffer == NULL )
 545         {
 546                 fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
 547                 zzinf_text_buffer_size);
 548                 exit(PCCTS_EXIT_FAILURE);
 549         }
 550         zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
 551         if ( zzinf_tokens == NULL )
 552         {
 553                 fprintf(stderr, "cannot allocate token buffer (%d tokens)\n",
 554                                 zzinf_token_buffer_size);
 555                 exit(PCCTS_EXIT_FAILURE);
 556         }
 557     zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
 558     if ( zzinf_line == NULL )
 559     {
 560         fprintf(stderr, "cannot allocate line buffer (%d ints)\n",
 561                 zzinf_token_buffer_size);
 562         exit(PCCTS_EXIT_FAILURE);
 563         }
 564
 565         /* get tokens, copying text to text buffer */
 566         zzinf_text_buffer_index = 0;
 567         do {
 568                 zzgettok();
 569                 line = zzreal_line;
 570                 while ( zzinf_lap>=zzinf_token_buffer_size )
 571                 {
 572                         zzinf_token_buffer_size += ZZINF_BUFFER_TOKEN_CHUNK_SIZE;
 573                         zzinf_tokens = (int *) realloc(zzinf_tokens,
 574                                                                                                  zzinf_token_buffer_size*sizeof(int));
 575                         if ( zzinf_tokens == NULL )
 576                         {
 577                                 fprintf(stderr, "cannot allocate lookahead token buffer (%d tokens)\n",
 578                                                 zzinf_token_buffer_size);
 579                                 exit(PCCTS_EXIT_FAILURE);
 580                         }
 581             zzinf_line = (int *) realloc(zzinf_line,
 582                                          zzinf_token_buffer_size*sizeof(int));
 583             if ( zzinf_line == NULL )
 584             {
 585                 fprintf(stderr, "cannot allocate lookahead line buffer (%d ints)\n",
 586                         zzinf_token_buffer_size);
 587                 exit(PCCTS_EXIT_FAILURE);
 588                         }
 589
 590                 }
 591                 while ( (zzinf_text_buffer_index+strlen(NLATEXT)+1) >= zzinf_text_buffer_size )
 592                 {
 593                         zzinf_text_buffer_size += ZZINF_BUFFER_TEXT_CHUNK_SIZE;
 594                         zzinf_text_buffer = (char *) realloc(zzinf_text_buffer,
 595                                                                                                  zzinf_text_buffer_size);
 596                         if ( zzinf_text_buffer == NULL )
 597                         {
 598                                 fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
 599                                                 zzinf_text_buffer_size);
 600                                 exit(PCCTS_EXIT_FAILURE);
 601                         }
 602                 }
 603                 /* record token and text and line of input symbol */
 604                 tok = zzinf_tokens[zzinf_lap] = NLA;
 605                 strcpy(&zzinf_text_buffer[zzinf_text_buffer_index], NLATEXT);
 606                 zzinf_text_buffer_index += strlen(NLATEXT)+1;
 607         zzinf_line[zzinf_lap] = line;
 608                 zzinf_lap++;
 609         } while (tok!=zzEOF_TOKEN);
 610         zzinf_labase = 0;
 611         zzinf_last = zzinf_lap-1;
 612
 613         /* allocate ptrs to text of ith token */
 614         zzinf_text = (char **) calloc(zzinf_last+1,sizeof(char *));
 615         if ( zzinf_text == NULL )
 616         {
 617                 fprintf(stderr, "cannot allocate lookahead text buffer (%d)\n",
 618                                 zzinf_text_buffer_size);
 619                 exit(PCCTS_EXIT_FAILURE);
 620         }
 621         zzinf_text_buffer_index = 0;
 622         zzinf_lap = 0;
 623         /* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
 624         while (zzinf_lap<=zzinf_last)
 625         {
 626             zzinf_text[zzinf_lap++] = &zzinf_text_buffer[zzinf_text_buffer_index];
 627                 zzinf_text_buffer_index += strlen(&zzinf_text_buffer[zzinf_text_buffer_index])+1;
 628         }
 629 }
 630 #endif
 631
 632 int
 633 #ifdef __USE_PROTOS
 634 _zzsetmatch(SetWordType *e, char **zzBadText, char **zzMissText,
 635                         int *zzMissTok, int *zzBadTok,
 636                         SetWordType **zzMissSet)
 637 #else
 638 _zzsetmatch(e, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
 639 SetWordType *e;
 640 char **zzBadText;
 641 char **zzMissText;
 642 int *zzMissTok, *zzBadTok;
 643 SetWordType **zzMissSet;
 644 #endif
 645 {
 646 #ifdef DEMAND_LOOK
 647 #ifdef LL_K
 648         if ( zzdirty==LL_K ) {zzCONSUME;}
 649 #else
 650         if ( zzdirty ) {zzCONSUME;}
 651 #endif
 652 #endif
 653         if ( !zzset_el((unsigned)LA(1), e) ) {
 654                 *zzBadText = LATEXT(1); *zzMissText=NULL;
 655                 *zzMissTok= 0; *zzBadTok=LA(1);
 656                 *zzMissSet=e;
 657                 return 0;
 658         }
 659 #ifdef DEMAND_LOOK
 660 #ifdef LL_K
 661         zzdirty++;
 662 #else
 663         zzdirty = 1;
 664 #endif
 665 #endif
 666         zzMakeAttr
 667         return 1;
 668 }
 669
 670 int
 671 #ifdef __USE_PROTOS
 672 _zzmatch_wdfltsig(int tokenWanted, SetWordType *whatFollows)
 673 #else
 674 _zzmatch_wdfltsig(tokenWanted, whatFollows)
 675 int tokenWanted;
 676 SetWordType *whatFollows;
 677 #endif
 678 {
 679 #ifdef DEMAND_LOOK
 680 #ifdef LL_K
 681         if ( zzdirty==LL_K ) {
 682                         zzCONSUME;
 683         }
 684 #else
 685         if ( zzdirty ) {zzCONSUME;}
 686 #endif
 687 #endif
 688
 689         if ( LA(1)!=tokenWanted )
 690         {
 691                 fprintf(stderr,
 692                                 "line %d: syntax error at \"%s\" missing %s\n",
 693                                 zzline,
 694                                 (LA(1)==zzEOF_TOKEN)?"<eof>":LATEXT(1),
 695                                 zztokens[tokenWanted]);
 696                 zzconsumeUntil( whatFollows );
 697                 return 0;
 698         }
 699         else {
 700                 zzMakeAttr
 701 #ifdef DEMAND_LOOK
 702 #ifdef LL_K
 703                 zzdirty++;
 704                 zzlabase++;
 705 #else
 706                 zzdirty = 1;
 707 #endif
 708 #else
 709 /*              zzCONSUME;               consume if not demand lookahead */
 710 #endif
 711                 return 1;
 712         }
 713 }
 714
 715 int
 716 #ifdef __USE_PROTOS
 717 _zzsetmatch_wdfltsig(SetWordType *tokensWanted,
 718                                          int tokenTypeOfSet,
 719                                          SetWordType *whatFollows)
 720 #else
 721 _zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows)
 722 SetWordType *tokensWanted;
 723 int tokenTypeOfSet;
 724 SetWordType *whatFollows;
 725 #endif
 726 {
 727 #ifdef DEMAND_LOOK
 728 #ifdef LL_K
 729         if ( zzdirty==LL_K ) {zzCONSUME;}
 730 #else
 731         if ( zzdirty ) {zzCONSUME;}
 732 #endif
 733 #endif
 734         if ( !zzset_el((unsigned)LA(1), tokensWanted) )
 735         {
 736                 fprintf(stderr,
 737                                 "line %d: syntax error at \"%s\" missing %s\n",
 738                                 zzline,
 739                                 (LA(1)==zzEOF_TOKEN)?"<eof>":LATEXT(1),
 740                                 zztokens[tokenTypeOfSet]);
 741                 zzconsumeUntil( whatFollows );
 742                 return 0;
 743         }
 744         else {
 745                 zzMakeAttr
 746 #ifdef DEMAND_LOOK
 747 #ifdef LL_K
 748                 zzdirty++;
 749                 zzlabase++;
 750 #else
 751                 zzdirty = 1;
 752 #endif
 753 #else
 754 /*              zzCONSUME;              consume if not demand lookahead */
 755 #endif
 756                 return 1;
 757         }
 758 }
 759
 760 int
 761 #ifdef __USE_PROTOS
 762 _zzsetmatch_wsig(SetWordType *e)
 763 #else
 764 _zzsetmatch_wsig(e)
 765 SetWordType *e;
 766 #endif
 767 {
 768 #ifdef DEMAND_LOOK
 769 #ifdef LL_K
 770         if ( zzdirty==LL_K ) {zzCONSUME;}
 771 #else
 772         if ( zzdirty ) {zzCONSUME;}
 773 #endif
 774 #endif
 775         if ( !zzset_el((unsigned)LA(1), e) ) return 0;
 776 #ifdef DEMAND_LOOK
 777 #ifdef LL_K
 778         zzdirty++;
 779 #else
 780         zzdirty = 1;
 781 #endif
 782 #endif
 783         zzMakeAttr
 784         return 1;
 785 }
 786
 787 #ifdef USER_ZZMODE_STACK
 788 static int  zzmstk[ZZMAXSTK] = { -1 };
 789 static int  zzmdep = 0;
 790 static char zzmbuf[70];
 791
 792 void
 793 #ifdef __USE_PROTOS
 794 zzmpush( int m )
 795 #else
 796 zzmpush( m )
 797 int m;
 798 #endif
 799 {
 800    if(zzmdep == ZZMAXSTK - 1) {
 801      sprintf(zzmbuf, "Mode stack overflow ");
 802      zzerr(zzmbuf);
 803    } else {
 804      zzmstk[zzmdep++] = zzauto;
 805      zzmode(m);
 806    }
 807 }
 808
 809 void
 810 #ifdef __USE_PROTOS
 811 zzmpop( void )
 812 #else
 813 zzmpop( )
 814 #endif
 815 {
 816    if(zzmdep == 0)
 817    {  sprintf(zzmbuf, "Mode stack underflow ");
 818       zzerr(zzmbuf);
 819    }
 820    else
 821    {  zzmdep--;
 822       zzmode(zzmstk[zzmdep]);
 823    }
 824 }
 825
 826 void
 827 #ifdef __USE_PROTOS
 828 zzsave_mode_stack( int modeStack[], int *modeLevel )
 829 #else
 830 zzsave_mode_stack( modeStack, modeLevel )
 831 int modeStack[];
 832 int *modeLevel;
 833 #endif
 834 {
 835   int i;
 836   memcpy(modeStack, zzmstk, sizeof(zzmstk));
 837   *modeLevel = zzmdep;
 838   zzmdep = 0;
 839
 840   return;
 841 }
 842
 843 void
 844 #ifdef __USE_PROTOS
 845 zzrestore_mode_stack( int modeStack[], int *modeLevel )
 846 #else
 847 zzrestore_mode_stack( modeStack, modeLevel )
 848 int modeStack[];
 849 int *modeLevel;
 850 #endif
 851 {
 852   int i;
 853
 854   memcpy(zzmstk, modeStack, sizeof(zzmstk));
 855   zzmdep = *modeLevel;
 856
 857   return;
 858 }
 859 #endif /* USER_ZZMODE_STACK */
 860
 861 #endif /* ERR_H */