[mirror_edk2.git] / EdkCompatibilityPkg / Other / Maintained / Tools / Pccts / h / AParser.cpp

/* ANTLRParser.C\r
 *\r
 * SOFTWARE RIGHTS\r
 *\r
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool\r
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or\r
 * company may do whatever they wish with source code distributed with\r
 * PCCTS or the code generated by PCCTS, including the incorporation of\r
 * PCCTS, or its output, into commerical software.\r
 *\r
 * We encourage users to develop software with PCCTS.  However, we do ask\r
 * that credit is given to us for developing PCCTS.  By "credit",\r
 * we mean that if you incorporate our source code into one of your\r
 * programs (commercial product, research project, or otherwise) that you\r
 * acknowledge this fact somewhere in the documentation, research report,\r
 * etc...  If you like PCCTS and have developed a nice tool with the\r
 * output, please mention that you developed it using PCCTS.  In\r
 * addition, we ask that this header remain intact in our source code.\r
 * As long as these guidelines are kept, we expect to continue enhancing\r
 * this system and expect to make other tools available as they are\r
 * completed.\r
 *\r
 * ANTLR 1.33\r
 * Terence Parr\r
 * Parr Research Corporation\r
 * with Purdue University and AHPCRC, University of Minnesota\r
 * 1989-1998\r
 */\r
\r
#include "pcctscfg.h"\r
\r
#include "pccts_stdlib.h"\r
#include "pccts_stdarg.h"\r
#include "pccts_string.h"\r
#include "pccts_stdio.h"\r
\r
PCCTS_NAMESPACE_STD\r
\r
/* I have to put this here due to C++ limitation\r
 * that you can't have a 'forward' decl for enums.\r
 * I hate C++!!!!!!!!!!!!!!!\r
 * Of course, if I could use real templates, this would go away.\r
 */\r
// MR1\r
// MR1  10-Apr-97  133MR1  Prevent use of varying sizes for the\r
// MR1  			ANTLRTokenType enum\r
// MR1\r
\r
enum ANTLRTokenType { TER_HATES_CPP=0, ITS_TOO_COMPLICATED=9999};	    // MR1\r
\r
#define ANTLR_SUPPORT_CODE\r
\r
#include ATOKEN_H\r
#include ATOKENBUFFER_H\r
#include APARSER_H\r
\r
static const int zzINF_DEF_TOKEN_BUFFER_SIZE = 2000;    /* MR14 */\r
static const int zzINF_BUFFER_TOKEN_CHUNK_SIZE = 1000;  /* MR14 */\r
\r
                 /* L o o k a h e a d  M a c r o s */\r
\r
/* maximum of 32 bits/unsigned int and must be 8 bits/byte;\r
 * we only use 8 bits of it.\r
 */\r
