开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
AParser.cpp
资源名称：pccts133.zip　[点击查看]
上传用户：itx_2006
上传日期：2007-01-06
资源大小：493k
文件大小：20k
源码类别：

编译器/解释器

开发平台：

Others

AParser.cpp：源码内容
  1. /* ANTLRParser.C
  2.  *
  3.  * SOFTWARE RIGHTS
  4.  *
  5.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  6.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  7.  * company may do whatever they wish with source code distributed with
  8.  * PCCTS or the code generated by PCCTS, including the incorporation of
  9.  * PCCTS, or its output, into commerical software.
  10.  *
  11.  * We encourage users to develop software with PCCTS.  However, we do ask
  12.  * that credit is given to us for developing PCCTS.  By "credit",
  13.  * we mean that if you incorporate our source code into one of your
  14.  * programs (commercial product, research project, or otherwise) that you
  15.  * acknowledge this fact somewhere in the documentation, research report,
  16.  * etc...  If you like PCCTS and have developed a nice tool with the
  17.  * output, please mention that you developed it using PCCTS.  In
  18.  * addition, we ask that this header remain intact in our source code.
  19.  * As long as these guidelines are kept, we expect to continue enhancing
  20.  * this system and expect to make other tools available as they are
  21.  * completed.
  22.  *
  23.  * ANTLR 1.33
  24.  * Terence Parr
  25.  * Parr Research Corporation
  26.  * with Purdue University and AHPCRC, University of Minnesota
  27.  * 1989-1998
  28.  */
  30. #include "pcctscfg.h"
  32. #include PCCTS_STDLIB_H
  33. #include PCCTS_STDARG_H
  34. #include PCCTS_STRING_H
  35. #include PCCTS_STDIO_H
  37. PCCTS_NAMESPACE_STD
  39. /* I have to put this here due to C++ limitation
  40.  * that you can't have a 'forward' decl for enums.
  41.  * I hate C++!!!!!!!!!!!!!!!
  42.  * Of course, if I could use real templates, this would go away.
  43.  */
  44. // MR1
  45. // MR1  10-Apr-97  133MR1  Prevent use of varying sizes for the
  46. // MR1   ANTLRTokenType enum
  47. // MR1
  49. enum ANTLRTokenType { TER_HATES_CPP=0, ITS_TOO_COMPLICATED=9999};     // MR1
  51. #define ANTLR_SUPPORT_CODE
  53. #include ATOKEN_H
  54. #include ATOKENBUFFER_H
  55. #include APARSER_H
  57. static const int zzINF_DEF_TOKEN_BUFFER_SIZE = 2000;    /* MR14 */
  58. static const int zzINF_BUFFER_TOKEN_CHUNK_SIZE = 1000;  /* MR14 */
  60.                  /* L o o k a h e a d  M a c r o s */
  62. /* maximum of 32 bits/unsigned int and must be 8 bits/byte;
  63.  * we only use 8 bits of it.
  64.  */
  65. SetWordType ANTLRParser::bitmask[sizeof(SetWordType)*8] = {
  66. 0x00000001, 0x00000002, 0x00000004, 0x00000008,
  67. 0x00000010, 0x00000020, 0x00000040, 0x00000080
  68. };
  70. char ANTLRParser::eMsgBuffer[500] = "";
  72. ANTLRParser::
  73. ~ANTLRParser()
  74. {
  75. delete [] token_type;
  76. }
  78. ANTLRParser::
  79. ANTLRParser(ANTLRTokenBuffer *_inputTokens,
  80. int k,
  81. int use_inf_look,
  82. int dlook,
  83. int ssize)
  84. {
  85. LLk = k;
  86. can_use_inf_look = use_inf_look;
  87. /* MR14 */    if (dlook != 0) {
  88. /* MR14 */      panic("ANTLRParser::ANTLRParser - Demand lookahead not supported in C++ mode");
  89. /* MR14 */
  90. /* MR14 */    };
  91.     demand_look = 0;    /* demand_look = dlook; */
  92.     bsetsize = ssize;
  93. guessing = 0;
  94. token_tbl = NULL;
  95. eofToken = (ANTLRTokenType)1;
  97. // allocate lookahead buffer
  98. token_type = new ANTLRTokenType[LLk];
  99. lap = 0;
  100. labase = 0;
  101. dirty = 0;
  102.     inf_labase = 0;                                                     // MR7
  103.     inf_last = 0;                                                       // MR7
  104. /* prime lookahead buffer, point to inputTokens */
  105. this->inputTokens = _inputTokens;
  106. this->inputTokens->setMinTokens(k);
  107. _inputTokens->setParser(this);                     // MR1
  108.     resynchConsumed=1;                                                  // MR8
  109.     zzFAILtext=NULL;                                                    // MR9
  110.     traceOptionValueDefault=0;                                          // MR10
  111.     traceReset();                                                       // MR10
  112.     zzGuessSeq=0;                                                       // MR10
  113.     syntaxErrCount=0;                                                   // MR11
  114. }
  116. void ANTLRParser::init()
  117. {
  118.    prime_lookahead();
  119.    resynchConsumed=1;                                                   // MR8
  120.    traceReset();                                                        // MR10
  121. }
  123. void ANTLRParser::traceReset()
  124. {
  125.    traceOptionValue=traceOptionValueDefault;
  126.    traceGuessOptionValue=1;
  127.    traceCurrentRuleName=NULL;
  128.    traceDepth=0;
  129. }
  131. int ANTLRParser::
  132. guess(ANTLRParserState *st)
  133. {
  134. saveState(st);
  135. guessing = 1;
  136. return setjmp(guess_start.state);
  137. }
  139. void ANTLRParser::
  140. saveState(ANTLRParserState *buf)
  141. {
  142. buf->guess_start = guess_start;
  143. buf->guessing = guessing;
  144. buf->inf_labase = inf_labase;
  145. buf->inf_last = inf_last;
  146. buf->dirty = dirty;
  147.     buf->traceOptionValue=traceOptionValue;            /* MR10 */
  148.     buf->traceGuessOptionValue=traceGuessOptionValue;  /* MR10 */
  149.     buf->traceCurrentRuleName=traceCurrentRuleName;    /* MR10 */
  150.     buf->traceDepth=traceDepth;                        /* MR10 */
  151. }
  153. void ANTLRParser::
  154. restoreState(ANTLRParserState *buf)
  155. {
  156. int     i;
  157.     int     prevTraceOptionValue;
  159. guess_start = buf->guess_start;
  160. guessing = buf->guessing;
  161. inf_labase = buf->inf_labase;
  162. inf_last = buf->inf_last;
  163. dirty = buf->dirty;
  165. // restore lookahead buffer from k tokens before restored TokenBuffer position
  166. // if demand_look, then I guess we don't look backwards for these tokens.
  167. for (i=1; i<=LLk; i++) token_type[i-1] =
  168. inputTokens->bufferedToken(i-LLk)->getType();
  169. lap = 0;
  170. labase = 0;
  172.     /* MR10 */
  174.     prevTraceOptionValue=traceOptionValue;
  175.     traceOptionValue=buf->traceOptionValue;
  176.     if ( (prevTraceOptionValue > 0) !=
  177.              (traceOptionValue > 0)) {
  178.       if (traceOptionValue > 0) {
  179.         fprintf(stderr,"trace enable restored in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  180.       };
  181.       if (traceOptionValue <= 0) {
  182.         fprintf(stderr,"trace disable restored in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  183.       };
  184.     };
  185.     traceGuessOptionValue=buf->traceGuessOptionValue;
  186.     traceCurrentRuleName=buf->traceCurrentRuleName;
  187.     traceDepth=buf->traceDepth;
  188.     traceGuessDone(buf);
  189. }
  191. /* Get the next symbol from the input stream; put it into lookahead buffer;
  192.  * fill token_type[] fast reference cache also.  NLA is the next place where
  193.  * a lookahead ANTLRAbstractToken should go.
  194.  */
  195. void ANTLRParser::
  196. consume()
  197. {
  199. #ifdef ZZDEBUG_CONSUME_ACTION
  200.     zzdebug_consume_action();
  201. #endif
  203.     NLA = inputTokens->getToken()->getType();
  204. dirty--;
  205. lap = (lap+1)&(LLk-1);
  206. }
  208. _ANTLRTokenPtr ANTLRParser::
  209. LT(int i)
  210. {
  211. #ifdef DEBUG_TOKENBUFFER
  212. if ( i >= inputTokens->bufferSize() || inputTokens->minTokens() <= LLk )
  213. {
  214. static char buf[2000];
  215.         sprintf(buf, "The minimum number of tokens you requested that thenANTLRTokenBuffer buffer is not enough to satisfy yournLT(%d) request; increase 'k' argument to constructor for ANTLRTokenBuffern", i);
  216. panic(buf);
  217. }
  218. #endif
  219. return inputTokens->bufferedToken(i-LLk);
  220. }
  222. void
  223. ANTLRParser::
  224. look(int k)
  225. {
  226. int i, c = k - (LLk-dirty);
  227. for (i=1; i<=c; i++) consume();
  228. }
  230. /* fill the lookahead buffer up with k symbols (even if DEMAND_LOOK);
  231.  */
  232. void
  233. ANTLRParser::
  234. prime_lookahead()
  235. {
  236. int i;
  237. for(i=1;i<=LLk; i++) consume();
  238. dirty=0;
  239. // lap = 0;     // MR14 Sinan Karasu (sinan.karasu@boeing.com)
  240. // labase = 0;  // MR14
  241.     labase=lap;     // MR14
  242. }
  244. /* check to see if the current input symbol matches '_t'.
  245.  * During NON demand lookahead mode, dirty will always be 0 and
  246.  * hence the extra code for consuming tokens in _match is never
  247.  * executed; the same routine can be used for both modes.
  248.  */
  249. int ANTLRParser::
  250. _match(ANTLRTokenType _t, ANTLRChar **MissText,
  251.    ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,
  252.    SetWordType **MissSet)
  253. {
  254. if ( dirty==LLk ) {
  255. consume();
  256. }
  257. if ( LA(1)!=_t ) {
  258. *MissText=NULL;
  259. *MissTok= _t; *BadTok = LT(1);
  260. *MissSet=NULL;
  261. return 0;
  262. }
  263. dirty++;
  264. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  265. return 1;
  266. }
  268. /* check to see if the current input symbol matches '_t'.
  269.  * Used during exception handling.
  270.  */
  271. int ANTLRParser::
  272. _match_wsig(ANTLRTokenType _t)
  273. {
  274. if ( dirty==LLk ) {
  275. consume();
  276. }
  277. if ( LA(1)!=_t ) return 0;
  278. dirty++;
  279. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  280. return 1;
  281. }
  283. /* check to see if the current input symbol matches any token in a set.
  284.  * During NON demand lookahead mode, dirty will always be 0 and
  285.  * hence the extra code for consuming tokens in _match is never
  286.  * executed; the same routine can be used for both modes.
  287.  */
  288. int ANTLRParser::
  289. _setmatch(SetWordType *tset, ANTLRChar **MissText,
  290.    ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,
  291.    SetWordType **MissSet)
  292. {
  293. if ( dirty==LLk ) {
  294. consume();
  295. }
  296. if ( !set_el(LA(1), tset) ) {
  297. *MissText=NULL;
  298. *MissTok= (ANTLRTokenType)0; *BadTok=LT(1);
  299. *MissSet=tset;
  300. return 0;
  301. }
  302. dirty++;
  303. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  304. return 1;
  305. }
  307. int ANTLRParser::
  308. _setmatch_wsig(SetWordType *tset)
  309. {
  310. if ( dirty==LLk ) {
  311. consume();
  312. }
  313. if ( !set_el(LA(1), tset) ) return 0;
  314. dirty++;
  315. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  316. return 1;
  317. }
  319.                    /* Exception handling routines */
  320. //
  321. //  7-Apr-97 133MR1
  322. //         Change suggested by Eli Sternheim (eli@interhdl.com)
  323. //
  324. void ANTLRParser::
  325. consumeUntil(SetWordType *st)
  326. {
  327. ANTLRTokenType tmp;                          // MR1
  328. const int Eof=1;                                          // MR1
  329. while ( !set_el( (tmp=LA(1)), st) && tmp!=Eof) { consume(); }       // MR1
  330. }
  332. //
  333. //  7-Apr-97 133MR1
  334. //         Change suggested by Eli Sternheim (eli@interhdl.com)
  335. //
  336. void ANTLRParser::
  337. consumeUntilToken(int t)
  338. {
  339. int tmp;                                                            // MR1
  340. const int Eof=1;                                                  // MR1
  341. while ( (tmp=LA(1)) !=t && tmp!=Eof) { consume(); }                 // MR1
  342. }
  345.                         /* Old error stuff */
  347. void ANTLRParser::
  348. resynch(SetWordType *wd,SetWordType mask)
  349. {
  351. /* MR8              S.Bochnak@microtool.com.pl                          */
  352. /* MR8              Change file scope static "consumed" to instance var */
  354. /* if you enter here without having consumed a token from last resynch
  355.  * force a token consumption.
  356.  */
  357. /* MR8 */   if ( !resynchConsumed ) {consume(); resynchConsumed=1; return;}
  359.     /* if current token is in resynch set, we've got what we wanted */
  361. /* MR8 */   if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;}
  363.     /* scan until we find something in the resynch set */
  365.          while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();}
  367. /* MR8 */ resynchConsumed=1;
  368. }
  370. /* standard error reporting function that assumes DLG-based scanners;
  371.  * you should redefine in subclass to change it or if you use your
  372.  * own scanner.
  373.  */
  374. void ANTLRParser::
  375. syn(_ANTLRTokenPtr tok, ANTLRChar *egroup, SetWordType *eset,
  376. ANTLRTokenType etok, int k)
  377. {
  378. int line;
  380. line = LT(1)->getLine();
  382.     syntaxErrCount++;                                   /* MR11 */
  383. fprintf(stderr, "line %d: syntax error at "%s"",
  384. line, LT(1)->getText());
  385. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  386. if ( k==1 ) fprintf(stderr, " missing");
  387. else
  388. {
  389. fprintf(stderr, "; "%s" not", LT(1)->getText());
  390. if ( set_deg(eset)>1 ) fprintf(stderr, " in");
  391. }
  392. if ( set_deg(eset)>0 ) edecode(eset);
  393. else fprintf(stderr, " %s", token_tbl[etok]);
  394. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  395. fprintf(stderr, "n");
  396. }
  398. /* is b an element of set p? */
  399. int ANTLRParser::
  400. set_el(ANTLRTokenType b, SetWordType *p)
  401. {
  402. return( p[DIVWORD(b)] & bitmask[MODWORD(b)] );
  403. }
  405. int ANTLRParser::
  406. set_deg(SetWordType *a)
  407. {
  408. /* Fast compute degree of a set... the number
  409.    of elements present in the set.  Assumes
  410.    that all word bits are used in the set
  411. */
  412. register SetWordType *p = a;
  413. register SetWordType *endp = &(a[bsetsize]);
  414. register int degree = 0;
  416. if ( a == NULL ) return 0;
  417. while ( p < endp )
  418. {
  419. register SetWordType t = *p;
  420. register SetWordType *b = &(bitmask[0]);
  421. do {
  422. if (t & *b) ++degree;
  423. } while (++b < &(bitmask[sizeof(SetWordType)*8]));
  424. p++;
  425. }
  427. return(degree);
  428. }
  430. void ANTLRParser::
  431. edecode(SetWordType *a)
  432. {
  433. register SetWordType *p = a;
  434. register SetWordType *endp = &(p[bsetsize]);
  435. register unsigned e = 0;
  437. if ( set_deg(a)>1 ) fprintf(stderr, " {");
  438. do {
  439. register SetWordType t = *p;
  440. register SetWordType *b = &(bitmask[0]);
  441. do {
  442. if ( t & *b ) fprintf(stderr, " %s", token_tbl[e]);
  443. e++;
  444. } while (++b < &(bitmask[sizeof(SetWordType)*8]));
  445. } while (++p < endp);
  446. if ( set_deg(a)>1 ) fprintf(stderr, " }");
  447. }
  449. /* input looks like:
  450.  *      zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk)
  451.  * where the zzMiss stuff is set here to the token that did not match
  452.  * (and which set wasn't it a member of).
  453.  */
  455. // MR9 29-Sep-97    Stan Bochnak (S.Bochnak@microTool.com.pl)
  456. // MR9              Original fix to static allocated text didn't
  457. // MR9                work because a pointer to it was passed back
  458. // MR9                to caller.  Replace with instance variable.
  460. const int   SETWORDCOUNT=20;
  462. void
  463. ANTLRParser::FAIL(int k, ...)
  464. {
  465. //
  466. //  MR1 10-Apr-97
  467. //
  469.     if (zzFAILtext == NULL) zzFAILtext=new char [1000];          // MR9
  470.     SetWordType **f=new SetWordType *[SETWORDCOUNT];             // MR1 // MR9
  471.     SetWordType **miss_set;
  472.     ANTLRChar **miss_text;
  473.     _ANTLRTokenPtr *bad_tok;
  474.     ANTLRChar **bad_text;
  475. //
  476. //  7-Apr-97 133MR1
  477. //   err_k is passed as a "int *", not "unsigned *"
  478. //
  479.     int *err_k;                                                         // MR1
  480.     int i;
  481.     va_list ap;
  483.     va_start(ap, k);
  485.     zzFAILtext[0] = '';
  486. if ( k > SETWORDCOUNT ) panic("FAIL: overflowed buffer");
  487.     for (i=1; i<=k; i++)    /* collect all lookahead sets */
  488.     {
  489.         f[i-1] = va_arg(ap, SetWordType *);
  490.     }
  491.     for (i=1; i<=k; i++)    /* look for offending token */
  492.     {
  493.         if ( i>1 ) strcat(zzFAILtext, " ");
  494.         strcat(zzFAILtext, LT(i)->getText());
  495.         if ( !set_el(LA(i), f[i-1]) ) break;
  496.     }
  497.     miss_set = va_arg(ap, SetWordType **);
  498.     miss_text = va_arg(ap, ANTLRChar **);
  499.     bad_tok = va_arg(ap, _ANTLRTokenPtr *);
  500.     bad_text = va_arg(ap, ANTLRChar **);
  501.     err_k = va_arg(ap, int *);                       // MR1
  502.     if ( i>k )
  503.     {
  504.         /* bad; lookahead is permutation that cannot be matched,
  505.          * but, the ith token of lookahead is valid at the ith position
  506.          * (The old LL sub 1 (k) versus LL(k) parsing technique)
  507.          */
  508.         *miss_set = NULL;
  509.         *miss_text = LT(1)->getText();
  510.         *bad_tok = LT(1);
  511.         *bad_text = (*bad_tok)->getText();
  512.         *err_k = k;
  513. //
  514. //  MR4 20-May-97 erroneously deleted contents of f[]
  515. //  MR4         reported by Bruce Guenter (bruceg@qcc.sk.ca)
  516. //  MR1 10-Apr-97 release temporary storage
  517. //
  518.       delete [] f;                                                      // MR1
  519.       return;                                                           // MR1
  520.     }
  521. /*  fprintf(stderr, "%s not in %dth setn", zztokens[LA(i)], i);*/
  522.     *miss_set = f[i-1];
  523.     *miss_text = zzFAILtext;
  524.     *bad_tok = LT(i);
  525.     *bad_text = (*bad_tok)->getText();
  526.     if ( i==1 ) *err_k = 1;
  527.     else *err_k = k;
  528. //
  529. //  MR4 20-May-97 erroneously deleted contents of f[]
  530. //  MR4       reported by Bruce Guenter (bruceg@qcc.sk.ca)
  531. //  MR1 10-Apr-97 release temporary storage
  532. //
  533.     delete [] f;                                                        // MR1
  534.     return;                                                             // MR1
  535. }
  537. int ANTLRParser::
  538. _match_wdfltsig(ANTLRTokenType tokenWanted, SetWordType *whatFollows)
  539. {
  540. if ( dirty==LLk ) consume();
  542. if ( LA(1)!=tokenWanted )
  543. {
  544.         syntaxErrCount++;                                   /* MR11 */
  545. fprintf(stderr,
  546. "line %d: syntax error at "%s" missing %sn",
  547. LT(1)->getLine(),
  548. (LA(1)==eofToken)?"<eof>":LT(1)->getText(),
  549. token_tbl[tokenWanted]);
  550. consumeUntil( whatFollows );
  551. return 0;
  552. }
  553. else {
  554. dirty++;
  555. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  556. /* if ( !demand_look ) consume(); */
  557. return 1;
  558. }
  559. }
  562. int ANTLRParser::
  563. _setmatch_wdfltsig(SetWordType *tokensWanted,
  564. ANTLRTokenType tokenTypeOfSet,
  565. SetWordType *whatFollows)
  566. {
  567. if ( dirty==LLk ) consume();
  568. if ( !set_el(LA(1), tokensWanted) )
  569. {
  570.         syntaxErrCount++;                                   /* MR11 */
  571. fprintf(stderr,
  572. "line %d: syntax error at "%s" missing %sn",
  573. LT(1)->getLine(),
  574. (LA(1)==eofToken)?"<eof>":LT(1)->getText(),
  575. token_tbl[tokenTypeOfSet]);
  576. consumeUntil( whatFollows );
  577. return 0;
  578. }
  579. else {
  580. dirty++;
  581. labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
  582. /* if ( !demand_look ) consume(); */
  583. return 1;
  584. }
  585. }
  587. char *ANTLRParser::
  588. eMsgd(char *err,int d)
  589. {
  590. sprintf(eMsgBuffer, err, d); // dangerous, but I don't care
  591. return eMsgBuffer;
  592. }
  594. char *ANTLRParser::
  595. eMsg(char *err, char *s)
  596. {
  597. sprintf(eMsgBuffer, err, s);
  598. return eMsgBuffer;
  599. }
  601. char *ANTLRParser::
  602. eMsg2(char *err,char *s, char *t)
  603. {
  604. sprintf(eMsgBuffer, err, s, t);
  605. return eMsgBuffer;
  606. }
  608. void ANTLRParser::
  609. panic(char *msg)
  610. {
  611. fprintf(stderr, "ANTLR panic: %sn", msg);
  612. exit(PCCTS_EXIT_FAILURE);           // MR1
  613. }
  615. const ANTLRChar *ANTLRParser::          // MR1
  616. parserTokenName(int tok) {              // MR1
  617. return token_tbl[tok];              // MR1
  618. }                                       // MR1
  620. void ANTLRParser::traceGuessDone(const ANTLRParserState *state) {
  622.   int   doIt=0;
  624.   if (traceCurrentRuleName == NULL) return;
  626.   if (traceOptionValue <= 0) {
  627.     doIt=0;
  628.   } else if (traceGuessOptionValue <= 0) {
  629.     doIt=0;
  630.   } else {
  631.     doIt=1;
  632.   };
  634.   if (doIt) {
  635.     fprintf(stderr,"guess done - returning to rule %s {"%s"} at depth %d",
  636.         state->traceCurrentRuleName,
  637.         LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
  638.         state->traceDepth);
  639.     if (state->guessing != 0) {
  640.       fprintf(stderr," (guess mode continues - an enclosing guess is still active)");
  641.     } else {
  642.       fprintf(stderr," (guess mode ends)");
  643.     };
  644.     fprintf(stderr,"n");
  645.   };
  646. }
  648. void ANTLRParser::traceGuessFail() {
  650.   int   doIt=0;
  652.   if (traceOptionValue <= 0) {
  653.     doIt=0;
  654.   } else if (guessing && traceGuessOptionValue <= 0) {
  655.     doIt=0;
  656.   } else {
  657.     doIt=1;
  658.   };
  660.   if (doIt) {
  661.     fprintf(stderr,"guess failedn");
  662.   };
  663. }
  665. /* traceOption:
  666.      zero value turns off trace
  667. */
  669. void ANTLRParser::tracein(const ANTLRChar * rule) {
  671.   int       doIt=0;
  673.   traceDepth++;
  674.   traceCurrentRuleName=rule;
  676.   if (traceOptionValue <= 0) {
  677.     doIt=0;
  678.   } else if (guessing && traceGuessOptionValue <= 0) {
  679.     doIt=0;
  680.   } else {
  681.     doIt=1;
  682.   };
  684.   if (doIt) {
  685.     fprintf(stderr,"enter rule %s {"%s"} depth %d",
  686.             rule,
  687.             LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
  688.             traceDepth);
  689.     if (guessing) fprintf(stderr," guessing");
  690.     fprintf(stderr,"n");
  691.   };
  692.   return;
  693. }
  695. void ANTLRParser::traceout(const ANTLRChar * rule) {
  697.   int       doIt=0;
  699.   traceDepth--;
  701.   if (traceOptionValue <= 0) {
  702.     doIt=0;
  703.   } else if (guessing && traceGuessOptionValue <= 0) {
  704.     doIt=0;
  705.   } else {
  706.     doIt=1;
  707.   };
  709.   if (doIt) {
  710.     fprintf(stderr,"exit rule %s {"%s"} depth %d",
  711.             rule,
  712.             LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
  713.             traceDepth+1);
  714.     if (guessing) fprintf(stderr," guessing");
  715.     fprintf(stderr,"n");
  716.   };
  717. }
  719. int ANTLRParser::traceOption(int delta) {
  721.     int     prevValue=traceOptionValue;
  723.     traceOptionValue=traceOptionValue+delta;
  725.     if (traceCurrentRuleName != NULL) {
  726.       if (prevValue <= 0 && traceOptionValue > 0) {
  727.         fprintf(stderr,"trace enabled in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  728.       };
  729.       if (prevValue > 0 && traceOptionValue <= 0) {
  730.         fprintf(stderr,"trace disabled in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  731.       };
  732.     };
  734.     return  prevValue;
  735. }
  737. int ANTLRParser::traceGuessOption(int delta) {
  739.     int     prevValue=traceGuessOptionValue;
  741.     traceGuessOptionValue=traceGuessOptionValue+delta;
  743.     if (traceCurrentRuleName != NULL) {
  744.       if (prevValue <= 0 && traceGuessOptionValue > 0) {
  745.         fprintf(stderr,"guess trace enabled in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  746.       };
  747.       if (prevValue > 0 && traceGuessOptionValue <= 0) {
  748.         fprintf(stderr,"guess trace disabled in rule %s depth %dn",traceCurrentRuleName,traceDepth);
  749.       };
  750.     };
  751.     return prevValue;
  752. }