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