lsys/antlr/AParser.h

/* ANTLRParser.h
 *
 * Define the generic ANTLRParser superclass, which is subclassed to
 * define an actual parser.
 *
 * Before entry into this file: ANTLRTokenType must be set.
 *
 * SOFTWARE RIGHTS
 *
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
 * company may do whatever they wish with source code distributed with
 * PCCTS or the code generated by PCCTS, including the incorporation of
 * PCCTS, or its output, into commerical software.
 *
 * We encourage users to develop software with PCCTS.  However, we do ask
 * that credit is given to us for developing PCCTS.  By "credit",
 * we mean that if you incorporate our source code into one of your
 * programs (commercial product, research project, or otherwise) that you
 * acknowledge this fact somewhere in the documentation, research report,
 * etc...  If you like PCCTS and have developed a nice tool with the
 * output, please mention that you developed it using PCCTS.  In
 * addition, we ask that this header remain intact in our source code.
 * As long as these guidelines are kept, we expect to continue enhancing
 * this system and expect to make other tools available as they are
 * completed.
 *
 * ANTLR 1.33
 * Terence Parr
 * Parr Research Corporation
 * with Purdue University and AHPCRC, University of Minnesota
 * 1989-2000
 */

#ifndef APARSER_H_GATE
#define APARSER_H_GATE

#include "pcctscfg.h"

#include "pccts_stdio.h"
#include "pccts_setjmp.h"

PCCTS_NAMESPACE_STD

#include ATOKEN_H
#include ATOKENBUFFER_H

#ifdef ZZCAN_GUESS
#ifndef ZZINF_LOOK
#define ZZINF_LOOK
#endif
#endif


#define NLA                     (token_type[lap&(LLk-1)])/* --> next LA */

typedef unsigned char SetWordType;

/* Define external bit set stuff (for SetWordType) */
#define EXT_WORDSIZE    (sizeof(char)*8)
#define EXT_LOGWORDSIZE 3

           /* s y n t a c t i c  p r e d i c a t e  s t u f f */

#ifndef zzUSER_GUESS_HOOK
#define zzUSER_GUESS_HOOK(seqFrozen,zzrv)
#endif

#ifndef zzUSER_GUESS_DONE_HOOK
#define zzUSER_GUESS_DONE_HOOK(seqFrozen)
#endif

/* MR14 Add zzUSER_GUESS_FAIL_HOOK and related code */

#define zzUSER_GUESS_FAIL_HOOK_INTERNAL zzUSER_GUESS_FAIL_HOOK(SeqFrozen)
#ifndef zzUSER_GUESS_FAIL_HOOK
#define zzUSER_GUESS_FAIL_HOOK(zzGuessSeq)
#endif


typedef struct _zzjmp_buf {
                        jmp_buf state;
                } zzjmp_buf;

/* these need to be macros not member functions */
#define zzGUESS_BLOCK           ANTLRParserState zzst; int zzrv; int _marker; int zzGuessSeqFrozen;
#define zzNON_GUESS_MODE        if ( !guessing )
#define zzGUESS_FAIL            guess_fail();

/*  Note:  zzGUESS_DONE does not execute longjmp() */

#define zzGUESS_DONE            {zzrv=1; inputTokens->rewind(_marker); guess_done(&zzst);zzUSER_GUESS_DONE_HOOK(zzGuessSeqFrozen) }
#define zzGUESS                         saveState(&zzst); \
                                                        guessing = 1; \
                            zzGuessSeqFrozen = ++zzGuessSeq; \
                                                        _marker = inputTokens->mark(); \
                                                        zzrv = setjmp(guess_start.state); \
                            zzUSER_GUESS_HOOK(zzGuessSeqFrozen,zzrv) \
                                                    if ( zzrv ) zzGUESS_DONE

#define zzTRACEdata     const ANTLRChar *zzTracePrevRuleName = NULL;

