| /* ANTLRParser.C |
| * |
| * 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 |
| */ |
| |
| #include "pcctscfg.h" |
| |
| #include "pccts_stdlib.h" |
| #include "pccts_stdarg.h" |
| #include "pccts_string.h" |
| #include "pccts_stdio.h" |
| |
| PCCTS_NAMESPACE_STD |
| |
| /* I have to put this here due to C++ limitation |
| * that you can't have a 'forward' decl for enums. |
| * I hate C++!!!!!!!!!!!!!!! |
| * Of course, if I could use real templates, this would go away. |
| */ |
| // MR1 |
| // MR1 10-Apr-97 133MR1 Prevent use of varying sizes for the |
| // MR1 ANTLRTokenType enum |
| // MR1 |
| |
| enum ANTLRTokenType { TER_HATES_CPP=0, ITS_TOO_COMPLICATED=9999}; // MR1 |
| |
| #define ANTLR_SUPPORT_CODE |
| |
| #include ATOKEN_H |
| #include ATOKENBUFFER_H |
| #include APARSER_H |
| |
| static const int zzINF_DEF_TOKEN_BUFFER_SIZE = 2000; /* MR14 */ |
| static const int zzINF_BUFFER_TOKEN_CHUNK_SIZE = 1000; /* MR14 */ |
| |
| /* L o o k a h e a d M a c r o s */ |
| |
| /* maximum of 32 bits/unsigned int and must be 8 bits/byte; |
| * we only use 8 bits of it. |
| */ |
| SetWordType ANTLRParser::bitmask[sizeof(SetWordType)*8] = { |
| 0x00000001, 0x00000002, 0x00000004, 0x00000008, |
| 0x00000010, 0x00000020, 0x00000040, 0x00000080 |
| }; |
| |
| char ANTLRParser::eMsgBuffer[500] = ""; |
| |
| ANTLRParser:: |
| ~ANTLRParser() |
| { |
| delete [] token_type; |
| delete [] zzFAILtext; // MR16 Manfred Kogler |
| } |
| |
| ANTLRParser:: |
| ANTLRParser(ANTLRTokenBuffer *_inputTokens, |
| int k, |
| int use_inf_look, |
| int dlook, |
| int ssize) |
| { |
| LLk = k; |
| can_use_inf_look = use_inf_look; |
| /* MR14 */ if (dlook != 0) { |
| /* MR14 */ panic("ANTLRParser::ANTLRParser - Demand lookahead not supported in C++ mode"); |
| /* MR14 */ |
| /* MR14 */ }; |
| demand_look = 0; /* demand_look = dlook; */ |
| bsetsize = ssize; |
| guessing = 0; |
| token_tbl = NULL; |
| eofToken = (ANTLRTokenType)1; |
| |
| // allocate lookahead buffer |
| token_type = new ANTLRTokenType[LLk]; |
| lap = 0; |
| labase = 0; |
| #ifdef ZZDEFER_FETCH |
| stillToFetch = 0; // MR19 |
| #endif |
| dirty = 0; |
| inf_labase = 0; // MR7 |
| inf_last = 0; // MR7 |
| /* prime lookahead buffer, point to inputTokens */ |
| this->inputTokens = _inputTokens; |
| this->inputTokens->setMinTokens(k); |
| _inputTokens->setParser(this); // MR1 |
| resynchConsumed=1; // MR8 |
| zzFAILtext=NULL; // MR9 |
| traceOptionValueDefault=0; // MR10 |
| traceReset(); // MR10 |
| zzGuessSeq=0; // MR10 |
| syntaxErrCount=0; // MR11 |
| } |
| |
| void ANTLRParser::init() |
| { |
| prime_lookahead(); |
| resynchConsumed=1; // MR8 |
| traceReset(); // MR10 |
| } |
| |
| void ANTLRParser::traceReset() |
| { |
| traceOptionValue=traceOptionValueDefault; |
| traceGuessOptionValue=1; |
| traceCurrentRuleName=NULL; |
| traceDepth=0; |
| } |
| |
| |
| #ifdef _MSC_VER // MR23 |
| //Turn off warning: |
| //interaction between '_setjmp' and C++ object destruction is non-portable |
| #pragma warning(disable : 4611) |
| #endif |
| int ANTLRParser:: |
| guess(ANTLRParserState *st) |
| { |
| saveState(st); |
| guessing = 1; |
| return setjmp(guess_start.state); |
| } |
| #ifdef _MSC_VER // MR23 |
| #pragma warning(default: 4611) |
| #endif |
| |
| void ANTLRParser:: |
| saveState(ANTLRParserState *buf) |
| { |
| buf->guess_start = guess_start; |
| buf->guessing = guessing; |
| buf->inf_labase = inf_labase; |
| buf->inf_last = inf_last; |
| buf->dirty = dirty; |
| buf->traceOptionValue=traceOptionValue; /* MR10 */ |
| buf->traceGuessOptionValue=traceGuessOptionValue; /* MR10 */ |
| buf->traceCurrentRuleName=traceCurrentRuleName; /* MR10 */ |
| buf->traceDepth=traceDepth; /* MR10 */ |
| } |
| |
| void ANTLRParser:: |
| restoreState(ANTLRParserState *buf) |
| { |
| int i; |
| int prevTraceOptionValue; |
| |
| guess_start = buf->guess_start; |
| guessing = buf->guessing; |
| inf_labase = buf->inf_labase; |
| inf_last = buf->inf_last; |
| dirty = buf->dirty; |
| |
| // restore lookahead buffer from k tokens before restored TokenBuffer position |
| // if demand_look, then I guess we don't look backwards for these tokens. |
| for (i=1; i<=LLk; i++) token_type[i-1] = |
| inputTokens->bufferedToken(i-LLk)->getType(); |
| lap = 0; |
| labase = 0; |
| |
| /* MR10 */ |
| |
| prevTraceOptionValue=traceOptionValue; |
| traceOptionValue=buf->traceOptionValue; |
| if ( (prevTraceOptionValue > 0) != |
| (traceOptionValue > 0)) { |
| if (traceCurrentRuleName != NULL) { /* MR21 */ |
| if (traceOptionValue > 0) { |
| /* MR23 */ printMessage(stderr, |
| "trace enable restored in rule %s depth %d\n", |
| traceCurrentRuleName, |
| traceDepth); |
| }; |
| if (traceOptionValue <= 0) { |
| /* MR23 */ printMessage(stderr, |
| "trace disable restored in rule %s depth %d\n", |
| traceCurrentRuleName, /* MR21 */ |
| traceDepth); |
| }; |
| } |
| }; |
| traceGuessOptionValue=buf->traceGuessOptionValue; |
| traceCurrentRuleName=buf->traceCurrentRuleName; |
| traceDepth=buf->traceDepth; |
| traceGuessDone(buf); |
| } |
| |
| /* Get the next symbol from the input stream; put it into lookahead buffer; |
| * fill token_type[] fast reference cache also. NLA is the next place where |
| * a lookahead ANTLRAbstractToken should go. |
| */ |
| void ANTLRParser:: |
| consume() |
| { |
| |
| #ifdef ZZDEBUG_CONSUME_ACTION |
| zzdebug_consume_action(); |
| #endif |
| |
| // MR19 V.H. Simonis |
| // Defer Fetch feature |
| // Moves action of consume() into LA() function |
| |
| #ifdef ZZDEFER_FETCH |
| stillToFetch++; |
| #else |
| NLA = inputTokens->getToken()->getType(); |
| dirty--; |
| lap = (lap+1)&(LLk-1); |
| #endif |
| |
| } |
| |
| _ANTLRTokenPtr ANTLRParser:: |
| LT(int i) |
| { |
| |
| // MR19 V.H. Simonis |
| // Defer Fetch feature |
| // Moves action of consume() into LA() function |
| |
| #ifdef ZZDEFER_FETCH |
| undeferFetch(); |
| #endif |
| |
| #ifdef DEBUG_TOKENBUFFER |
| if ( i >= inputTokens->bufferSize() || inputTokens->minTokens() < LLk ) /* MR20 Was "<=" */ |
| { |
| char buf[2000]; /* MR20 Was "static" */ |
| 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); |
| panic(buf); |
| } |
| #endif |
| return inputTokens->bufferedToken(i-LLk); |
| } |
| |
| void |
| ANTLRParser:: |
| look(int k) |
| { |
| int i, c = k - (LLk-dirty); |
| for (i=1; i<=c; i++) consume(); |
| } |
| |
| /* fill the lookahead buffer up with k symbols (even if DEMAND_LOOK); |
| */ |
| void |
| ANTLRParser:: |
| prime_lookahead() |
| { |
| int i; |
| for(i=1;i<=LLk; i++) consume(); |
| dirty=0; |
| // lap = 0; // MR14 Sinan Karasu (sinan.karasu@boeing.com) |
| // labase = 0; // MR14 |
| labase=lap; // MR14 |
| } |
| |
| /* check to see if the current input symbol matches '_t'. |
| * During NON demand lookahead mode, dirty will always be 0 and |
| * hence the extra code for consuming tokens in _match is never |
| * executed; the same routine can be used for both modes. |
| */ |
| int ANTLRParser:: |
| _match(ANTLRTokenType _t, ANTLRChar **MissText, |
| ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok, |
| SetWordType **MissSet) |
| { |
| if ( dirty==LLk ) { |
| consume(); |
| } |
| if ( LA(1)!=_t ) { |
| *MissText=NULL; |
| *MissTok= _t; |
| *BadTok = LT(1); |
| *MissSet=NULL; |
| return 0; |
| } |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| return 1; |
| } |
| |
| /* check to see if the current input symbol matches '_t'. |
| * Used during exception handling. |
| */ |
| int ANTLRParser:: |
| _match_wsig(ANTLRTokenType _t) |
| { |
| if ( dirty==LLk ) { |
| consume(); |
| } |
| if ( LA(1)!=_t ) return 0; |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| return 1; |
| } |
| |
| /* check to see if the current input symbol matches any token in a set. |
| * During NON demand lookahead mode, dirty will always be 0 and |
| * hence the extra code for consuming tokens in _match is never |
| * executed; the same routine can be used for both modes. |
| */ |
| int ANTLRParser:: |
| _setmatch(SetWordType *tset, ANTLRChar **MissText, |
| ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok, |
| SetWordType **MissSet, SetWordType *tokclassErrset) |
| { |
| if ( dirty==LLk ) { |
| consume(); |
| } |
| if ( !set_el(LA(1), tset) ) { |
| *MissText=NULL; /* MR23 */ |
| *MissTok=(ANTLRTokenType) 0; /* MR23 */ |
| *BadTok=LT(1); /* MR23 */ |
| *MissSet=tokclassErrset; /* MR23 */ |
| return 0; |
| } |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| return 1; |
| } |
| |
| int ANTLRParser:: |
| _setmatch_wsig(SetWordType *tset) |
| { |
| if ( dirty==LLk ) { |
| consume(); |
| } |
| if ( !set_el(LA(1), tset) ) return 0; |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| return 1; |
| } |
| |
| /* Exception handling routines */ |
| // |
| // 7-Apr-97 133MR1 |
| // Change suggested by Eli Sternheim (eli@interhdl.com) |
| // |
| void ANTLRParser:: |
| consumeUntil(SetWordType *st) |
| { |
| ANTLRTokenType tmp; // MR1 |
| const int Eof=1; // MR1 |
| while ( !set_el( (tmp=LA(1)), st) && tmp!=Eof) { consume(); } // MR1 |
| } |
| |
| // |
| // 7-Apr-97 133MR1 |
| // Change suggested by Eli Sternheim (eli@interhdl.com) |
| // |
| void ANTLRParser:: |
| consumeUntilToken(int t) |
| { |
| int tmp; // MR1 |
| const int Eof=1; // MR1 |
| while ( (tmp=LA(1)) !=t && tmp!=Eof) { consume(); } // MR1 |
| } |
| |
| |
| /* Old error stuff */ |
| |
| void ANTLRParser:: |
| resynch(SetWordType *wd,SetWordType mask) |
| { |
| |
| /* MR8 S.Bochnak@microtool.com.pl */ |
| /* MR8 Change file scope static "consumed" to instance var */ |
| |
| /* if you enter here without having consumed a token from last resynch |
| * force a token consumption. |
| */ |
| /* MR8 */ if ( !resynchConsumed ) {consume(); resynchConsumed=1; return;} |
| |
| /* if current token is in resynch set, we've got what we wanted */ |
| |
| /* MR8 */ if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;} |
| |
| /* scan until we find something in the resynch set */ |
| |
| while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();} |
| |
| /* MR8 */ resynchConsumed=1; |
| } |
| |
| /* standard error reporting function that assumes DLG-based scanners; |
| * you should redefine in subclass to change it or if you use your |
| * own scanner. |
| */ |
| |
| /* MR23 THM There appears to be a parameter "badText" passed to syn() |
| which is not present in the parameter list. This may be |
| because in C mode there is no attribute function which |
| returns the text, so the text representation of the token |
| must be passed explicitly. I think. |
| */ |
| |
| void ANTLRParser:: |
| syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset, |
| ANTLRTokenType etok, int k) |
| { |
| int line; |
| |
| line = LT(1)->getLine(); |
| |
| syntaxErrCount++; /* MR11 */ |
| |
| /* MR23 If the token is not an EOF token, then use the ->getText() value. |
| |
| If the token is the EOF token the text returned by ->getText() |
| may be garbage. If the text from the token table is "@" use |
| "<eof>" instead, because end-users don't know what "@" means. |
| If the text is not "@" then use that text, which must have been |
| supplied by the grammar writer. |
| */ |
| const char * errorAt = LT(1)->getText(); |
| if (LA(1) == eofToken) { |
| errorAt = parserTokenName(LA(1)); |
| if (errorAt[0] == '@') errorAt = "<eof>"; |
| } |
| /* MR23 */ printMessage(stderr, "line %d: syntax error at \"%s\"", |
| line, errorAt); |
| if ( !etok && !eset ) {/* MR23 */ printMessage(stderr, "\n"); return;} |
| if ( k==1 ) /* MR23 */ printMessage(stderr, " missing"); |
| else |
| { |
| /* MR23 */ printMessage(stderr, "; \"%s\" not", LT(k)->getText()); // MR23 use LT(k) since k>1 |
| if ( set_deg(eset)>1 ) /* MR23 */ printMessage(stderr, " in"); |
| } |
| if ( set_deg(eset)>0 ) edecode(eset); |
| else /* MR23 */ printMessage(stderr, " %s", token_tbl[etok]); |
| if ( strlen(egroup) > 0 ) /* MR23 */ printMessage(stderr, " in %s", egroup); |
| /* MR23 */ printMessage(stderr, "\n"); |
| } |
| |
| /* is b an element of set p? */ |
| int ANTLRParser:: |
| set_el(ANTLRTokenType b, SetWordType *p) |
| { |
| return( p[DIVWORD(b)] & bitmask[MODWORD(b)] ); |
| } |
| |
| int ANTLRParser:: |
| set_deg(SetWordType *a) |
| { |
| /* Fast compute degree of a set... the number |
| of elements present in the set. Assumes |
| that all word bits are used in the set |
| */ |
| register SetWordType *p = a; |
| register SetWordType *endp = &(a[bsetsize]); |
| register int degree = 0; |
| |
| if ( a == NULL ) return 0; |
| while ( p < endp ) |
| { |
| register SetWordType t = *p; |
| register SetWordType *b = &(bitmask[0]); |
| do { |
| if (t & *b) ++degree; |
| } while (++b < &(bitmask[sizeof(SetWordType)*8])); |
| p++; |
| } |
| |
| return(degree); |
| } |
| |
| void ANTLRParser:: |
| edecode(SetWordType *a) |
| { |
| register SetWordType *p = a; |
| register SetWordType *endp = &(p[bsetsize]); |
| register unsigned e = 0; |
| |
| if ( set_deg(a)>1 ) /* MR23 */ printMessage(stderr, " {"); |
| do { |
| register SetWordType t = *p; |
| register SetWordType *b = &(bitmask[0]); |
| do { |
| if ( t & *b ) /* MR23 */ printMessage(stderr, " %s", token_tbl[e]); |
| e++; |
| } while (++b < &(bitmask[sizeof(SetWordType)*8])); |
| } while (++p < endp); |
| if ( set_deg(a)>1 ) /* MR23 */ printMessage(stderr, " }"); |
| } |
| |
| /* input looks like: |
| * zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk) |
| * where the zzMiss stuff is set here to the token that did not match |
| * (and which set wasn't it a member of). |
| */ |
| |
| // MR9 29-Sep-97 Stan Bochnak (S.Bochnak@microTool.com.pl) |
| // MR9 Original fix to static allocated text didn't |
| // MR9 work because a pointer to it was passed back |
| // MR9 to caller. Replace with instance variable. |
| |
| const int SETWORDCOUNT=20; |
| |
| void |
| ANTLRParser::FAIL(int k, ...) |
| { |
| // |
| // MR1 10-Apr-97 |
| // |
| |
| if (zzFAILtext == NULL) zzFAILtext=new char [1000]; // MR9 |
| SetWordType **f=new SetWordType *[SETWORDCOUNT]; // MR1 // MR9 |
| SetWordType **miss_set; |
| ANTLRChar **miss_text; |
| _ANTLRTokenPtr *bad_tok; |
| ANTLRChar **bad_text; |
| // |
| // 7-Apr-97 133MR1 |
| // err_k is passed as a "int *", not "unsigned *" |
| // |
| int *err_k; // MR1 |
| int i; |
| va_list ap; |
| |
| va_start(ap, k); |
| |
| zzFAILtext[0] = '\0'; |
| if ( k > SETWORDCOUNT ) panic("FAIL: overflowed buffer"); |
| for (i=1; i<=k; i++) /* collect all lookahead sets */ |
| { |
| f[i-1] = va_arg(ap, SetWordType *); |
| } |
| for (i=1; i<=k; i++) /* look for offending token */ |
| { |
| if ( i>1 ) strcat(zzFAILtext, " "); |
| strcat(zzFAILtext, LT(i)->getText()); |
| if ( !set_el(LA(i), f[i-1]) ) break; |
| } |
| miss_set = va_arg(ap, SetWordType **); |
| miss_text = va_arg(ap, ANTLRChar **); |
| bad_tok = va_arg(ap, _ANTLRTokenPtr *); |
| bad_text = va_arg(ap, ANTLRChar **); |
| err_k = va_arg(ap, int *); // MR1 |
| if ( i>k ) |
| { |
| /* bad; lookahead is permutation that cannot be matched, |
| * but, the ith token of lookahead is valid at the ith position |
| * (The old LL sub 1 (k) versus LL(k) parsing technique) |
| */ |
| *miss_set = NULL; |
| *miss_text = LT(1)->getText(); |
| *bad_tok = LT(1); |
| *bad_text = (*bad_tok)->getText(); |
| *err_k = k; |
| // |
| // MR4 20-May-97 erroneously deleted contents of f[] |
| // MR4 reported by Bruce Guenter (bruceg@qcc.sk.ca) |
| // MR1 10-Apr-97 release temporary storage |
| // |
| delete [] f; // MR1 |
| return; // MR1 |
| } |
| /* MR23 printMessage(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/ |
| *miss_set = f[i-1]; |
| *miss_text = zzFAILtext; |
| *bad_tok = LT(i); |
| *bad_text = (*bad_tok)->getText(); |
| if ( i==1 ) *err_k = 1; |
| else *err_k = k; |
| // |
| // MR4 20-May-97 erroneously deleted contents of f[] |
| // MR4 reported by Bruce Guenter (bruceg@qcc.sk.ca) |
| // MR1 10-Apr-97 release temporary storage |
| // |
| delete [] f; // MR1 |
| return; // MR1 |
| } |
| |
| int ANTLRParser:: |
| _match_wdfltsig(ANTLRTokenType tokenWanted, SetWordType *whatFollows) |
| { |
| if ( dirty==LLk ) consume(); |
| |
| if ( LA(1)!=tokenWanted ) |
| { |
| syntaxErrCount++; /* MR11 */ |
| /* MR23 */ printMessage(stderr, |
| "line %d: syntax error at \"%s\" missing %s\n", |
| LT(1)->getLine(), |
| (LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */ |
| token_tbl[tokenWanted]); |
| consumeUntil( whatFollows ); |
| return 0; |
| } |
| else { |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| /* if ( !demand_look ) consume(); */ |
| return 1; |
| } |
| } |
| |
| |
| int ANTLRParser:: |
| _setmatch_wdfltsig(SetWordType *tokensWanted, |
| ANTLRTokenType tokenTypeOfSet, |
| SetWordType *whatFollows) |
| { |
| if ( dirty==LLk ) consume(); |
| if ( !set_el(LA(1), tokensWanted) ) |
| { |
| syntaxErrCount++; /* MR11 */ |
| /* MR23 */ printMessage(stderr, |
| "line %d: syntax error at \"%s\" missing %s\n", |
| LT(1)->getLine(), |
| (LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */ |
| token_tbl[tokenTypeOfSet]); |
| consumeUntil( whatFollows ); |
| return 0; |
| } |
| else { |
| dirty++; |
| labase = (labase+1)&(LLk-1); // labase maintained even if !demand look |
| /* if ( !demand_look ) consume(); */ |
| return 1; |
| } |
| } |
| |
| char *ANTLRParser:: |
| eMsgd(char *err,int d) |
| { |
| sprintf(eMsgBuffer, err, d); // dangerous, but I don't care |
| return eMsgBuffer; |
| } |
| |
| char *ANTLRParser:: |
| eMsg(char *err, char *s) |
| { |
| sprintf(eMsgBuffer, err, s); |
| return eMsgBuffer; |
| } |
| |
| char *ANTLRParser:: |
| eMsg2(char *err,char *s, char *t) |
| { |
| sprintf(eMsgBuffer, err, s, t); |
| return eMsgBuffer; |
| } |
| |
| void ANTLRParser:: |
| panic(const char *msg) // MR20 const |
| { |
| /* MR23 */ printMessage(stderr, "ANTLR panic: %s\n", msg); |
| exit(PCCTS_EXIT_FAILURE); // MR1 |
| } |
| |
| const ANTLRChar *ANTLRParser:: // MR1 |
| parserTokenName(int tok) { // MR1 |
| return token_tbl[tok]; // MR1 |
| } // MR1 |
| |
| void ANTLRParser::traceGuessDone(const ANTLRParserState *state) { |
| |
| int doIt=0; |
| |
| if (traceCurrentRuleName == NULL) return; |
| |
| if (traceOptionValue <= 0) { |
| doIt=0; |
| } else if (traceGuessOptionValue <= 0) { |
| doIt=0; |
| } else { |
| doIt=1; |
| }; |
| |
| if (doIt) { |
| /* MR23 */ printMessage(stderr,"guess done - returning to rule %s {\"%s\"} at depth %d", |
| state->traceCurrentRuleName, |
| LT(1)->getType() == eofToken ? "@" : LT(1)->getText(), |
| state->traceDepth); |
| if (state->guessing != 0) { |
| /* MR23 */ printMessage(stderr," (guess mode continues - an enclosing guess is still active)"); |
| } else { |
| /* MR23 */ printMessage(stderr," (guess mode ends)"); |
| }; |
| /* MR23 */ printMessage(stderr,"\n"); |
| }; |
| } |
| |
| void ANTLRParser::traceGuessFail() { |
| |
| int doIt=0; |
| |
| if (traceCurrentRuleName == NULL) return; /* MR21 */ |
| |
| if (traceOptionValue <= 0) { |
| doIt=0; |
| } else if (guessing && traceGuessOptionValue <= 0) { |
| doIt=0; |
| } else { |
| doIt=1; |
| }; |
| |
| if (doIt) { |
| /* MR23 */ printMessage(stderr,"guess failed in %s\n",traceCurrentRuleName); |
| }; |
| } |
| |
| /* traceOption: |
| zero value turns off trace |
| */ |
| |
| void ANTLRParser::tracein(const ANTLRChar * rule) { |
| |
| int doIt=0; |
| |
| traceDepth++; |
| traceCurrentRuleName=rule; |
| |
| if (traceOptionValue <= 0) { |
| doIt=0; |
| } else if (guessing && traceGuessOptionValue <= 0) { |
| doIt=0; |
| } else { |
| doIt=1; |
| }; |
| |
| if (doIt) { |
| /* MR23 */ printMessage(stderr,"enter rule %s {\"%s\"} depth %d", |
| rule, |
| LT(1)->getType() == eofToken ? "@" : LT(1)->getText(), |
| traceDepth); |
| if (guessing) /* MR23 */ printMessage(stderr," guessing"); |
| /* MR23 */ printMessage(stderr,"\n"); |
| }; |
| return; |
| } |
| |
| void ANTLRParser::traceout(const ANTLRChar * rule) { |
| |
| int doIt=0; |
| |
| traceDepth--; |
| |
| if (traceOptionValue <= 0) { |
| doIt=0; |
| } else if (guessing && traceGuessOptionValue <= 0) { |
| doIt=0; |
| } else { |
| doIt=1; |
| }; |
| |
| if (doIt) { |
| /* MR23 */ printMessage(stderr,"exit rule %s {\"%s\"} depth %d", |
| rule, |
| LT(1)->getType() == eofToken ? "@" : LT(1)->getText(), |
| traceDepth+1); |
| if (guessing) /* MR23 */ printMessage(stderr," guessing"); |
| /* MR23 */ printMessage(stderr,"\n"); |
| }; |
| } |
| |
| int ANTLRParser::traceOption(int delta) { |
| |
| int prevValue=traceOptionValue; |
| |
| traceOptionValue=traceOptionValue+delta; |
| |
| if (traceCurrentRuleName != NULL) { |
| if (prevValue <= 0 && traceOptionValue > 0) { |
| /* MR23 */ printMessage(stderr,"trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth); |
| }; |
| if (prevValue > 0 && traceOptionValue <= 0) { |
| /* MR23 */ printMessage(stderr,"trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth); |
| }; |
| }; |
| |
| return prevValue; |
| } |
| |
| int ANTLRParser::traceGuessOption(int delta) { |
| |
| int prevValue=traceGuessOptionValue; |
| |
| traceGuessOptionValue=traceGuessOptionValue+delta; |
| |
| if (traceCurrentRuleName != NULL) { |
| if (prevValue <= 0 && traceGuessOptionValue > 0) { |
| /* MR23 */ printMessage(stderr,"guess trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth); |
| }; |
| if (prevValue > 0 && traceGuessOptionValue <= 0) { |
| /* MR23 */ printMessage(stderr,"guess trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth); |
| }; |
| }; |
| return prevValue; |
| } |
| |
| // MR19 V.H. Simonis Defer Fetch feature |
| |
| void ANTLRParser::undeferFetch() |
| { |
| |
| #ifdef ZZDEFER_FETCH |
| if (stillToFetch) { |
| for (int stillToFetch_x = 0; stillToFetch_x < stillToFetch; ++stillToFetch_x) { |
| NLA = inputTokens->getToken()->getType(); |
| dirty--; |
| lap = (lap+1)&(LLk-1); |
| } |
| stillToFetch = 0; |
| } |
| #else |
| return; |
| #endif |
| |
| } |
| |
| int ANTLRParser::isDeferFetchEnabled() |
| { |
| #ifdef ZZDEFER_FETCH |
| return 1; |
| #else |
| return 0; |
| #endif |
| } |
| |
| //MR23 |
| int ANTLRParser::printMessage(FILE* pFile, const char* pFormat, ...) |
| { |
| va_list marker; |
| va_start( marker, pFormat ); |
| int iRet = printMessageV(pFile, pFormat, marker); |
| va_end( marker ); |
| return iRet; |
| } |
| |
| int ANTLRParser::printMessageV(FILE* pFile, const char* pFormat, va_list arglist) // MR23 |
| { |
| return vfprintf(pFile, pFormat, arglist); |
| } |
| |
| // MR23 Move semantic predicate error handling from macro to virtual function |
| // |
| // Called by the zzfailed_pred |
| |
| void ANTLRParser::failedSemanticPredicate(const char* predicate) |
| { |
| printMessage(stdout,"line %d: semantic error; failed predicate: '%s'\n", |
| LT(1)->getLine(), predicate); |
| } |
