BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h

   1 /* antlr.h
   2  *
   3  * SOFTWARE RIGHTS
   4  *
   5  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
   6  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
   7  * company may do whatever they wish with source code distributed with
   8  * PCCTS or the code generated by PCCTS, including the incorporation of
   9  * PCCTS, or its output, into commerical software.
  10  *
  11  * We encourage users to develop software with PCCTS.  However, we do ask
  12  * that credit is given to us for developing PCCTS.  By "credit",
  13  * we mean that if you incorporate our source code into one of your
  14  * programs (commercial product, research project, or otherwise) that you
  15  * acknowledge this fact somewhere in the documentation, research report,
  16  * etc...  If you like PCCTS and have developed a nice tool with the
  17  * output, please mention that you developed it using PCCTS.  In
  18  * addition, we ask that this header remain intact in our source code.
  19  * As long as these guidelines are kept, we expect to continue enhancing
  20  * this system and expect to make other tools available as they are
  21  * completed.
  22  *
  23  * ANTLR 1.33
  24  * Terence Parr
  25  * Parr Research Corporation
  26  * with Purdue University and AHPCRC, University of Minnesota
  27  * 1989-2000
  28  */
  29
  30 #ifndef ANTLR_H
  31 #define ANTLR_H
  32
  33 #include "pcctscfg.h"
  34
  35 #include "pccts_stdio.h"
  36
  37 /* turn off warnings for unreferenced labels */
  38
  39 #ifdef _MSC_VER
  40 #pragma warning(disable:4102)
  41 #endif
  42
  43 /*
  44  * Define all of the stack setup and manipulation of $i, #i variables.
  45  *
  46  *      Notes:
  47  *              The type 'Attrib' must be defined before entry into this .h file.
  48  */
  49
  50
  51 #ifdef __USE_PROTOS
  52 #include "pccts_stdlib.h"
  53 #else
  54 #ifdef VAXC
  55 #include <stdlib.h>
  56 #else
  57 #include <malloc.h>
  58 #endif
  59 #endif
  60 #include "pccts_string.h"
  61
  62 #if 0
  63 #include "set.h"
  64 #endif
  65
  66
  67 typedef int ANTLRTokenType;
  68 typedef unsigned char SetWordType;
  69
  70 typedef char ANTLRChar;
  71
  72                                                 /* G u e s s  S t u f f */
  73
  74 #ifdef ZZCAN_GUESS
  75 #ifndef ZZINF_LOOK
  76 #define ZZINF_LOOK
  77 #endif
  78 #endif
  79
  80 #ifdef ZZCAN_GUESS
  81 typedef struct _zzjmp_buf {
  82                         jmp_buf state;
  83                 } zzjmp_buf;
  84 #endif
  85
  86
  87 /* can make this a power of 2 for more efficient lookup */
  88
  89 #ifndef ZZLEXBUFSIZE
  90 #define ZZLEXBUFSIZE    8000 /* MR22 raise from 2k to 8k */
  91 #endif
  92
  93 #define zzOvfChk                                                                                                                \
  94             if ( zzasp <= 0 )                                           \
  95             {                                                           \
  96                 fprintf(stderr, zzStackOvfMsg, __FILE__, __LINE__);             \
  97                 exit(PCCTS_EXIT_FAILURE);                                               \
  98             }
  99
 100 #ifndef ZZA_STACKSIZE
 101 #define ZZA_STACKSIZE   400
 102 #endif
 103 #ifndef ZZAST_STACKSIZE
 104 #define ZZAST_STACKSIZE 400
 105 #endif
 106
 107 #ifndef zzfailed_pred
 108 #ifdef ZZCAN_GUESS
 109 #define zzfailed_pred(_p,_hasuseraction,_useraction) \
 110   if (zzguessing) { \
 111     zzGUESS_FAIL; \
 112   } else { \
 113     zzfailed_pred_action(_p,_hasuseraction,_useraction); \
 114   }
 115 #else
 116 #define zzfailed_pred(_p,_hasuseraction,_useraction) \
 117     zzfailed_pred_action(_p,_hasuseraction,_useraction);
 118 #endif
 119 #endif
 120
 121 /*  MR23            Provide more control over failed predicate action
 122                     without any need for user to worry about guessing internals.
 123                     _hasuseraction == 0 => no user specified error action
 124                     _hasuseraction == 1 => user specified error action
 125 */
 126
 127 #ifndef zzfailed_pred_action
 128 #define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
 129     if (_hasuseraction) { _useraction } \
 130     else { fprintf(stderr, "semantic error; failed predicate: '%s'\n",_p); }
 131 #endif
 132
 133 /* MR19 zzchar_t additions */
 134
 135 #ifdef LL_K
 136 #define LOOKAHEAD \
 137         int zztokenLA[LL_K]; \
 138         zzchar_t zztextLA[LL_K][ZZLEXBUFSIZE]; \
 139         int zzlap = 0, zzlabase=0; /* labase only used for DEMAND_LOOK */
 140 #else
 141 #define LOOKAHEAD                                                                                               \
 142         int zztoken;
 143 #endif
 144
 145 #ifndef zzcr_ast
 146 #define zzcr_ast(ast,attr,tok,text)
 147 #endif
 148
 149 #ifdef DEMAND_LOOK
 150 #define DemandLookData  int zzdirty=1;
 151 #else
 152 #define DemandLookData
 153 #endif
 154
 155 #ifndef zzUSER_GUESS_HOOK
 156 #define zzUSER_GUESS_HOOK(seqFrozen,zzrv)
 157 #endif
 158
 159 #ifndef zzUSER_GUESS_DONE_HOOK
 160 #define zzUSER_GUESS_DONE_HOOK(seqFrozen)
 161 #endif
 162
 163                                                 /* S t a t e  S t u f f */
 164
 165 #ifdef ZZCAN_GUESS
 166 #define zzGUESS_BLOCK           zzantlr_state zzst; int zzrv; int zzGuessSeqFrozen;
 167
 168 /* MR10 change zzGUESS: do zzGUESS_DONE when zzrv==1 after longjmp as in C++ mode */
 169
 170 #define zzGUESS                         zzsave_antlr_state(&zzst); \
 171                                                         zzguessing = 1; \
 172                             zzGuessSeqFrozen=++zzGuessSeq; \
 173                                                         zzrv = setjmp(zzguess_start.state); \
 174                             zzUSER_GUESS_HOOK(zzGuessSeqFrozen,zzrv) \
 175                             if (zzrv) zzGUESS_DONE;
 176 #ifdef zzTRACE_RULES
 177 #define zzGUESS_FAIL            { zzTraceGuessFail(); longjmp(zzguess_start.state, 1); }
 178 #else
 179 #define zzGUESS_FAIL            longjmp(zzguess_start.state, 1)
 180 #endif
 181
 182 /* MR10 change zzGUESS_DONE: zzrv=1 to simulate longjmp() return value as in C++ mode */
 183
 184 #define zzGUESS_DONE            { zzrestore_antlr_state(&zzst); zzrv=1; zzUSER_GUESS_DONE_HOOK(zzGuessSeqFrozen) }
 185 #define zzNON_GUESS_MODE        if ( !zzguessing )
 186 #define zzGuessData                                     \
 187             zzjmp_buf zzguess_start;                    \
 188             int zzguessing;
 189 #else
 190 #define zzGUESS_BLOCK
 191 #define zzGUESS
 192 #define zzGUESS_FAIL
 193 #define zzGUESS_DONE
 194 #define zzNON_GUESS_MODE
 195 #define zzGuessData
 196 #endif
 197
 198 typedef struct _zzantlr_state {
 199 #ifdef ZZCAN_GUESS
 200                         zzjmp_buf guess_start;
 201                         int guessing;
 202 #endif
 203                         int asp;
 204                         int ast_sp;
 205 #ifdef ZZINF_LOOK
 206                         int inf_lap;    /* not sure we need to save this one */
 207                         int inf_labase;
 208                         int inf_last;
 209
 210 /* MR6  Gunnar Rxnning (gunnar@candleweb.no)                                */
 211 /* MR6    Additional state needs to be saved/restored                       */
 212 /* MR6    Matching changes in err.h                                         */
 213
 214                         int *inf_tokens;                                             /* MR6 */
 215                         char **inf_text;                                             /* MR6 */
 216                         char *inf_text_buffer;                                       /* MR6 */
 217                         int *inf_line;                                               /* MR6 */
 218 #endif
 219 #ifdef DEMAND_LOOK
 220                         int dirty;
 221 #endif
 222
 223 #ifdef LL_K
 224                         int tokenLA[LL_K];
 225                         char textLA[LL_K][ZZLEXBUFSIZE];
 226                         int lap;
 227                         int labase;
 228 #else
 229                         int token;
 230                         char text[ZZLEXBUFSIZE];
 231 #endif
 232 #ifdef zzTRACE_RULES
 233             int     traceOptionValue;       /* MR10 */
 234             int     traceGuessOptionValue;  /* MR10 */
 235             char    *traceCurrentRuleName;  /* MR10 */
 236             int     traceDepth;             /* MR10 */
 237 #endif
 238
 239                 } zzantlr_state;
 240
 241 #ifdef zzTRACE_RULES
 242 extern int  zzTraceOptionValueDefault;
 243 extern int  zzTraceOptionValue;
 244 extern int  zzTraceGuessOptionValue;
 245 extern char *zzTraceCurrentRuleName;
 246 extern int  zzTraceDepth;
 247 #endif
 248
 249 extern int zzGuessSeq;                      /* MR10 */
 250 extern int zzSyntaxErrCount;                /* MR11 */
 251 extern int zzLexErrCount;                   /* MR11 */
 252
 253                  /* I n f i n i t e  L o o k a h e a d */
 254
 255
 256 #ifdef ZZINF_LOOK
 257 #define InfLookData     \
 258         int *zzinf_tokens;      \
 259         char **zzinf_text;      \
 260         char *zzinf_text_buffer;        \
 261         int *zzinf_line;        \
 262         int zzinf_labase;       \
 263         int zzinf_last;
 264 #else
 265 #define InfLookData
 266 #endif
 267
 268 #ifdef ZZINF_LOOK
 269
 270 #ifndef ZZINF_DEF_TEXT_BUFFER_SIZE
 271 #define ZZINF_DEF_TEXT_BUFFER_SIZE          20000
 272 #endif
 273 #ifndef ZZINF_DEF_TOKEN_BUFFER_SIZE
 274 #define ZZINF_DEF_TOKEN_BUFFER_SIZE         2000
 275 #endif
 276 /* WARNING!!!!!!
 277  * ZZINF_BUFFER_TEXT_CHUNK_SIZE must be > sizeof(text) largest possible token.
 278  */
 279 #ifndef ZZINF_BUFFER_TEXT_CHUNK_SIZE
 280 #define ZZINF_BUFFER_TEXT_CHUNK_SIZE    5000
 281 #endif
 282 #ifndef ZZINF_BUFFER_TOKEN_CHUNK_SIZE
 283 #define ZZINF_BUFFER_TOKEN_CHUNK_SIZE   1000
 284 #endif
 285
 286 #if ZZLEXBUFSIZE > ZZINF_BUFFER_TEXT_CHUNK_SIZE
 287 #define ZZINF_BUFFER_TEXT_CHUNK_SIZE    ZZLEXBUFSIZE+5
 288 #endif
 289
 290 /* make inf_look user-access macros */
 291 #ifdef LL_K
 292 #define ZZINF_LA_VALID(i)       (((zzinf_labase+i-1)-LL_K+1) <= zzinf_last)
 293 #define ZZINF_LA(i)                     zzinf_tokens[(zzinf_labase+i-1)-LL_K+1]
 294 #define ZZINF_LATEXT(i)         zzinf_text[(zzinf_labase+i-1)-LL_K+1]
 295 /* MR6  In 1.33 vanilla the #define ZZINF_LINE(i) is was commented out  */
 296 #define ZZINF_LINE(i)       zzinf_line[(zzinf_labase+i-1)-LL_K+1]
 297 #else
 298 #define ZZINF_LA_VALID(i)       (((zzinf_labase+i-1)) <= zzinf_last)
 299 #define ZZINF_LA(i)                     zzinf_tokens[(zzinf_labase+i-1)]
 300 #define ZZINF_LATEXT(i)         zzinf_text[(zzinf_labase+i-1)]
 301 #endif
 302
 303 #define inf_zzgettok _inf_zzgettok()
 304 extern void _inf_zzgettok();
 305
 306 #endif  /* ZZINF_LOOK */
 307
 308
 309 #ifdef LL_K
 310
 311 #ifdef __USE_PROTOS
 312 #define ANTLR_INFO      \
 313         Attrib zzempty_attr(void) {static Attrib a; return a;} \
 314         Attrib zzconstr_attr(int _tok, char *_text) \
 315                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;} \
 316         int zzasp=ZZA_STACKSIZE; \
 317         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
 318         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData \
 319         InfLookData \
 320     zzGuessData
 321 #else
 322 #define ANTLR_INFO                                                                                              \
 323         Attrib zzempty_attr() {static Attrib a; return a;}                  \
 324         Attrib zzconstr_attr(_tok, _text) int _tok; char *_text;    \
 325                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}           \
 326         int zzasp=ZZA_STACKSIZE;                                            \
 327         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n";  \
 328         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                      \
 329         InfLookData                                                 \
 330     zzGuessData
 331 #endif
 332
 333 #else
 334
 335 #ifdef __USE_PROTOS
 336 #define ANTLR_INFO                                                                                              \
 337         Attrib zzempty_attr(void) {static Attrib a; return a;}                  \
 338         Attrib zzconstr_attr(int _tok, char *_text)                             \
 339                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 340         int zzasp=ZZA_STACKSIZE;                                                \
 341         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n";      \
 342         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 343         InfLookData                                                             \
 344     zzGuessData
 345 #else
 346 #define ANTLR_INFO                                                                                              \
 347         Attrib zzempty_attr() {static Attrib a; return a;}                      \
 348         Attrib zzconstr_attr(_tok, _text) int _tok; char *_text;                \
 349                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 350         int zzasp=ZZA_STACKSIZE;                                                \
 351         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n";      \
 352         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 353         InfLookData                                                             \
 354     zzGuessData
 355 #endif
 356
 357 #endif /* LL_k */
 358
 359
 360 #ifdef ZZINF_LOOK
 361
 362 #ifdef LL_K
 363 #ifdef DEMAND_LOOK
 364 #define zzPrimeLookAhead  {zzdirty=LL_K; zzlap = zzlabase = 0;}
 365 #else
 366 #define zzPrimeLookAhead  {zzlap = zzlabase = 0; zzfill_inf_look();\
 367                                                   {int _i;  for(_i=1;_i<=LL_K; _i++)            \
 368                                                                                 {zzCONSUME;} zzlap = zzlabase = 0;}}
 369 #endif
 370
 371 #else /* LL_K */
 372
 373 #ifdef DEMAND_LOOK
 374 #define zzPrimeLookAhead  zzfill_inf_look(); zzdirty=1
 375 #else
 376 #define zzPrimeLookAhead  zzfill_inf_look(); inf_zzgettok
 377
 378 #endif
 379 #endif  /* LL_K */
 380
 381 #else   /* ZZINF_LOOK */
 382
 383 #ifdef LL_K
 384 #ifdef DEMAND_LOOK
 385 #define zzPrimeLookAhead  {zzdirty=LL_K; zzlap = zzlabase = 0;}
 386 #else
 387 #define zzPrimeLookAhead  {int _i; zzlap = 0; for(_i=1;_i<=LL_K; _i++)          \
 388                                                                                 {zzCONSUME;} zzlap = 0;}
 389 #endif
 390
 391 #else
 392
 393 #ifdef DEMAND_LOOK
 394 #define zzPrimeLookAhead  zzdirty=1
 395 #else
 396 #define zzPrimeLookAhead  zzgettok()
 397 #endif
 398 #endif  /* LL_K */
 399
 400 #endif  /* ZZINF_LOOK */
 401
 402
 403 #ifdef LL_K
 404 #define zzenterANTLRs(s)                            \
 405         zzlextext = &(zztextLA[0][0]); zzrdstr( s ); zzPrimeLookAhead;
 406 #define zzenterANTLRf(f)                                                        \
 407                 zzlextext = &(zztextLA[0][0]); zzrdfunc( f ); zzPrimeLookAhead;
 408 #define zzenterANTLR(f)                                                 \
 409                 zzlextext = &(zztextLA[0][0]); zzrdstream( f ); zzPrimeLookAhead;
 410 #ifdef ZZINF_LOOK
 411 #define zzleaveANTLR(f)                 free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 412 #define zzleaveANTLRf(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 413 #define zzleaveANTLRs(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 414 #else
 415 #define zzleaveANTLR(f)
 416 #define zzleaveANTLRf(f)
 417 #define zzleaveANTLRs(f)
 418 #endif
 419
 420 #else
 421
 422 #define zzenterANTLRs(s)                            \
 423         {static char zztoktext[ZZLEXBUFSIZE];   \
 424         zzlextext = zztoktext; zzrdstr( s ); zzPrimeLookAhead;}
 425 #define zzenterANTLRf(f)                                                        \
 426                 {static char zztoktext[ZZLEXBUFSIZE];   \
 427                 zzlextext = zztoktext; zzrdfunc( f ); zzPrimeLookAhead;}
 428 #define zzenterANTLR(f)                                                 \
 429                 {static char zztoktext[ZZLEXBUFSIZE];   \
 430                 zzlextext = zztoktext; zzrdstream( f ); zzPrimeLookAhead;}
 431 #ifdef ZZINF_LOOK
 432 #define zzleaveANTLR(f)                 free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 433 #define zzleaveANTLRf(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 434 #define zzleaveANTLRs(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 435 #else
 436 #define zzleaveANTLR(f)
 437 #define zzleaveANTLRf(f)
 438 #define zzleaveANTLRs(f)
 439 #endif
 440
 441 #endif
 442
 443 /* MR19 Paul D. Smith (psmith@baynetworks.com)
 444    Need to adjust AST stack pointer at exit.
 445    Referenced in ANTLRx macros.
 446 */
 447
 448 #ifdef GENAST
 449 #define ZZAST_ADJUST ++zzast_sp;
 450 #else
 451 #define ZZAST_ADJUST
 452 #endif
 453
 454 #define ANTLR(st, f)    zzbufsize = ZZLEXBUFSIZE;       \
 455                                                 zzenterANTLR(f);                        \
 456             {                                            \
 457               zzBLOCK(zztasp1);                          \
 458                                                   st; /* ++zzasp; Removed MR20 G. Hobbelt */     \
 459                                                       /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
 460               /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */  \
 461               zzEXIT_ANTLR(zztasp1 + 1);                 \
 462             }                                            \
 463                                                 zzleaveANTLR(f);
 464
 465 #define ANTLRm(st, f, _m)       zzbufsize = ZZLEXBUFSIZE;       \
 466                                                 zzmode(_m);                             \
 467                                                 zzenterANTLR(f);                        \
 468             {                                            \
 469               zzBLOCK(zztasp1);                          \
 470                                                   st; /* ++zzasp; Removed MR20 G. Hobbelt */     \
 471                                                       /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
 472               /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */  \
 473               zzEXIT_ANTLR(zztasp1 + 1);                 \
 474             }                                            \
 475                                                 zzleaveANTLR(f);
 476
 477 #define ANTLRf(st, f)   zzbufsize = ZZLEXBUFSIZE;       \
 478                                                 zzenterANTLRf(f);                       \
 479             {                                            \
 480               zzBLOCK(zztasp1);                          \
 481                                                   st; /* ++zzasp; Removed MR20 G. Hobbelt */     \
 482                                                       /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
 483               /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */  \
 484               zzEXIT_ANTLR(zztasp1 + 1);                 \
 485             }                                            \
 486                                                 zzleaveANTLRf(f);
 487
 488 #define ANTLRs(st, s)   zzbufsize = ZZLEXBUFSIZE;       \
 489                         zzenterANTLRs(s);           \
 490             {                                            \
 491               zzBLOCK(zztasp1);                          \
 492                                                   st; /* ++zzasp; Removed MR20 G. Hobbelt */     \
 493                                                       /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
 494               /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */  \
 495               zzEXIT_ANTLR(zztasp1 + 1);                 \
 496             }                                            \
 497                         zzleaveANTLRs(s);
 498
 499 #ifdef LL_K
 500 #define zztext          (&(zztextLA[zzlap][0]))
 501 #else
 502 #define zztext          zzlextext
 503 #endif
 504
 505
 506                                         /* A r g u m e n t  A c c e s s */
 507
 508 #define zzaCur                  (zzaStack[zzasp])
 509 #define zzaRet                  (*zzaRetPtr)
 510 #define zzaArg(v,n)             zzaStack[v-n]
 511 #define zzMakeAttr              { zzNON_GUESS_MODE {zzOvfChk; --zzasp; zzcr_attr(&(zzaStack[zzasp]),LA(1),LATEXT(1));}}
 512 #ifdef zzdef0
 513 #define zzMake0                 { zzOvfChk; --zzasp; zzdef0(&(zzaStack[zzasp]));}
 514 #else
 515 #define zzMake0                 { zzOvfChk; --zzasp;}
 516 #endif
 517 #define zzaPush(_v)             { zzOvfChk; zzaStack[--zzasp] = _v;}
 518 #ifndef zzd_attr
 519 #define zzREL(t)                zzasp=(t);              /* Restore state of stack */
 520 #else
 521 #define zzREL(t)                for (; zzasp<(t); zzasp++)                              \
 522                                                 { zzd_attr(&(zzaStack[zzasp])); }
 523 #endif
 524
 525
 526 #define zzsetmatch(_es,_tokclassErrset)                                         \
 527         if ( !_zzsetmatch(_es, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet, _tokclassErrset) ) goto fail; /* MR23 */
 528
 529 #ifdef ZZCAN_GUESS
 530 #define zzsetmatch_wsig(_es, handler)           \
 531         if ( !_zzsetmatch_wsig(_es) ) if (zzguessing) { zzGUESS_FAIL; } else {_signal=MismatchedToken; goto handler;}
 532 #else
 533 #define zzsetmatch_wsig(_es, handler)           \
 534         if ( !_zzsetmatch_wsig(_es) ) {_signal=MismatchedToken; goto handler;}
 535 #endif
 536
 537 #ifdef __USE_PROTOS
 538 extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
 539 extern int _zzsetmatch_wsig(SetWordType *);
 540 #else
 541 extern int _zzsetmatch();
 542 extern int _zzsetmatch_wsig();
 543 #endif
 544
 545 #define zzmatch(_t)                                                     \
 546         if ( !_zzmatch(_t, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet) ) goto fail;
 547
 548 #ifdef ZZCAN_GUESS
 549 #define zzmatch_wsig(_t,handler)                        \
 550         if ( !_zzmatch_wsig(_t) ) if (zzguessing) { zzGUESS_FAIL; } else {_signal=MismatchedToken; goto handler;}
 551 #else
 552 #define zzmatch_wsig(_t,handler)                        \
 553         if ( !_zzmatch_wsig(_t) ) {_signal=MismatchedToken; goto handler;}
 554 #endif
 555
 556 #ifdef __USE_PROTOS
 557 extern int _zzmatch(int, char **, char **, int *, int *, SetWordType **);
 558 extern int _zzmatch_wsig(int);
 559 #else
 560 extern int _zzmatch();
 561 extern int _zzmatch_wsig();
 562 #endif
 563
 564 #define zzmatch_wdfltsig(_t,_f)                 \
 565         if ( !_zzmatch_wdfltsig(_t,_f) ) _signal=MismatchedToken;
 566 #define zzsetmatch_wdfltsig(tw,tt,wf)           \
 567         if ( !_zzsetmatch_wdfltsig(tw,tt,wf) ) _signal=MismatchedToken;
 568
 569 #ifdef __USE_PROTOS
 570 extern int _zzmatch_wdfltsig(int, SetWordType *);
 571 extern int _zzsetmatch_wdfltsig(SetWordType *tokensWanted,
 572                                                                 int tokenTypeOfSet,
 573                                                                 SetWordType *whatFollows);
 574 #else
 575 extern int _zzmatch_wdfltsig();
 576 extern int _zzsetmatch_wdfltsig();
 577 #endif
 578
 579 #ifdef GENAST
 580 #define zzRULE          Attrib *zzaRetPtr = &(zzaStack[zzasp-1]);       \
 581                                         SetWordType *zzMissSet=NULL; int zzMissTok=0;           \
 582                                         int zzBadTok=0; char *zzBadText="";             \
 583                                         int zzErrk=1,zzpf=0;                                    \
 584                     zzTRACEdata \
 585                                         char *zzMissText=""; zzASTVars
 586 #else
 587 #define zzRULE          Attrib *zzaRetPtr = &(zzaStack[zzasp-1]);       \
 588                                         int zzBadTok=0; char *zzBadText="";             \
 589                                         int zzErrk=1,zzpf=0;                                                            \
 590                     zzTRACEdata \
 591                                         SetWordType *zzMissSet=NULL; int zzMissTok=0; char *zzMissText=""
 592 #endif
 593
 594 #ifdef GENAST
 595 #define zzBLOCK(i)      int i = zzasp - 1; int zztsp = zzast_sp
 596 #define zzEXIT(i)       zzREL(i); zzastREL; zzNON_GUESS_MODE { zzastPush(*_root); }
 597 #define zzEXIT_ANTLR(i) zzREL(i); zzastREL /* [i_a] added as we want this for the ANTLRx() macros */
 598 #define zzLOOP(i)       zzREL(i); zzastREL
 599 #else
 600 #define zzBLOCK(i)      int i = zzasp - 1
 601 #define zzEXIT(i)       zzREL(i)
 602 #define zzEXIT_ANTLR(i) zzREL(i)           /* [i_a] added as we want this for the ANTLRx() macros */
 603 #define zzLOOP(i)       zzREL(i)
 604 #endif
 605
 606 #ifdef LL_K
 607
 608 #ifdef DEMAND_LOOK
 609 #define LOOK(_k)        {int i,stop=_k-(LL_K-zzdirty); for (i=1; i<=stop; i++)  \
 610                                         zzCONSUME;}
 611 #define zzCONSUME       {zzgettok(); zzdirty--;                                                 \
 612                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 613                                         zzlextext = &(zztextLA[zzlap][0]);}
 614 #else
 615 #ifdef ZZINF_LOOK
 616 #define zzCONSUME       {inf_zzgettok;                                                                  \
 617                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 618                                         zzlextext = &(zztextLA[zzlap][0]);                              \
 619                                         }
 620 #else
 621 #define zzCONSUME       {zzgettok();                                                                    \
 622                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 623                                         zzlextext = &(zztextLA[zzlap][0]);}
 624 #endif /* ZZINF_LOOK */
 625 #endif /* DEMAND_LOOK */
 626
 627 #else /* LL_K */
 628
 629 #ifdef DEMAND_LOOK
 630 #define LOOK(_k)        if ( zzdirty) zzCONSUME;
 631 #ifdef ZZINF_LOOK
 632 #define zzCONSUME       inf_zzgettok; zzdirty=0;
 633 #else
 634 #define zzCONSUME       zzgettok(); zzdirty=0;
 635 #endif /* ZZINF_LOOK */
 636
 637 #else  /* DEMAND_LOOK */
 638
 639 #ifdef ZZINF_LOOK
 640 #define zzCONSUME       inf_zzgettok
 641 #else
 642 #define zzCONSUME       zzgettok();
 643 #endif
 644
 645 #endif /* DEMAND_LOOK */
 646
 647 #endif /* LL_K */
 648
 649 #ifdef LL_K
 650 #define NLA                     zztokenLA[zzlap&(LL_K-1)]       /* --> next LA */
 651 #define NLATEXT         zztextLA[zzlap&(LL_K-1)]        /* --> next text of LA */
 652 #ifdef DEMAND_LOOK
 653 #define LA(i)       zztokenLA[(zzlabase+(i)-1)&(LL_K-1)]
 654 #define LATEXT(i)   (&(zztextLA[(zzlabase+(i)-1)&(LL_K-1)][0]))
 655 #else
 656 #define LA(i)       zztokenLA[(zzlap+(i)-1)&(LL_K-1)]
 657 #define LATEXT(i)   (&(zztextLA[(zzlap+(i)-1)&(LL_K-1)][0]))
 658 #endif
 659 #else
 660 #define NLA                     zztoken
 661 #define NLATEXT         zztext
 662 #define LA(i)       zztoken
 663 #define LATEXT(i)   zztext
 664 #endif
 665
 666
 667            /* S t a n d a r d  S i g n a l s */
 668
 669 #define NoSignal                        0
 670 #define MismatchedToken         1
 671 #define NoViableAlt                     2
 672 #define NoSemViableAlt          3
 673
 674 /* MR7  Allow more control over signalling                                  */
 675 /*        by adding "Unwind" and "zzsetSignal"                              */
 676
 677 #define Unwind              4
 678 #define zzsetSignal(newValue) *_retsignal=_signal=(newValue)
 679 #define zzsuppressSignal *_retsignal=_signal=0
 680 #define zzexportSignal    *_retsignal=_signal
 681
 682            /* F u n c t i o n  T r a c i n g */
 683
 684 #ifndef zzTRACE_RULES
 685 #define zzTRACEdata
 686 #else
 687 #ifndef zzTRACEdata
 688 #define zzTRACEdata     ANTLRChar *zzTracePrevRuleName = NULL;
 689 #endif
 690 #endif
 691
 692 #ifndef zzTRACEIN
 693 #define zzTRACEIN(r)    zzTracePrevRuleName=zzTraceCurrentRuleName;zzTraceIn(r);
 694 #endif
 695 #ifndef zzTRACEOUT
 696 #define zzTRACEOUT(r)   zzTraceOut(r);zzTraceCurrentRuleName=zzTracePrevRuleName;
 697 #endif
 698
 699 /* MR19 zzchar_t additions */
 700
 701 #ifndef zzchar_t
 702 #ifdef ZZWCHAR_T
 703 #define zzchar_t wchar_t
 704 #else
 705 #define zzchar_t char
 706 #endif
 707 #endif
 708
 709
 710 /* MR26 */
 711
 712 #ifdef PCCTS_USE_STDARG
 713 extern void zzFAIL(int k, ...);
 714 #else
 715 extern void zzFAIL();
 716 #endif
 717                                 /* E x t e r n  D e f s */
 718
 719 #ifdef __USE_PROTOS
 720 extern Attrib zzempty_attr(void);
 721 extern Attrib zzconstr_attr(int, char *);
 722 extern void zzsyn(char *, int, char *, SetWordType *, int, int, char *);
 723 extern int zzset_el(unsigned, SetWordType *);
 724 extern int zzset_deg(SetWordType *);
 725 extern void zzedecode(SetWordType *);
 726
 727 extern void zzresynch(SetWordType *, SetWordType);
 728 extern void zzsave_antlr_state(zzantlr_state *);
 729 extern void zzrestore_antlr_state(zzantlr_state *);
 730 extern void zzfill_inf_look(void);
 731 extern void zzconsumeUntil(SetWordType *st);                         /* MR7 */
 732 extern void zzconsumeUntilToken(int t);                              /* MR7 */
 733 extern void zzTraceIn(char * ruleName);                              /* MR10 */
 734 extern void zzTraceOut(char * ruleName);                             /* MR10 */
 735 extern int  zzTraceOption(int delta);                                /* MR10 */
 736 extern int  zzTraceGuessOption(int delta);                           /* MR10 */
 737 extern void zzTraceReset(void);                                      /* MR10 */
 738 extern void zzTraceGuessFail(void);                                  /* MR10 */
 739 #ifdef EXCEPTION_HANDLING
 740 extern void zzdflthandlers(int, int *);
 741 #endif
 742 #else
 743 extern Attrib zzempty_attr();
 744 extern Attrib zzconstr_attr();
 745 extern void zzsyn();
 746 extern int zzset_el();
 747 extern int zzset_deg();
 748 extern void zzedecode();
 749 extern void zzresynch();
 750 extern void zzsave_antlr_state();
 751 extern void zzrestore_antlr_state();
 752 extern void zzfill_inf_look();
 753 extern void zzconsumeUntil();                                        /* MR7 */
 754 extern void zzconsumeUntilToken();                                   /* MR7 */
 755 extern void zzTraceIn();                                             /* MR10 */
 756 extern void zzTraceOut();                                            /* MR10 */
 757 extern int  zzTraceOption();                                         /* MR10 */
 758 extern int  zzTraceGuessOption();                                    /* MR10 */
 759 extern void zzTraceReset();                                          /* MR10 */
 760 extern void zzTraceGuessFail();                                      /* MR10 */
 761 #ifdef EXCEPTION_HANDLING
 762 extern void zzdflthandlers();
 763 #endif
 764 #endif
 765
 766                                 /* G l o b a l  V a r i a b l e s */
 767
 768 /* Define a parser; user should do a "#parser myname" in their grammar file */
 769 /*extern struct pccts_parser zzparser;*/
 770
 771 extern char *zztokens[];
 772 #ifdef LL_K
 773 extern int zztokenLA[];
 774 extern zzchar_t zztextLA[][ZZLEXBUFSIZE];
 775 extern int zzlap;
 776 extern int zzlabase;
 777 #else
 778 extern int zztoken;
 779 #endif
 780
 781 extern char zzStackOvfMsg[];
 782 extern int zzasp;
 783 extern Attrib zzaStack[];
 784 #ifdef ZZINF_LOOK
 785 extern int *zzinf_tokens;
 786 extern char **zzinf_text;
 787 extern char *zzinf_text_buffer;
 788 extern int *zzinf_line;
 789 extern int zzinf_labase;
 790 extern int zzinf_last;
 791 #endif
 792 #ifdef DEMAND_LOOK
 793 extern int zzdirty;
 794 #endif
 795 #ifdef ZZCAN_GUESS
 796 extern int zzguessing;
 797 extern zzjmp_buf zzguess_start;
 798 #endif
 799
 800 /* Define global variables that refer to values exported by the scanner.
 801  * These declarations duplicate those in dlgdef.h, but are needed
 802  * if ANTLR is not to generate a .dlg file (-gx); PS, this is a hack.
 803  */
 804 extern zzchar_t *zzlextext;     /* text of most recently matched token */
 805 extern int      zzbufsize;      /* how long zzlextext is */
 806
 807 #endif