#ifndef zzTRACEIN
#define zzTRACEIN(r)    zzTracePrevRuleName=traceCurrentRuleName;tracein(r);
#endif
#ifndef zzTRACEOUT
#define zzTRACEOUT(r)   traceout(r);traceCurrentRuleName=zzTracePrevRuleName;
#endif

                  /* a n t l r  p a r s e r  d e f */

struct ANTLRParserState {
        /* class variables */
        zzjmp_buf guess_start;
        int guessing;

        int inf_labase;
        int inf_last;

        int dirty;

    int             traceOptionValue;       // MR10
    int             traceGuessOptionValue;  // MR10
    const ANTLRChar *traceCurrentRuleName;  // MR10
    int             traceDepth;             // MR10

};

/* notes:
 *
 * multiple inheritance is a cool way to include what stuff is needed
 * in this structure (like guess stuff).  however, i'm not convinced that
 * multiple inheritance works correctly on all platforms.  not that
 * much space is used--just include all possibly useful members.
 *
 * the class should also be a template with arguments for the lookahead
 * depth and so on.  that way, more than one parser can be defined (as
 * each will probably have different lookahead requirements).  however,
 * am i sure that templates work?  no, i'm not sure.
 *
 * no attributes are maintained and, hence, the 'asp' variable is not
 * needed.  $i can still be referenced, but it refers to the token
 * associated with that rule element.  question: where are the token's
 * stored if not on the software stack?  in local variables created
 * and assigned to by antlr.
 */
class ANTLRParser {
protected:
        /* class variables */
        static SetWordType bitmask[sizeof(SetWordType)*8];
        static char eMsgBuffer[500];

protected:
        int LLk;                                        // number of lookahead symbols (old LL_K)
        int demand_look;
        ANTLRTokenType eofToken;                        // when do I stop during resynch()s
        int bsetsize;                                   // size of bitsets created by ANTLR in
                                                                        // units of SetWordType

        ANTLRTokenBuffer *inputTokens;  //place to get input tokens

        zzjmp_buf guess_start;          // where to jump back to upon failure
        int guessing;                           // if guessing (using (...)? predicate)

        // infinite lookahead stuff
        int can_use_inf_look;           // set by subclass (generated by ANTLR)
        int inf_lap;
        int inf_labase;
        int inf_last;
        int *_inf_line;

        const ANTLRChar **token_tbl; // pointer to table of token type strings MR20 const

        int dirty;                                      // used during demand lookahead

        ANTLRTokenType *token_type;             // fast reference cache of token.getType()
//      ANTLRLightweightToken **token;  // the token with all its attributes
        int lap;
        int labase;
#ifdef ZZDEFER_FETCH
        int stillToFetch;                               // MR19 V.H. Simonis
#endif

private:
        void fill_inf_look();

protected:
        virtual void guess_fail() {                         // MR9 27-Sep-97 make virtual
        traceGuessFail();                               // MR10
        longjmp(guess_start.state, 1); }                // MR9
        virtual void guess_done(ANTLRParserState *st) {     // MR9 27-Sep-97 make virtual
         restoreState(st); }                            // MR9
        virtual int guess(ANTLRParserState *);              // MR9 27-Sep-97 make virtual
        void look(int);
    int _match(ANTLRTokenType, ANTLRChar **, ANTLRTokenType *,
                           _ANTLRTokenPtr *, SetWordType **);
    int _setmatch(SetWordType *, ANTLRChar **, ANTLRTokenType *,
                           _ANTLRTokenPtr *, SetWordType **,
                           SetWordType * tokclassErrset /* MR23 */);
    int _match_wsig(ANTLRTokenType);
    int _setmatch_wsig(SetWordType *);
    virtual void consume();
    virtual void resynch(SetWordType *wd,SetWordType mask); // MR21
        void prime_lookahead();
        virtual void tracein(const ANTLRChar *r);              // MR10
        virtual void traceout(const ANTLRChar *r);             // MR10
        static unsigned MODWORD(unsigned x) {return x & (EXT_WORDSIZE-1);}      // x % EXT_WORDSIZE // MR9
        static unsigned DIVWORD(unsigned x) {return x >> EXT_LOGWORDSIZE;}      // x / EXT_WORDSIZE // MR9
        int set_deg(SetWordType *);
        int set_el(ANTLRTokenType, SetWordType *);
        virtual void edecode(SetWordType *);                            // MR1
        virtual void FAIL(int k, ...);                                      // MR1
    int                 traceOptionValue;                           // MR10
    int                 traceGuessOptionValue;                      // MR10
    const ANTLRChar     *traceCurrentRuleName;                      // MR10
    int                 traceDepth;                                 // MR10
    void                traceReset();                               // MR10
    virtual void        traceGuessFail();                           // MR10
    virtual void        traceGuessDone(const ANTLRParserState *);   // MR10
    int                 zzGuessSeq;                                 // MR10

public:
        ANTLRParser(ANTLRTokenBuffer *,
                                int k=1,
                                int use_inf_look=0,
                                int demand_look=0,
                                int bsetsize=1);
        virtual ~ANTLRParser();