SetWordType ANTLRParser::bitmask[sizeof(SetWordType)*8] = {\r
	0x00000001, 0x00000002, 0x00000004, 0x00000008,\r
	0x00000010, 0x00000020, 0x00000040, 0x00000080\r
};\r
\r
char ANTLRParser::eMsgBuffer[500] = "";\r
\r
ANTLRParser::\r
~ANTLRParser()\r
{\r
	delete [] token_type;\r
    delete [] zzFAILtext;       // MR16 Manfred Kogler\r
}\r
\r
ANTLRParser::\r
ANTLRParser(ANTLRTokenBuffer *_inputTokens,\r
			int k,\r
			int use_inf_look,\r
			int dlook,\r
			int ssize)\r
{\r
	LLk = k;\r
	can_use_inf_look = use_inf_look;\r
/* MR14 */    if (dlook != 0) {\r
/* MR14 */      panic("ANTLRParser::ANTLRParser - Demand lookahead not supported in C++ mode");\r
/* MR14 */\r
/* MR14 */    };\r
    demand_look = 0;    /* demand_look = dlook; */\r
    bsetsize = ssize;\r
	guessing = 0;\r
	token_tbl = NULL;\r
	eofToken = (ANTLRTokenType)1;\r
\r
	// allocate lookahead buffer\r
	token_type = new ANTLRTokenType[LLk];\r
	lap = 0;\r
	labase = 0;\r
#ifdef ZZDEFER_FETCH\r
	stillToFetch = 0;                                                   // MR19\r
#endif\r
	dirty = 0;\r
    inf_labase = 0;                                                     // MR7\r
    inf_last = 0;                                                       // MR7\r
	/* prime lookahead buffer, point to inputTokens */\r
	this->inputTokens = _inputTokens;\r
	this->inputTokens->setMinTokens(k);\r
	_inputTokens->setParser(this);					                    // MR1\r
    resynchConsumed=1;                                                  // MR8\r
    zzFAILtext=NULL;                                                    // MR9\r
    traceOptionValueDefault=0;                                          // MR10\r
    traceReset();                                                       // MR10\r
    zzGuessSeq=0;                                                       // MR10\r
    syntaxErrCount=0;                                                   // MR11\r
}\r
\r
void ANTLRParser::init()\r
{\r
   prime_lookahead();\r
   resynchConsumed=1;                                                   // MR8\r
   traceReset();                                                        // MR10\r
}\r
\r
void ANTLRParser::traceReset()\r
{\r
   traceOptionValue=traceOptionValueDefault;\r
   traceGuessOptionValue=1;\r
   traceCurrentRuleName=NULL;\r
   traceDepth=0;\r
}\r
\r
int ANTLRParser::\r
guess(ANTLRParserState *st)\r
{\r
	saveState(st);\r
	guessing = 1;\r
	return setjmp(guess_start.state);\r
}\r
\r
void ANTLRParser::\r
saveState(ANTLRParserState *buf)\r
{\r
	buf->guess_start = guess_start;\r
	buf->guessing = guessing;\r
	buf->inf_labase = inf_labase;\r
	buf->inf_last = inf_last;\r
	buf->dirty = dirty;\r
    buf->traceOptionValue=traceOptionValue;            /* MR10 */\r
    buf->traceGuessOptionValue=traceGuessOptionValue;  /* MR10 */\r
    buf->traceCurrentRuleName=traceCurrentRuleName;    /* MR10 */\r
    buf->traceDepth=traceDepth;                        /* MR10 */\r
}\r
\r
void ANTLRParser::\r
restoreState(ANTLRParserState *buf)\r
{\r
	int     i;\r
    int     prevTraceOptionValue;\r
\r
	guess_start = buf->guess_start;\r
	guessing = buf->guessing;\r
	inf_labase = buf->inf_labase;\r
	inf_last = buf->inf_last;\r
	dirty = buf->dirty;\r
\r
	// restore lookahead buffer from k tokens before restored TokenBuffer position\r
	// if demand_look, then I guess we don't look backwards for these tokens.\r
	for (i=1; i<=LLk; i++) token_type[i-1] =\r
		inputTokens->bufferedToken(i-LLk)->getType();\r
	lap = 0;\r
	labase = 0;\r
\r
    /* MR10 */\r
\r
    prevTraceOptionValue=traceOptionValue;\r
    traceOptionValue=buf->traceOptionValue;\r
    if ( (prevTraceOptionValue > 0) !=\r
             (traceOptionValue > 0)) {\r
      if (traceCurrentRuleName != NULL) {  /* MR21 */\r
          if (traceOptionValue > 0) {\r
            fprintf(stderr,\r
                   "trace enable restored in rule %s depth %d\n",\r
                   traceCurrentRuleName,\r
                   traceDepth);\r
          };\r
          if (traceOptionValue <= 0) {\r
            fprintf(stderr,\r
            "trace disable restored in rule %s depth %d\n",\r
            traceCurrentRuleName, /* MR21 */\r
            traceDepth);\r
          };\r
       }\r
    };\r
    traceGuessOptionValue=buf->traceGuessOptionValue;\r
    traceCurrentRuleName=buf->traceCurrentRuleName;\r
    traceDepth=buf->traceDepth;\r
    traceGuessDone(buf);\r
}\r
\r
/* Get the next symbol from the input stream; put it into lookahead buffer;\r
 * fill token_type[] fast reference cache also.  NLA is the next place where\r
 * a lookahead ANTLRAbstractToken should go.\r
 */\r
