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

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

编译器/解释器

开发平台：

Others

gen.c：源码内容
  1. /*
  2.  * gen.c
  3.  *
  4.  * Generate C code (ANSI, K&R, C++)
  5.  *
  6.  * SOFTWARE RIGHTS
  7.  *
  8.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  9.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  10.  * company may do whatever they wish with source code distributed with
  11.  * PCCTS or the code generated by PCCTS, including the incorporation of
  12.  * PCCTS, or its output, into commerical software.
  13.  *
  14.  * We encourage users to develop software with PCCTS.  However, we do ask
  15.  * that credit is given to us for developing PCCTS.  By "credit",
  16.  * we mean that if you incorporate our source code into one of your
  17.  * programs (commercial product, research project, or otherwise) that you
  18.  * acknowledge this fact somewhere in the documentation, research report,
  19.  * etc...  If you like PCCTS and have developed a nice tool with the
  20.  * output, please mention that you developed it using PCCTS.  In
  21.  * addition, we ask that this header remain intact in our source code.
  22.  * As long as these guidelines are kept, we expect to continue enhancing
  23.  * this system and expect to make other tools available as they are
  24.  * completed.
  25.  *
  26.  * ANTLR 1.33
  27.  * Terence Parr
  28.  * Parr Research Corporation
  29.  * with Purdue University and AHPCRC, University of Minnesota
  30.  * 1989-1998
  31.  */
  33. #include <stdio.h>
  34. #include <ctype.h>
  35. #include "set.h"
  36. #include "syn.h"
  37. #include "hash.h"
  38. #include "generic.h"
  39. #include "dlgdef.h"
  41. #define NumExprPerLine 4
  42. static int on1line=0;
  43. static set tokensRefdInBlock;
  45. extern char *PRED_AND_LIST;
  46. extern char *PRED_OR_LIST;
  49. /* T r a n s l a t i o n  T a b l e s */
  51. /* C_Trans[node type] == pointer to function that knows how to translate that node. */
  52. #ifdef __cplusplus
  53. void (*C_Trans[NumNodeTypes+1])(...) = {
  54. NULL,
  55. NULL, /* See next table.
  56. Junctions have many types */
  57. (void (*)(...)) genRuleRef,
  58. (void (*)(...)) genToken,
  59. (void (*)(...)) genAction
  60.  };
  61. #else
  62. void (*C_Trans[NumNodeTypes+1])() = {
  63. NULL,
  64. NULL, /* See next table.
  65. Junctions have many types */
  66. genRuleRef,
  67. genToken,
  68. genAction
  69.  };
  70. #endif
  72. /* C_JTrans[Junction type] == pointer to function that knows how to translate that
  73.  * kind of junction node.
  74.  */
  75. #ifdef __cplusplus
  76. void (*C_JTrans[NumJuncTypes+1])(...) = {
  77. NULL,
  78. (void (*)(...)) genSubBlk,
  79. (void (*)(...)) genOptBlk,
  80. (void (*)(...)) genLoopBlk,
  81. (void (*)(...)) genEndBlk,
  82. (void (*)(...)) genRule,
  83. (void (*)(...)) genJunction,
  84. (void (*)(...)) genEndRule,
  85. (void (*)(...)) genPlusBlk,
  86. (void (*)(...)) genLoopBegin
  87.  };
  88. #else
  89. void (*C_JTrans[NumJuncTypes+1])() = {
  90. NULL,
  91. genSubBlk,
  92. genOptBlk,
  93. genLoopBlk,
  94. genEndBlk,
  95. genRule,
  96. genJunction,
  97. genEndRule,
  98. genPlusBlk,
  99. genLoopBegin
  100.  };
  101. #endif
  103. #define PastWhiteSpace(s) while (*(s) == ' ' || *(s) == 't') {s++;}
  105. static int tabs = 0;
  107. /* MR6 Got tired of text running off page when using standard tab stops */
  109. #define TAB { int i;                  
  110.       if (TabWidth==0) {                  
  111.          for (i=0; i<tabs; i++) fputc('t', output);
  112.       } else {           
  113.  for (i=0; i<tabs*TabWidth; i++) fputc(' ',output);     
  114.       };                 
  115.     }
  117. static void
  118. #ifdef __USE_PROTOS
  119. tab( void )
  120. #else
  121. tab( )
  122. #endif
  123. TAB
  125. #ifdef __USE_PROTOS
  126. static char *tokenFollowSet(TokNode *);
  127. static ActionNode *findImmedAction( Node * );
  128. static void dumpRetValAssign(char *, char *);
  129. static void dumpAfterActions(FILE *output);
  130. static set ComputeErrorSet(Junction *, int);
  131. static void makeErrorClause(Junction *, set, int);
  132. static void DumpFuncHeader( Junction *, RuleEntry * );
  133. static int has_guess_block_as_first_item(Junction *);
  134. static int genExprSets(set *, int);
  135. static void genExprTree( Tree *t, int k );
  136. static void genExprTreeOriginal( Tree *t, int k );                  /* MR10 */
  137. static char * findOuterHandlerLabel(ExceptionGroup *eg);            /* MR7 */
  138. static void OutLineInfo(FILE *file,int line,char *fileName);        /* MR14 */
  139. #else
  140. static char *tokenFollowSet();
  141. static ActionNode *findImmedAction();
  142. static void dumpRetValAssign();
  143. static void dumpAfterActions();
  144. static set ComputeErrorSet();
  145. static void makeErrorClause();
  146. static void DumpFuncHeader();
  147. static int has_guess_block_as_first_item();
  148. static int genExprSets();
  149. static void genExprTree();
  150. static void genExprTreeOriginal();                                  /* MR10 */
  151. static char * findOuterHandlerLabel();                              /* MR7 */
  152. static void OutLineInfo();                                          /* MR14 */
  153. #endif
  155. #define gen(s) {tab(); fprintf(output, s);}
  156. #define gen1(s,a) {tab(); fprintf(output, s,a);}
  157. #define gen2(s,a,b) {tab(); fprintf(output, s,a,b);}
  158. #define gen3(s,a,b,c) {tab(); fprintf(output, s,a,b,c);}
  159. #define gen4(s,a,b,c,d) {tab(); fprintf(output, s,a,b,c,d);}
  160. #define gen5(s,a,b,c,d,e) {tab(); fprintf(output, s,a,b,c,d,e);}
  161. #define gen6(s,a,b,c,d,e,f) {tab(); fprintf(output, s,a,b,c,d,e,f);}
  162. #define gen7(s,a,b,c,d,e,f,g) {tab(); fprintf(output, s,a,b,c,d,e,f,g);}
  164. #define _gen(s) {fprintf(output, s);}
  165. #define _gen1(s,a) {fprintf(output, s,a);}
  166. #define _gen2(s,a,b) {fprintf(output, s,a,b);}
  167. #define _gen3(s,a,b,c) {fprintf(output, s,a,b,c);}
  168. #define _gen4(s,a,b,c,d){fprintf(output, s,a,b,c,d);}
  169. #define _gen5(s,a,b,c,d,e){fprintf(output, s,a,b,c,d,e);}
  170. #define _gen6(s,a,b,c,d,e,f){fprintf(output, s,a,b,c,d,e,f);}
  171. #define _gen7(s,a,b,c,d,e,f,g){fprintf(output, s,a,b,c,d,e,f,g);}
  174. /* MR11 a convenient place to set a break point */
  176. void MR_break() {
  177.   return;
  178. }
  180. /* MR10 genTraceOut(Junction *)      */
  182. #ifdef __STDC__
  183. static void genTraceOut(Junction *q)
  184. #else
  185. static void genTraceOut(q)
  186.   Junction  *q;
  187. #endif
  188. {
  189.   if ( TraceGen )
  190. if ( GenCC ) {gen1("zzTRACEOUT("%s");n", q->rname);}
  191.      else gen1("zzTRACEOUT((ANTLRChar *)"%s");n", q->rname);
  192. }
  194. static void
  195. #ifdef __USE_PROTOS
  196. warn_about_using_gk_option(void)
  197. #else
  198. warn_about_using_gk_option()
  199. #endif
  200. {
  201. static int warned_already=0;
  203. if ( !DemandLookahead || warned_already ) return;
  204. warned_already = 1;
  205. warnNoFL("-gk option could cause trouble for <<...>>? predicates");
  206. }
  208. void
  209. #ifdef __USE_PROTOS
  210. freeBlkFsets( Junction *q )
  211. #else
  212. freeBlkFsets( q )
  213. Junction *q;
  214. #endif
  215. {
  216. int i;
  217. Junction *alt;
  218. require(q!=NULL, "freeBlkFsets: invalid node");
  220. for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
  221. {
  222. for (i=1; i<=CLL_k; i++) set_free(alt->fset[i]);
  223. }
  224. }
  226. /*
  227.  * Generate a local variable allocation for each token references
  228.  * in this block.
  229.  */
  230. static void
  231. #ifdef __USE_PROTOS
  232. genTokenPointers( Junction *q )
  233. #else
  234. genTokenPointers( q )
  235. Junction *q;
  236. #endif
  237. {
  238. /* Rule refs are counted and can be referenced, but their
  239.  * value is not set to anything useful ever.
  240.  *
  241.      * The ptrs are to be named _tij where i is the current level
  242.  * and j is the element number within an alternative.
  243.  */
  244. int first=1, t=0;
  245. set a;
  246. tokensRefdInBlock = q->tokrefs;
  248. if ( set_deg(q->tokrefs) == 0 ) return;
  249. a = set_dup(q->tokrefs);
  250. gen("ANTLRTokenPtr ");
  251. for (; !set_nil(a); set_rm(t, a))
  252. {
  253. t = set_int(a);
  254. if ( first ) first = 0;
  255. else _gen(",");
  256. if ( !DontCopyTokens ) _gen2("_tv%d%d,", BlkLevel, t);
  257. _gen2("_t%d%d", BlkLevel, t);
  258. if ( !DontCopyTokens ) {_gen2("= &_tv%d%d", BlkLevel, t);}
  259. else _gen("=NULL");
  260. }
  261. _gen(";n");
  262. set_free(a);
  263. }
  265. static int
  266. #ifdef __USE_PROTOS
  267. hasDefaultException(ExceptionGroup *eg)
  268. #else
  269. hasDefaultException(eg)
  270. ExceptionGroup *eg;
  271. #endif
  272. {
  273.     ListNode *q;
  275.     for (q = eg->handlers->next; q!=NULL; q=q->next)
  276.     {
  277.         ExceptionHandler *eh = (ExceptionHandler *)q->elem;
  278.         if ( strcmp("default", eh->signalname)==0 ) {
  279.             return 1;
  280.         }
  281.     }
  282.     return 0;
  283. }
  284. static void
  285. #ifdef __USE_PROTOS
  286. dumpException(ExceptionGroup *eg, int no_default_case)
  287. #else
  288. dumpException(eg, no_default_case)
  289. ExceptionGroup *eg;
  290. int no_default_case;
  291. #endif
  292. {
  293.     char    *outerLabel;                                             /* MR7 */
  294.     int     nullOuterLabel=0;                                        /* MR7 */
  295.     int     altHandler=0;                                            /* MR7 */
  296.     int     ruleHandler=0;                                           /* MR7 */
  297.     int     namedHandler=0;                                          /* MR7 */
  299.     outerLabel=findOuterHandlerLabel(eg);                            /* MR7 */
  301.     if (*outerLabel=='') nullOuterLabel=1;                         /* MR7 */
  303.     if (eg->label != NULL) {                                         /* MR7 */
  304.       namedHandler=1;                                                /* MR7 */
  305.     } else if (eg->forRule) {                                        /* MR7 */
  306.       ruleHandler=1;                                                 /* MR7 */
  307.     } else {                                                         /* MR7 */
  308.       altHandler=1;                                                  /* MR7 */
  309.     };                                                               /* MR7 */
  311. #if 0
  312. **     if (! eg->used) {                                             /* MR7 */
  313. **      warnFL("exception group never used",                         /* MR7 */
  314. **             FileStr[eg->altstart->file],eg->altstart->line);      /* MR7 */
  315. **     };                                                            /* MR7 */
  316. #endif
  318.     if (namedHandler) {                                              /* MR7 */
  319.   gen1("switch ( _signal ) {  /* [%s] */n",eg->label);          /* MR7 */
  320.     } else {                                                         /* MR7 */
  321.   gen("switch ( _signal ) {n");                                 /* MR7 */
  322.       gen("case NoSignal: break;  /* MR7 */n");                     /* MR7 */
  323.     };                                                               /* MR7 */
  324. {
  325. ListNode *q;
  326. for (q = eg->handlers->next; q!=NULL; q=q->next)
  327. {
  328. ExceptionHandler *eh = (ExceptionHandler *)q->elem;
  329. if ( strcmp("default", eh->signalname)==0 ) {
  330. gen("default :n");
  331. tabs++;
  332. dumpAction(eh->action, output, tabs, -1, 1, 1);
  333.                 gen("_signal=NoSignal;  /* MR7 */n");               /* MR7 */
  334.                 gen("break;  /* MR7 */n");                          /* MR7 */
  335. tabs--;
  336. gen("}n");
  338.                 /* copied from later code in dumpException              MR7 */
  340.                 if (namedHandler) {                                  /* MR7 */
  341.                   gen("if (_signal != NoSignal)");                   /* MR7 */
  342.                   _gen1(" goto %s_handler;  /* MR7 */n",outerLabel);/* MR7 */
  343.                 } else if (altHandler) {                             /* MR7 */
  344.                   gen1("goto %s_handler;  /* MR7 */n",outerLabel);  /* MR7 */
  345.                 };
  346. return;
  347. }
  348. gen1("case %s :n", eh->signalname);
  349. tabs++;
  350. if ( eh->action != NULL )
  351. {
  352. dumpAction(eh->action, output, tabs, -1, 1, 1);
  353.                 gen("break;  /* MR7 */n");                          /* MR7 */
  354. }
  355. tabs--;
  356. }
  357. }
  358. if ( no_default_case ) return;
  360. gen("default :n");
  361.     tabs++;                                                         /* MR7 */
  362.     gen("break;  /* MR7 */n");                                     /* MR7 */
  363.     tabs--;                                                         /* MR7 */
  365. tabs++;
  366. /***** gen("*_retsignal = _signal;n"); *****/
  368. tabs--;
  369. gen("}n");
  371.     if (namedHandler) {                                             /* MR7 */
  372.       gen("if (_signal != NoSignal)");                              /* MR7 */
  373.       _gen1(" goto %s_handler;  /* MR7 */n",outerLabel);           /* MR7 */
  374.     } else if (altHandler) {                                        /* MR7 */
  375.       gen1("goto %s_handler;  /* MR7 */n",outerLabel);             /* MR7 */
  376.     };
  378. }
  380. static void
  381. #ifdef __USE_PROTOS
  382. dumpExceptions(ListNode *list)
  383. #else
  384. dumpExceptions(list)
  385. ListNode *list;
  386. #endif
  387. {
  388. ListNode *p;
  390. for (p = list->next; p!=NULL; p=p->next)
  391. {
  392. ExceptionGroup *eg = (ExceptionGroup *) p->elem;
  393. _gen2("%s%s_handler:n",
  394.   eg->label==NULL?"":eg->label,
  395.   eg->altID==NULL?"":eg->altID);
  396. if ( eg->altID!=NULL ) dumpException(eg, 0);
  397. else {
  398. /* This must be the rule exception handler */
  399. dumpException(eg, 1);
  400. if ( !hasDefaultException(eg) )
  401.             {
  402.                 gen("default :n");
  403.                 tabs++;
  404.                 gen("zzdflthandlers(_signal,_retsignal);n");
  405.                 tabs--;
  406.                 gen("}n");
  407.             }
  408. }
  409. }
  410. }
  412. /* For each element label that is found in a rule, generate a unique
  413.  * Attribute (and AST pointer if GenAST) variable.
  414.  */
  415. void
  416. #ifdef __USE_PROTOS
  417. genElementLabels(ListNode *list)
  418. #else
  419. genElementLabels(list)
  420. ListNode *list;
  421. #endif
  422. {
  423. int first=1;
  424. ListNode *p;
  426. if ( GenCC ) {gen("ANTLRTokenPtr");}
  427. else {gen("Attrib");}
  428. for (p = list->next; p!=NULL; p=p->next)
  429. {
  430. char *ep = (char *)p->elem;
  431. if ( first ) first = 0;
  432. else _gen(",");
  433. if ( GenCC ) {_gen1(" %s=NULL",ep);}
  434. else {_gen1(" %s",ep);}
  435. }
  436. _gen(";n");
  438. if ( !GenAST ) return;
  440. first = 1;
  441. gen("AST");
  442. for (p = list->next; p!=NULL; p=p->next)
  443. {
  444. char *ep = (char *)p->elem;
  445. if ( first ) first = 0;
  446. else _gen(",");
  447. _gen1(" *%s_ast=NULL",ep);
  448. }
  449. _gen(";n");
  450. }
  452. /*
  453.  * Generate a local variable allocation for each token or rule reference
  454.  * in this block.
  455.  */
  456. static void
  457. #ifdef __USE_PROTOS
  458. genASTPointers( Junction *q )
  459. #else
  460. genASTPointers( q )
  461. Junction *q;
  462. #endif
  463. {
  464. int first=1, t;
  465. set a;
  467. a = set_or(q->tokrefs, q->rulerefs);
  468. if ( set_deg(a) > 0 )
  469. {
  470. gen("AST ");
  471. for (; !set_nil(a); set_rm(t, a))
  472. {
  473. t = set_int(a);
  474. if ( first ) first = 0;
  475. else _gen(",");
  476. _gen2("*_ast%d%d=NULL", BlkLevel, t);
  477. }
  478. set_free(a);
  479. }
  480. _gen(";n");
  481. }
  483. static void
  484. #ifdef __USE_PROTOS
  485. BLOCK_Head( void )
  486. #else
  487. BLOCK_Head( )
  488. #endif
  489. {
  490. gen("{n");
  491. tabs++;
  492. if ( !GenCC ) gen1("zzBLOCK(zztasp%d);n", BlkLevel);
  493. }
  495. static void
  496. #ifdef __USE_PROTOS
  497. BLOCK_Tail( void )
  498. #else
  499. BLOCK_Tail( )
  500. #endif
  501. {
  502. if ( !GenCC ) gen1("zzEXIT(zztasp%d);n", BlkLevel);
  503. if ( !GenCC ) gen("}n");
  504. tabs--;
  505. gen("}n");
  506. }
  508. static void
  509. #ifdef __USE_PROTOS
  510. BLOCK_Preamble( Junction *q )
  511. #else
  512. BLOCK_Preamble( q )
  513. Junction *q;
  514. #endif
  515. {
  516. ActionNode *a;
  517. Junction *begin;
  519. BLOCK_Head();
  520. if ( GenCC ) genTokenPointers(q);
  521. if ( GenCC&&GenAST ) genASTPointers(q);
  522. if ( q->jtype == aPlusBlk ) gen("int zzcnt=1;n");
  523. if ( q->parm != NULL && !q->predparm ) gen1("zzaPush(%s);n", q->parm)
  524. else if ( !GenCC ) gen("zzMake0;n");
  525. if ( !GenCC ) gen("{n");
  526. if ( q->jtype == aLoopBegin ) begin = (Junction *) ((Junction *)q->p1);
  527. else begin = q;
  528. if ( has_guess_block_as_first_item(begin) )
  529. {
  530. gen("zzGUESS_BLOCKn");
  531. }
  532. if ( q->jtype == aLoopBegin )
  533. a = findImmedAction( ((Junction *)q->p1)->p1 ); /* look at aLoopBlk */
  534. else
  535. a = findImmedAction( q->p1 );
  536. if ( a!=NULL && !a->is_predicate) {
  537. if (!a->noHoist) dumpAction(a->action, output, tabs, a->file, a->line, 1);
  538. a->done = 1; /* remove action. We have already handled it */
  539. }
  540. }
  542. void
  543. #ifdef __USE_PROTOS
  544. genCombinedPredTreeContextOrig( Predicate *p )
  545. #else
  546. genCombinedPredTreeContextOrig( p )
  547. Predicate *p;
  548. #endif
  549. {
  550. static set *ctx=NULL; /* genExprSets() is destructive, make copy*/
  551. require(p!=NULL, "can't make context tree for NULL pred tree");
  553. #ifdef DBG_PRED
  554. fprintf(stderr, "enter genCombinedPredTreeContextOrig(%s,0x%x) with sets:n", p->expr, p);
  555. s_fprT(stderr, p->scontext[1]);
  556. fprintf(stderr, "n");
  557. #endif
  558. if ( p->down == NULL )
  559. {
  560. /*** if ( p->k>1 && p->tcontext!=NULL ) ***/
  561. if ( p->tcontext!=NULL )
  562. {
  563. _gen("(");
  564. genExprTree(p->tcontext, 1);
  565. _gen(")");
  566. }
  567. /*** else if ( p->k==1 && set_deg(p->scontext[1])>0 ) ***/
  568. else if ( set_deg(p->scontext[1])>0 )
  569. {
  570. if ( ctx==NULL ) ctx = (set *)calloc(CLL_k+1, sizeof(set));
  571. require(ctx!=NULL, "ctx cannot allocate");
  572. ctx[0]=empty;
  573. ctx[1]=set_dup(p->scontext[1]);
  574. _gen("(");
  575. genExprSets(&(ctx[0]), p->k);
  576. _gen(")");
  577. set_free(ctx[1]);
  578. }
  579. else if ( p->expr==PRED_AND_LIST || p->expr==PRED_OR_LIST ) {
  580. fatal_internal("pred tree is orphan OR or AND list");
  581. }
  582. else {
  583.             if (! HoistPredicateContext) {
  584.               _gen(" 1 /* no context: prc is off */ ");
  585.             } else {
  586.               fatal_internal("pred tree context is empty");
  587.             };
  588. }
  589. return;
  590. }
  592. /* MR10 - make AND just like OR */
  594. if ( p->expr == PRED_AND_LIST )
  595. {
  596.         Predicate *list = p->down;
  597.         for (; list!=NULL; list=list->right)
  598.         {
  599.            genCombinedPredTreeContextOrig(list);
  600.          if ( list->right!=NULL ) _gen("|| /* MR10 was wrong */ ");
  601.         };
  602. return;
  603. }
  605. if ( p->expr == PRED_OR_LIST )
  606. {
  607.         Predicate *list = p->down;
  608.         for (; list!=NULL; list=list->right)
  609.         {
  610.            genCombinedPredTreeContextOrig(list);
  611.            if ( list->right!=NULL ) _gen("||");
  612.         };
  613.         return;
  614.      };
  616. fatal("pred tree is really wacked");
  617. }
  619. /* [genCombinedPredTreeContext] */
  621. void
  622. #ifdef __USE_PROTOS
  623. genCombinedPredTreeContext( Predicate *p )
  624. #else
  625. genCombinedPredTreeContext( p )
  626. Predicate *p;
  627. #endif
  628. {
  629.   Tree  *t;
  630.   int   predDepth=0;
  632.   if (0 && ! MR_usingPredNames && ! MRhoisting) {
  633.     genCombinedPredTreeContextOrig(p);
  634.   } else {
  635. /* MR13 */    MR_pred_depth(p,&predDepth);
  636. /* MR13 */    if (predDepth == 1) {
  637. /* MR13 */
  638. /* MR13 */      set   scontext[2];
  639. /* MR13 */      scontext[0]=empty;
  640. /* MR13 */      scontext[1]=MR_compute_pred_set(p);
  641. /* MR13 */      if (set_nil(scontext[1])) {
  642. /* MR13 */        _gen(" 1 /* MR12 no context (-prc off) */ ");
  643. /* MR13 */      } else {
  644. /* MR13 */        _gen("(");
  645. /* MR13 */        genExprSets(&scontext[0], 1);
  646. /* MR13 */        set_free(scontext[1]);
  647. /* MR13 */        _gen(")");
  648. /* MR13 */      };
  650.     } else {
  651.       t=MR_compute_pred_tree_context(p);
  652.       if (t == NULL) {
  653.         _gen(" 1 /* MR12 no context (-prc off) */ ");
  654.       } else {
  655.         _gen("(");
  656.         genExprTree(t, 1);
  657.         Tfree(t);   /* MR10 */
  658.         _gen(")");
  659.       };
  660.     };
  661.   };
  662. }
  664. /* [genPredTreeGate] */
  666. void
  667. #ifdef __USE_PROTOS
  668. genPredTreeGate( Predicate *p, int in_and_expr )
  669. #else
  670. genPredTreeGate( p, in_and_expr )
  671. Predicate *p;
  672. int in_and_expr;
  673. #endif
  674. {
  675. if ( in_and_expr )
  676. {
  677. _gen("!(");
  678. genCombinedPredTreeContext(p);
  679. _gen(")||");
  680. if ( p->down!=NULL ) _gen("n");
  681. }
  682. else
  683. {
  684. _gen("(");
  685. genCombinedPredTreeContext(p);
  686. _gen(")&&");
  687. if ( p->down!=NULL ) _gen("n");
  688. }
  689. }
  691. #ifdef __USE_PROTOS
  692. void genPredEntry(Predicate *p,int outer)
  693. #else
  694. void genPredEntry(p,outer)
  695.   Predicate     *p;
  696.   int           outer;
  697. #endif
  698. {
  699.     int         inverted=0;
  700.     Predicate   *q;
  701.     int         localOuter=outer;
  702.     int         needRP=0;
  704.     if (p == NULL) return;
  706.     if (p->predEntry != NULL && p->predEntry->predLiteral != NULL) {
  707.       if (p->inverted != p->predEntry->pred->inverted) {
  708.         _gen("! /* inverted pred */ (");
  709.         needRP=1;
  710.       } else {
  711.         if (!localOuter) _gen("(");
  712.         needRP=1;
  713.       };
  714.       dumpAction(p->predEntry->predLiteral,output,0,p->source->file,p->source->line,0);
  715.       if (needRP) _gen(")");
  716.       return;
  717.     };
  719.     inverted=p->inverted;
  721.     if (inverted) {
  722.       _gen(" ! /* inverted pred */ (");
  723.       localOuter=1;
  724.     };
  726.     if (p->expr == PRED_OR_LIST) {
  727.       if (!localOuter) _gen("(");
  728.       for (q=p->down; q != NULL ; q=q->right) {
  729.         genPredEntry(q,0);
  730.         if (q->right != NULL) _gen(" || ");
  731.       };
  732.       if (!localOuter) _gen(")");
  733.     } else if (p->expr == PRED_AND_LIST) {
  734.       if (!localOuter) _gen("(");
  735.       for (q=p->down; q != NULL ; q=q->right) {
  736.         genPredEntry(q,0);
  737.         if (q->right != NULL) _gen(" && ");
  738.       };
  739.       if (!localOuter) _gen(")");
  740.     } else {
  741.       if (!localOuter) _gen("(");
  742.       require (p->source != NULL,"predEntry->source == NULL");
  743.       require (p->source->inverted == 0,"dumpPredEntry p->source->inverted != 0");
  744.       dumpAction(p->source->action,output,0,p->source->file,p->source->line,0);
  745.       if (!localOuter) _gen(")");
  746.     };
  748.     if (inverted) {
  749.         _gen(")");
  750.     }
  751. }
  753. void
  754. #ifdef __USE_PROTOS
  755. dumpPredAction(ActionNode *anode,
  756.                     char *s,FILE *output,int tabs,int file,int line,int final_newline)
  757. #else
  758. dumpPredAction(anode,
  759.                     s,output,tabs,file,line,final_newline)
  761.     ActionNode  *anode;
  762.     char        *s;
  763.     FILE        *output;
  764.     int         tabs;
  765.     int         file;
  766.     int         line;
  767.     int         final_newline;
  768. #endif
  769. {
  770.     PredEntry   *predEntry=anode->predEntry;
  771.     int         inverted=anode->inverted;
  772.     Predicate   *workPred;
  774.     if (predEntry == NULL) {
  776.       /* inline predicate literal */
  778.       require(inverted == 0,"dumpPredAction action->inverted");
  779.      dumpAction(s,output,tabs,file,line,final_newline);
  781.     } else {
  783.       /* a reference to a predicate - possibly with an inverted source */
  785.       if (predEntry->predLiteral != NULL) {
  786.         if (inverted) _gen("! /* inverted pred */ (");
  787.         dumpAction(predEntry->predLiteral,output,0,anode->file,anode->line,0);
  788.         if (inverted) _gen(")");
  789.       } else {
  790.         workPred=predicate_dup(predEntry->pred);
  791.         if (inverted) workPred->inverted=!workPred->inverted;
  792.         genPredEntry(workPred,1);
  793.         predicate_free(workPred);
  794.       };
  795.     };
  796. }
  798. /* [genPred] */
  800. void
  801. #ifdef __USE_PROTOS
  802. genPred(Predicate *p, Node *j,int suppress_sva)
  803. #else
  804. genPred(p,j,suppress_sva)
  805.     Predicate   *p;
  806.     Node        *j;
  807.     int         suppress_sva;
  808. #endif
  809. {
  810. if ( FoundException && !suppress_sva) {_gen("(_sva=(");}    /* MR11 suppress_sva */
  811. else {_gen("(");}
  812. if ( GenLineInfo && j->file != -1 ) _gen("n");
  813.     if (p->source != NULL && p->source->ampersandPred != NULL) {
  814.       if (p->source->ampersandPred->k == 1) {
  816.             set     ctx[2];
  818. ctx[0]=empty;
  819. ctx[1]=set_dup(p->source->ampersandPred->scontext[1]);
  821. _gen("(");
  822. genExprSets(&(ctx[0]), p->k);
  823. _gen(") && ");
  824. set_free(ctx[1]);
  825.       } else {
  826.         _gen("( ");
  827.         genExprTree(p->source->ampersandPred->tcontext,1);
  828. _gen(" ) && ");
  829.       };
  830.     };
  832.     dumpPredAction((ActionNode *)p->source,
  833.                 p->expr, output, 0, -1 /*indicates no line info*/, j->line, 0);
  835. if ( FoundException && !suppress_sva)   /* MR11 suppress_sva */
  836.          {_gen("),_sva)");}    /* MR10 - get red of "meant ==" messages */
  837. else {_gen(")");}
  838. }
  840. void
  841. #ifdef __USE_PROTOS
  842. MR_distinctORcontextOpt(Predicate *p,Node *j,int in_and_expr)
  843. #else
  844. MR_distinctORcontextOpt(p,j,in_and_expr)
  845.     Predicate   *p;
  846.     Node        *j;
  847.     int         in_and_expr;
  848. #endif
  849. {
  850.     Predicate   *q;
  852.     _gen(" /* MR10 Distinct OR context optimization */ n");
  854.     if (in_and_expr) {
  855.       gen("zzpf=0,n");
  856.       for (q=p->down; q != NULL; q=q->right) {
  857.         gen("(  ");
  858.         genCombinedPredTreeContext(q);
  859.         _gen(" && (zzpf=1, ");
  860.         genPred(q,j,0);
  861.         _gen("  )) ||n");
  862.       };
  863.       gen("!zzpf)");
  864.     } else {
  865.       require (0,
  866.             "MR_distinctORcontextOpt: can't get here when using MR_predSimplify");
  867. #if 0
  868. **      for (q=p->down; q != NULL; q=q->right) {
  869. **        gen("(  ");
  870. **        genCombinedPredTreeContext(q);
  871. **        _gen(" && ");
  872. **        genPred(q,j);
  873. **        if (q->right != NULL) {
  874. **          _gen("  ) ||n");
  875. **        };
  876. **      };
  877. **      gen(")");
  878. #endif
  879.    };
  880. }
  882. void
  883. #ifdef __USE_PROTOS
  884. genPredTreeOrig( Predicate *p, Node *j, int in_and_expr )
  885. #else
  886. genPredTreeOrig( p, j, in_and_expr )
  887. Predicate *p;
  888. Node *j;
  889. int in_and_expr;
  890. #endif
  891. {
  893. /* MR10 */  int     allHaveContext=1;
  894. /* MR10 */  int     noneHaveContext=1;
  896. /* MR10 */  MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
  898. if ( ! noneHaveContext )                  /* MR10 context guards ignored when -prc off */
  899. {
  900. _gen("(");
  901. genPredTreeGate(p, in_and_expr);
  902. }
  904. /* if leaf node, just gen predicate */
  906. if ( p->down==NULL )
  907. {
  908. genPred(p,j,0);
  909. if ( ! noneHaveContext ) _gen(")");   /* MR10 context guards ignored when -prc off */
  910. return;
  911. }
  913. /* if AND list, do both preds (only two possible) */
  914. if ( p->expr == PRED_AND_LIST )
  915. {
  916. #if 0
  917. ** _gen("(");
  918. ** genPredTreeOrig(p->down, j, 1);
  919. ** _gen("&&");
  920. ** genPredTreeOrig(p->down->right, j, 1);
  921. ** _gen(")");
  922. ** if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
  923. ** return;
  924. #endif
  925.         /* MR11 - make it work with AND with more than two children - like OR */
  927. Predicate *list;
  928. _gen("(");
  929. list = p->down;
  930. for (; list!=NULL; list=list->right)
  931. {
  932. genPredTreeOrig(list, j, 1);
  933. if ( list->right!=NULL ) _gen("&&");
  934. }
  935. _gen(")");
  936. if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
  937. return;
  938.     };
  940. if ( p->expr == PRED_OR_LIST )
  941. {
  942. Predicate *list;
  943. _gen("(");
  944. list = p->down;
  945. for (; list!=NULL; list=list->right)
  946. {
  947. genPredTreeOrig(list, j, 0);
  948. if ( list->right!=NULL ) _gen("||");
  949. }
  950. _gen(")");
  951. if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
  952. return;
  953. }
  955. fatal_internal("genPredTreeOrig: predicate tree is wacked");
  956. }
  958. #if 0
  959. **   Predicate member dummyPredDepth is no longer used in MR10
  960. **     but we might need it again in the future
  961. **
  962. **   if (MRhoisting) {
  963. **     if ( !noneHaveContext &&
  964. **          ! in_and_expr &&
  965. **          p->source != NULL &&
  966. **          p->source->dummyPredicateDepth > 0 &&
  967. **          p->down == NULL) {
  968. **  _gen("(");
  969. **  genCombinedPredTreeContext(p);
  970. **  _gen("  )n");
  971. **  return;
  972. **     };
  973. **   };
  974. #endif
  976. /* [genPredTree] */
  978. /* in_and_expr
  980.    what to do if the context is wrong
  981.    what to do if the context is correct but the predicate is false
  983.    remember: if the context is wrong it's the same as if the
  984.              predicate is true as far as enabling an alternative
  986.         Consider (AND p q r)
  988.         if in an ... && ... expression then you don't want
  989.         the entire predicate chain to fail just because the
  990.         context for one component is wrong: so return true
  992.         Consider (OR p q r)
  994.         if in an ... || ... expression then you don't want
  995.         the entire predicate chain to succeed just because
  996.         the context for one component is correct when the
  997.         corresponding test is false: so return false when
  998.         the context is correct but the test is false.
  999. */
  1001. void
  1002. #ifdef __USE_PROTOS
  1003. genPredTree( Predicate *p, Node *j, int in_and_expr, int suppress_sva )
  1004. #else
  1005. genPredTree( p, j, in_and_expr, suppress_sva)
  1006.   Predicate     *p;
  1007.   Node          *j;
  1008.   int           in_and_expr;
  1009.   int           suppress_sva;
  1010. #endif
  1011. {
  1013.     int         allHaveContext=1;
  1014.     int         noneHaveContext=1;
  1015.     Tree        *groupTree;
  1016.     Tree        *oneTree;
  1017.     Predicate   *q;
  1018.     int         identicalORcontextOptimization=0;
  1019.     int         identicalANDcontextOptimization=0;
  1021.     if (0 && !MR_usingPredNames && !MRhoisting) {
  1022.       genPredTreeOrig(p,j,in_and_expr);
  1023.       return;
  1024.     };
  1026.     MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
  1028. if ( ! noneHaveContext ) {                 /* MR10 context guards ignored when -prc off */
  1030.       _gen("(");
  1032.             /* MR10 optimize OR predicates which are all leaves */
  1034.       if (p->expr == PRED_OR_LIST && MR_allPredLeaves(p->down)) {
  1035.         groupTree=MR_compute_pred_tree_context(p);
  1036.         for (q=p->down ; q != NULL ; q=q->right) {
  1037.           oneTree=MR_compute_pred_tree_context(q);
  1038.           if (! MR_tree_equ(groupTree,oneTree)) {
  1039.             Tfree(oneTree);
  1040.             break;
  1041.           };
  1042.           Tfree(oneTree);
  1043.         };
  1044.         Tfree(groupTree);
  1045.         if (q == NULL) {
  1046.           _gen("/* MR10 individual OR gates suppressed when all predicates are leaves");
  1047.           _gen(" with identical context */n");
  1048.           genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
  1049.           identicalORcontextOptimization=1;
  1050.         } else {
  1051.           MR_distinctORcontextOpt(p,j,in_and_expr);
  1052.           return;
  1053.         };
  1054.       } else if (p->expr == PRED_AND_LIST && MR_allPredLeaves(p->down)) {
  1056.             /* MR12 optimize AND predicates which are all leaves */
  1058.         groupTree=MR_compute_pred_tree_context(p);
  1059.         for (q=p->down ; q != NULL ; q=q->right) {
  1060.           oneTree=MR_compute_pred_tree_context(q);
  1061.           if (! MR_tree_equ(groupTree,oneTree)) {
  1062.             Tfree(oneTree);
  1063.             break;
  1064.           };
  1065.           Tfree(oneTree);
  1066.         };
  1067.         Tfree(groupTree);
  1068.         if (q == NULL) {
  1069.           _gen("/* MR12 individual AND gates suppressed when all predicates are leaves");
  1070.           _gen(" with identical context */n");
  1071.           genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
  1072.           identicalANDcontextOptimization=1;
  1073.         } else {
  1074.           genPredTreeGate(p, in_and_expr);
  1075.         };
  1076.       } else {
  1077.        genPredTreeGate(p, in_and_expr);
  1078.       };
  1079. }
  1081. /* if leaf node, just gen predicate */
  1083. if ( p->down==NULL )
  1084. {
  1085. genPred(p,j,suppress_sva);
  1086. if ( ! noneHaveContext ) _gen(")");   /* MR10 context guards ignored when -prc off */
  1087. return;
  1088. }
  1090. /* if AND list, do both preds (only two possible) */
  1091.     /* MR10    not any more ! */
  1093. if ( p->expr == PRED_AND_LIST )
  1094. {
  1095. Predicate *list;
  1096. _gen("(");
  1097. list = p->down;
  1098.         for (; list != NULL; list=list->right) {
  1099.           if (identicalANDcontextOptimization) {
  1100.             genPred(list, j,suppress_sva);
  1101.           } else {
  1102.         genPredTree(list, j, 1, suppress_sva);  /* in and context */
  1103.           };
  1104.           if ( list->right!=NULL ) _gen("&&");
  1105.         };
  1106. _gen(")");
  1107. if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
  1108. return;
  1109. }
  1111. if ( p->expr == PRED_OR_LIST )
  1112. {
  1113. Predicate *list;
  1114. _gen("(");
  1115. list = p->down;
  1116. for (; list!=NULL; list=list->right)
  1117. {
  1118.             if (identicalORcontextOptimization) {
  1119.           genPred(list, j,suppress_sva);
  1120.             } else {
  1121.           genPredTree(list, j, 0, suppress_sva);
  1122.             };
  1123. if ( list->right!=NULL ) _gen("||");
  1124. }
  1125. _gen(")");
  1126. if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
  1127. return;
  1128. }
  1130. fatal_internal("predicate tree is wacked");
  1131. }
  1133. /* [genPredTreeMainXX] */
  1135. Predicate *     /* MR10 */
  1136. #ifdef __USE_PROTOS
  1137. genPredTreeMainXX( Predicate *p, Node *j ,int in_and_expr)
  1138. #else
  1139. genPredTreeMainXX( p, j ,in_and_expr)
  1140.     Predicate   *p;
  1141.     Node        *j;
  1142.     int         in_and_expr;
  1143. #endif
  1144. {
  1146.     int     allHaveContext=1;
  1147.     int     noneHaveContext=1;
  1149. #if 0
  1150.     fprintf(stderr,"Pred beforen");
  1151.     dumppred(p);
  1152.     fprintf(stderr,"n");
  1153.     fprintf(stderr,"Pred aftern");
  1154.     dumppred(p);
  1155.     fprintf(stderr,"n");
  1156. #endif
  1158.     p=MR_predSimplifyALL(p);    /* MR10 */
  1160.     require (MR_predicate_context_completed(p),"predicate context is not complete");
  1162.     MR_cleanup_pred_trees(p);   /* MR10 */
  1164.     MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
  1165.     if (!noneHaveContext & !allHaveContext) {
  1166.       warnFL("predicate contains elements both with and without context",
  1167.                 FileStr[j->file],j->line);
  1168.     };
  1170.     if (InfoP) {
  1171.        _gen("n#if 0nn");
  1172.        MR_dumpPred(p,1);
  1173.        _gen("#endifn");
  1174.     };
  1175. genPredTree(p,j,in_and_expr,0);
  1176.     return p;
  1177. }
  1179. Predicate *     /* MR10 */
  1180. #ifdef __USE_PROTOS
  1181. genPredTreeMain( Predicate *p, Node *j)
  1182. #else
  1183. genPredTreeMain( p, j)
  1184.     Predicate   *p;
  1185.     Node        *j;
  1186. #endif
  1187. {
  1188.   return genPredTreeMainXX(p,j,1);
  1189. }
  1191. static void
  1192. #ifdef __USE_PROTOS
  1193. genExprTreeOriginal( Tree *t, int k )
  1194. #else
  1195. genExprTreeOriginal( t, k )
  1196. Tree *t;
  1197. int k;
  1198. #endif
  1199. {
  1200. require(t!=NULL, "genExprTreeOriginal: NULL tree");
  1202. if ( t->token == ALT )
  1203. {
  1204. _gen("("); genExprTreeOriginal(t->down, k); _gen(")");
  1205. if ( t->right!=NULL )
  1206. {
  1207. _gen("||");
  1208. on1line++;
  1209. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1210. _gen("("); genExprTreeOriginal(t->right, k); _gen(")");
  1211. }
  1212. return;
  1213. }
  1214. if ( t->down!=NULL ) _gen("(");
  1215. _gen1("LA(%d)==",k);
  1216. if ( TokenString(t->token) == NULL ) _gen1("%d", t->token)
  1217. else _gen1("%s", TokenString(t->token));
  1218. if ( t->down!=NULL )
  1219. {
  1220. _gen("&&");
  1221. on1line++;
  1222. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1223. _gen("("); genExprTreeOriginal(t->down, k+1); _gen(")");
  1224. }
  1225. if ( t->down!=NULL ) _gen(")");
  1226. if ( t->right!=NULL )
  1227. {
  1228. _gen("||");
  1229. on1line++;
  1230. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1231. _gen("("); genExprTreeOriginal(t->right, k); _gen(")");
  1232. }
  1233. }
  1235. #ifdef __STDC__
  1236. static void MR_LAtokenString(int k,int token)
  1237. #else
  1238. static void MR_LAtokenString(k,token)
  1239.   int   k;
  1240.   int   token;
  1241. #endif
  1242. {
  1243.     char    *ts;
  1245.     ts=TokenString(token);
  1246.     if (ts == NULL) {
  1247.       _gen2(" LA(%d)==%d",k,token);
  1248.     } else {
  1249.       _gen2(" LA(%d)==%s",k,ts);
  1250.     };
  1251. }
  1254. #ifdef __STDC__
  1255. static int MR_countLeaves(Tree *t)
  1256. #else
  1257. static int MR_countLeaves(t)
  1258.   Tree  *t;
  1259. #endif
  1260. {
  1261.   if (t == NULL) return 0;
  1262.   if (t->token == ALT) {
  1263.     return MR_countLeaves(t->down)+MR_countLeaves(t->right);
  1264.   } else {
  1265.     return 1+MR_countLeaves(t->down)+MR_countLeaves(t->right);
  1266.   };
  1267. }
  1269. #ifdef __STDC__
  1270. static void MR_genOneLine(Tree *tree,int k)
  1271. #else
  1272. static void MR_genOneLine(tree,k)
  1273.   Tree      *tree;
  1274.   int       k;
  1275. #endif
  1276. {
  1277.     if (tree == NULL) return;
  1278.     if (tree->token == ALT) {
  1279.        MR_genOneLine(tree->down,k);
  1280.     } else {
  1281.        MR_LAtokenString(k,tree->token);
  1282.        if (tree->down != NULL &&
  1283.            tree->down->right == NULL) {
  1284.           _gen(" &&");
  1285.           MR_genOneLine(tree->down,k+1);
  1286.        } else if (tree->down != NULL) {
  1287.          _gen(" && (");
  1288.          MR_genOneLine(tree->down,k+1);
  1289.          _gen(")");
  1290.        };
  1291.     };
  1292.     if (tree->right != NULL) {
  1293.       _gen(" ||");
  1294.       MR_genOneLine(tree->right,k);
  1295.     };
  1296. }
  1298. /* @@@ */
  1300. static int across;
  1301. static int depth;
  1302. static int lastkonline;
  1304. #ifdef __STDC__
  1305. static void MR_genMultiLine(Tree *tree,int k)
  1306. #else
  1307. static void MR_genMultiLine(tree,k)
  1308.   Tree  *tree;
  1309.   int   k;
  1310. #endif
  1311. {
  1312.     int     i;
  1314.     if (tree == NULL) return;
  1315.     if (tree->token == ALT) {
  1316.       MR_genMultiLine(tree,k);
  1317.     } else {
  1318.       MR_LAtokenString(k,tree->token);
  1319.       lastkonline=k;
  1320.       across++;
  1321.       if (tree->down != NULL && tree->down->right == NULL) {
  1322.         if (across > 3) {
  1323.           _gen("n");
  1324.           across=0;
  1325.           lastkonline=0;
  1326.           for (i=0 ; i < depth+k ; i++) _gen("   ");
  1327.           _gen("&&");
  1328.         } else {
  1329.           _gen(" &&");
  1330.         };
  1331.         MR_genMultiLine(tree->down,k+1);
  1332.       } else if (tree->down != NULL) {
  1333.         _gen("n");
  1334.         lastkonline=0;
  1335.         across=0;
  1336.         for (i=0 ; i < depth+k ; i++) _gen("   ");
  1337.         _gen("&& (");
  1338.         MR_genMultiLine(tree->down,k+1);
  1339.         _gen(")");
  1340.       };
  1341.     };
  1342.     if (tree->right != NULL) {
  1343.       if (k < lastkonline) {
  1344.         _gen("n");
  1345.         across=0;
  1346.         lastkonline=0;
  1347.         for (i=0; i < depth+k-1 ; i++) _gen("   ");
  1348.         _gen("||");
  1349.       } else if (across > 3 ) {
  1350.         _gen("n");
  1351.         across=0;
  1352.         lastkonline=0;
  1353.         for (i=0; i < depth+k ; i++) _gen("   ");
  1354.         _gen("||");
  1355.       } else {
  1356.         _gen(" ||");
  1357.       };
  1358.       MR_genMultiLine(tree->right,k);
  1359.     };
  1360. }
  1362. #ifdef __STDC__
  1363. static void genExprTree(Tree *tree,int k)
  1364. #else
  1365. static void genExprTree(tree,k)
  1366.   Tree  *tree;
  1367.   int   k;
  1368. #endif
  1369. {
  1370.     int     count;
  1371.     int     across;
  1373.     require (tree != NULL,"genExprTree: tree is NULL");
  1374.     require (k > 0,"genExprTree: k <= 0");
  1376.     if (0 && !MRhoisting) {   /* MR11 make new version standard */
  1377.       genExprTreeOriginal(tree,k);
  1378.     } else {
  1379.       count=MR_countLeaves(tree);
  1380.       if (count < 5) {
  1381.         MR_genOneLine(tree,k);
  1382.       } else {
  1383.         _gen("n");
  1384.         across=0;
  1385.         depth=0;
  1386.         lastkonline=0;
  1387.         MR_genMultiLine(tree,k);
  1388.         _gen("n");
  1389.       };
  1390.     };
  1391. }
  1394. /*
  1395.  * Generate LL(k) type expressions of the form:
  1396.  *
  1397.  *  (LA(1) == T1 || LA(1) == T2 || ... || LA(1) == Tn) &&
  1398.  *  (LA(2) == T1 || LA(2) == T2 || ... || LA(2) == Tn) &&
  1399.  * .....
  1400.  *  (LA(k) == T1 || LA(k) == T2 || ... || LA(k) == Tn)
  1401.  *
  1402.  * If GenExprSetsOpt generate:
  1403.  *
  1404.  * (setwdi[LA(1)]&(1<<j)) && (setwdi[LA(2)]&(1<<j)) ...
  1405.  *
  1406.  * where n is set_deg(expr) and Ti is some random token and k is the last nonempty
  1407.  * set in fset <=CLL_k.
  1408.  * k=1..CLL_k where CLL_k >= 1.
  1409.  *
  1410.  * This routine is visible only to this file and cannot answer a TRANS message.
  1411.  *
  1412.  */
  1414. /*  [genExpr] */
  1416. static int
  1417. #ifdef __USE_PROTOS
  1418. genExpr( Junction *j )
  1419. #else
  1420. genExpr( j )
  1421. Junction *j;
  1422. #endif
  1423. {
  1424. int max_k;
  1426. /* if full LL(k) is sufficient, then don't use approximate (-ck) lookahead
  1427.  * from CLL_k..LL_k
  1428.  */
  1429. {
  1430. int limit;
  1431. if ( j->ftree!=NULL ) limit = LL_k;
  1432. else limit = CLL_k;
  1433. max_k = genExprSets(j->fset, limit);
  1434. }
  1436. /* Do tests for real tuples from other productions that conflict with
  1437.  * artificial tuples generated by compression (using sets of tokens
  1438.  * rather than k-trees).
  1439.  */
  1440. if ( j->ftree != NULL )
  1441. {
  1442. _gen(" && !("); genExprTree(j->ftree, 1); _gen(")");
  1443. }
  1445. if ( ParseWithPredicates && j->predicate!=NULL )
  1446. {
  1447. Predicate *p = j->predicate;
  1448. warn_about_using_gk_option();
  1449. _gen("&&");
  1450. j->predicate=genPredTreeMain(p, (Node *)j);     /* MR10 */
  1451. }
  1453. return max_k;
  1454. }
  1456. static int
  1457. #ifdef __USE_PROTOS
  1458. genExprSets( set *fset, int limit )
  1459. #else
  1460. genExprSets( fset, limit )
  1461. set *fset;
  1462. int limit;
  1463. #endif
  1464. {
  1465. int k = 1;
  1466. int max_k = 0;
  1467. unsigned *e, *g, firstTime=1;
  1469.     if (set_nil(fset[1])) {
  1470.       _gen(" 0 /* MR13 empty set expression  - undefined rule ? infinite left recursion ? */ ");
  1471.       MR_BadExprSets++;
  1472.     };
  1474. if ( GenExprSetsOpt )
  1475. {
  1476. while ( k <= limit && !set_nil(fset[k]) )   /* MR11 */
  1477. {
  1478. if ( set_deg(fset[k])==1 ) /* too simple for a set? */
  1479. {
  1480. int e;
  1481. _gen1("(LA(%d)==",k);
  1482. e = set_int(fset[k]);
  1483. if ( TokenString(e) == NULL ) _gen1("%d)", e)
  1484. else _gen1("%s)", TokenString(e));
  1485. }
  1486. else
  1487. {
  1488. NewSet();
  1489. FillSet( fset[k] );
  1490. _gen3("(setwd%d[LA(%d)]&0x%x)", wordnum, k, 1<<setnum);
  1491. }
  1492. if ( k>max_k ) max_k = k;
  1493. if ( k == CLL_k ) break;
  1494. k++;
  1495. if ( k<=limit && !set_nil(fset[k]) ) _gen(" && ");  /* MR11 */
  1496. on1line++;
  1497. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1498. }
  1499. return max_k;
  1500. }
  1502. while ( k<= limit &&  !set_nil(fset[k]) )       /* MR11 */
  1503. {
  1504. if ( (e=g=set_pdq(fset[k])) == NULL ) fatal_internal("genExpr: cannot allocate IF expr pdq set");
  1505. for (; *e!=nil; e++)
  1506. {
  1507. if ( !firstTime ) _gen(" || ") else { _gen("("); firstTime = 0; }
  1508. on1line++;
  1509. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1510. _gen1("LA(%d)==",k);
  1511. if ( TokenString(*e) == NULL ) _gen1("%d", *e)
  1512. else _gen1("%s", TokenString(*e));
  1513. }
  1514. free( (char *)g );
  1515. _gen(")");
  1516. if ( k>max_k ) max_k = k;
  1517. if ( k == CLL_k ) break;
  1518. k++;
  1519. if ( k <= limit && !set_nil(fset[k]) ) { firstTime=1; _gen(" && "); }   /* MR11 */
  1520. on1line++;
  1521. if ( on1line > NumExprPerLine ) { on1line=0; _gen("n"); }
  1522. }
  1523. return max_k;
  1524. }
  1526. /*
  1527.  * Generate code for any type of block.  If the last alternative in the block is
  1528.  * empty (not even an action) don't bother doing it.  This permits us to handle
  1529.  * optional and loop blocks as well.
  1530.  *
  1531.  * Only do this block, return after completing the block.
  1532.  * This routine is visible only to this file and cannot answer a TRANS message.
  1533.  */
  1534. static set
  1535. #ifdef __USE_PROTOS
  1536. genBlk( Junction *q, int jtype, int *max_k, int *need_right_curly )
  1537. #else
  1538. genBlk( q, jtype, max_k, need_right_curly )
  1539. Junction *q;
  1540. int jtype;
  1541. int *max_k;
  1542. int *need_right_curly;
  1543. #endif
  1544. {
  1545. set f;
  1546. Junction *alt;
  1547. int a_guess_in_block = 0;
  1548. require(q!=NULL, "genBlk: invalid node");
  1549. require(q->ntype == nJunction, "genBlk: not junction");
  1551. *need_right_curly=0;
  1552. if ( q->p2 == NULL ) /* only one alternative?  Then don't need if */
  1553. {
  1554. if (first_item_is_guess_block((Junction *)q->p1)!=NULL )
  1555. {
  1556.             if (jtype != aLoopBlk && jtype != aOptBlk && jtype != aPlusBlk) {
  1557.      warnFL("(...)? as only alternative of block is unnecessary", FileStr[q->file], q->line);
  1558.             };
  1559.             gen("zzGUESSn"); /* guess anyway to make output code consistent */
  1560. /* MR10 disable */  /**** gen("if ( !zzrv )n"); ****/
  1561. /* MR10 */          gen("if ( !zzrv ) {n"); tabs++; (*need_right_curly)++;
  1562.         };
  1563. TRANS(q->p1);
  1564. return empty; /* no decision to be made-->no error set */
  1565. }
  1567. f = First(q, 1, jtype, max_k);
  1568. for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
  1569. {
  1570. if ( alt->p2 == NULL ) /* chk for empty alt */
  1571. {
  1572. Node *p = alt->p1;
  1573. if ( p->ntype == nJunction )
  1574. {
  1575. /* we have empty alt */
  1576. if ( ((Junction *)p)->p1 == (Node *)q->end )
  1577. {
  1578. break; /* don't do this one, quit */
  1579. }
  1580. }
  1581. }
  1582. /* MR10 */        if (alt->p2 == NULL &&
  1583. /* MR10 */               ( q->jtype == aSubBlk || q->jtype == RuleBlk) ) {
  1584. /* MR10 */          if (first_item_is_guess_block(alt)) {
  1585. /* MR10 */               warnFL("(...)? as last alternative of block is unnecessary",
  1586. /* MR10 */                                FileStr[alt->file],alt->line);
  1587. /* MR10 */          };
  1588. /* MR10 */        };
  1590. if ( alt != q ) gen("else ")
  1591. else
  1592. {
  1593. if ( DemandLookahead )
  1594. if ( !GenCC ) {gen1("LOOK(%d);n", *max_k);}
  1595. else gen1("look(%d);n", *max_k);
  1596. }
  1598. if ( alt!=q )
  1599. {
  1600. _gen("{n");
  1601. tabs++;
  1602. (*need_right_curly)++;
  1603. /* code to restore state if a prev alt didn't follow guess */
  1604. if ( a_guess_in_block )
  1605. gen("if ( !zzrv ) zzGUESS_DONE;n");
  1606. }
  1607. if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL )
  1608. {
  1609. a_guess_in_block = 1;
  1610. gen("zzGUESSn");
  1611. }
  1612. gen("if ( ");
  1613. if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) _gen("!zzrv && ");
  1614. genExpr(alt);
  1615. _gen(" ) ");
  1616. _gen("{n");
  1617. tabs++;
  1618. TRANS(alt->p1);
  1619. --tabs;
  1620. gen("}n");
  1621. /* MR10 */        if (alt->p2 == NULL) {
  1622. /* MR10 */          if (first_item_is_guess_block(alt)) {
  1623. /* MR10 */            gen("/* MR10 */ else {n");
  1624. /* MR10 */            tabs++;
  1625. /* MR10 */     (*need_right_curly)++;
  1626. /* MR10 */     /* code to restore state if a prev alt didn't follow guess */
  1627. /* MR10 */            gen("/* MR10 */ if ( !zzrv ) zzGUESS_DONE;n");
  1628. /* MR10 */            gen("/* MR10 */ if (0) {}     /* last alternative of block is guess block */n");
  1629. /* MR10 */          };
  1630. /* MR10 */        };
  1631. }
  1632. return f;
  1633. }
  1635. static int
  1636. #ifdef __USE_PROTOS
  1637. has_guess_block_as_first_item( Junction *q )
  1638. #else
  1639. has_guess_block_as_first_item( q )
  1640. Junction *q;
  1641. #endif
  1642. {
  1643. Junction *alt;
  1645. for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
  1646. {
  1647. if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) return 1;
  1648. }
  1649. return 0;
  1650. }
  1652. static int
  1653. #ifdef __USE_PROTOS
  1654. has_guess_block_as_last_item( Junction *q )
  1655. #else
  1656. has_guess_block_as_last_item( q )
  1657. Junction *q;
  1658. #endif
  1659. {
  1660. Junction *alt;
  1662.     if (q == NULL) return 0;
  1663. for (alt=q; alt->p2 != NULL && !( (Junction *) alt->p2)->ignore; alt= (Junction *) alt->p2 ) {};
  1664.     return first_item_is_guess_block( (Junction *) alt->p1) != NULL;
  1665. }
  1667. /* return NULL if 1st item of alt is NOT (...)? block; else return ptr to aSubBlk node
  1668.  * of (...)?;  This function ignores actions and predicates.
  1669.  */
  1670. Junction *
  1671. #ifdef __USE_PROTOS
  1672. first_item_is_guess_block( Junction *q )
  1673. #else
  1674. first_item_is_guess_block( q )
  1675. Junction *q;
  1676. #endif
  1677. {
  1678.     /* MR14  Couldnt' find aSubBlock which was a guess block when it lay
  1679.              behind aLoopBlk.  The aLoopBlk only appear in conjunction with
  1680.              aLoopBegin, but the routine didn't know that.  I think.
  1681.     */
  1683. while ( q!=NULL &&
  1684.           ( q->ntype==nAction ) ||
  1685.           ( q->ntype==nJunction && (q->jtype==Generic || q->jtype == aLoopBlk )) )
  1686. {
  1687. if ( q->ntype==nJunction ) q = (Junction *)q->p1;
  1688. else q = (Junction *) ((ActionNode *)q)->next;
  1689. }
  1691. if ( q==NULL ) return NULL;
  1692. if ( q->ntype!=nJunction ) return NULL;
  1693. if ( q->jtype!=aSubBlk ) return NULL;
  1694. if ( !q->guess ) return NULL;
  1695. return q;
  1696. }
  1698. /* MR1                       */
  1699. /* MR1  10-Apr-97 MR1 Routine to stringize failed semantic predicates msgs  */
  1700. /* MR1                                                         */
  1702. #define STRINGIZEBUFSIZE 1024
  1704. static char stringizeBuf[STRINGIZEBUFSIZE];
  1705. char *
  1706. #ifdef __USE_PROTOS
  1707. stringize(char * s)
  1708. #else
  1709. stringize(s)
  1710. char *s;
  1711. #endif
  1713. {
  1714.   char *p;
  1715.   char *stop;
  1717.   p=stringizeBuf;
  1718.   stop=&stringizeBuf[1015];
  1720.   if (s != 0) {
  1721.     while (*s != 0) {
  1722.       if (p >= stop) {
  1723. goto stringizeStop;
  1724.       } else if (*s == 'n') {
  1725.         *p++='\';
  1726.         *p++='n';
  1727.         *p++='\';
  1728. *p++=*s++;
  1729.       } else if (*s == '\') {
  1730. *p++=*s;
  1731. *p++=*s++;
  1732.       } else if (*s == '"') {
  1733.         *p++='\';
  1734. *p++=*s++;
  1735.         while (*s != 0) {
  1736.           if (p >= stop) {
  1737.      goto stringizeStop;
  1738.   } else if (*s == 'n') {
  1739.     *p++='\';
  1740.     *p++=*s++;
  1741.   } else if (*s == '\') {
  1742.     *p++=*s++;
  1743.     *p++=*s++;
  1744.   } else if (*s == '"') {
  1745.     *p++='\';
  1746.     *p++=*s++;
  1747.     break;
  1748.   } else {
  1749.     *p++=*s++;
  1750.           };
  1751.         };
  1752.       } else if (*s == ''') {
  1753. *p++=*s++;
  1754.         while (*s != 0) {
  1755.           if (p >= stop) {
  1756.      goto stringizeStop;
  1757.   } else if (*s == ''') {
  1758.     *p++=*s++;
  1759.     break;
  1760.   } else if (*s == '\') {
  1761.     *p++=*s++;
  1762.     *p++=*s++;
  1763.   } else if (*s == '"') {
  1764.     *p++='\';
  1765.     *p++=*s++;
  1766.     break;
  1767.   } else {
  1768.     *p++=*s++;
  1769.           };
  1770.         };
  1771.       } else {
  1772.         *p++=*s++;
  1773.       };
  1774.     };
  1775.   };
  1776.   goto stringizeExit;
  1777. stringizeStop:
  1778.   *p++='.';        
  1779.   *p++='.';        
  1780.   *p++='.';        
  1781. stringizeExit:
  1782.   *p=0;
  1783.   return stringizeBuf;
  1784. }
  1786. #ifdef __STDC__
  1787. int isNullAction(char *s)
  1788. #else
  1789. int isNullAction(s)
  1790.   char  *s;
  1791. #endif
  1792. {
  1793.   char  *p;
  1794.   for (p=s; *p != '' ; p++) {
  1795.     if (*p != ';' && *p !=' ') return 0;
  1796.   };
  1797.   return 1;
  1798. }
  1799. /* MR1                                     */
  1800. /* MR1 End of Routine to stringize code for failed predicates msgs         */
  1801. /* MR1                                                         */
  1803. /* Generate an action.  Don't if action is NULL which means that it was already
  1804.  * handled as an init action.
  1805.  */
  1806. void
  1807. #ifdef __USE_PROTOS
  1808. genAction( ActionNode *p )
  1809. #else
  1810. genAction( p )
  1811. ActionNode *p;
  1812. #endif
  1813. {
  1814. require(p!=NULL, "genAction: invalid node and/or rule");
  1815. require(p->ntype==nAction, "genAction: not action");
  1817. if ( !p->done )  /* MR10 */ /* MR11 */
  1818. {
  1819. if ( p->is_predicate)
  1820. {
  1821. if ( p->guardpred != NULL )
  1822. {
  1823.                 Predicate *guardDup=predicate_dup(p->guardpred); /* MR10 */
  1824.                 gen("if (!");
  1825.         guardDup=genPredTreeMain(guardDup, (Node *)p);
  1826.                 predicate_free(guardDup);
  1827. }
  1828. /* MR10 */  else if (p->ampersandPred != NULL) {
  1829. /* MR10 */      gen("if (!");
  1830. /* MR10 */      p->ampersandPred=genPredTreeMain(p->ampersandPred, (Node *)p);
  1831. /* MR10 */  }
  1832. else
  1833. {
  1834. gen("if (!(");
  1835. /* make sure that '#line n' is on front of line */
  1836. if ( GenLineInfo && p->file != -1 ) _gen("n");
  1837. dumpPredAction(p,p->action, output, 0, p->file, p->line, 0);
  1838. _gen(")");
  1839. }
  1840. if ( p->pred_fail != NULL )
  1841. {
  1842. _gen(")n");
  1843. tabs++;
  1844. /* MR1                                                         */
  1845. /* MR1  10-Apr-97 MR1  Put {...} envelope around failed semantic predicates */
  1846. /* MR1                                                         */
  1847. gen1("{%s};n", p->pred_fail);                      /* MR1 */
  1848. tabs--;
  1849. }
  1850. /* MR1                                                 */
  1851. /* MR1  10-Apr-97 MR1 Properly stringize failed semantic predicates      */
  1852. /* MR1                                                         */
  1853. else _gen1(") {zzfailed_pred("%s");}n",               /* MR1 */
  1854. stringize(p->action));                      /* MR1 */
  1855. }
  1856. else    /* not a predicate */
  1857. {
  1858.             if (! isNullAction(p->action) && !p->noHoist) {
  1859.         if ( FoundGuessBlk ) {
  1860. if ( GenCC ) {
  1861.                   gen("if ( !guessing ) {n");
  1862.                 } else {
  1863.   gen("zzNON_GUESS_MODE {n");
  1864.                 };
  1865.               };
  1866.   dumpAction(p->action, output, tabs, p->file, p->line, 1);
  1867.   if ( FoundGuessBlk ) gen("}n");
  1868.             };
  1869. }
  1870. }
  1871. TRANS(p->next)
  1872. }
  1874. /*
  1875.  * if invoking rule has !noAST pass zzSTR to rule ref and zzlink it in
  1876.  * else pass addr of temp root ptr (&_ast) (don't zzlink it in).
  1877.  *
  1878.  * if ! modifies rule-ref, then never link it in and never pass zzSTR.
  1879.  * Always pass address of temp root ptr.
  1880.  */
  1881. void
  1882. #ifdef __USE_PROTOS
  1883. genRuleRef( RuleRefNode *p )
  1884. #else
  1885. genRuleRef( p )
  1886. RuleRefNode *p;
  1887. #endif
  1888. {
  1889. Junction *q;
  1890. char *handler_id = "";
  1891. RuleEntry *r, *r2;
  1892. char *parm = "", *exsig = "";
  1894.     int     genRuleRef_emittedGuessGuard=0;     /* MR10 */
  1896. require(p!=NULL, "genRuleRef: invalid node and/or rule");
  1897. require(p->ntype==nRuleRef, "genRuleRef: not rule reference");
  1899. if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
  1900. handler_id = p->altstart->exception_label;
  1902. r = (RuleEntry *) hash_get(Rname, p->text);
  1903. if ( r == NULL )
  1904. {
  1905. warnFL( eMsg1("rule %s not defined",
  1906.   p->text), FileStr[p->file], p->line );
  1907. return;
  1908. }
  1910. /* MR8 5-Aug-97     Reported by S.Bochnak@microtool.com.pl                  */
  1911. /*                  Don't do assign when no return values declared          */
  1912. /*                  Move definition of q up and use it to guard p->assign   */
  1914. q = RulePtr[r->rulenum]; /* find definition of ref'd rule */  /* MR8 */
  1916. r2 = (RuleEntry *) hash_get(Rname, p->rname);
  1917. if ( r2 == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}
  1919.     OutLineInfo(output,p->line,FileStr[p->file]);
  1921. if ( GenCC && GenAST ) {
  1922. gen("_ast = NULL;n");
  1923. }
  1925. if ( FoundGuessBlk && p->assign!=NULL && q->ret != NULL ) {      /* MR8 */
  1926. if ( GenCC ) {
  1927.           gen("if ( !guessing ) {n");
  1928.         } else {
  1929.           gen("zzNON_GUESS_MODE {n");
  1930.         };
  1931.         tabs++;                                                      /* MR11 */
  1932.         genRuleRef_emittedGuessGuard=1;                              /* MR11 */
  1933.     };
  1935. if ( FoundException ) exsig = "&_signal";
  1937. tab();
  1938. if ( GenAST )
  1939. {
  1940. if ( GenCC ) {
  1941. /**** if ( r2->noAST || p->astnode==ASTexclude )
  1942. ****/
  1943. {
  1944. /**** _gen("_ast = NULL;n");
  1945. ****/
  1946. parm = "&_ast";
  1947. }
  1948. /*** we always want to set just a pointer now, then set correct
  1949. pointer after
  1951. else {
  1952. _gen("_astp =
  1953. (_tail==NULL)?(&_sibling):(&(_tail->_right));n");
  1954. parm = "_astp";
  1955. }
  1956. ****/
  1957. }
  1958. else {
  1959. if ( r2->noAST || p->astnode==ASTexclude )
  1960. {
  1961. _gen("_ast = NULL; ");
  1962. parm = "&_ast";
  1963. }
  1964. else parm = "zzSTR";
  1965. }
  1966. if ( p->assign!=NULL && q->ret!=NULL )                       /* MR8 */
  1967. {
  1968. if ( !HasComma(p->assign) ) {_gen1("%s = ",p->assign);}
  1969. else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
  1970. }
  1971. if ( FoundException ) {
  1972. _gen5("%s%s(%s,&_signal%s%s); ",
  1973.   RulePrefix,
  1974.   p->text,
  1975.   parm,
  1976.   (p->parms!=NULL)?",":"",
  1977.   (p->parms!=NULL)?p->parms:"");
  1978. if ( p->ex_group!=NULL ) {
  1979. _gen("n");
  1980. gen("if (_signal) {n");
  1981. tabs++;
  1982. dumpException(p->ex_group, 0);
  1983. tabs--;
  1984. gen("}");
  1985. }
  1986. else {
  1987. _gen1("if (_signal) goto %s_handler;", handler_id);
  1988. }
  1989. }
  1990. else {
  1991. _gen5("%s%s(%s%s%s);",
  1992.   RulePrefix,
  1993.   p->text,
  1994.   parm,
  1995.   (p->parms!=NULL)?",":"",
  1996.   (p->parms!=NULL)?p->parms:"");
  1997. }
  1998. if ( GenCC && (r2->noAST || p->astnode==ASTexclude) )
  1999. {
  2000. /* rule has a ! or element does */
  2001. /* still need to assign to #i so we can play with it */
  2002. _gen("n");
  2003. gen2("_ast%d%d = (AST *)_ast;", BlkLevel-1, p->elnum);
  2004. }
  2005. else if ( !r2->noAST && p->astnode == ASTinclude )
  2006. {
  2007. /* rule doesn't have a ! and neither does element */
  2008. /* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {
  2009. /* MR10 */    _gen("n");
  2010. /* MR10 */    if (GenCC) gen ("if (!guessing) {    /* MR10 */")
  2011. /* MR10 */          else gen ("if (!zzguessing) {    /* MR10 */n");
  2012. /* MR10 */    tabs++;
  2013. /* MR10 */  };
  2014. if ( GenCC ) {
  2015. _gen("n");
  2016. gen("if ( _tail==NULL ) _sibling = _ast; else _tail->setRight(_ast);n");
  2017. gen2("_ast%d%d = (AST *)_ast;n", BlkLevel-1, p->elnum);
  2018. tab();
  2019. }
  2020. else _gen(" ");
  2021.             if ( GenCC ) {
  2022.                 _gen("ASTBase::"); }
  2023.                 else _gen("zz");
  2024. _gen("link(_root, &_sibling, &_tail);");
  2026. /* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {     /* MR10 */
  2027. /* MR10 */    _gen("n");
  2028. /* MR10 */    tabs--;
  2029. /* MR10 */    if (GenCC) gen ("};    /* MR10 */")
  2030. /* MR10 */          else gen ("};    /* MR10 */");
  2031. /* MR10 */  };
  2032. }
  2033. }
  2034. else
  2035. {
  2036. if ( p->assign!=NULL && q->ret!=NULL )                       /* MR8 */
  2037. {
  2038. if ( !HasComma(p->assign) ) {_gen1("%s = ",p->assign);}
  2039. else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
  2040. }
  2041. if ( FoundException ) {
  2042. _gen4("%s%s(&_signal%s%s); ",
  2043.   RulePrefix,
  2044.   p->text,
  2045.   (p->parms!=NULL)?",":"",
  2046.   (p->parms!=NULL)?p->parms:"");
  2047. if ( p->ex_group!=NULL ) {
  2048. _gen("n");
  2049. gen("if (_signal) {n");
  2050. tabs++;
  2051. dumpException(p->ex_group, 0);
  2052. tabs--;
  2053. gen("}");
  2054. }
  2055. else {
  2056. _gen1("if (_signal) goto %s_handler;", handler_id);
  2057. }
  2058. }
  2059. else {
  2060. _gen3("%s%s(%s);",
  2061.   RulePrefix,
  2062.   p->text,
  2063.   (p->parms!=NULL)?p->parms:"");
  2064. }
  2065. if ( p->assign!=NULL && q->ret!=NULL ) _gen("n");           /* MR8 */
  2066. }
  2068. if ( p->assign!=NULL && q->ret!=NULL) {                          /* MR8 */
  2069. if ( HasComma(p->assign) )
  2070. {
  2071. _gen("n");
  2072. dumpRetValAssign(p->assign, q->ret);
  2073. _gen("}");
  2074. }
  2075. }
  2076. _gen("n");
  2078. /* Handle element labels now */
  2079. if ( p->el_label!=NULL )
  2080. {
  2081. if ( GenAST )
  2082. {
  2083. if ( GenCC ) {
  2084. gen3("%s_ast = _ast%d%d;n", p->el_label, BlkLevel-1, p->elnum);
  2085. }
  2086. else {gen1("%s_ast = zzastCur;n", p->el_label);}
  2087. }
  2088.         else if (!GenCC ) {
  2089. gen1("%s = zzaCur;n", p->el_label);
  2090.         }
  2091. }
  2093. if ( FoundGuessBlk && p->assign!=NULL && q->ret!=NULL ) {       /* MR8 */
  2094. /* in guessing mode, don't branch to handler upon error */
  2095.         tabs--;                                                     /* MR11 */
  2096. gen("} else {n");
  2097.         tabs++;                                                     /* MR11 */
  2098. if ( FoundException ) {
  2099. gen6("%s%s(%s%s&_signal%s%s);n",
  2100.  RulePrefix,
  2101.  p->text,
  2102.  parm,
  2103.                  (*parm!='')?",":"",
  2104.                  (p->parms!=NULL)?",":"",
  2105.  (p->parms!=NULL)?p->parms:"");
  2106. }
  2107. else {
  2108. gen5("%s%s(%s%s%s);n",
  2109.  RulePrefix,
  2110.  p->text,
  2111.  parm,
  2112.  (p->parms!=NULL && *parm!='')?",":"",
  2113.  (p->parms!=NULL)?p->parms:"");
  2114. }
  2115.         tabs--;                                                     /* MR11 */
  2116. gen("}n");
  2117. }
  2118. TRANS(p->next)
  2119. }
  2121. /*
  2122.  * Generate code to match a token.
  2123.  *
  2124.  * Getting the next token is tricky.  We want to ensure that any action
  2125.  * following a token is executed before the next GetToken();
  2126.  */
  2127. void
  2128. #ifdef __USE_PROTOS
  2129. genToken( TokNode *p )
  2130. #else
  2131. genToken( p )
  2132. TokNode *p;
  2133. #endif
  2134. {
  2135. RuleEntry *r;
  2136. char *handler_id = "";
  2137. ActionNode *a;
  2138. char *set_name;
  2139. require(p!=NULL, "genToken: invalid node and/or rule");
  2140. require(p->ntype==nToken, "genToken: not token");
  2142. if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
  2143. handler_id = p->altstart->exception_label;
  2145. r = (RuleEntry *) hash_get(Rname, p->rname);
  2146. if ( r == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}
  2148.     OutLineInfo(output,p->line,FileStr[p->file]);
  2150. if ( !set_nil(p->tset) ) /* implies '.', ~Tok, or tokenclass */
  2151. {
  2152. unsigned e;
  2153. set b;
  2154. b = set_dup(p->tset);
  2155. if ( p->tclass!=NULL ) /* token class? */
  2156. {
  2157. static char buf[MaxRuleName+1];
  2158. if ( p->tclass->dumped )
  2159. e = p->tclass->setnum;
  2160. else {
  2161. e = DefErrSet(&b, 0, TokenString(p->token));
  2162. p->tclass->dumped = 1; /* indicate set has been created */
  2163. p->tclass->setnum = e;
  2164. }
  2165. sprintf(buf, "%s_set", TokenString(p->token));
  2166. set_name = buf;
  2167. }
  2168. else { /* wild card to ~ operator */
  2169. static char buf[sizeof("zzerr")+10];
  2170. int n = DefErrSet( &b, 0, NULL );
  2171. if ( GenCC ) sprintf(buf, "err%d", n);
  2172. else sprintf(buf, "zzerr%d", n);
  2173. set_name = buf;
  2174. }
  2176. if ( !FoundException )
  2177. {gen1("zzsetmatch(%s);", set_name);}
  2178. else if ( p->ex_group==NULL ) {
  2179.             if ( p->use_def_MT_handler )
  2180.                 gen3("zzsetmatch_wdfltsig(%s,(ANTLRTokenType)%d,%s);",
  2181.                      set_name,
  2182.                      p->token,
  2183.                      tokenFollowSet(p))
  2184.             else
  2185.                 gen2("zzsetmatch_wsig(%s, %s_handler);",
  2186.                      set_name,
  2187.                      handler_id);
  2188. }
  2189. else
  2190. {
  2191. gen1("if ( !_setmatch_wsig(%s) ) {n", set_name);
  2192. tabs++;
  2193. /* MR6 */ if (FoundGuessBlk) {
  2194. /* MR6 */   if ( GenCC ) {gen("if ( guessing ) goto fail;n");}
  2195. /* MR6 */   else gen("if ( zzguessing ) goto fail;n");
  2196. /* MR6 */ };
  2197. gen("_signal=MismatchedToken;n");
  2198. dumpException(p->ex_group, 0);
  2199. tabs--;
  2200. gen("}n");
  2201. }
  2202. set_free(b);
  2203. }
  2204. else if ( TokenString(p->token)!=NULL )
  2205. {
  2206. if ( FoundException ) {
  2207. if ( p->use_def_MT_handler )
  2208. gen2("zzmatch_wdfltsig(%s,%s);",TokenString(p->token),tokenFollowSet(p))
  2209. else if ( p->ex_group==NULL )
  2210. {
  2211. gen2("zzmatch_wsig(%s, %s_handler);",
  2212.  TokenString(p->token),
  2213.  handler_id);
  2214. }
  2215. else
  2216. {
  2217. /* MR6 */ if (GenCC) {
  2218. /* MR6 */   gen1("if ( !_match_wsig(%s) ) {n", TokenString(p->token));
  2219. /* MR6 */ } else {
  2220. /* MR6 */   gen1("if ( !_zzmatch_wsig(%s) ) {n", TokenString(p->token));
  2221. /* MR6 */ };
  2222. tabs++;
  2223. /* MR6 */ if (FoundGuessBlk) {
  2224. /* MR6 */      if ( GenCC ) {gen("if ( guessing ) goto fail;n");}
  2225. /* MR6 */   else gen("if ( zzguessing ) goto fail;n");
  2226. /* MR6 */ };
  2227. gen("_signal=MismatchedToken;n");
  2228. dumpException(p->ex_group, 0);
  2229. tabs--;
  2230. gen("}n");
  2231. }
  2232. }
  2233. else gen1("zzmatch(%s);", TokenString(p->token));
  2234. }
  2235. else {
  2236.         if ( FoundException ) {
  2237.             if ( p->use_def_MT_handler )
  2238. gen2("zzmatch_wdfltsig((ANTLRTokenType)%d,%s);",
  2239.  p->token,tokenFollowSet(p))
  2240.             else
  2241.                 gen2("zzmatch_wsig(%d,%s_handler);",p->token,handler_id);
  2242.         }
  2243. else {gen1("zzmatch(%d);", p->token);}
  2244. }
  2246. a = findImmedAction( p->next );
  2247. /* generate the token labels */
  2248. if ( GenCC && p->elnum>0 )
  2249. {
  2250. /* If building trees in C++, always gen the LT() assigns */
  2251. if ( set_el(p->elnum, tokensRefdInBlock) || GenAST )
  2252. {
  2253. /* MR10 */ if ( FoundGuessBlk ) {
  2254. /* MR10 */    gen("n");
  2255. /* MR10 */    if (p->label_used_in_semantic_pred) {
  2256. /* MR10 */ gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);  /* MR10 */n", BlkLevel-1, p->elnum);
  2257. /* MR10 */    } else {
  2258. /* MR10 */ gen("if ( !guessing ) {n"); tab();
  2259. /* MR10 */ _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);n", BlkLevel-1, p->elnum);
  2260. /* MR10 */      _gen("}n");
  2261. /* MR10 */    };
  2262. /* MR10 */  } else {
  2263. /* MR10 */   _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);", BlkLevel-1, p->elnum);
  2264. /* MR10 */  };
  2265. /* MR10 */
  2266. }
  2268. if ( LL_k>1 )
  2269. if ( !DemandLookahead ) _gen(" labase++;");
  2270. _gen("n");
  2271. tab();
  2272. }
  2273. if ( GenAST )
  2274. {
  2275. if ( FoundGuessBlk && !(p->astnode == ASTexclude || r->noAST) )
  2276. {
  2277. if ( GenCC ) {_gen("if ( !guessing ) {n"); tab();}
  2278. else {_gen("zzNON_GUESS_MODE {n"); tab();}
  2279. }
  2280. if ( !r->noAST )
  2281. {
  2282. if ( GenCC && !(p->astnode == ASTexclude || r->noAST) ) {
  2283. _gen("n");
  2284. /* MR13 */      if (NewAST) {
  2285. /* MR13 */         gen4("_ast%d%d = newAST(_t%d%d);n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
  2286. /* MR13 */      } else {
  2287. /* MR13 */         gen4("_ast%d%d = new AST(_t%d%d);n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
  2288. /* MR13 */      }
  2289. tab();
  2290. }
  2291. if ( GenCC && !(p->astnode == ASTexclude || r->noAST) )
  2292. {_gen2("_ast%d%d->", BlkLevel-1, p->elnum);}
  2293. else _gen(" ");
  2294. if ( p->astnode==ASTchild ) {
  2295. if ( !GenCC ) _gen("zz");
  2296. _gen("subchild(_root, &_sibling, &_tail);");
  2297. }
  2298. else if ( p->astnode==ASTroot ) {
  2299. if ( !GenCC ) _gen("zz");
  2300. _gen("subroot(_root, &_sibling, &_tail);");
  2301. }
  2302. if ( GenCC && !(p->astnode == ASTexclude || r->noAST) ) {
  2303. _gen("n");
  2304. tab();
  2305. }
  2306. }
  2307. else if ( !GenCC ) _gen(" zzastDPush;");
  2308. if ( FoundGuessBlk && !(p->astnode == ASTexclude || r->noAST) )
  2309. {_gen("}n"); tab();}
  2310. }
  2312. /* Handle element labels now */
  2313. if ( p->el_label!=NULL )
  2314. {
  2315.         int     done_NON_GUESSMODE=0;
  2317. _gen("n");
  2319. /* MR10 */    /* do Attrib / Token ptr for token label used in semantic pred */
  2320. /* MR10 */    /* for these cases do assign even in guess mode                */
  2321. /* MR10 */
  2322. /* MR10 */    if (p->label_used_in_semantic_pred) {
  2323. /* MR10 */      if ( GenCC ) {
  2324. /* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
  2325. /* MR10 */          gen3("%s = _t%d%d;", p->el_label, BlkLevel-1, p->elnum);
  2326. /* MR10 */        } else {
  2327. /* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);n", p->el_label);
  2328. /* MR10 */        };
  2329. /* MR10 */      } else {
  2330. /* MR10 */   gen1("%s = zzaCur;", p->el_label);
  2331. /* MR10 */      };
  2332. /* MR10 */      if (FoundGuessBlk) _gen("  /* MR10 */");
  2333. /* MR10 */      _gen("n");
  2334. /* MR10 */    };
  2336. /* Do Attrib / Token ptr */
  2338. /* MR10 */  if (! p->label_used_in_semantic_pred) {
  2339. /* MR10 */
  2340. /* MR10 */      if ( FoundGuessBlk ) {
  2341. /* MR10 */        if (! done_NON_GUESSMODE) {
  2342. /* MR10 */          done_NON_GUESSMODE=1;
  2343. /* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {n"); tab();}
  2344. /* MR10 */          else {gen("zzNON_GUESS_MODE {n"); tab();}
  2345. /* MR10 */        };
  2346. /* MR10 */      };
  2347. /* MR10 */
  2348. /* MR10 */      if ( GenCC ) {
  2349. /* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
  2350. /* MR10 */          gen3("%s = _t%d%d;n", p->el_label, BlkLevel-1, p->elnum);
  2351. /* MR10 */        } else {
  2352. /* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);n", p->el_label);
  2353. /* MR10 */        };
  2354. /* MR10 */      } else {
  2355. /* MR10 */        gen1("%s = zzaCur;n", p->el_label);
  2356. /* MR10 */      };
  2357. /* MR10 */  };
  2359. /* Do AST ptr */
  2360. if ( GenAST && !(p->astnode == ASTexclude || r->noAST) )
  2361. {
  2363. /* MR10 */      if ( FoundGuessBlk ) {
  2364. /* MR10 */        if (! done_NON_GUESSMODE) {
  2365. /* MR10 */          done_NON_GUESSMODE=1;
  2366. /* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {n"); tab();}
  2367. /* MR10 */          else {gen("zzNON_GUESS_MODE {n"); tab();}
  2368. /* MR10 */        };
  2369. /* MR10 */      };
  2371. if ( GenCC ) {
  2372. gen3("%s_ast = _ast%d%d;n", p->el_label, BlkLevel-1, p->elnum);
  2373. }
  2374. else {gen1("%s_ast = zzastCur;n", p->el_label);}
  2375. }
  2377. /* MR10 */  if (done_NON_GUESSMODE) {
  2378. /* MR10 */    gen("}n"); tab();
  2379. /* MR10 */  };
  2381. }
  2383. /* Handle any actions immediately following action */
  2384. if ( a != NULL )  /* MR10 */ /* MR11 */
  2385.     {
  2386.      /* delay next token fetch until after action */
  2387. _gen("n");
  2388. if ( a->is_predicate)
  2389. {
  2390. gen("if (!(");
  2391. /* make sure that '#line n' is on front of line */  /* MR14 */
  2392. if ( GenLineInfo && p->file != -1 ) _gen("n");     /* MR14 */
  2393. dumpPredAction(a,a->action, output, 0, a->file, a->line, 0);
  2394. if ( a->pred_fail != NULL )
  2395. {
  2396. _gen(")) {n");
  2397. /************** if ( FoundGuessBlk ) gen("zzNON_GUESS_MODE {n"); *****/
  2398. tabs++;
  2399. /* MR1                                                         */
  2400. /* MR1  10-Apr-97 MR1  Put {...} envelope around failed semantic predicates */
  2401. /* MR1                                                         */
  2402. gen1("{%s};n", a->pred_fail);
  2403. tabs--;
  2404. gen("}n");
  2405. /************** if ( FoundGuessBlk ) gen("}n"); *****/
  2406. }
  2407. /* MR1                                      */
  2408. /* MR1  10-Apr-97 MR1 Properly stringize failed semantic predicates      */
  2409. /* MR1                                                 */
  2410. else
  2411.             {
  2412.                  _gen1(")) {zzfailed_pred("%s");}n",              /* MR1 */
  2413. stringize(a->action));                      /* MR1 */
  2414.             }
  2415. }
  2416. else    /* MR9 a regular action - not a predicate action */
  2417. {
  2418. if ( FoundGuessBlk )
  2419. if ( GenCC ) {gen("if ( !guessing ) {n");}
  2420. else gen("zzNON_GUESS_MODE {n");
  2421. dumpAction(a->action, output, tabs, a->file, a->line, 1);
  2422. if ( FoundGuessBlk ) gen("}n");
  2423. }
  2424. a->done = 1;
  2425. if ( !DemandLookahead ) {
  2426. if ( GenCC ) {
  2427. if ( FoundException && p->use_def_MT_handler ) gen("if (!_signal)");
  2428. _gen(" consume();")
  2429.                 if ( FoundException && p->use_def_MT_handler )
  2430.                     _gen(" _signal=NoSignal;");
  2431.                 _gen("n");
  2432. }
  2433.             else
  2434.             {
  2435.                 if ( FoundException && p->use_def_MT_handler ) _gen("if (!_signal)");
  2436. _gen(" zzCONSUME;n");
  2437.                 if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
  2438.                 _gen("n");
  2439.             }
  2440. }
  2441. else gen("n");
  2442. TRANS( a->next );
  2443. }
  2444. else
  2445. {
  2446.         if ( !DemandLookahead ) {
  2447. if ( GenCC ) {
  2448. if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
  2449. _gen(" consume();")
  2450. if (FoundException&&p->use_def_MT_handler) _gen(" _signal=NoSignal;");
  2451. _gen("n");
  2452. }
  2453. else {
  2454. if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
  2455. _gen(" zzCONSUME;");
  2456. if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
  2457. _gen("n");
  2458. }
  2459. }
  2460. else _gen("n");
  2461. TRANS(p->next);
  2462. }
  2463. }
  2465. void
  2466. #ifdef __USE_PROTOS
  2467. genOptBlk( Junction *q )
  2468. #else
  2469. genOptBlk( q )
  2470. Junction *q;
  2471. #endif
  2472. {
  2473. int max_k;
  2474. set f;
  2475. int need_right_curly;
  2476. set savetkref;
  2477. savetkref = tokensRefdInBlock;
  2478. require(q!=NULL, "genOptBlk: invalid node and/or rule");
  2479. require(q->ntype == nJunction, "genOptBlk: not junction");
  2480. require(q->jtype == aOptBlk, "genOptBlk: not optional block");
  2482.     OutLineInfo(output,q->line,FileStr[q->file]);
  2484. BLOCK_Preamble(q);
  2485. BlkLevel++;
  2486. f = genBlk(q, aOptBlk, &max_k, &need_right_curly);
  2487. set_free(f);
  2488. freeBlkFsets(q);
  2489. BlkLevel--;
  2490.     if ( first_item_is_guess_block((Junction *)q->p1)!=NULL )
  2491. {
  2492. gen("else if ( !zzrv ) zzGUESS_DONE;n");
  2493. }
  2494. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  2495. BLOCK_Tail();
  2496. tokensRefdInBlock = savetkref;
  2497. if (q->end->p1 != NULL) TRANS(q->end->p1);
  2498. }
  2500. /*
  2501.  * Generate code for a loop blk of form:
  2502.  *
  2503.  *  |---|
  2504.  *  v   |
  2505.  *    --o-G-o-->o--
  2506.  */
  2507. void
  2508. #ifdef __USE_PROTOS
  2509. genLoopBlk( Junction *begin, Junction *q, Junction *start, int max_k )
  2510. #else
  2511. genLoopBlk( begin, q, start, max_k )
  2512. Junction *begin;
  2513. Junction *q;
  2514. Junction *start; /* where to start generating code from */
  2515. int max_k;
  2516. #endif
  2517. {
  2518. set         f;
  2519. int         need_right_curly;
  2520. set         savetkref;
  2521.     Junction    *guessBlock;    /* MR10 */
  2522.     int         singleAlt;      /* MR10 */
  2524. savetkref = tokensRefdInBlock;
  2525. require(q->ntype == nJunction, "genLoopBlk: not junction");
  2526. require(q->jtype == aLoopBlk, "genLoopBlk: not loop block");
  2528. if ( q->visited ) return;
  2529. q->visited = TRUE;
  2531.     /* first_item_is_guess_block doesn't care what kind of node it is */
  2533.     guessBlock=first_item_is_guess_block( (Junction *) q->p1);  /* MR10 */
  2534.     singleAlt=q->p2==NULL;                                      /* MR10 */
  2536. if (singleAlt && !guessBlock)     /* MR10 */ /* only one alternative? */
  2537. {
  2538. if ( DemandLookahead )
  2539. if ( !GenCC ) {gen1("LOOK(%d);n", max_k);}
  2540. else gen1("look(%d);n", max_k);
  2541. gen("while ( ");
  2542. if ( begin!=NULL ) genExpr(begin);
  2543. else genExpr(q);
  2544. /* if no predicates have been hoisted for this single alt (..)*
  2545.  * do so now
  2546.  */
  2547.         require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
  2548. if ( ParseWithPredicates && begin->predicate==NULL )
  2549. {
  2550. Predicate *a = MR_find_predicates_and_supp((Node *)q->p1);
  2551.             require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
  2553. if ( a!=NULL )
  2554. {
  2555. _gen("&&");
  2556. a=genPredTreeMain(a, (Node *)q);    /* MR10 */
  2557. }
  2558. /* MR10 */  if (MRhoisting) {
  2559. /* MR10 */    predicate_free(a);
  2560. /* MR10 */  };
  2561. }
  2562. _gen(" ) {n");
  2563. tabs++;
  2564. TRANS(q->p1);
  2565. if ( !GenCC ) gen1("zzLOOP(zztasp%d);n", BlkLevel-1);
  2566. if ( DemandLookahead )
  2567. if ( !GenCC ) {gen1("LOOK(%d);n", max_k);}
  2568. else gen1("look(%d);n", max_k);
  2569. --tabs;
  2570. gen("}n");
  2571. freeBlkFsets(q);
  2572. q->visited = FALSE;
  2573. tokensRefdInBlock = savetkref;
  2574. return;
  2575. }
  2576. gen("while ( 1 ) {n");
  2577. tabs++;
  2578. /* MR6                  */
  2579. /* MR6     "begin" can never be null when called from genLoopBegin */
  2580. /* MR6     because q==(Junction *)begin->p1 and we know q is valid */
  2581. /* MR6                              */
  2582. /* MR6    from genLoopBegin:                 */
  2583. /* MR6                              */
  2584. /* MR6  if ( LL_k>1 && !set_nil(q->fset[2]) )         */
  2585. /* MR6      genLoopBlk( q, (Junction *)q->p1, q, max_k );     */
  2586. /* MR6 else genLoopBlk( q, (Junction *)q->p1, NULL, max_k ); */
  2587. /* MR6                               */
  2588. if ( begin!=NULL )
  2589. {
  2590. if ( DemandLookahead )
  2591. {
  2592. if ( !GenCC ) {gen1("LOOK(%d);n", max_k);}
  2593. else gen1("look(%d);n", max_k);
  2594. }
  2595. /* The bypass arc of the (...)* predicts what to do when you fail, but
  2596.  * ONLY after having tested the loop start expression.  To avoid this,
  2597.  * we simply break out of the (...)* loop when we find something that
  2598.  * is not in the prediction of the loop (all alts thereof).
  2599.  */
  2600. gen("if ( !(");
  2602. /*** TJP says: It used to use the prediction expression for the bypass arc
  2603.       of the (...)*.  HOWEVER, if a non LL^1(k) decision was found, this
  2604.      thing would miss the ftree stored in the aLoopBegin node and generate
  2605.      an LL^1(k) decision anyway.
  2607.  *** genExpr((Junction *)begin->p2);
  2608.  ***/
  2610.             genExpr((Junction *)begin);
  2611.             _gen(")) break;n");
  2613. }
  2615. /* generate code for terminating loop (this is optional branch) */
  2617. f = genBlk(q, aLoopBlk, &max_k, &need_right_curly);
  2618. set_free(f);
  2619. freeBlkFsets(q);
  2621. /* generate code for terminating loop (this is optional branch) */
  2623. /* MR6                                   */
  2624. /* MR6  30-May-97 Bug reported by Manuel Ornato             */
  2625. /* MR6            A definite bug involving the exit from a loop block   */
  2626. /* MR6    In 1.23 and later versions (including 1.33) Instead       */
  2627. /* MR6              exiting the block and reporting a syntax error the  */
  2628. /* MR6     code loops forever.                      */
  2629. /* MR6           Looking at 1.20 which generates proper code it is not */
  2630. /* MR6     clear which of two changes should be undone.            */
  2631. /* MR6   This is my best guess.                                    */
  2632. /* MR6   From earlier MR6 note we know that begin can never be     */
  2633. /* MR6     null when genLoopBlk called from genLoopBegin           */
  2634. /* MR6 */
  2635. /* MR6 */ if ( begin==NULL) {
  2636. /* MR6 */   /* code for exiting loop "for sure" */
  2637. /* MR6 */   gen("/* Suppressed by MR6 */ /*** else break; ***/n");
  2638. /* MR6 */ };
  2640. /* MR10 */if (singleAlt && guessBlock) {
  2641. /* MR10 */  tabs--;
  2642. /* MR6 */   gen("} else break; /* MR6 code for exiting loop "for sure" */n");
  2643. /* MR10 */  need_right_curly--;
  2644. /* MR10 */ } else {
  2645. /* MR6 */   gen("else break; /* MR6 code for exiting loop "for sure" */n");
  2646. /* MR10 */ };
  2648. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  2649. if ( !GenCC ) gen1("zzLOOP(zztasp%d);n", BlkLevel-1);
  2650. --tabs;
  2651. gen("}n");
  2652. q->visited = FALSE;
  2653. tokensRefdInBlock = savetkref;
  2654. }
  2656. /*
  2657.  * Generate code for a loop blk of form:
  2658.  *
  2659.  *           |---|
  2660.  *      v   |
  2661.  *    --o-->o-->o-G-o-->o--
  2662.  *                   |           ^
  2663.  *                   v           |
  2664.  *  o-----------o
  2665.  *
  2666.  * q->end points to the last node (far right) in the blk.
  2667.  *
  2668.  * Note that q->end->jtype must be 'EndBlk'.
  2669.  *
  2670.  * Generate code roughly of the following form:
  2671.  *
  2672.  * do {
  2673.  * ... code for alternatives ...
  2674.  *  } while ( First Set of aLoopBlk );
  2675.  *
  2676.  * OR if > 1 alternative
  2677.  *
  2678.  * do {
  2679.  * ... code for alternatives ...
  2680.  * else break;
  2681.  *  } while ( 1 );
  2682.  */
  2683. void
  2684. #ifdef __USE_PROTOS
  2685. genLoopBegin( Junction *q )
  2686. #else
  2687. genLoopBegin( q )
  2688. Junction *q;
  2689. #endif
  2690. {
  2691. set f;
  2692. int i;
  2693. int max_k;
  2694. set savetkref;
  2695. savetkref = tokensRefdInBlock;
  2696. require(q!=NULL, "genLoopBegin: invalid node and/or rule");
  2697. require(q->ntype == nJunction, "genLoopBegin: not junction");
  2698. require(q->jtype == aLoopBegin, "genLoopBegin: not loop block");
  2699. require(q->p2!=NULL, "genLoopBegin: invalid Loop Graph");
  2701.     OutLineInfo(output,q->line,FileStr[q->file]);
  2703. BLOCK_Preamble(q);
  2704. BlkLevel++;
  2705. f = First(q, 1, aLoopBegin, &max_k);
  2706. /* If not simple LL(1), must specify to start at LoopBegin, not LoopBlk */
  2707. if ( LL_k>1 && !set_nil(q->fset[2]) )
  2708. genLoopBlk( q, (Junction *)q->p1, q, max_k );
  2709. else genLoopBlk( q, (Junction *)q->p1, NULL, max_k );
  2711. for (i=1; i<=CLL_k; i++) set_free(q->fset[i]);
  2712. for (i=1; i<=CLL_k; i++) set_free(((Junction *)q->p2)->fset[i]);
  2713. --BlkLevel;
  2714. BLOCK_Tail();
  2715. set_free(f);
  2716. tokensRefdInBlock = savetkref;
  2717. if (q->end->p1 != NULL) TRANS(q->end->p1);
  2718. }
  2720. /*
  2721.  * Generate code for a loop blk of form:
  2722.  *
  2723.  *   |---|
  2724.  *  v   |
  2725.  *        --o-G-o-->o--
  2726.  *
  2727.  * q->end points to the last node (far right) in the blk.
  2728.  * Note that q->end->jtype must be 'EndBlk'.
  2729.  *
  2730.  * Generate code roughly of the following form:
  2731.  *
  2732.  * do {
  2733.  * ... code for alternatives ...
  2734.  *  } while ( First Set of aPlusBlk );
  2735.  *
  2736.  * OR if > 1 alternative
  2737.  *
  2738.  * do {
  2739.  * ... code for alternatives ...
  2740.  * else if not 1st time through, break;
  2741.  *  } while ( 1 );
  2742.  */
  2743. void
  2744. #ifdef __USE_PROTOS
  2745. genPlusBlk( Junction *q )
  2746. #else
  2747. genPlusBlk( q )
  2748. Junction *q;
  2749. #endif
  2750. {
  2751. int         max_k;
  2752. set         f;
  2753. int         need_right_curly;
  2754. set         savetkref;
  2755.     Junction    *guessBlock;    /* MR10 */
  2756.     int         singleAlt;      /* MR10 */
  2758. savetkref = tokensRefdInBlock;
  2759. require(q!=NULL, "genPlusBlk: invalid node and/or rule");
  2760. require(q->ntype == nJunction, "genPlusBlk: not junction");
  2761. require(q->jtype == aPlusBlk, "genPlusBlk: not Plus block");
  2762. require(q->p2 != NULL, "genPlusBlk: not a valid Plus block");
  2764. if ( q->visited ) return;
  2765. q->visited = TRUE;
  2766.     OutLineInfo(output,q->line,FileStr[q->file]);
  2767. BLOCK_Preamble(q);
  2768. BlkLevel++;
  2770.     /* first_item_is_guess_block  doesn't care what kind of node it is */
  2772.     guessBlock=first_item_is_guess_block( (Junction *)q->p1);   /* MR10 */
  2774. /* if the ignore flag is set on the 2nd alt and that alt is empty,
  2775.  * then it is the implied optional alternative that we added for (...)+
  2776.  * and, hence, only 1 alt.
  2777.  */
  2779. /* MR10  Reported by Pulkkinen Esa (esap@cs.tut.fi)
  2780.  *       Outer code for guess blocks ignored when there is only one alt
  2781.  *         for a (...)+ block.
  2782.  *       Force use of regular code rather than "optimized" code for that case
  2783.  */
  2785.     singleAlt=( ( (Junction *) q->p2)->p2 == NULL) &&
  2786.            ( ( (Junction *) q->p2)->ignore ); /* only one alternative? */
  2788.     if (singleAlt && !guessBlock)   /* MR10 */
  2789. {
  2791. Predicate *a=NULL;
  2792. /* if the only alt has a semantic predicate, hoist it; must test before
  2793.  * entering loop.
  2794.  */
  2795. if ( ParseWithPredicates )
  2796. {
  2797.             require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
  2798. a = MR_find_predicates_and_supp((Node *)q);
  2799.             require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
  2801. if ( a!=NULL ) {
  2802. gen("if (");
  2803. a=genPredTreeMain(a, (Node *)q);    /* MR10 */
  2804. _gen(") {n");
  2805. }
  2806. }
  2807. gen("do {n");
  2808. tabs++;
  2809. TRANS(q->p1);
  2810. if ( !GenCC ) gen1("zzLOOP(zztasp%d);n", BlkLevel-1);
  2811. f = First(q, 1, aPlusBlk, &max_k);
  2812. if ( DemandLookahead )
  2813. if ( !GenCC ) {gen1("LOOK(%d);n", max_k);}
  2814. else gen1("look(%d);n", max_k);
  2815. --tabs;
  2816. gen("} while ( ");
  2817. if ( q->parm!=NULL && q->predparm ) _gen1("(%s) && ", q->parm);
  2818. genExpr(q);
  2819. if ( ParseWithPredicates && a!=NULL )
  2820. {
  2821.             if (! MR_comparePredicates(q->predicate,a)) {
  2822.      _gen("&&");
  2823.      a=genPredTreeMain(a, (Node *)q);    /* MR10 */
  2824.             };
  2825. }
  2826. _gen(" );n");
  2827. if ( ParseWithPredicates && a!=NULL ) gen("}n");
  2828. --BlkLevel;
  2829. BLOCK_Tail();
  2830. q->visited = FALSE;
  2831. freeBlkFsets(q);
  2832. set_free(f);
  2833. tokensRefdInBlock = savetkref;
  2834. if (q->end->p1 != NULL) TRANS(q->end->p1);
  2835. /* MR10 */  if (MRhoisting) {
  2836. /* MR10 */    predicate_free(a);
  2837. /* MR10 */  };
  2838. return;
  2839. }
  2840. gen("do {n");
  2841. tabs++;
  2842. f = genBlk(q, aPlusBlk, &max_k, &need_right_curly);
  2843. /* MR6                       */
  2844. /* MR6 Sinan Karasu (sinan@tardis.ds.boeing.com) */
  2845. /* MR6    Failed to turn off guess mode when leaving block */
  2846. /* MR6                             */
  2847. /* MR6  */ if ( has_guess_block_as_last_item(q) ) {
  2848. /* MR10 */   gen("/* MR10 ()+ */ else {n");
  2849. /* MR10 */   tabs++;
  2850. /* MR10 */   need_right_curly++;
  2851. /* MR10 */   gen("/* MR10 ()+ */ if ( !zzrv ) zzGUESS_DONE;n");
  2852. /* MR6  */   gen("/* MR10 ()+ */ if ( zzcnt > 1 ) break;n");
  2853. /* MR10 */ } else {
  2854. /* MR10 */   gen("/* MR10 ()+ */ else {n");
  2855. /* MR10 */   tabs++;
  2856. /* MR10 */   need_right_curly++;
  2857. /* MR10 */   gen("if ( zzcnt > 1 ) break;n");
  2858. /* MR10 */ };
  2860. tab();
  2861. makeErrorClause(q,f,max_k);
  2862. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  2863. freeBlkFsets(q);
  2864. gen("zzcnt++;");
  2865. if ( !GenCC ) _gen1(" zzLOOP(zztasp%d);", BlkLevel-1);
  2866. _gen("n");
  2867. if ( DemandLookahead )
  2868. if ( !GenCC ) {gen1("LOOK(%d);n", max_k);}
  2869. else gen1("look(%d);n", max_k);
  2870. --tabs;
  2871. if ( q->parm!=NULL && q->predparm ) {gen1("} while (%s);n", q->parm);}
  2872. else gen("} while ( 1 );n");
  2873. --BlkLevel;
  2874. BLOCK_Tail();
  2875. q->visited = FALSE;
  2876. tokensRefdInBlock = savetkref;
  2877. if (q->end->p1 != NULL) TRANS(q->end->p1);
  2878. }
  2880. /*
  2881.  * Generate code for a sub blk of alternatives of form:
  2882.  *
  2883.  *        --o-G1--o--
  2884.  *  |     ^
  2885.  *  v    /|
  2886.  *          o-G2-o|
  2887.  *  |     ^
  2888.  *  v     |
  2889.  *    ..........
  2890.  *  |     ^
  2891.  *  v    /
  2892.  *          o-Gn-o
  2893.  *
  2894.  * q points to the 1st junction of blk (upper-left).
  2895.  * q->end points to the last node (far right) in the blk.
  2896.  * Note that q->end->jtype must be 'EndBlk'.
  2897.  * The last node in every alt points to q->end.
  2898.  *
  2899.  * Generate code of the following form:
  2900.  * if ( First(G1) ) {
  2901.  * ...code for G1...
  2902.  * }
  2903.  * else if ( First(G2) ) {
  2904.  * ...code for G2...
  2905.  * }
  2906.  * ...
  2907.  * else {
  2908.  * ...code for Gn...
  2909.  * }
  2910.  */
  2911. void
  2912. #ifdef __USE_PROTOS
  2913. genSubBlk( Junction *q )
  2914. #else
  2915. genSubBlk( q )
  2916. Junction *q;
  2917. #endif
  2918. {
  2919. int max_k;
  2920. set f;
  2921. int need_right_curly;
  2922. set savetkref;
  2923. savetkref = tokensRefdInBlock;
  2924. require(q->ntype == nJunction, "genSubBlk: not junction");
  2925. require(q->jtype == aSubBlk, "genSubBlk: not subblock");
  2927.     OutLineInfo(output,q->line,FileStr[q->file]);
  2928. BLOCK_Preamble(q);
  2929. BlkLevel++;
  2930. f = genBlk(q, aSubBlk, &max_k, &need_right_curly);
  2931. if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k);}
  2932. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  2933. freeBlkFsets(q);
  2934. --BlkLevel;
  2935. BLOCK_Tail();
  2937. if ( q->guess )
  2938. {
  2939. gen("zzGUESS_DONEn");
  2940. }
  2942. /* must duplicate if (alpha)?; one guesses (validates), the
  2943.  * second pass matches */
  2944. if ( q->guess && analysis_point(q)==q )
  2945. {
  2946.         OutLineInfo(output,q->line,FileStr[q->file]);
  2947. BLOCK_Preamble(q);
  2948. BlkLevel++;
  2949. f = genBlk(q, aSubBlk, &max_k, &need_right_curly);
  2950. if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k);}
  2951. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  2952. freeBlkFsets(q);
  2953. --BlkLevel;
  2954. BLOCK_Tail();
  2955. }
  2957. tokensRefdInBlock = savetkref;
  2958. if (q->end->p1 != NULL) TRANS(q->end->p1);
  2959. }
  2961. static int TnodesAllocatedPrevRule=0;
  2963. /*
  2964.  * Generate code for a rule.
  2965.  *
  2966.  * rule--> o-->o-Alternatives-o-->o
  2967.  * Or,
  2968.  * rule--> o-->o-Alternative-o-->o
  2969.  *
  2970.  * The 1st junction is a RuleBlk.  The second can be a SubBlk or just a junction
  2971.  * (one alternative--no block), the last is EndRule.
  2972.  * The second to last is EndBlk if more than one alternative exists in the rule.
  2973.  *
  2974.  * To get to the init-action for a rule, we must bypass the RuleBlk,
  2975.  * and possible SubBlk.
  2976.  * Mark any init-action as generated so genBlk() does not regenerate it.
  2977.  */
  2978. void
  2979. #ifdef __USE_PROTOS
  2980. genRule( Junction *q )
  2981. #else
  2982. genRule( q )
  2983. Junction *q;
  2984. #endif
  2985. {
  2988. do {    /* MR10     Change recursion into iteration         */
  2990. int max_k;
  2991. set follow, rk, f;
  2992. ActionNode *a;
  2993. RuleEntry *r;
  2994. static int file = -1;
  2995. int need_right_curly;
  2996. require(q->ntype == nJunction, "genRule: not junction");
  2997. require(q->jtype == RuleBlk, "genRule: not rule");
  2999. /* MR14 */    require (MR_BackTraceStack.count == 0,"-alpha MR_BackTraceStack.count != 0");
  3000. /* MR14 */    MR_pointerStackReset(&MR_BackTraceStack);
  3001. /* MR14 */    if (AlphaBetaTrace) MR_MaintainBackTrace=1;
  3003.     CurRule=q->rname;                               /* MR11 */
  3005. r = (RuleEntry *) hash_get(Rname, q->rname);
  3006. if ( r == NULL ) warnNoFL("Rule hash table is screwed up beyond belief");
  3007. if ( q->file != file ) /* open new output file if need to */
  3008. {
  3009. /* MR6               */
  3010. /* MR6  Simpler to debug when output goes to stdout rather than a file  */
  3011. /* MR6                  */
  3012. /* MR6 */ if (UseStdout) {
  3013. /* MR6 */   output = stdout;
  3014. /* MR6 */ } else {
  3015. /* MR6 */     if ( output != NULL) fclose( output );
  3016. /* MR6 */   output = fopen(OutMetaName(outname(FileStr[q->file])), "w");
  3017. /* MR6 */ };
  3018. require(output != NULL, "genRule: can't open output file");
  3020. #ifdef SPECIAL_FOPEN
  3021.        special_fopen_actions(OutMetaName(outname(FileStr[q->file]))); /* MR1 */
  3022. #endif
  3023. if ( file == -1 ) genHdr1(q->file);
  3024. else genHdr(q->file);
  3025. file = q->file;
  3026. }
  3028.     if (InfoM) {
  3029.       fprintf(stderr,"    rule %sn",q->rname);
  3030.       fflush(output);
  3031.     };
  3033. #if 0
  3034.     if (strcmp(q->rname,"***debug***") == 0) {
  3035.       fprintf(stderr,"***debug*** %s reachedn",q->rname);
  3036.       MR_break();
  3037.     };
  3038. #endif
  3040. DumpFuncHeader(q,r);
  3041. tabs++;
  3042. if ( q->ret!=NULL )
  3043. {
  3044. /* Declare the return value - and PURIFY it -ATG 6/5/95 */
  3046. /* MR7      Moved PURIFY() to after all local variables have been declared */
  3047. /* MR7      so that the generated code is valid C as well as C++           */
  3048. /* MR7        Jan Mikkelsen 10-June-1997                                   */
  3050. if ( HasComma(q->ret) )
  3051. {
  3052. gen1("struct _rv%d _retv;n",r->rulenum);
  3053. }
  3054. else
  3055. {
  3056. tab();
  3057. DumpType(q->ret, output);
  3059. /* MR3  17-May-97  Undo change since _retv is of unpredictable type        */
  3060. /* MR3    If an object it may not be possible to assign 0 or NULL     */
  3061. /* MR3    Reported by Cortland Starrett (cort@shay.ecn.purdue.edu     */
  3062. /* MR1  10-Apr-97  Get rid of annoying Possibly ref'd before use msgs      */
  3064. gen(" _retv;n");            /* MR1 MR3         */
  3065. }
  3066. }
  3068.     OutLineInfo(output,q->line,FileStr[q->file]);
  3070.     if (InfoM) {
  3071.       fflush(output);
  3072.     };
  3074. gen("zzRULE;n");
  3075. if ( FoundException )
  3076. {
  3077. gen("int _sva=1;n");
  3078. }
  3079. if ( GenCC && GenAST )
  3080. gen("ASTBase *_ast = NULL, *_sibling = NULL, *_tail = NULL;n");
  3081. if ( GenCC ) genTokenPointers(q);
  3082. if ( GenCC&&GenAST ) genASTPointers(q);
  3083. if ( q->el_labels!=NULL ) genElementLabels(q->el_labels);
  3084. if ( FoundException ) gen("int _signal=NoSignal;n");
  3086. if ( !GenCC ) gen1("zzBLOCK(zztasp%d);n", BlkLevel);
  3088. /* MR10 */  /* move zzTRACEIN to before init action */
  3090. /* MR10 */ if ( TraceGen )
  3091. /* MR10 */ if ( GenCC ) {gen1("zzTRACEIN("%s");n", q->rname);}
  3092. /* MR10 */ else gen1("zzTRACEIN((ANTLRChar *)"%s");n", q->rname);
  3094. /* MR7      Moved PURIFY() to after all local variables have been declared */
  3095. /* MR7      so that the generated code is valid C as well as C++           */
  3096. /* MR7        Jan Mikkelsen 10-June-1997                                   */
  3098. if ( q->ret != NULL )                                            /* MR7 */
  3099. {                                                                /* MR7 */
  3100. if ( HasComma(q->ret) )                                      /* MR7 */
  3101. {                                                            /* MR7 */
  3102. gen1("PURIFY(_retv,sizeof(struct _rv%d))n",r->rulenum); /* MR7 */
  3103. }                                                            /* MR7 */
  3104. else                                                         /* MR7 */
  3105. {                                                            /* MR7 */
  3106. gen("PURIFY(_retv,sizeof(");                             /* MR7 */
  3107. DumpType(q->ret, output);                                /* MR7 */
  3108. gen("))n");                                             /* MR7 */
  3109. }                                                            /* MR7 */
  3110. }                                                                /* MR7 */
  3111. if ( !GenCC ) gen("zzMake0;n");
  3112. if ( FoundException ) gen("*_retsignal = NoSignal;n");
  3114. if ( !GenCC ) gen("{n");
  3116. if ( has_guess_block_as_first_item((Junction *)q->p1) )
  3117. {
  3118. gen("zzGUESS_BLOCKn");
  3119. }
  3121. /* L o o k  F o r  I n i t  A c t i o n */
  3122. if ( ((Junction *)q->p1)->jtype == aSubBlk )
  3123. a = findImmedAction( ((Junction *)q->p1)->p1 );
  3124. else
  3125. a = findImmedAction( q->p1 ); /* only one alternative in rule */
  3126. if ( a!=NULL && !a->is_predicate)
  3127. {
  3128. if (!a->noHoist) dumpAction(a->action, output, tabs, a->file, a->line, 1);
  3129. a->done = 1; /* ignore action. We have already handled it */
  3130. }
  3132. BlkLevel++;
  3133. q->visited = TRUE; /* mark RULE as visited for FIRST/FOLLOW */
  3134. f = genBlk((Junction *)q->p1, RuleBlk, &max_k, &need_right_curly);
  3135. if ( q->p1 != NULL )
  3136. if ( ((Junction *)q->p1)->p2 != NULL )
  3137. {tab(); makeErrorClause((Junction *)q->p1,f,max_k);}
  3138. { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}n");} }
  3139. freeBlkFsets((Junction *)q->p1);
  3140. q->visited = FALSE;
  3141. --BlkLevel;
  3142. if ( !GenCC ) gen1("zzEXIT(zztasp%d);n", BlkLevel);
  3144.     genTraceOut(q);
  3146. if ( q->ret!=NULL ) gen("return _retv;n") else gen("return;n");
  3147. /* E r r o r  R e c o v e r y */
  3148. NewSet();
  3149. rk = empty;
  3151. /* MR14 */    if (r->dontComputeErrorSet) {
  3152. /* MR14 */      follow=empty;
  3153.               } else {
  3154.                 MR_pointerStackReset(&MR_BackTraceStack);   /* MR14 */
  3155.                 MR_ErrorSetComputationActive=1;
  3156.                 REACH(q->end, 1, &rk, follow);
  3157.                 MR_ErrorSetComputationActive=0;
  3158.                 require (MR_BackTraceStack.count == 0,"K: MR_BackTraceStack.count != 0");
  3159.               }
  3160. FillSet( follow );
  3161. set_free( follow );
  3163. _gen("fail:n");
  3164. if ( !GenCC ) gen("zzEXIT(zztasp1);n");
  3165. if ( FoundGuessBlk )
  3166.     if ( !GenCC ) {gen("if ( zzguessing ) zzGUESS_FAIL;n");}
  3167. else gen("if ( guessing ) zzGUESS_FAIL;n");
  3168. if ( q->erraction!=NULL )
  3169. dumpAction(q->erraction, output, tabs, q->file, q->line, 1);
  3170. if ( GenCC )
  3171. {
  3172. gen1("syn(zzBadTok, %s, zzMissSet, zzMissTok, zzErrk);n",
  3173.  r->egroup==NULL?"(ANTLRChar *)""":r->egroup);
  3174. }
  3175. else
  3176. {
  3177. gen1("zzsyn(zzMissText, zzBadTok, %s, zzMissSet, zzMissTok, zzErrk, zzBadText);n",
  3178.  r->egroup==NULL?"(ANTLRChar *)""":r->egroup);
  3179. }
  3180. gen3("%sresynch(setwd%d, 0x%x);n", GenCC?"":"zz", wordnum, 1<<setnum);
  3183. if ( q->ret!=NULL ) {
  3184.       genTraceOut(q);
  3185.       gen("return _retv;n");
  3186.     } else if ( q->exceptions!=NULL ) {
  3187.       genTraceOut(q);
  3188.       gen("return;n");
  3189.     } else if (!FoundException) {       /* MR10 */
  3190.       genTraceOut(q);                   /* MR10 */
  3191.     };
  3193. if ( !GenCC ) gen("}n");
  3195. /* Gen code for exception handlers */
  3196.     /* make sure each path out contains genTraceOut() */
  3198. if ( q->exceptions!=NULL )
  3199. {
  3201. gen("/* exception handlers */n");
  3203. dumpExceptions(q->exceptions);
  3205.         if ( !r->has_rule_exception )
  3206.         {
  3207.             _gen("_handler:n");
  3208.             gen("zzdflthandlers(_signal,_retsignal);n");
  3209.         }
  3210. _gen("_adios:n");
  3211. if ( q->ret!=NULL ) {
  3212.             genTraceOut(q);
  3213.             gen("return _retv;n");
  3214.         }
  3215. else {
  3216.             genTraceOut(q);
  3217.             gen("return;n");
  3218.         }
  3219. }
  3220. else if ( FoundException )
  3221. {
  3222.       _gen("_handler:n");
  3223.       gen("zzdflthandlers(_signal,_retsignal);n");
  3225. /* MR1                                                                      */
  3226. /* MR1  7-Apr-97 Fix suggested by: John Bair (jbair@iftime.com)            */
  3227. /* MR1                                             */
  3229.       if ( q->ret != NULL) {                              /* MR1 */
  3230.             genTraceOut(q);                                          /* MR10 */
  3231.             gen("return _retv;n");                          /* MR1 */
  3232.       } else {                                      /* MR1 */
  3233.             genTraceOut(q);                                          /* MR10 */
  3234.             gen("return;n")    ;                      /* MR1 */
  3235.       };                                      /* MR1 */
  3236. }
  3238. tabs--;
  3239. gen("}n");
  3241. /* MR10     Tired of looking at stacks that are as deep as the number of    */
  3242. /* MR10       rules.  Changes recursion to iteration.                       */
  3244.     MR_releaseResourcesUsedInRule( (Node *) q );      /* MR10 */
  3246.     if (InfoT) {
  3247.       fprintf(output,"n/* tnodes created for rule %s:  %d */n",
  3248.                 q->rname, (TnodesAllocated-TnodesAllocatedPrevRule) );
  3249.     };
  3251.     TnodesAllocatedPrevRule=TnodesAllocated;
  3253.     if (q->p2 == NULL) dumpAfterActions( output );
  3254.     q=(Junction *)q->p2;
  3255.     require(q==NULL || q->jtype==RuleBlk,"RuleBlk p2 does not point to another RuleBlk");
  3257. } while (q != NULL);
  3259. /**** The old code                           ****/
  3260. /**** if ( q->p2 != NULL ) {TRANS(q->p2);} ****/ /* generate code for next rule too */
  3261. /**** else dumpAfterActions( output );     ****/
  3263. }
  3265. static void
  3266. #ifdef __USE_PROTOS
  3267. DumpFuncHeader( Junction *q, RuleEntry *r )
  3268. #else
  3269. DumpFuncHeader( q, r )
  3270. Junction *q;
  3271. RuleEntry *r;
  3272. #endif
  3273. {
  3274. /*                                             */
  3275. /*  MR1 10-Apr-97  MR1  Simplify insertion of commas in function header     */
  3276. /*                                             */
  3277. int needComma;                                  /* MR1 */
  3279. /* A N S I */
  3280. _gen("n");
  3281. if ( q->ret!=NULL )
  3282. {
  3283. if ( HasComma(q->ret) )
  3284. {
  3285. if (GenCC) gen2("%s::_rv%dn", CurrentClassName, r->rulenum)
  3286. else gen1("struct _rv%dn",r->rulenum);
  3287. }
  3288. else
  3289. {
  3290. DumpType(q->ret, output);
  3291. gen("n");
  3292. }
  3293. }
  3294. else
  3295. {
  3296. _gen("voidn");
  3297. }
  3298. /*  MR1                                                             */
  3299. /*  MR1 10-Apr-97  133MR1 Replace __STDC__ with __USE_PROTOS              */
  3300. /*  MR1                                         */
  3301. if ( !GenCC ) _gen("#ifdef __USE_PROTOSn");      /* MR1 */
  3302. if ( !GenCC ) gen2("%s%s(", RulePrefix, q->rname)
  3303. else gen3("%s::%s%s(", CurrentClassName, RulePrefix,q->rname);
  3304. DumpANSIFunctionArgDef(output,q);
  3305. _gen("n");
  3307. if ( GenCC ) {
  3308.       gen("{n");
  3309.       return;
  3310.     }
  3312. /* K & R */
  3313. gen("#elsen");
  3314. gen2("%s%s(", RulePrefix, q->rname);
  3315. needComma=0;                              /* MR1 */
  3316. if ( GenAST )                              /* MR1 */
  3317. {                                      /* MR1 */
  3318. _gen("_root");                              /* MR1 */
  3319. needComma=1;                              /* MR1 */
  3320. }                                      /* MR1 */
  3321. if ( FoundException )                          /* MR1 */
  3322. {                                      /* MR1 */
  3323. if (needComma) {_gen(",");needComma=0;};                  /* MR1 */
  3324. _gen("_retsignal");                              /* MR1 */
  3325. needComma=1;                              /* MR1 */
  3326. }                                      /* MR1 */
  3327. /* MR5 Change below by Jan Mikkelsen (janm@zeta.org.au) 26-May-97      MR5 */
  3328. DumpListOfParmNames( q->pdecl, output, needComma );              /* MR5 */
  3329. gen(")n");
  3330. if ( GenAST ) gen("AST **_root;n");
  3331. if ( FoundException ) gen("int *_retsignal;n");
  3332. DumpOldStyleParms( q->pdecl, output );
  3333. gen("#endifn");
  3334.     gen("{n");
  3335. }
  3337. void
  3338. #ifdef __USE_PROTOS
  3339. DumpANSIFunctionArgDef(FILE *f, Junction *q)
  3340. #else
  3341. DumpANSIFunctionArgDef(f,q)
  3342. FILE *f;
  3343. Junction *q;
  3344. #endif
  3345. {
  3346. if ( GenAST )
  3347. {
  3348. if ( GenCC ) {fprintf(f,"ASTBase **_root");}
  3349. else fprintf(f,"AST**_root");
  3350. if ( !FoundException && q->pdecl!=NULL ) fprintf(f,",");
  3351. }
  3352. if ( FoundException )
  3353. {
  3354. if ( GenAST ) fprintf(f,",");
  3355. fprintf(f,"int *_retsignal");
  3356. if ( q->pdecl!=NULL ) fprintf(f,",");
  3357. }
  3358. if ( q->pdecl!=NULL ) {fprintf(f,"%s", q->pdecl);}
  3359. else if ( !GenAST && !FoundException ) fprintf(f,"void");
  3360. fprintf(f,")");
  3361. }
  3363. void
  3364. #ifdef __USE_PROTOS
  3365. genJunction( Junction *q )
  3366. #else
  3367. genJunction( q )
  3368. Junction *q;
  3369. #endif
  3370. {
  3371. require(q->ntype == nJunction, "genJunction: not junction");
  3372. require(q->jtype == Generic, "genJunction: not generic junction");
  3374. if ( q->p1 != NULL ) TRANS(q->p1);
  3375. if ( q->p2 != NULL ) TRANS(q->p2);
  3376. }
  3378. void
  3379. #ifdef __USE_PROTOS
  3380. genEndBlk( Junction *q )
  3381. #else
  3382. genEndBlk( q )
  3383. Junction *q;
  3384. #endif
  3385. {
  3386. }
  3388. void
  3389. #ifdef __USE_PROTOS
  3390. genEndRule( Junction *q )
  3391. #else
  3392. genEndRule( q )
  3393. Junction *q;
  3394. #endif
  3395. {
  3396. }
  3398. void
  3399. #ifdef __USE_PROTOS
  3400. genHdr( int file )
  3401. #else
  3402. genHdr( file )
  3403. int file;
  3404. #endif
  3405. {
  3406.     int     i;
  3408. _gen("/*n");
  3409. _gen(" * A n t l r  T r a n s l a t i o n  H e a d e rn");
  3410. _gen(" *n");
  3411. _gen(" * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998n");
  3412. _gen(" * Purdue University Electrical Engineeringn");
  3413. _gen(" * With AHPCRC, University of Minnesotan");
  3414. _gen1(" * ANTLR Version %sn", Version);
  3415. _gen(" *n");
  3416. /* MR10 */    _gen(" *  ");
  3417. /* MR10 */    for (i=0 ; i < Save_argc ; i++) {
  3418. /* MR10 */      _gen(" ");
  3419. /* MR10 */      _gen(Save_argv[i]);
  3420. /* MR10 */    };
  3421. _gen("n");
  3422. _gen(" *n");
  3423.     _gen(" */nn");
  3424. _gen1("#define ANTLR_VERSION %sn", VersionDef);
  3425. if (FirstAction != NULL ) dumpAction( FirstAction, output, 0, -1, 0, 1);    /* MR11 */
  3426. _gen("#include "pcctscfg.h"n");
  3427. _gen("#include PCCTS_STDIO_Hn");
  3428. if ( strcmp(ParserName, DefaultParserName)!=0 )
  3429. _gen2("#define %s %sn", DefaultParserName, ParserName);
  3430.     if ( strcmp(ParserName, DefaultParserName)!=0 )
  3431. {_gen1("#include "%s"n", RemapFileName);}
  3432.     OutLineInfo(output,1,FileStr[file]);
  3433. if ( GenCC ) {
  3434. if ( UserTokenDefsFile != NULL )
  3435. fprintf(output, "#include %sn", UserTokenDefsFile);
  3436. else
  3437. fprintf(output, "#include "%s"n", DefFileName);
  3438. }
  3440. if ( HdrAction != NULL ) dumpAction( HdrAction, output, 0, -1, 0, 1);
  3441. if ( !GenCC && FoundGuessBlk )
  3442. {
  3443. _gen("#define ZZCAN_GUESSn");
  3444. _gen("#include PCCTS_SETJMPn");
  3445. }
  3446. if ( FoundException )
  3447. {
  3448. _gen("#define EXCEPTION_HANDLINGn");
  3449. _gen1("#define NUM_SIGNALS %dn", NumSignals);
  3450. }
  3451. if ( !GenCC && OutputLL_k > 1 ) _gen1("#define LL_K %dn", OutputLL_k);
  3452. if ( GenAST&&!GenCC ) _gen("#define GENASTnn");
  3453. if ( GenAST ) {
  3454. if ( GenCC ) {_gen1("#include "%s"nn", ASTBASE_H);}
  3455. else _gen("#include "ast.h"nn");
  3456. }
  3457. if ( !GenCC && DemandLookahead ) _gen("#define DEMAND_LOOKnn");
  3458. #ifdef DUM
  3459. if ( !GenCC && LexGen ) {
  3460. _gen1("#define zzEOF_TOKEN %dn", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
  3461. }
  3462. #endif
  3463. /* ###WARNING: This will have to change when SetWordSize changes */
  3464. if ( !GenCC ) _gen1("#define zzSET_SIZE %dn", NumWords(TokenNum-1)*sizeof(unsigned));
  3465.     if (TraceGen) {
  3466.       _gen("#define zzTRACE_RULESn");  /* MR10 */
  3467.     };
  3468. if ( !GenCC ) {_gen("#include "antlr.h"n");}
  3469. else {
  3470. _gen1("#include "%s"n", APARSER_H);
  3471. _gen1("#include "%s.h"n", CurrentClassName);
  3472. }
  3473. if ( !GenCC ) {
  3474. if ( UserDefdTokens )
  3475. {_gen1("#include %sn", UserTokenDefsFile);}
  3476. /* still need this one as it has the func prototypes */
  3477. _gen1("#include "%s"n", DefFileName);
  3478. }
  3479. /* still need this one as it defines the DLG interface */
  3480. if ( !GenCC ) _gen("#include "dlgdef.h"n");
  3481. if ( LexGen && GenCC ) _gen1("#include "%s"n", DLEXERBASE_H);
  3482. if ( GenCC ) _gen1("#include "%s"n", ATOKPTR_H);
  3483. if ( !GenCC && LexGen ) _gen1("#include "%s"n", ModeFileName);
  3485. /* MR10  Ofer Ben-Ami (gremlin@cs.huji.ac.il)           */
  3486. /* MR10    Finally, a definition of the Purify macro    */
  3488. _gen("#ifndef PURIFYn");
  3489.     _gen("#define PURIFY(r,s) memset((char *) &(r),'\0',(s));n");
  3490.     _gen("#endifn");
  3491. }
  3493. void
  3494. #ifdef __USE_PROTOS
  3495. genHdr1( int file )
  3496. #else
  3497. genHdr1( file )
  3498. int file;
  3499. #endif
  3500. {
  3501. ListNode *p;
  3503. genHdr(file);
  3504. if ( GenAST )
  3505. {
  3506. if ( !GenCC ) {
  3507. _gen("#include "ast.c"n");
  3508. _gen("zzASTgvarsnn");
  3509. }
  3510. }
  3511. if ( !GenCC ) _gen("ANTLR_INFOn");
  3512. if ( BeforeActions != NULL )
  3513. {
  3514. for (p = BeforeActions->next; p!=NULL; p=p->next)
  3515. {
  3516. UserAction *ua = (UserAction *)p->elem;
  3517. dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
  3518. }
  3519. }
  3521. if ( !FoundException ) return;
  3523. if ( GenCC )
  3524. {
  3525. _gen1("nvoid %s::n", CurrentClassName);
  3526. _gen("zzdflthandlers( int _signal, int *_retsignal )n");
  3527. _gen("{n");
  3528. }
  3529. else
  3530. {
  3531. _gen("nvoidn");
  3532. /*  MR1                                                         */
  3533. /*  MR1 10-Apr-97  133MR1 Replace __STDC__ with __USE_PROTOS              */
  3534. /*  MR1                                                                     */
  3535.     _gen("#ifdef __USE_PROTOSn");                               /* MR1 */
  3536. _gen("zzdflthandlers( int _signal, int *_retsignal )n");
  3537. _gen("#elsen");
  3538. _gen("zzdflthandlers( _signal, _retsignal )n");
  3539. _gen("int _signal;n");
  3540. _gen("int *_retsignal;n");
  3541. _gen("#endifn");
  3542. _gen("{n");
  3543. }
  3544. tabs++;
  3545. if ( DefaultExGroup!=NULL )
  3546. {
  3547. dumpException(DefaultExGroup, 1);
  3548. if ( !hasDefaultException(DefaultExGroup) )
  3549. {
  3550. gen("default :n");
  3551. tabs++;
  3552. gen("*_retsignal = _signal;n");
  3553. tabs--;
  3554. gen("}n");
  3555. }
  3556. }
  3557. else {
  3558. gen("*_retsignal = _signal;n");
  3559. }
  3561. tabs--;
  3562. _gen("}nn");
  3563. }
  3565. void
  3566. #ifdef __USE_PROTOS
  3567. genStdPCCTSIncludeFile( FILE *f,char *gate )    /* MR10 */
  3568. #else
  3569. genStdPCCTSIncludeFile( f , gate)               /* MR10 */
  3570. FILE *f;
  3571. char * gate;                                    /* MR10 */
  3572. #endif
  3573. {
  3574. /* MR10 Ramanathan Santhanam (ps@kumaran.com)           */
  3575. /* MR10 Same preprocessor symbol use to gate stdpccts.h */
  3576. /* MR10   even when two grammars are in use.            */
  3577. /* MR10 Derive gate symbol from -fh filename            */
  3579.     if (gate == NULL) {
  3580.       fprintf(f,"#ifndef STDPCCTS_Hn");          /* MR10 */
  3581.       fprintf(f,"#define STDPCCTS_Hn");          /* MR10 */
  3582.     } else {
  3583.       fprintf(f,"#ifndef STDPCCTS_%s_Hn",gate);  /* MR10 */
  3584.       fprintf(f,"#define STDPCCTS_%s_Hn",gate);  /* MR10 */
  3585.     };
  3586. fprintf(f,"/*n");
  3587.     if (gate == NULL) {
  3588.   fprintf(f," * %s -- P C C T S  I n c l u d en", stdpccts);
  3589.     } else {
  3590.   fprintf(f," * Standard PCCTS include file with -fh %s -- P C C T S  I n c l u d en", stdpccts);
  3591.     }
  3592. fprintf(f," *n");
  3593. fprintf(f," * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998n");
  3594. fprintf(f," * Purdue University Electrical Engineeringn");
  3595. fprintf(f," * With AHPCRC, University of Minnesotan");
  3596. fprintf(f," * ANTLR Version %sn", Version);
  3597. fprintf(f," */nn");
  3599.     fprintf(f,"#ifndef ANTLR_VERSIONn");
  3600. fprintf(f,"#define ANTLR_VERSION %sn", VersionDef);
  3601.     fprintf(f,"#endifnn");
  3603.     if (FirstAction != NULL ) dumpAction(FirstAction, f, 0, -1, 0, 1);  /* MR11 */
  3605. fprintf(f,"#include "pcctscfg.h"n");
  3606. fprintf(f,"#include PCCTS_STDIO_Hn");
  3607. if ( GenCC )
  3608. {
  3609. if ( UserDefdTokens )
  3610. fprintf(f, "#include %sn", UserTokenDefsFile);
  3611. else {
  3612. fprintf(f, "#include "%s"n", DefFileName);
  3613. }
  3615. fprintf(f, "#include "%s"n", ATOKEN_H);
  3617. if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);
  3619. fprintf(f, "#include "%s"n", ATOKENBUFFER_H);
  3621. if ( OutputLL_k > 1 ) fprintf(f,"static const unsigned LL_K=%d;n", OutputLL_k);
  3622. if ( GenAST ) {
  3623. fprintf(f, "#include "%s"n", ASTBASE_H);
  3624. }
  3625. fprintf(f,"#include "%s"n", APARSER_H);
  3626. fprintf(f,"#include "%s.h"n", CurrentClassName);
  3627. if ( LexGen ) fprintf(f,"#include "%s"n", DLEXERBASE_H);
  3628. fprintf(f, "#endifn");
  3629. return;
  3630. }
  3632. if ( strcmp(ParserName, DefaultParserName)!=0 )
  3633. fprintf(f, "#define %s %sn", DefaultParserName, ParserName);
  3634. if ( strcmp(ParserName, DefaultParserName)!=0 )
  3635. fprintf(f, "#include "%s"n", RemapFileName);
  3636. if ( UserTokenDefsFile != NULL )
  3637.    fprintf(f, "#include %sn", UserTokenDefsFile);
  3638. if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);
  3639. if ( FoundGuessBlk )
  3640. {
  3641. fprintf(f,"#define ZZCAN_GUESSn");
  3642. fprintf(f,"#include <setjmp.h>n");
  3643. }
  3644.     if (TraceGen) {
  3645.       fprintf(f,"#define zzTRACE_RULESn");  /* MR10 */
  3646.     };
  3647. if ( OutputLL_k > 1 ) fprintf(f,"#define LL_K %dn", OutputLL_k);
  3648. if ( GenAST ) fprintf(f,"#define GENASTn");
  3649. if ( FoundException )
  3650. {
  3651. /* MR1  7-Apr-97  1.33MR1                            */
  3652. /* MR1      Fix suggested by:                    */
  3653. /* MR1    Francois-Xavier Fontaine (fontaine_f@istvax.ist.lu)         */
  3655. fprintf(f,"#define EXCEPTION_HANDLINGn");             /* MR1 */
  3656. fprintf(f,"#define NUM_SIGNALS %dn", NumSignals);          /* MR1 */
  3657. }
  3658. if ( DemandLookahead ) fprintf(f,"#define DEMAND_LOOKn");
  3659. #ifdef DUM
  3660. if ( LexGen ) fprintf(f, "#define zzEOF_TOKEN %dn", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
  3661. #endif
  3662. /* ###WARNING: This will have to change when SetWordSize changes */
  3663. fprintf(f, "#define zzSET_SIZE %dn", NumWords(TokenNum-1)*sizeof(unsigned));
  3664. fprintf(f,"#include "antlr.h"n");
  3665. if ( GenAST ) fprintf(f,"#include "ast.h"n");
  3666. if ( UserDefdTokens )
  3667. fprintf(f, "#include %sn", UserTokenDefsFile);
  3668. /* still need this one as it has the func prototypes */
  3669. fprintf(f, "#include "%s"n", DefFileName);
  3670. /* still need this one as it defines the DLG interface */
  3671. fprintf(f,"#include "dlgdef.h"n");
  3672. /* don't need this one unless DLG is used */
  3673. if ( LexGen ) fprintf(f,"#include "%s"n", ModeFileName);
  3674. fprintf(f,"#endifn");
  3675. }
  3677. /* dump action 's' to file 'output' starting at "local" tab 'tabs'
  3678.    Dump line information in front of action if GenLineInfo is set
  3679.    If file == -1 then GenLineInfo is ignored.
  3680.    The user may redefine the LineInfoFormatStr to his/her liking
  3681.    most compilers will like the default, however.
  3683.    June '93; changed so that empty lines are left alone so that
  3684.    line information is correct for the compiler/debuggers.
  3685. */
  3686. void
  3687. #ifdef __USE_PROTOS
  3688. dumpAction( char *s, FILE *output, int tabs, int file, int line,
  3689. int final_newline )
  3690. #else
  3691. dumpAction( s, output, tabs, file, line, final_newline )
  3692. char *s;
  3693. FILE *output;
  3694. int tabs;
  3695. int file;
  3696. int line;
  3697. int final_newline;
  3698. #endif
  3699. {
  3700.     int inDQuote, inSQuote;
  3701.     require(s!=NULL,  "dumpAction: NULL action");
  3702.     require(output!=NULL, eMsg1("dumpAction: output FILE is NULL for %s",s));
  3704. if ( GenLineInfo && file != -1 )
  3705. {
  3706.         OutLineInfo(output,line,FileStr[file]);
  3707. }
  3708.     PastWhiteSpace( s );
  3709. /* don't print a tab if first non-white char is a # (preprocessor command) */
  3710. if ( *s!='#' ) {TAB;}
  3711.     inDQuote = inSQuote = FALSE;
  3712.     while ( *s != '' )
  3713.     {
  3714.         if ( *s == '\' )
  3715.         {
  3716.             fputc( *s++, output ); /* Avoid '"' Case */
  3717.             if ( *s == '' ) return;
  3718.             if ( *s == ''' ) fputc( *s++, output );
  3719.             if ( *s == '"' ) fputc( *s++, output );
  3720.         }
  3721.         if ( *s == ''' )
  3722.         {
  3723.             if ( !inDQuote ) inSQuote = !inSQuote;
  3724.         }
  3725.         if ( *s == '"' )
  3726.         {
  3727.             if ( !inSQuote ) inDQuote = !inDQuote;
  3728.         }
  3729.         if ( *s == 'n' )
  3730.         {
  3731.             fputc('n', output);
  3732. s++;
  3733.             PastWhiteSpace( s );
  3734.             if ( *s == '}' )
  3735.             {
  3736.                 --tabs;
  3737. TAB;
  3738.                 fputc( *s++, output );
  3739.                 continue;
  3740.             }
  3741.             if ( *s == '' ) return;
  3742. if ( *s != '#' ) /* #define, #endif etc.. start at col 1 */
  3743.             {
  3744. TAB;
  3745. }
  3746.         }
  3747.         if ( *s == '}' && !(inSQuote || inDQuote) )
  3748.         {
  3749.             --tabs;            /* Indent one fewer */
  3750.         }
  3751.         if ( *s == '{' && !(inSQuote || inDQuote) )
  3752.         {
  3753.             tabs++;            /* Indent one more */
  3754.         }
  3755.         fputc( *s, output );
  3756.         s++;
  3757.     }
  3758.     if ( final_newline ) fputc('n', output);
  3759. }
  3761. static void
  3762. #ifdef __USE_PROTOS
  3763. dumpAfterActions( FILE *output )
  3764. #else
  3765. dumpAfterActions( output )
  3766. FILE *output;
  3767. #endif
  3768. {
  3769. ListNode *p;
  3770. require(output!=NULL, "dumpAfterActions: output file was NULL for some reason");
  3771. if ( AfterActions != NULL )
  3772. {
  3773. for (p = AfterActions->next; p!=NULL; p=p->next)
  3774. {
  3775. UserAction *ua = (UserAction *)p->elem;
  3776. dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
  3777. }
  3778. }
  3779. fclose( output );
  3780. }
  3782. /*
  3783.  * Find the next action in the stream of execution.  Do not pass
  3784.  * junctions with more than one path leaving them.
  3785.  * Only pass generic junctions.
  3786.  *
  3787.  * Scan forward while (generic junction with p2==NULL)
  3788.  * If we stop on an action, return ptr to the action
  3789.  * else return NULL;
  3790.  */
  3791. static ActionNode *
  3792. #ifdef __USE_PROTOS
  3793. findImmedAction( Node *q )
  3794. #else
  3795. findImmedAction( q )
  3796. Node *q;
  3797. #endif
  3798. {
  3799. Junction *j;
  3800. require(q!=NULL, "findImmedAction: NULL node");
  3801. require(q->ntype>=1 && q->ntype<=NumNodeTypes, "findImmedAction: invalid node");
  3803. while ( q->ntype == nJunction )
  3804. {
  3805. j = (Junction *)q;
  3806. if ( j->jtype != Generic || j->p2 != NULL ) return NULL;
  3807. q = j->p1;
  3808. if ( q == NULL ) return NULL;
  3809. }
  3810. if ( q->ntype == nAction ) return (ActionNode *)q;
  3811. return NULL;
  3812. }
  3814. static void
  3815. #ifdef __USE_PROTOS
  3816. dumpRetValAssign( char *retval, char *ret_def )
  3817. #else
  3818. dumpRetValAssign( retval, ret_def )
  3819. char *retval;
  3820. char *ret_def;
  3821. #endif
  3822. {
  3823. char *q = ret_def;
  3825. tab();
  3826. while ( *retval != '' )
  3827. {
  3828. while ( isspace((*retval)) ) retval++;
  3829. while ( *retval!=',' && *retval!='' ) fputc(*retval++, output);
  3830. fprintf(output, " = _trv.");
  3832. DumpNextNameInDef(&q, output);
  3833. fputc(';', output); fputc(' ', output);
  3834. if ( *retval == ',' ) retval++;
  3835. }
  3836. }
  3838. /* This function computes the set of tokens that can possibly be seen k
  3839.  * tokens in the future from point j
  3840.  */
  3841. static set
  3842. #ifdef __USE_PROTOS
  3843. ComputeErrorSet( Junction *j, int k )
  3844. #else
  3845. ComputeErrorSet( j, k )
  3846. Junction *j;
  3847. int k;
  3848. #endif
  3849. {
  3850. Junction *alt1;
  3851. set a, rk, f;
  3852. require(j->ntype==nJunction, "ComputeErrorSet: non junction passed");
  3854. f = rk = empty;
  3855. for (alt1=j; alt1!=NULL; alt1 = (Junction *)alt1->p2)
  3856. {
  3857. REACH(alt1->p1, k, &rk, a);
  3858. require(set_nil(rk), "ComputeErrorSet: rk != nil");
  3859. set_free(rk);
  3860. set_orin(&f, a);
  3861. set_free(a);
  3862. }
  3863. return f;
  3864. }
  3866. static char *
  3867. #ifdef __USE_PROTOS
  3868. tokenFollowSet(TokNode *p)
  3869. #else
  3870. tokenFollowSet(p)
  3871. TokNode *p;
  3872. #endif
  3873. {
  3874.     static char buf[100];
  3875.     set rk, a;
  3876.     int n;
  3877.     rk = empty;
  3879.     REACH(p->next, 1, &rk, a);
  3880.     require(set_nil(rk), "rk != nil");
  3881.     set_free(rk);
  3882.     n = DefErrSet( &a, 0, NULL );
  3883.     set_free(a);
  3884.     if ( GenCC )
  3885.         sprintf(buf, "err%d", n);
  3886.     else
  3887.         sprintf(buf, "zzerr%d", n);
  3888.     return buf;
  3889. }
  3891. static void
  3892. #ifdef __USE_PROTOS
  3893. makeErrorClause( Junction *q, set f, int max_k )
  3894. #else
  3895. makeErrorClause( q, f, max_k )
  3896. Junction *q;
  3897. set f;
  3898. int max_k;
  3899. #endif
  3900. {
  3901.     char *  handler_id="";                                           /* MR7 */
  3902.     int     nilf=0;                                                  /* MR13 */
  3903.     RuleEntry *ruleEntry;                                            /* MR14 */
  3905. if ( FoundException )
  3906. {
  3907. _gen("else {n");
  3908. tabs++;
  3909. if ( FoundGuessBlk )
  3910. {
  3911. if ( GenCC ) {gen("if ( guessing ) goto fail;n");}
  3912. else gen("if ( zzguessing ) goto fail;n");
  3913. }
  3914. gen("if (_sva) _signal=NoViableAlt;n");
  3915. gen("else _signal=NoSemViableAlt;n");
  3916.         if (q->outerEG != NULL) {
  3917.           handler_id=q->outerEG->altID;
  3918. #if 0
  3919.         } else {
  3920.           printf("q->curAltNum=%d q->exception_label=%sn",q->curAltNum,q->exception_label);
  3921.           gen("*** DEBUG *** outerEG==NULLn");
  3922. #endif
  3923.         };
  3924. gen1("goto %s_handler;  /* MR7 */n",handler_id);    /* MR7 */
  3925. tabs--;
  3926. gen("}n");
  3927. return;
  3928. }
  3930. if ( max_k == 1 )
  3931. {
  3932. /* MR13 */  nilf=set_nil(f);
  3933.         if ( GenCC ) {
  3934.               _gen1("else {FAIL(1,err%d", DefErrSet1(1,&f,1,NULL));
  3935.             } else {
  3936.                _gen1("else {zzFAIL(1,zzerr%d", DefErrSet1(1,&f,1,NULL));
  3937.             };
  3938.      set_free(f);
  3939. }
  3940. else
  3941. {
  3942. int i;
  3943. set_free(f);
  3944. if ( GenCC ) {_gen1("else {FAIL(%d", max_k);}
  3945. else _gen1("else {zzFAIL(%d", max_k);
  3947.         ruleEntry = (RuleEntry *) hash_get(Rname,q->rname);
  3949. for (i=1; i<=max_k; i++)
  3950. {
  3951. /* MR14 */  if (ruleEntry->dontComputeErrorSet) {
  3952. /* MR14 */    f=empty;
  3953.             } else {
  3954.            f = ComputeErrorSet(q, i);
  3955.             }
  3956. if ( GenCC ) {_gen1(",err%d", DefErrSet( &f, 1, NULL ));}
  3957. else _gen1(",zzerr%d", DefErrSet( &f, 1, NULL ));
  3959. set_free(f);
  3960. }
  3961. }
  3962. _gen(",&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}n");
  3963. /* MR13 */  if (nilf) {
  3964. /* MR13 */    errFL("empty error set for alt - probably because of undefined rule or infinite left recursion",
  3965. /* MR13 */                 FileStr[q->file],q->line);
  3966. /* MR13 */    gen(" /* MR13 empty error set for this alt - undef rule ? infinite left recursion ? */");
  3967. /* MR13 */  };
  3968. }
  3970. static                                                               /* MR7 */
  3971. #ifdef __USE_PROTOS
  3972. char * findOuterHandlerLabel(ExceptionGroup *eg)                     /* MR7 */
  3973. #else
  3974. char * findOuterHandlerLabel(eg)                                     /* MR7 */
  3975. ExceptionGroup *eg;                                                  /* MR7 */
  3976. #endif
  3977. {
  3978.   char              *label=NULL;                                     /* MR7 */
  3979.   ExceptionGroup    *outerEG;                                        /* MR7 */
  3981.   if (eg->forRule == 0) {                                            /* MR7 */
  3982.     if (eg->labelEntry != NULL) {                                    /* MR7 */
  3983.       outerEG=eg->labelEntry->outerEG;                               /* MR7 */
  3984.       if (outerEG != NULL) {                                         /* MR7 */
  3985.         label=outerEG->altID;                                        /* MR7 */
  3986.         outerEG->used=1;                                             /* MR7 */
  3987.       };                                                             /* MR7 */
  3988.     } else if (eg->outerEG != NULL) {                                /* MR7 */
  3989.       outerEG=eg->outerEG;                                           /* MR7 */
  3990.       label=outerEG->altID;                                          /* MR7 */
  3991.       outerEG->used=1;                                               /* MR7 */
  3992.     };                                                               /* MR7 */
  3993.   };                                                                 /* MR7 */
  3994.   return (label==NULL ? "" : label);                                 /* MR7 */
  3995. }                                                                    /* MR7 */
  3997. /*** debug ***/
  3998. #if 0
  3999. ** static                                                               /* MR7 */
  4000. ** #ifdef __USE_PROTOS
  4001. ** char * findOuterAltHandlerLabel(Junction *startJ)                    /* MR7 */
  4002. ** #else
  4003. ** char * findOuterAltHandlerLabel(startJ)                              /* MR7 */
  4004. ** Junction *startJ;                                                    /* MR7 */
  4005. ** #endif
  4006. ** {                                                                    /* MR7 */
  4007. **   char      *label=NULL;                                             /* MR7 */
  4008. **   Junction  *alt;                                                    /* MR7 */
  4009. **                                                                      /* MR7 */
  4010. **   for (alt=startJ; alt != NULL; alt=alt->outerAltstart) {            /* MR7 */
  4011. **     label=alt->exception_label;                                      /* MR7 */
  4012. **     if (label != NULL) break;                                        /* MR7 */
  4013. **   };                                                                 /* MR7 */
  4014. **   return (label==NULL ? "" : label);                                 /* MR7 */
  4015. ** }                                                                    /* MR7 */
  4016. #endif
  4018. #ifdef __USE_PROTOS
  4019. static void OutLineInfo(FILE *file,int line,char *fileName)
  4020. #else
  4021. static void OutLineInfo(file,line,fileName)
  4022.   FILE *    file;
  4023.   int       line;
  4024.   char *    fileName;
  4025. #endif
  4026. {
  4027.     static  char * prevFileName=NULL;
  4028.     static  char * prevFileNameMS=NULL;
  4030.     char *  p;
  4031.     char *  q;
  4033.     if (! GenLineInfo) return;
  4035.     if (! GenLineInfoMS) {
  4036.     fprintf(file, LineInfoFormatStr,line,fileName);
  4037.     } else {
  4038.       if (fileName == prevFileName) {
  4039.     fprintf(file, LineInfoFormatStr,line,prevFileNameMS);
  4040.       } else {
  4041.         if (prevFileNameMS != NULL) free (prevFileNameMS);
  4042.         prevFileNameMS=(char *)calloc(1,strlen(fileName)+1);
  4043.         require(prevFileNameMS != NULL,"why not do this in calloc wrapper");
  4044.         q=prevFileNameMS;
  4045.         for (p=fileName; *p != 0; p++) {
  4046.             *q=*p;
  4047.             if (*q == '\') *q='/';
  4048.             q++;
  4049.         }
  4050.       }
  4051.       prevFileName=fileName;
  4052.     };
  4053. }