pd.if.org Git - pccts/blob - 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-1995
  28  */
  29 #ifndef ANTLR_H
  30 #define ANTLR_H
  31
  32 #include "config.h"
  33
  34 /*
  35  * Define all of the stack setup and manipulation of $i, #i variables.
  36  *
  37  *      Notes:
  38  *              The type 'Attrib' must be defined before entry into this .h file.
  39  */
  40
  41 #ifdef __USE_PROTOS
  42 #include <stdlib.h>
  43 #else
  44 #ifdef VAXC
  45 #include <stdlib.h>
  46 #else
  47 #include <malloc.h>
  48 #endif
  49 #endif
  50 #include <string.h>
  51
  52 typedef int ANTLRTokenType;
  53 typedef unsigned char SetWordType;
  54
  55 typedef char ANTLRChar;
  56
  57                                                 /* G u e s s  S t u f f */
  58
  59 #ifdef ZZCAN_GUESS
  60 #ifndef ZZINF_LOOK
  61 #define ZZINF_LOOK
  62 #endif
  63 #endif
  64
  65 #ifdef ZZCAN_GUESS
  66 typedef struct _zzjmp_buf {
  67                         jmp_buf state;
  68                 } zzjmp_buf;
  69 #endif
  70
  71
  72 /* can make this a power of 2 for more efficient lookup */
  73 #ifndef ZZLEXBUFSIZE
  74 #define ZZLEXBUFSIZE    2000
  75 #endif
  76
  77 #define zzOvfChk                                                                                                                \
  78             if ( zzasp <= 0 )                                           \
  79             {                                                           \
  80                 fprintf(stderr, zzStackOvfMsg, __FILE__, __LINE__);             \
  81                 exit(PCCTS_EXIT_FAILURE);                                               \
  82             }
  83
  84 #ifndef ZZA_STACKSIZE
  85 #define ZZA_STACKSIZE   400
  86 #endif
  87 #ifndef ZZAST_STACKSIZE
  88 #define ZZAST_STACKSIZE 400
  89 #endif
  90
  91 #ifndef zzfailed_pred
  92 #define zzfailed_pred(_p)       \
  93         fprintf(stderr, "semantic error; failed predicate: '%s'\n",_p)
  94 #endif
  95
  96 #ifdef LL_K
  97 #define LOOKAHEAD                                                                                               \
  98         int zztokenLA[LL_K];                                                                            \
  99         char zztextLA[LL_K][ZZLEXBUFSIZE];                                                      \
 100         int zzlap = 0, zzlabase=0; /* labase only used for DEMAND_LOOK */
 101 #else
 102 #define LOOKAHEAD                                                                                               \
 103         int zztoken;
 104 #endif
 105
 106 #ifndef zzcr_ast
 107 #define zzcr_ast(ast,attr,tok,text)
 108 #endif
 109
 110 #ifdef DEMAND_LOOK
 111 #define DemandLookData  int zzdirty=1;
 112 #else
 113 #define DemandLookData
 114 #endif
 115
 116                                                 /* S t a t e  S t u f f */
 117
 118 #ifdef ZZCAN_GUESS
 119 #define zzGUESS_BLOCK           zzantlr_state zzst; int zzrv;
 120 #define zzGUESS                         zzsave_antlr_state(&zzst); \
 121                                                         zzguessing = 1; \
 122                                                         zzrv = setjmp(zzguess_start.state);
 123 #define zzGUESS_FAIL            longjmp(zzguess_start.state, 1)
 124 #define zzGUESS_DONE            zzrestore_antlr_state(&zzst);
 125 #define zzNON_GUESS_MODE        if ( !zzguessing )
 126 #define zzGuessData                                     \
 127             zzjmp_buf zzguess_start;                    \
 128             int zzguessing;
 129 #else
 130 #define zzGUESS_BLOCK
 131 #define zzGUESS
 132 #define zzGUESS_FAIL
 133 #define zzGUESS_DONE
 134 #define zzNON_GUESS_MODE
 135 #define zzGuessData
 136 #endif
 137
 138 typedef struct _zzantlr_state {
 139 #ifdef ZZCAN_GUESS
 140                         zzjmp_buf guess_start;
 141                         int guessing;
 142 #endif
 143                         int asp;
 144                         int ast_sp;
 145 #ifdef ZZINF_LOOK
 146                         int inf_lap;    /* not sure we need to save this one */
 147                         int inf_labase;
 148                         int inf_last;
 149 #endif
 150 #ifdef DEMAND_LOOK
 151                         int dirty;
 152 #endif
 153
 154 #ifdef LL_K
 155                         int tokenLA[LL_K];
 156                         char textLA[LL_K][ZZLEXBUFSIZE];
 157                         int lap;
 158                         int labase;
 159 #else
 160                         int token;
 161                         char text[ZZLEXBUFSIZE];
 162 #endif
 163                 } zzantlr_state;
 164
 165
 166                  /* I n f i n i t e  L o o k a h e a d */
 167
 168
 169 #ifdef ZZINF_LOOK
 170 #define InfLookData     \
 171         int *zzinf_tokens;      \
 172         char **zzinf_text;      \
 173         char *zzinf_text_buffer;        \
 174         int *zzinf_line;        \
 175         int zzinf_labase;       \
 176         int zzinf_last;
 177 #else
 178 #define InfLookData
 179 #endif
 180
 181 #ifdef ZZINF_LOOK
 182
 183 #ifndef ZZINF_DEF_TEXT_BUFFER_SIZE
 184 #define ZZINF_DEF_TEXT_BUFFER_SIZE          20000
 185 #endif
 186 #ifndef ZZINF_DEF_TOKEN_BUFFER_SIZE
 187 #define ZZINF_DEF_TOKEN_BUFFER_SIZE         2000
 188 #endif
 189 /* WARNING!!!!!!
 190  * ZZINF_BUFFER_TEXT_CHUNK_SIZE must be > sizeof(text) largest possible token.
 191  */
 192 #ifndef ZZINF_BUFFER_TEXT_CHUNK_SIZE
 193 #define ZZINF_BUFFER_TEXT_CHUNK_SIZE    5000
 194 #endif
 195 #ifndef ZZINF_BUFFER_TOKEN_CHUNK_SIZE
 196 #define ZZINF_BUFFER_TOKEN_CHUNK_SIZE   1000
 197 #endif
 198
 199 #if ZZLEXBUFSIZE > ZZINF_BUFFER_TEXT_CHUNK_SIZE
 200 #define ZZINF_BUFFER_TEXT_CHUNK_SIZE    ZZLEXBUFSIZE+5
 201 #endif
 202
 203 /* make inf_look user-access macros */
 204 #ifdef LL_K
 205 #define ZZINF_LA_VALID(i)       (((zzinf_labase+i-1)-LL_K+1) <= zzinf_last)
 206 #define ZZINF_LA(i)                     zzinf_tokens[(zzinf_labase+i-1)-LL_K+1]
 207 #define ZZINF_LATEXT(i)         zzinf_text[(zzinf_labase+i-1)-LL_K+1]
 208 /* #define ZZINF_LINE(i)       zzinf_line[(zzinf_labase+i-1)-LL_K+1]*/
 209 #else
 210 #define ZZINF_LA_VALID(i)       (((zzinf_labase+i-1)) <= zzinf_last)
 211 #define ZZINF_LA(i)                     zzinf_tokens[(zzinf_labase+i-1)]
 212 #define ZZINF_LATEXT(i)         zzinf_text[(zzinf_labase+i-1)]
 213 #endif
 214
 215 #define inf_zzgettok _inf_zzgettok()
 216 extern void _inf_zzgettok();
 217
 218 #endif  /* ZZINF_LOOK */
 219
 220
 221 #ifdef LL_K
 222
 223 #ifdef __USE_PROTOS
 224 #define ANTLR_INFO                                                                                              \
 225         Attrib zzempty_attr() {static Attrib a; return a;}                      \
 226         Attrib zzconstr_attr(int _tok, char *_text)\
 227                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 228         int zzasp=ZZA_STACKSIZE;                                                                        \
 229         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
 230         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 231         InfLookData                                                 \
 232     zzGuessData
 233 #else
 234 #define ANTLR_INFO                                                                                              \
 235         Attrib zzempty_attr() {static Attrib a; return a;}                      \
 236         Attrib zzconstr_attr(_tok, _text) int _tok; char *_text;\
 237                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 238         int zzasp=ZZA_STACKSIZE;                                                                        \
 239         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
 240         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 241         InfLookData                                                 \
 242     zzGuessData
 243 #endif
 244
 245 #else
 246
 247 #ifdef __USE_PROTOS
 248 #define ANTLR_INFO                                                                                              \
 249         Attrib zzempty_attr() {static Attrib a; return a;}                      \
 250         Attrib zzconstr_attr(int _tok, char *_text)\
 251                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 252         int zzasp=ZZA_STACKSIZE;                                                                        \
 253         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
 254         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 255         InfLookData                                                 \
 256     zzGuessData
 257 #else
 258 #define ANTLR_INFO                                                                                              \
 259         Attrib zzempty_attr() {static Attrib a; return a;}                      \
 260         Attrib zzconstr_attr(_tok, _text) int _tok; char *_text;\
 261                 {Attrib a; zzcr_attr((&a),_tok,_text); return a;}               \
 262         int zzasp=ZZA_STACKSIZE;                                                                        \
 263         char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
 264         Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData                          \
 265         InfLookData                                                 \
 266     zzGuessData
 267 #endif
 268
 269 #endif /* LL_k */
 270
 271
 272 #ifdef ZZINF_LOOK
 273
 274 #ifdef LL_K
 275 #ifdef DEMAND_LOOK
 276 #define zzPrimeLookAhead  {zzdirty=LL_K; zzlap = zzlabase = 0;}
 277 #else
 278 #define zzPrimeLookAhead  {zzlap = zzlabase = 0; zzfill_inf_look();\
 279                                                   {int _i;  for(_i=1;_i<=LL_K; _i++)            \
 280                                                                                 {zzCONSUME;} zzlap = zzlabase = 0;}}
 281 #endif
 282
 283 #else /* LL_K */
 284
 285 #ifdef DEMAND_LOOK
 286 #define zzPrimeLookAhead  zzfill_inf_look(); zzdirty=1
 287 #else
 288 #define zzPrimeLookAhead  zzfill_inf_look(); inf_zzgettok
 289
 290 #endif
 291 #endif  /* LL_K */
 292
 293 #else   /* ZZINF_LOOK */
 294
 295 #ifdef LL_K
 296 #ifdef DEMAND_LOOK
 297 #define zzPrimeLookAhead  {zzdirty=LL_K; zzlap = zzlabase = 0;}
 298 #else
 299 #define zzPrimeLookAhead  {int _i; zzlap = 0; for(_i=1;_i<=LL_K; _i++)          \
 300                                                                                 {zzCONSUME;} zzlap = 0;}
 301 #endif
 302
 303 #else
 304
 305 #ifdef DEMAND_LOOK
 306 #define zzPrimeLookAhead  zzdirty=1
 307 #else
 308 #define zzPrimeLookAhead  zzgettok()
 309 #endif
 310 #endif  /* LL_K */
 311
 312 #endif  /* ZZINF_LOOK */
 313
 314
 315 #ifdef LL_K
 316 #define zzenterANTLRs(s)                            \
 317         zzlextext = &(zztextLA[0][0]); zzrdstr( s ); zzPrimeLookAhead;
 318 #define zzenterANTLRf(f)                                                        \
 319                 zzlextext = &(zztextLA[0][0]); zzrdfunc( f ); zzPrimeLookAhead;
 320 #define zzenterANTLR(f)                                                 \
 321                 zzlextext = &(zztextLA[0][0]); zzrdstream( f ); zzPrimeLookAhead;
 322 #ifdef ZZINF_LOOK
 323 #define zzleaveANTLR(f)                 free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 324 #define zzleaveANTLRf(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 325 #define zzleaveANTLRs(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 326 #else
 327 #define zzleaveANTLR(f)
 328 #define zzleaveANTLRf(f)
 329 #define zzleaveANTLRs(f)
 330 #endif
 331
 332 #else
 333
 334 #define zzenterANTLRs(s)                            \
 335         {static char zztoktext[ZZLEXBUFSIZE];   \
 336         zzlextext = zztoktext; zzrdstr( s ); zzPrimeLookAhead;}
 337 #define zzenterANTLRf(f)                                                        \
 338                 {static char zztoktext[ZZLEXBUFSIZE];   \
 339                 zzlextext = zztoktext; zzrdfunc( f ); zzPrimeLookAhead;}
 340 #define zzenterANTLR(f)                                                 \
 341                 {static char zztoktext[ZZLEXBUFSIZE];   \
 342                 zzlextext = zztoktext; zzrdstream( f ); zzPrimeLookAhead;}
 343 #ifdef ZZINF_LOOK
 344 #define zzleaveANTLR(f)                 free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 345 #define zzleaveANTLRf(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 346 #define zzleaveANTLRs(f)                free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
 347 #else
 348 #define zzleaveANTLR(f)
 349 #define zzleaveANTLRf(f)
 350 #define zzleaveANTLRs(f)
 351 #endif
 352
 353 #endif
 354
 355 #define ANTLR(st, f)    zzbufsize = ZZLEXBUFSIZE;       \
 356                                                 zzenterANTLR(f);                        \
 357                                                 st; ++zzasp;                            \
 358                                                 zzleaveANTLR(f);
 359
 360 #define ANTLRm(st, f, _m)       zzbufsize = ZZLEXBUFSIZE;       \
 361                                                 zzmode(_m);                             \
 362                                                 zzenterANTLR(f);                        \
 363                                                 st; ++zzasp;                            \
 364                                                 zzleaveANTLR(f);
 365
 366 #define ANTLRf(st, f)   zzbufsize = ZZLEXBUFSIZE;       \
 367                                                 zzenterANTLRf(f);                       \
 368                                                 st; ++zzasp;                            \
 369                                                 zzleaveANTLRf(f);
 370
 371 #define ANTLRs(st, s)   zzbufsize = ZZLEXBUFSIZE;       \
 372                         zzenterANTLRs(s);           \
 373                         st; ++zzasp;                            \
 374                         zzleaveANTLRs(s);
 375
 376 #ifdef LL_K
 377 #define zztext          (&(zztextLA[zzlap][0]))
 378 #else
 379 #define zztext          zzlextext
 380 #endif
 381
 382
 383                                         /* A r g u m e n t  A c c e s s */
 384
 385 #define zzaCur                  (zzaStack[zzasp])
 386 #define zzaRet                  (*zzaRetPtr)
 387 #define zzaArg(v,n)             zzaStack[v-n]
 388 #define zzMakeAttr              { zzNON_GUESS_MODE {zzOvfChk; --zzasp; zzcr_attr(&(zzaStack[zzasp]),LA(1),LATEXT(1));}}
 389 #ifdef zzdef0
 390 #define zzMake0                 { zzOvfChk; --zzasp; zzdef0(&(zzaStack[zzasp]));}
 391 #else
 392 #define zzMake0                 { zzOvfChk; --zzasp;}
 393 #endif
 394 #define zzaPush(_v)             { zzOvfChk; zzaStack[--zzasp] = _v;}
 395 #ifndef zzd_attr
 396 #define zzREL(t)                zzasp=(t);              /* Restore state of stack */
 397 #else
 398 #define zzREL(t)                for (; zzasp<(t); zzasp++)                              \
 399                                                 { zzd_attr(&(zzaStack[zzasp])); }
 400 #endif
 401
 402 #define zzsetmatch(_es)                                         \
 403         if ( !_zzsetmatch(_es, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet) ) goto fail;
 404 #define zzsetmatch_wsig(_es, handler)           \
 405         if ( !_zzsetmatch_wsig(_es) ) {_signal=MismatchedToken; goto handler;}
 406
 407 #ifdef __USE_PROTOS
 408 extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **);
 409 extern int _zzsetmatch_wsig(SetWordType *);
 410 #else
 411 extern int _zzsetmatch();
 412 extern int _zzsetmatch_wsig();
 413 #endif
 414
 415 #define zzmatch(_t)                                                     \
 416         if ( !_zzmatch(_t, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet) ) goto fail;
 417 #define zzmatch_wsig(_t,handler)                        \
 418         if ( !_zzmatch_wsig(_t) ) {_signal=MismatchedToken; goto handler;}
 419
 420 #ifdef __USE_PROTOS
 421 extern int _zzmatch(int, char **, char **, int *, int *, SetWordType **);
 422 extern int _zzmatch_wsig(int);
 423 #else
 424 extern int _zzmatch();
 425 extern int _zzmatch_wsig();
 426 #endif
 427
 428 #define zzmatch_wdfltsig(_t,_f)                 \
 429         if ( !_zzmatch_wdfltsig(_t,_f) ) _signal=MismatchedToken;
 430 #define zzsetmatch_wdfltsig(tw,tt,wf)           \
 431         if ( !_zzsetmatch_wdfltsig(tw,tt,wf) ) _signal=MismatchedToken;
 432
 433 #ifdef __USE_PROTOS
 434 extern int _zzmatch_wdfltsig(int, SetWordType *);
 435 extern int _zzsetmatch_wdfltsig(SetWordType *tokensWanted,
 436                                                                 int tokenTypeOfSet,
 437                                                                 SetWordType *whatFollows);
 438 #else
 439 extern int _zzmatch_wdfltsig();
 440 extern int _zzsetmatch_wdfltsig();
 441 #endif
 442
 443 #ifdef GENAST
 444 #define zzRULE          Attrib *zzaRetPtr = &(zzaStack[zzasp-1]);       \
 445                                         SetWordType *zzMissSet=NULL; int zzMissTok=0;           \
 446                                         int zzBadTok=0; char *zzBadText="";             \
 447                                         int zzErrk=1;                                                           \
 448                                         char *zzMissText=""; zzASTVars
 449 #else
 450 #define zzRULE          Attrib *zzaRetPtr = &(zzaStack[zzasp-1]);       \
 451                                         int zzBadTok=0; char *zzBadText="";             \
 452                                         int zzErrk=1;                                                           \
 453                                         SetWordType *zzMissSet=NULL; int zzMissTok=0; char *zzMissText=""
 454 #endif
 455
 456 #ifdef GENAST
 457 #define zzBLOCK(i)      int i = zzasp - 1; int zztsp = zzast_sp
 458 #define zzEXIT(i)       zzREL(i); zzastREL; zzNON_GUESS_MODE { zzastPush(*_root); }
 459 #define zzLOOP(i)       zzREL(i); zzastREL
 460 #else
 461 #define zzBLOCK(i)      int i = zzasp - 1
 462 #define zzEXIT(i)       zzREL(i)
 463 #define zzLOOP(i)       zzREL(i)
 464 #endif
 465
 466 #ifdef LL_K
 467
 468 #ifdef DEMAND_LOOK
 469 #define LOOK(_k)        {int i,stop=_k-(LL_K-zzdirty); for (i=1; i<=stop; i++)  \
 470                                         zzCONSUME;}
 471 #define zzCONSUME       {zzgettok(); zzdirty--;                                                 \
 472                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 473                                         zzlextext = &(zztextLA[zzlap][0]);}
 474 #else
 475 #ifdef ZZINF_LOOK
 476 #define zzCONSUME       {inf_zzgettok;                                                                  \
 477                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 478                                         zzlextext = &(zztextLA[zzlap][0]);                              \
 479                                         }
 480 #else
 481 #define zzCONSUME       {zzgettok();                                                                    \
 482                                         zzlap = (zzlap+1)&(LL_K-1);                                             \
 483                                         zzlextext = &(zztextLA[zzlap][0]);}
 484 #endif /* ZZINF_LOOK */
 485 #endif /* DEMAND_LOOK */
 486
 487 #else /* LL_K */
 488
 489 #ifdef DEMAND_LOOK
 490 #define LOOK(_k)        if ( zzdirty) zzCONSUME;
 491 #ifdef ZZINF_LOOK
 492 #define zzCONSUME       inf_zzgettok; zzdirty=0;
 493 #else
 494 #define zzCONSUME       zzgettok(); zzdirty=0;
 495 #endif /* ZZINF_LOOK */
 496
 497 #else  /* DEMAND_LOOK */
 498
 499 #ifdef ZZINF_LOOK
 500 #define zzCONSUME       inf_zzgettok
 501 #else
 502 #define zzCONSUME       zzgettok();
 503 #endif
 504
 505 #endif /* DEMAND_LOOK */
 506
 507 #endif /* LL_K */
 508
 509 #ifdef LL_K
 510 #define NLA                     zztokenLA[zzlap&(LL_K-1)]       /* --> next LA */
 511 #define NLATEXT         zztextLA[zzlap&(LL_K-1)]        /* --> next text of LA */
 512 #ifdef DEMAND_LOOK
 513 #define LA(i)       zztokenLA[(zzlabase+(i)-1)&(LL_K-1)]
 514 #define LATEXT(i)   (&(zztextLA[(zzlabase+(i)-1)&(LL_K-1)][0]))
 515 #else
 516 #define LA(i)       zztokenLA[(zzlap+(i)-1)&(LL_K-1)]
 517 #define LATEXT(i)   (&(zztextLA[(zzlap+(i)-1)&(LL_K-1)][0]))
 518 #endif
 519 #else
 520 #define NLA                     zztoken
 521 #define NLATEXT         zztext
 522 #define LA(i)       zztoken
 523 #define LATEXT(i)   zztext
 524 #endif
 525
 526
 527            /* S t a n d a r d  S i g n a l s */
 528
 529 #define NoSignal                        0
 530 #define MismatchedToken         1
 531 #define NoViableAlt                     2
 532 #define NoSemViableAlt          3
 533
 534
 535            /* F u n c t i o n  T r a c i n g */
 536
 537 #ifndef zzTRACEIN
 538 #define zzTRACEIN(r)    fprintf(stderr, "enter rule \"%s\"\n", r);
 539 #endif
 540 #ifndef zzTRACEOUT
 541 #define zzTRACEOUT(r)   fprintf(stderr, "exit rule \"%s\"\n", r);
 542 #endif
 543
 544 #ifdef ZZWCHAR_T
 545 #define zzchar_t wchar_t
 546 #else
 547 #define zzchar_t char
 548 #endif
 549
 550                                 /* E x t e r n  D e f s */
 551
 552 #ifdef __USE_PROTOS
 553 extern Attrib zzempty_attr();
 554 extern Attrib zzconstr_attr(int, char *);
 555 extern void zzsyn(char *, int, char *, SetWordType *, int, int, char *);
 556 extern int zzset_el(unsigned, SetWordType *);
 557 extern int zzset_deg(SetWordType *);
 558 extern void zzedecode(SetWordType *);
 559 extern void zzFAIL(int k, ...);
 560 extern void zzresynch(SetWordType *, SetWordType);
 561 extern void zzsave_antlr_state(zzantlr_state *);
 562 extern void zzrestore_antlr_state(zzantlr_state *);
 563 extern void zzfill_inf_look(void);
 564 #ifdef EXCEPTION_HANDLING
 565 extern void zzdflthandlers(int, int *);
 566 #endif
 567 #else
 568 extern Attrib zzempty_attr();
 569 extern Attrib zzconstr_attr();
 570 extern void zzsyn();
 571 extern int zzset_el();
 572 extern int zzset_deg();
 573 extern void zzedecode();
 574 extern void zzFAIL();
 575 extern void zzresynch();
 576 extern void zzsave_antlr_state();
 577 extern void zzrestore_antlr_state();
 578 extern void zzfill_inf_look();
 579 #ifdef EXCEPTION_HANDLING
 580 extern void zzdflthandlers();
 581 #endif
 582 #endif
 583
 584                                 /* G l o b a l  V a r i a b l e s */
 585
 586 /* Define a parser; user should do a "#parser myname" in their grammar file */
 587 /*extern struct pccts_parser zzparser;*/
 588
 589 extern char *zztokens[];
 590 #ifdef LL_K
 591 extern int zztokenLA[];
 592 extern char zztextLA[][ZZLEXBUFSIZE];
 593 extern int zzlap;
 594 extern int zzlabase;
 595 #else
 596 extern int zztoken;
 597 #endif
 598
 599 extern char zzStackOvfMsg[];
 600 extern int zzasp;
 601 extern Attrib zzaStack[];
 602 #ifdef ZZINF_LOOK
 603 extern int *zzinf_tokens;
 604 extern char **zzinf_text;
 605 extern char *zzinf_text_buffer;
 606 extern int *zzinf_line;
 607 extern int zzinf_labase;
 608 extern int zzinf_last;
 609 #endif
 610 #ifdef DEMAND_LOOK
 611 extern int zzdirty;
 612 #endif
 613 #ifdef ZZCAN_GUESS
 614 extern int zzguessing;
 615 extern zzjmp_buf zzguess_start;
 616 #endif
 617
 618 /* Define global veriables that refer to values exported by the scanner.
 619  * These declarations duplicate those in dlgdef.h, but are needed
 620  * if ANTLR is not to generate a .dlg file (-gx); PS, this is a hack.
 621  */
 622 extern zzchar_t *zzlextext;     /* text of most recently matched token */
 623 extern int      zzbufsize;      /* how long zzlextext is */
 624
 625 #endif