        virtual void init();
        
        ANTLRTokenType LA(int i)
        {
//
//  MR14 demand look will always be 0 for C++ mode
//
////    return demand_look ? token_type[(labase+(i)-1)&(LLk-1)] :
////                                            token_type[(lap+(i)-1)&(LLk-1)];

// MR19 V.H. Simonis Defer fetch feature

#ifdef ZZDEFER_FETCH
      undeferFetch();
#endif
          return token_type[(lap+(i)-1)&(LLk-1)];
        }
        _ANTLRTokenPtr LT(int i);

        void setEofToken(ANTLRTokenType t)      { eofToken = t; }
        ANTLRTokenType getEofToken() const  { return eofToken; }    // MR14

        void noGarbageCollectTokens()   { inputTokens->noGarbageCollectTokens(); }
        void garbageCollectTokens()             { inputTokens->garbageCollectTokens(); }

    virtual void syn(_ANTLRTokenPtr tok, ANTLRChar *egroup,
                                         SetWordType *eset, ANTLRTokenType etok, int k);
        virtual void saveState(ANTLRParserState *);     // MR9 27-Sep-97 make virtual
        virtual void restoreState(ANTLRParserState *);  // MR9 27-Sep-97 make virtual

        virtual void panic(const char *msg); // MR20 const

        static char *eMsgd(char *,int);
        static char *eMsg(char *,char *);
        static char *eMsg2(char *,char *,char *);

        virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
        virtual int printMessageV(FILE* pFile, const char* pFormat, va_list arglist); // MR23

        void consumeUntil(SetWordType *st);
        void consumeUntilToken(int t);

        virtual int _setmatch_wdfltsig(SetWordType *tokensWanted,
                                         ANTLRTokenType tokenTypeOfSet,
                                         SetWordType *whatFollows);
        virtual int _match_wdfltsig(ANTLRTokenType tokenWanted,
                                         SetWordType *whatFollows);
        
        const ANTLRChar * parserTokenName(int tok);                     // MR1

    int                 traceOptionValueDefault;        // MR11
    int                 traceOption(int delta);         // MR11
    int                 traceGuessOption(int delta);    // MR11

//  MR8  5-Aug-97   S.Bochnak@microtool.com.pl
//  MR8             Move resynch static local variable
//  MR8               to class instance

    int                 syntaxErrCount;                      // MR12
    ANTLRTokenStream   *getLexer() const {                   // MR12
      return inputTokens ? inputTokens->getLexer() : 0; }    // MR12
protected:                                              // MR8
    int     resynchConsumed;                            // MR8
    char    *zzFAILtext; // workarea required by zzFAIL // MR9
    void    undeferFetch();                             // MR19 V.H. Simonis
    int     isDeferFetchEnabled();                      // MR19 V.H. Simonis
    virtual void failedSemanticPredicate(const char* predicate); /* MR23 */
};