void ANTLRParser::\r
consume()\r
{\r
\r
#ifdef ZZDEBUG_CONSUME_ACTION\r
    zzdebug_consume_action();\r
#endif\r
\r
// MR19 V.H. Simonis\r
//      Defer Fetch feature\r
//      Moves action of consume() into LA() function\r
\r
#ifdef ZZDEFER_FETCH\r
      stillToFetch++;\r
#else\r
      NLA = inputTokens->getToken()->getType();\r
      dirty--;\r
      lap = (lap+1)&(LLk-1);\r
#endif\r
\r
}\r
\r
_ANTLRTokenPtr ANTLRParser::\r
LT(int i)\r
{\r
\r
// MR19 V.H. Simonis\r
//      Defer Fetch feature\r
//      Moves action of consume() into LA() function\r
\r
#ifdef ZZDEFER_FETCH\r
    undeferFetch();\r
#endif\r
\r
#ifdef DEBUG_TOKENBUFFER\r
	if ( i >= inputTokens->bufferSize() || inputTokens->minTokens() < LLk )     /* MR20 Was "<=" */\r
	{\r
		char buf[2000];                 /* MR20 Was "static" */\r
        sprintf(buf, "The minimum number of tokens you requested that the\nANTLRTokenBuffer buffer is not enough to satisfy your\nLT(%d) request; increase 'k' argument to constructor for ANTLRTokenBuffer\n", i);\r
		panic(buf);\r
	}\r
#endif\r
	return inputTokens->bufferedToken(i-LLk);\r
}\r
\r
void\r
ANTLRParser::\r
look(int k)\r
{\r
	int i, c = k - (LLk-dirty);\r
	for (i=1; i<=c; i++) consume();\r
}\r
\r
/* fill the lookahead buffer up with k symbols (even if DEMAND_LOOK);\r
 */\r
void\r
ANTLRParser::\r
prime_lookahead()\r
{\r
	int i;\r
	for(i=1;i<=LLk; i++) consume();\r
	dirty=0;\r
	// lap = 0;     // MR14 Sinan Karasu (sinan.karasu@boeing.com)\r
	// labase = 0;  // MR14\r
    labase=lap;     // MR14\r
}\r
\r
/* check to see if the current input symbol matches '_t'.\r
 * During NON demand lookahead mode, dirty will always be 0 and\r
 * hence the extra code for consuming tokens in _match is never\r
 * executed; the same routine can be used for both modes.\r
 */\r
int ANTLRParser::\r
_match(ANTLRTokenType _t, ANTLRChar **MissText,\r
	   ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,\r
	   SetWordType **MissSet)\r
{\r
	if ( dirty==LLk ) {\r
		consume();\r
	}\r
	if ( LA(1)!=_t ) {\r
		*MissText=NULL;\r
		*MissTok= _t; *BadTok = LT(1);\r
		*MissSet=NULL;\r
		return 0;\r
	}\r
	dirty++;\r
	labase = (labase+1)&(LLk-1);	// labase maintained even if !demand look\r
	return 1;\r
}\r
\r
/* check to see if the current input symbol matches '_t'.\r
 * Used during exception handling.\r
 */\r
int ANTLRParser::\r
_match_wsig(ANTLRTokenType _t)\r
{\r
	if ( dirty==LLk ) {\r
		consume();\r
	}\r
	if ( LA(1)!=_t ) return 0;\r
	dirty++;\r
	labase = (labase+1)&(LLk-1);	// labase maintained even if !demand look\r
	return 1;\r
}\r
\r
/* check to see if the current input symbol matches any token in a set.\r
 * During NON demand lookahead mode, dirty will always be 0 and\r
 * hence the extra code for consuming tokens in _match is never\r
 * executed; the same routine can be used for both modes.\r
 */\r
int ANTLRParser::\r
_setmatch(SetWordType *tset, ANTLRChar **MissText,\r
	   ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,\r
	   SetWordType **MissSet)\r
{\r
	if ( dirty==LLk ) {\r
		consume();\r
	}\r
	if ( !set_el(LA(1), tset) ) {\r
		*MissText=NULL;\r
		*MissTok= (ANTLRTokenType)0; *BadTok=LT(1);\r
		*MissSet=tset;\r
		return 0;\r
	}\r
	dirty++;\r
	labase = (labase+1)&(LLk-1);	// labase maintained even if !demand look\r
	return 1;\r
}\r
\r
int ANTLRParser::\r
_setmatch_wsig(SetWordType *tset)\r
{\r
	if ( dirty==LLk ) {\r
		consume();\r
	}\r
	if ( !set_el(LA(1), tset) ) return 0;\r
	dirty++;\r
	labase = (labase+1)&(LLk-1);	// labase maintained even if !demand look\r
	return 1;\r
}\r
\r
                   /* Exception handling routines */\r
//\r
//  7-Apr-97 133MR1\r
//   	     Change suggested by Eli Sternheim (eli@interhdl.com)\r
//\r
void ANTLRParser::\r
consumeUntil(SetWordType *st)\r
{\r
	ANTLRTokenType		tmp;	                        				// MR1\r
	const			int Eof=1;                                          // MR1\r
	while ( !set_el( (tmp=LA(1)), st) && tmp!=Eof) { consume(); }       // MR1\r
}\r
\r
//\r
//  7-Apr-97 133MR1\r
//   	     Change suggested by Eli Sternheim (eli@interhdl.com)\r
//\r
void ANTLRParser::\r
consumeUntilToken(int t)\r
{\r
	int	tmp;                                                            // MR1\r
	const	int Eof=1;                                                  // MR1\r
	while ( (tmp=LA(1)) !=t && tmp!=Eof) { consume(); }                 // MR1\r
}\r
\r
\r
                        /* Old error stuff */\r
\r
void ANTLRParser::\r
resynch(SetWordType *wd,SetWordType mask)\r
{\r
\r
/* MR8              S.Bochnak@microtool.com.pl                          */\r
/* MR8              Change file scope static "consumed" to instance var */\r
\r
	/* if you enter here without having consumed a token from last resynch\r
	 * force a token consumption.\r
	 */\r
/* MR8 */  	if ( !resynchConsumed ) {consume(); resynchConsumed=1; return;}\r
\r
   	/* if current token is in resynch set, we've got what we wanted */\r
\r
/* MR8 */  	if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;}\r
	\r
   	/* scan until we find something in the resynch set */\r
\r
        	while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();}\r
\r
/* MR8 */	resynchConsumed=1;\r
}\r
\r
/* standard error reporting function that assumes DLG-based scanners;\r
 * you should redefine in subclass to change it or if you use your\r
 * own scanner.\r
 */\r
void ANTLRParser::\r
syn(_ANTLRTokenPtr tok, ANTLRChar *egroup, SetWordType *eset,\r
	ANTLRTokenType etok, int k)\r
{\r
	int line;\r
\r
	line = LT(1)->getLine();\r
\r
    syntaxErrCount++;                                   /* MR11 */\r
	fprintf(stderr, "line %d: syntax error at \"%s\"",\r
					line,\r
    				(LA(1)==eofToken && LT(1)->getText()[0] == '@')? \r
                                        "<eof>":LT(1)->getText() /* MR21a */);\r
	if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}\r
	if ( k==1 ) fprintf(stderr, " missing");\r
	else\r
	{\r
		fprintf(stderr, "; \"%s\" not", LT(1)->getText());\r
		if ( set_deg(eset)>1 ) fprintf(stderr, " in");\r
	}\r
	if ( set_deg(eset)>0 ) edecode(eset);\r
	else fprintf(stderr, " %s", token_tbl[etok]);\r
	if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);\r
	fprintf(stderr, "\n");\r
}\r
\r
/* is b an element of set p? */\r
int ANTLRParser::\r
set_el(ANTLRTokenType b, SetWordType *p)\r
{\r
	return( p[DIVWORD(b)] & bitmask[MODWORD(b)] );\r
}\r
\r
int ANTLRParser::\r
set_deg(SetWordType *a)\r
{\r
	/* Fast compute degree of a set... the number\r
	   of elements present in the set.  Assumes\r
	   that all word bits are used in the set\r
	*/\r
	register SetWordType *p = a;\r
	register SetWordType *endp = &(a[bsetsize]);\r
	register int degree = 0;\r
\r
	if ( a == NULL ) return 0;\r
	while ( p < endp )\r
	{\r
		register SetWordType t = *p;\r
		register SetWordType *b = &(bitmask[0]);\r
		do {\r
			if (t & *b) ++degree;\r
		} while (++b < &(bitmask[sizeof(SetWordType)*8]));\r
		p++;\r
	}\r
\r
	return(degree);\r
}\r
\r
void ANTLRParser::\r
edecode(SetWordType *a)\r
{\r
	register SetWordType *p = a;\r
	register SetWordType *endp = &(p[bsetsize]);\r
	register unsigned e = 0;\r
\r
	if ( set_deg(a)>1 ) fprintf(stderr, " {");\r
	do {\r
		register SetWordType t = *p;\r
		register SetWordType *b = &(bitmask[0]);\r
		do {\r
			if ( t & *b ) fprintf(stderr, " %s", token_tbl[e]);\r
			e++;\r
		} while (++b < &(bitmask[sizeof(SetWordType)*8]));\r
	} while (++p < endp);\r
	if ( set_deg(a)>1 ) fprintf(stderr, " }");\r
}\r
\r
/* input looks like:\r
 *      zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk)\r
 * where the zzMiss stuff is set here to the token that did not match\r
 * (and which set wasn't it a member of).\r
 */\r