#define zzmatch(_t)                                                     \
        if ( !_match((ANTLRTokenType)_t, &zzMissText, &zzMissTok, \
                                 (_ANTLRTokenPtr *) &zzBadTok, &zzMissSet) ) goto fail;

#define zzmatch_wsig(_t,handler)                                                \
        if ( !_match_wsig((ANTLRTokenType)_t) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}

#define zzsetmatch(_ts,_tokclassErrset)                                                 \
        if ( !_setmatch(_ts, &zzMissText, &zzMissTok, \
                                 (_ANTLRTokenPtr *) &zzBadTok, &zzMissSet, _tokclassErrset) ) goto fail;

#define zzsetmatch_wsig(_ts, handler)                           \
        if ( !_setmatch_wsig(_ts) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}

/* For the dflt signal matchers, a FALSE indicates that an error occurred
 * just like the other matchers, but in this case, the routine has already
 * recovered--we do NOT want to consume another token.  However, when
 * the match was successful, we do want to consume hence _signal=0 so that
 * a token is consumed by the "if (!_signal) consume(); _signal=NoSignal;"
 * preamble.
 */
#define zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) \
        if ( !_setmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) ) \
                _signal = MismatchedToken;

#define zzmatch_wdfltsig(tokenWanted, whatFollows) \
        if ( !_match_wdfltsig(tokenWanted, whatFollows) ) _signal = MismatchedToken;


//  MR1  10-Apr-97      zzfailed_pred() macro does not backtrack in guess mode.
//  MR1                     Identification and correction due to J. Lilley
//
//  MR23            Call virtual method to report error.
//  MR23            Provide more control over failed predicate action
//                  without any need for user to worry about guessing internals.

#ifndef zzfailed_pred
#define zzfailed_pred(_p,_hasuseraction,_useraction) \
  if (guessing) { \
    zzGUESS_FAIL; \
  } else { \
    zzfailed_pred_action(_p,_hasuseraction,_useraction) \
  }
#endif

//  MR23            Provide more control over failed predicate action
//                  without any need for user to worry about guessing internals.
//                  _hasuseraction == 0 => no user specified error action
//                  _hasuseraction == 1 => user specified error action

#ifndef zzfailed_pred_action
#define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
    if (_hasuseraction) { _useraction } else { failedSemanticPredicate(_p); }
#endif

#define zzRULE \
                SetWordType *zzMissSet=NULL; ANTLRTokenType zzMissTok=(ANTLRTokenType)0;        \
                _ANTLRTokenPtr zzBadTok=NULL; ANTLRChar *zzBadText=(ANTLRChar *)"";     \
                int zzErrk=1,zzpf=0; \
        zzTRACEdata \
                ANTLRChar *zzMissText=(ANTLRChar *)"";

#endif

        /* S t a n d a r d  E x c e p t i o n  S i g n a l s */

#define NoSignal                        0
#define MismatchedToken         1
#define NoViableAlt                     2
#define NoSemViableAlt          3

/* MR7  Allow more control over signalling                                  */
/*        by adding "Unwind" and "SetSignal"                                */

#define Unwind              4
#define setSignal(newValue) *_retsignal=_signal=(newValue)
#define suppressSignal       *_retsignal=_signal=0
#define exportSignal        *_retsignal=_signal
Revision:	1.1
Committed:	Thu Nov 6 14:31:24 2008 UTC (17 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/* ANTLRParser.h
2			*
3			* Define the generic ANTLRParser superclass, which is subclassed to
4			* define an actual parser.
5			*
6			* Before entry into this file: ANTLRTokenType must be set.
7			*
8			* SOFTWARE RIGHTS
9			*
10			* We reserve no LEGAL rights to the Purdue Compiler Construction Tool
11			* Set (PCCTS) -- PCCTS is in the public domain. An individual or
12			* company may do whatever they wish with source code distributed with
13			* PCCTS or the code generated by PCCTS, including the incorporation of
14			* PCCTS, or its output, into commerical software.
15			*
16			* We encourage users to develop software with PCCTS. However, we do ask
17			* that credit is given to us for developing PCCTS. By "credit",
18			* we mean that if you incorporate our source code into one of your
19			* programs (commercial product, research project, or otherwise) that you
20			* acknowledge this fact somewhere in the documentation, research report,
21			* etc... If you like PCCTS and have developed a nice tool with the
22			* output, please mention that you developed it using PCCTS. In
23			* addition, we ask that this header remain intact in our source code.
24			* As long as these guidelines are kept, we expect to continue enhancing
25			* this system and expect to make other tools available as they are
26			* completed.
27			*
28			* ANTLR 1.33
29			* Terence Parr
30			* Parr Research Corporation
31			* with Purdue University and AHPCRC, University of Minnesota
32			* 1989-2000
33			*/
34
35			#ifndef APARSER_H_GATE
36			#define APARSER_H_GATE
37
38			#include "pcctscfg.h"
39
40			#include "pccts_stdio.h"
41			#include "pccts_setjmp.h"
42
43			PCCTS_NAMESPACE_STD
44
45			#include ATOKEN_H
46			#include ATOKENBUFFER_H
47
48			#ifdef ZZCAN_GUESS
49			#ifndef ZZINF_LOOK
50			#define ZZINF_LOOK
51			#endif
52			#endif
53
54
55			#define NLA (token_type[lap&(LLk-1)])/* --> next LA */
56
57			typedef unsigned char SetWordType;
58
59			/* Define external bit set stuff (for SetWordType) */
60			#define EXT_WORDSIZE (sizeof(char)*8)
61			#define EXT_LOGWORDSIZE 3
62
63			/* s y n t a c t i c p r e d i c a t e s t u f f */
64
65			#ifndef zzUSER_GUESS_HOOK
66			#define zzUSER_GUESS_HOOK(seqFrozen,zzrv)
67			#endif
68
69			#ifndef zzUSER_GUESS_DONE_HOOK
70			#define zzUSER_GUESS_DONE_HOOK(seqFrozen)
71			#endif
72
73			/* MR14 Add zzUSER_GUESS_FAIL_HOOK and related code */
74
75			#define zzUSER_GUESS_FAIL_HOOK_INTERNAL zzUSER_GUESS_FAIL_HOOK(SeqFrozen)
76			#ifndef zzUSER_GUESS_FAIL_HOOK
77			#define zzUSER_GUESS_FAIL_HOOK(zzGuessSeq)
78			#endif
79
80
81			typedef struct _zzjmp_buf {
82			jmp_buf state;
83			} zzjmp_buf;
84
85			/* these need to be macros not member functions */
86			#define zzGUESS_BLOCK ANTLRParserState zzst; int zzrv; int _marker; int zzGuessSeqFrozen;
87			#define zzNON_GUESS_MODE if ( !guessing )
88			#define zzGUESS_FAIL guess_fail();
89
90			/* Note: zzGUESS_DONE does not execute longjmp() */
91
92			#define zzGUESS_DONE {zzrv=1; inputTokens->rewind(_marker); guess_done(&zzst);zzUSER_GUESS_DONE_HOOK(zzGuessSeqFrozen) }
93			#define zzGUESS saveState(&zzst); \
94			guessing = 1; \
95			zzGuessSeqFrozen = ++zzGuessSeq; \
96			_marker = inputTokens->mark(); \
97			zzrv = setjmp(guess_start.state); \
98			zzUSER_GUESS_HOOK(zzGuessSeqFrozen,zzrv) \
99			if ( zzrv ) zzGUESS_DONE
100
101			#define zzTRACEdata const ANTLRChar *zzTracePrevRuleName = NULL;
102
103			#ifndef zzTRACEIN
104			#define zzTRACEIN(r) zzTracePrevRuleName=traceCurrentRuleName;tracein(r);
105			#endif
106			#ifndef zzTRACEOUT
107			#define zzTRACEOUT(r) traceout(r);traceCurrentRuleName=zzTracePrevRuleName;
108			#endif
109
110			/* a n t l r p a r s e r d e f */
111
112			struct ANTLRParserState {
113			/* class variables */
114			zzjmp_buf guess_start;
115			int guessing;
116
117			int inf_labase;
118			int inf_last;
119
120			int dirty;
121
122			int traceOptionValue; // MR10
123			int traceGuessOptionValue; // MR10
124			const ANTLRChar *traceCurrentRuleName; // MR10
125			int traceDepth; // MR10
126
127			};
128
129			/* notes:
130			*
131			* multiple inheritance is a cool way to include what stuff is needed
132			* in this structure (like guess stuff). however, i'm not convinced that
133			* multiple inheritance works correctly on all platforms. not that
134			* much space is used--just include all possibly useful members.
135			*
136			* the class should also be a template with arguments for the lookahead
137			* depth and so on. that way, more than one parser can be defined (as
138			* each will probably have different lookahead requirements). however,
139			* am i sure that templates work? no, i'm not sure.
140			*
141			* no attributes are maintained and, hence, the 'asp' variable is not
142			* needed. $i can still be referenced, but it refers to the token
143			* associated with that rule element. question: where are the token's
144			* stored if not on the software stack? in local variables created
145			* and assigned to by antlr.
146			*/
147			class ANTLRParser {
148			protected:
149			/* class variables */
150			static SetWordType bitmask[sizeof(SetWordType)*8];
151			static char eMsgBuffer[500];
152
153			protected:
154			int LLk; // number of lookahead symbols (old LL_K)
155			int demand_look;
156			ANTLRTokenType eofToken; // when do I stop during resynch()s
157			int bsetsize; // size of bitsets created by ANTLR in
158			// units of SetWordType
159
160			ANTLRTokenBuffer *inputTokens; //place to get input tokens
161
162			zzjmp_buf guess_start; // where to jump back to upon failure
163			int guessing; // if guessing (using (...)? predicate)
164
165			// infinite lookahead stuff
166			int can_use_inf_look; // set by subclass (generated by ANTLR)
167			int inf_lap;
168			int inf_labase;
169			int inf_last;
170			int *_inf_line;
171
172			const ANTLRChar **token_tbl; // pointer to table of token type strings MR20 const
173
174			int dirty; // used during demand lookahead
175
176			ANTLRTokenType *token_type; // fast reference cache of token.getType()
177			// ANTLRLightweightToken **token; // the token with all its attributes
178			int lap;
179			int labase;
180			#ifdef ZZDEFER_FETCH
181			int stillToFetch; // MR19 V.H. Simonis
182			#endif
183
184			private:
185			void fill_inf_look();
186
187			protected:
188			virtual void guess_fail() { // MR9 27-Sep-97 make virtual
189			traceGuessFail(); // MR10
190			longjmp(guess_start.state, 1); } // MR9
191			virtual void guess_done(ANTLRParserState *st) { // MR9 27-Sep-97 make virtual
192			restoreState(st); } // MR9
193			virtual int guess(ANTLRParserState *); // MR9 27-Sep-97 make virtual
194			void look(int);
195			int _match(ANTLRTokenType, ANTLRChar *, ANTLRTokenType ,
196			_ANTLRTokenPtr , SetWordType *);
197			int _setmatch(SetWordType , ANTLRChar , ANTLRTokenType ,
198			_ANTLRTokenPtr , SetWordType *,
199			SetWordType * tokclassErrset /* MR23 */);
200			int _match_wsig(ANTLRTokenType);
201			int _setmatch_wsig(SetWordType *);
202			virtual void consume();
203			virtual void resynch(SetWordType *wd,SetWordType mask); // MR21
204			void prime_lookahead();
205			virtual void tracein(const ANTLRChar *r); // MR10
206			virtual void traceout(const ANTLRChar *r); // MR10
207			static unsigned MODWORD(unsigned x) {return x & (EXT_WORDSIZE-1);} // x % EXT_WORDSIZE // MR9
208			static unsigned DIVWORD(unsigned x) {return x >> EXT_LOGWORDSIZE;} // x / EXT_WORDSIZE // MR9
209			int set_deg(SetWordType *);
210			int set_el(ANTLRTokenType, SetWordType *);
211			virtual void edecode(SetWordType *); // MR1
212			virtual void FAIL(int k, ...); // MR1
213			int traceOptionValue; // MR10
214			int traceGuessOptionValue; // MR10
215			const ANTLRChar *traceCurrentRuleName; // MR10
216			int traceDepth; // MR10
217			void traceReset(); // MR10
218			virtual void traceGuessFail(); // MR10
219			virtual void traceGuessDone(const ANTLRParserState *); // MR10
220			int zzGuessSeq; // MR10
221
222			public:
223			ANTLRParser(ANTLRTokenBuffer *,
224			int k=1,
225			int use_inf_look=0,
226			int demand_look=0,
227			int bsetsize=1);
228			virtual ~ANTLRParser();
229
230			virtual void init();
231
232			ANTLRTokenType LA(int i)
233			{
234			//
235			// MR14 demand look will always be 0 for C++ mode
236			//
237			//// return demand_look ? token_type[(labase+(i)-1)&(LLk-1)] :
238			//// token_type[(lap+(i)-1)&(LLk-1)];
239
240			// MR19 V.H. Simonis Defer fetch feature
241
242			#ifdef ZZDEFER_FETCH
243			undeferFetch();
244			#endif
245			return token_type[(lap+(i)-1)&(LLk-1)];
246			}
247			_ANTLRTokenPtr LT(int i);
248
249			void setEofToken(ANTLRTokenType t) { eofToken = t; }
250			ANTLRTokenType getEofToken() const { return eofToken; } // MR14
251
252			void noGarbageCollectTokens() { inputTokens->noGarbageCollectTokens(); }
253			void garbageCollectTokens() { inputTokens->garbageCollectTokens(); }
254
255			virtual void syn(_ANTLRTokenPtr tok, ANTLRChar *egroup,
256			SetWordType *eset, ANTLRTokenType etok, int k);
257			virtual void saveState(ANTLRParserState *); // MR9 27-Sep-97 make virtual
258			virtual void restoreState(ANTLRParserState *); // MR9 27-Sep-97 make virtual
259
260			virtual void panic(const char *msg); // MR20 const
261
262			static char eMsgd(char ,int);
263			static char eMsg(char ,char *);
264			static char eMsg2(char ,char ,char );
265
266			virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
267			virtual int printMessageV(FILE* pFile, const char* pFormat, va_list arglist); // MR23
268
269			void consumeUntil(SetWordType *st);
270			void consumeUntilToken(int t);
271
272			virtual int _setmatch_wdfltsig(SetWordType *tokensWanted,
273			ANTLRTokenType tokenTypeOfSet,
274			SetWordType *whatFollows);
275			virtual int _match_wdfltsig(ANTLRTokenType tokenWanted,
276			SetWordType *whatFollows);
277
278			const ANTLRChar * parserTokenName(int tok); // MR1
279
280			int traceOptionValueDefault; // MR11
281			int traceOption(int delta); // MR11
282			int traceGuessOption(int delta); // MR11
283
284			// MR8 5-Aug-97 S.Bochnak@microtool.com.pl
285			// MR8 Move resynch static local variable
286			// MR8 to class instance
287
288			int syntaxErrCount; // MR12
289			ANTLRTokenStream *getLexer() const { // MR12
290			return inputTokens ? inputTokens->getLexer() : 0; } // MR12
291			protected: // MR8
292			int resynchConsumed; // MR8
293			char *zzFAILtext; // workarea required by zzFAIL // MR9
294			void undeferFetch(); // MR19 V.H. Simonis
295			int isDeferFetchEnabled(); // MR19 V.H. Simonis
296			virtual void failedSemanticPredicate(const char* predicate); /* MR23 */
297			};
298
299			#define zzmatch(_t) \
300			if ( !_match((ANTLRTokenType)_t, &zzMissText, &zzMissTok, \
301			(_ANTLRTokenPtr *) &zzBadTok, &zzMissSet) ) goto fail;
302
303			#define zzmatch_wsig(_t,handler) \
304			if ( !_match_wsig((ANTLRTokenType)_t) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}
305
306			#define zzsetmatch(_ts,_tokclassErrset) \
307			if ( !_setmatch(_ts, &zzMissText, &zzMissTok, \
308			(_ANTLRTokenPtr *) &zzBadTok, &zzMissSet, _tokclassErrset) ) goto fail;
309
310			#define zzsetmatch_wsig(_ts, handler) \
311			if ( !_setmatch_wsig(_ts) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}
312
313			/* For the dflt signal matchers, a FALSE indicates that an error occurred
314			* just like the other matchers, but in this case, the routine has already
315			* recovered--we do NOT want to consume another token. However, when
316			* the match was successful, we do want to consume hence _signal=0 so that
317			* a token is consumed by the "if (!_signal) consume(); _signal=NoSignal;"
318			* preamble.
319			*/
320			#define zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) \
321			if ( !_setmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) ) \
322			_signal = MismatchedToken;
323
324			#define zzmatch_wdfltsig(tokenWanted, whatFollows) \
325			if ( !_match_wdfltsig(tokenWanted, whatFollows) ) _signal = MismatchedToken;
326
327
328			// MR1 10-Apr-97 zzfailed_pred() macro does not backtrack in guess mode.
329			// MR1 Identification and correction due to J. Lilley
330			//
331			// MR23 Call virtual method to report error.
332			// MR23 Provide more control over failed predicate action
333			// without any need for user to worry about guessing internals.
334
335			#ifndef zzfailed_pred
336			#define zzfailed_pred(_p,_hasuseraction,_useraction) \
337			if (guessing) { \
338			zzGUESS_FAIL; \
339			} else { \
340			zzfailed_pred_action(_p,_hasuseraction,_useraction) \
341			}
342			#endif
343
344			// MR23 Provide more control over failed predicate action
345			// without any need for user to worry about guessing internals.
346			// _hasuseraction == 0 => no user specified error action
347			// _hasuseraction == 1 => user specified error action
348
349			#ifndef zzfailed_pred_action
350			#define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
351			if (_hasuseraction) { _useraction } else { failedSemanticPredicate(_p); }
352			#endif
353
354			#define zzRULE \
355			SetWordType *zzMissSet=NULL; ANTLRTokenType zzMissTok=(ANTLRTokenType)0; \
356			_ANTLRTokenPtr zzBadTok=NULL; ANTLRChar zzBadText=(ANTLRChar )""; \
357			int zzErrk=1,zzpf=0; \
358			zzTRACEdata \
359			ANTLRChar zzMissText=(ANTLRChar )"";
360
361			#endif
362
363			/* S t a n d a r d E x c e p t i o n S i g n a l s */
364
365			#define NoSignal 0
366			#define MismatchedToken 1
367			#define NoViableAlt 2
368			#define NoSemViableAlt 3
369
370			/* MR7 Allow more control over signalling */
371			/* by adding "Unwind" and "SetSignal" */
372
373			#define Unwind 4
374			#define setSignal(newValue) *_retsignal=_signal=(newValue)
375			#define suppressSignal *_retsignal=_signal=0
376			#define exportSignal *_retsignal=_signal