\r
// MR9 29-Sep-97    Stan Bochnak (S.Bochnak@microTool.com.pl)\r
// MR9              Original fix to static allocated text didn't\r
// MR9                work because a pointer to it was passed back\r
// MR9                to caller.  Replace with instance variable.\r
\r
const int   SETWORDCOUNT=20;\r
\r
void\r
ANTLRParser::FAIL(int k, ...)\r
{\r
//\r
//  MR1 10-Apr-97	\r
//\r
\r
    if (zzFAILtext == NULL) zzFAILtext=new char [1000];          // MR9\r
    SetWordType **f=new SetWordType *[SETWORDCOUNT];             // MR1 // MR9\r
    SetWordType **miss_set;\r
    ANTLRChar **miss_text;\r
    _ANTLRTokenPtr *bad_tok;\r
    ANTLRChar **bad_text;\r
//\r
//  7-Apr-97 133MR1\r
//  		err_k is passed as a "int *", not "unsigned *"\r
//\r
    int	*err_k;                                                         // MR1\r
    int i;\r
    va_list ap;\r
\r
    va_start(ap, k);\r
\r
    zzFAILtext[0] = '\0';\r
	if ( k > SETWORDCOUNT ) panic("FAIL: overflowed buffer");\r
    for (i=1; i<=k; i++)    /* collect all lookahead sets */\r
    {\r
        f[i-1] = va_arg(ap, SetWordType *);\r
    }\r
    for (i=1; i<=k; i++)    /* look for offending token */\r
    {\r
        if ( i>1 ) strcat(zzFAILtext, " ");\r
        strcat(zzFAILtext, LT(i)->getText());\r
        if ( !set_el(LA(i), f[i-1]) ) break;\r
    }\r
    miss_set = va_arg(ap, SetWordType **);\r
    miss_text = va_arg(ap, ANTLRChar **);\r
    bad_tok = va_arg(ap, _ANTLRTokenPtr *);\r
    bad_text = va_arg(ap, ANTLRChar **);\r
    err_k = va_arg(ap, int *);                      					// MR1\r
    if ( i>k )\r
    {\r
        /* bad; lookahead is permutation that cannot be matched,\r
         * but, the ith token of lookahead is valid at the ith position\r
         * (The old LL sub 1 (k) versus LL(k) parsing technique)\r
         */\r
        *miss_set = NULL;\r
        *miss_text = LT(1)->getText();\r
        *bad_tok = LT(1);\r
        *bad_text = (*bad_tok)->getText();\r
        *err_k = k;\r
//\r
//  MR4 20-May-97	erroneously deleted contents of f[]\r
//  MR4			        reported by Bruce Guenter (bruceg@qcc.sk.ca)\r
//  MR1 10-Apr-97	release temporary storage\r
//\r
      delete [] f;                                                      // MR1\r
      return;                                                           // MR1\r
    }\r
/*  fprintf(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/\r
    *miss_set = f[i-1];\r
    *miss_text = zzFAILtext;\r
    *bad_tok = LT(i);\r
    *bad_text = (*bad_tok)->getText();\r
    if ( i==1 ) *err_k = 1;\r
    else *err_k = k;\r
//\r
//  MR4 20-May-97	erroneously deleted contents of f[]\r
//  MR4			      reported by Bruce Guenter (bruceg@qcc.sk.ca)\r
//  MR1 10-Apr-97	release temporary storage\r
//\r
    delete [] f;                                                        // MR1\r
    return;                                                             // MR1\r
}\r
\r
int ANTLRParser::\r
_match_wdfltsig(ANTLRTokenType tokenWanted, SetWordType *whatFollows)\r
{\r
	if ( dirty==LLk ) consume();\r
\r
	if ( LA(1)!=tokenWanted )\r
	{\r
        syntaxErrCount++;                                   /* MR11 */\r
		fprintf(stderr,\r
				"line %d: syntax error at \"%s\" missing %s\n",\r
				LT(1)->getLine(),\r
				(LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */\r
				token_tbl[tokenWanted]);\r
		consumeUntil( whatFollows );\r
		return 0;\r
	}\r
	else {\r
		dirty++;\r
		labase = (labase+1)&(LLk-1); // labase maintained even if !demand look\r
/*		if ( !demand_look ) consume(); */\r
		return 1;\r
	}\r
}\r
\r
\r
int ANTLRParser::\r
_setmatch_wdfltsig(SetWordType *tokensWanted,\r
					ANTLRTokenType tokenTypeOfSet,\r
					SetWordType *whatFollows)\r
{\r
	if ( dirty==LLk ) consume();\r
	if ( !set_el(LA(1), tokensWanted) )\r
	{\r
        syntaxErrCount++;                                   /* MR11 */\r
		fprintf(stderr,\r
				"line %d: syntax error at \"%s\" missing %s\n",\r
				LT(1)->getLine(),\r
				(LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */\r
				token_tbl[tokenTypeOfSet]);\r
		consumeUntil( whatFollows );\r
		return 0;\r
	}\r
	else {\r
		dirty++;\r
		labase = (labase+1)&(LLk-1); // labase maintained even if !demand look\r
/*		if ( !demand_look ) consume(); */\r
		return 1;\r
	}\r
}\r
\r
char *ANTLRParser::\r
eMsgd(char *err,int d)\r
{\r
	sprintf(eMsgBuffer, err, d);	// dangerous, but I don't care\r
	return eMsgBuffer;\r
}\r
\r
char *ANTLRParser::\r
eMsg(char *err, char *s)\r
{\r
	sprintf(eMsgBuffer, err, s);\r
	return eMsgBuffer;\r
}\r
\r
char *ANTLRParser::\r
eMsg2(char *err,char *s, char *t)\r
{\r
	sprintf(eMsgBuffer, err, s, t);\r
	return eMsgBuffer;\r
}\r
\r
void ANTLRParser::\r
panic(const char *msg)  // MR20 const\r
{\r
	fprintf(stderr, "ANTLR panic: %s\n", msg);\r
	exit(PCCTS_EXIT_FAILURE);           // MR1\r
}\r
\r
const ANTLRChar *ANTLRParser::          // MR1\r
parserTokenName(int tok) {              // MR1\r
	return token_tbl[tok];              // MR1\r
}                                       // MR1\r
\r
void ANTLRParser::traceGuessDone(const ANTLRParserState *state) {\r
\r
  int   doIt=0;\r
\r
  if (traceCurrentRuleName == NULL) return;\r
\r
  if (traceOptionValue <= 0) {\r
    doIt=0;\r
  } else if (traceGuessOptionValue <= 0) {\r
    doIt=0;\r
  } else {\r
    doIt=1;\r
  };\r
\r
  if (doIt) {\r
    fprintf(stderr,"guess done - returning to rule %s {\"%s\"} at depth %d",\r
        state->traceCurrentRuleName,\r
        LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),\r
        state->traceDepth);\r
    if (state->guessing != 0) {\r
      fprintf(stderr," (guess mode continues - an enclosing guess is still active)");\r
    } else {\r
      fprintf(stderr," (guess mode ends)");\r
    };\r
    fprintf(stderr,"\n");\r
  };\r
}\r
\r
void ANTLRParser::traceGuessFail() {\r
\r
  int   doIt=0;\r
\r
  if (traceCurrentRuleName == NULL) return;     /* MR21 */\r
\r
  if (traceOptionValue <= 0) {\r
    doIt=0;\r
  } else if (guessing && traceGuessOptionValue <= 0) {\r
    doIt=0;\r
  } else {\r
    doIt=1;\r
  };\r
\r
  if (doIt) {\r
    fprintf(stderr,"guess failed\n");\r
  };\r
}\r
\r
/* traceOption:\r
     zero value turns off trace\r
*/\r
\r
void ANTLRParser::tracein(const ANTLRChar * rule) {\r
\r
  int       doIt=0;\r
\r
  traceDepth++;\r
  traceCurrentRuleName=rule;\r
\r
  if (traceOptionValue <= 0) {\r
    doIt=0;\r
  } else if (guessing && traceGuessOptionValue <= 0) {\r
    doIt=0;\r
  } else {\r
    doIt=1;\r
  };\r
\r
  if (doIt) {\r
    fprintf(stderr,"enter rule %s {\"%s\"} depth %d",\r
            rule,\r
            LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),\r
            traceDepth);\r
    if (guessing) fprintf(stderr," guessing");\r
    fprintf(stderr,"\n");\r
  };\r
  return;\r
}\r
\r
void ANTLRParser::traceout(const ANTLRChar * rule) {\r
\r
  int       doIt=0;\r
\r
  traceDepth--;\r
\r
  if (traceOptionValue <= 0) {\r
    doIt=0;\r
  } else if (guessing && traceGuessOptionValue <= 0) {\r
    doIt=0;\r
  } else {\r
    doIt=1;\r
  };\r
\r
  if (doIt) {\r
    fprintf(stderr,"exit rule %s {\"%s\"} depth %d",\r
            rule,\r
            LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),\r
            traceDepth+1);\r
    if (guessing) fprintf(stderr," guessing");\r
    fprintf(stderr,"\n");\r
  };\r
}\r
\r
int ANTLRParser::traceOption(int delta) {\r
\r
    int     prevValue=traceOptionValue;\r
\r
    traceOptionValue=traceOptionValue+delta;\r
\r
    if (traceCurrentRuleName != NULL) {\r
      if (prevValue <= 0 && traceOptionValue > 0) {\r
        fprintf(stderr,"trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);\r
      };\r
      if (prevValue > 0 && traceOptionValue <= 0) {\r
        fprintf(stderr,"trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);\r
      };\r
    };\r
\r
    return  prevValue;\r
}\r
\r
int ANTLRParser::traceGuessOption(int delta) {\r
\r
    int     prevValue=traceGuessOptionValue;\r
\r
    traceGuessOptionValue=traceGuessOptionValue+delta;\r
\r
    if (traceCurrentRuleName != NULL) {\r
      if (prevValue <= 0 && traceGuessOptionValue > 0) {\r
        fprintf(stderr,"guess trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);\r
      };\r
      if (prevValue > 0 && traceGuessOptionValue <= 0) {\r
        fprintf(stderr,"guess trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);\r
      };\r
    };\r
    return prevValue;\r
}\r
\r
// MR19 V.H. Simonis Defer Fetch feature\r
\r
void ANTLRParser::undeferFetch()\r
{\r
\r
#ifdef ZZDEFER_FETCH\r
    if (stillToFetch) {\r
        for (int stillToFetch_x = 0; stillToFetch_x < stillToFetch; ++stillToFetch_x) {\r
    		NLA = inputTokens->getToken()->getType();\r
    		dirty--;\r
    		lap = (lap+1)&(LLk-1);\r
        }\r
        stillToFetch = 0;\r
    }\r
#else\r
    return;\r
#endif\r
\r
}\r
\r
int ANTLRParser::isDeferFetchEnabled()\r
{\r
#ifdef ZZDEFER_FETCH\r
    return 1;\r
#else\r
    return 0;\r
#endif\r
}\r