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

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

编译器/解释器

开发平台：

Others

pred.c：源码内容
  1. /*
  2.  * pred.c -- source for predicate detection, manipulation
  3.  *
  4.  * SOFTWARE RIGHTS
  5.  *
  6.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  7.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  8.  * company may do whatever they wish with source code distributed with
  9.  * PCCTS or the code generated by PCCTS, including the incorporation of
  10.  * PCCTS, or its output, into commerical software.
  11.  *
  12.  * We encourage users to develop software with PCCTS.  However, we do ask
  13.  * that credit is given to us for developing PCCTS.  By "credit",
  14.  * we mean that if you incorporate our source code into one of your
  15.  * programs (commercial product, research project, or otherwise) that you
  16.  * acknowledge this fact somewhere in the documentation, research report,
  17.  * etc...  If you like PCCTS and have developed a nice tool with the
  18.  * output, please mention that you developed it using PCCTS.  In
  19.  * addition, we ask that this header remain intact in our source code.
  20.  * As long as these guidelines are kept, we expect to continue enhancing
  21.  * this system and expect to make other tools available as they are
  22.  * completed.
  23.  *
  24.  * ANTLR 1.33
  25.  * Terence Parr
  26.  * Parr Research Corporation
  27.  * with Purdue University and AHPCRC, University of Minnesota
  28.  * 1989-1998
  29.  */
  31. #include <stdio.h>
  32. #ifdef __cplusplus
  33. #ifndef __STDC__
  34. #define __STDC__
  35. #endif
  36. #endif
  37. #include "set.h"
  38. #include "syn.h"
  39. #include "hash.h"
  40. #include "generic.h"
  41. #include "dlgdef.h"
  42. #include <ctype.h>
  44. #ifdef __STDC__
  45. static void complete_context_sets(RuleRefNode *, Predicate *);
  46. static void complete_context_trees(RuleRefNode *, Predicate *);
  47. #else
  48. static void complete_context_sets();
  49. static void complete_context_trees();
  50. #endif
  52. char *PRED_AND_LIST = "AND";
  53. char *PRED_OR_LIST = "OR";
  55. /*
  56.  * In C mode, return the largest constant integer found as the
  57.  * sole argument to LATEXT(i).
  58.  *
  59.  * In C++ mode, return the largest constant integer found as the
  60.  * sole argument to LT(i) given that the char before is nonalpha.
  61.  */
  63. int
  64. #ifdef __STDC__
  65. predicateLookaheadDepth(ActionNode *a)
  66. #else
  67. predicateLookaheadDepth(a)
  68. ActionNode *a;
  69. #endif
  70. {
  71. int     max_k=0;
  73.     if (a->predEntry != NULL) {
  74.        MR_pred_depth(a->predEntry->pred,&max_k);
  75.        goto PREDENTRY_EXIT;
  76.     }
  78. if ( GenCC )
  79. {
  80. /* scan for LT(i) */
  81. int k = 0;
  82. char *p = a->action;
  83. while ( p!=NULL )
  84. {
  85. p = strstr(p, "LT(");
  86. if ( p!=NULL )
  87. {
  88. if ( p>=a->action && !isalpha(*(p-1)) )
  89. {
  90. k = atoi(p+strlen("LT("));
  91. if ( k>max_k ) max_k=k;
  92. }
  93. p += strlen("LT(");
  94. }
  95. }
  96. }
  97. else {
  98. /* scan for LATEXT(i) */
  99. int k = 0;
  100. char *p = a->action;
  101. while ( p!=NULL )
  102. {
  103. p = strstr(p, "LATEXT(");
  104. if ( p!=NULL )
  105. {
  106. p += strlen("LATEXT(");
  107. k = atoi(p);
  108. if ( k>max_k ) max_k=k;
  109. }
  110. }
  111. }
  113. if ( max_k==0 )
  114. {
  115. if ( !a->frmwarned )
  116. {
  117. a->frmwarned = 1;
  118. warnFL(eMsg1("predicate: %s missing, bad, or with i=0; assuming i=1",
  119.  GenCC?"LT(i)":"LATEXT(i)"),
  120.    FileStr[a->file], a->line);
  121. }
  122. max_k = 1;
  123. }
  125. /* MR10 */    if ( max_k > CLL_k) {
  126. /* MR10 */ if ( !a->frmwarned )
  127. /* MR10 */        {
  128. /* MR10 */ a->frmwarned = 1;
  129. /* MR11 */ errFL(eMsgd2("predicate refers to lookahead token %d. Semantic lookahead is limited to max(k,ck)==%d",
  130. /* MR10 */                        max_k,CLL_k),
  131. /* MR10 */                        FileStr[a->file],a->line);
  132. /* MR10 */          if (max_k >= OutputLL_k) {
  133. /* MR10 */            if (!GenCC) {
  134. /* MR10 */              errFL(eMsgd("    the lookahead buffer size in C mode is %d token(s) (including the one just recognized)",
  135. /* MR10 */                        OutputLL_k),
  136. /* MR10 */                        FileStr[a->file],a->line);
  137. /* MR10 */            };
  138. /* MR10 */          };
  139. /* MR10 */        };
  140. /* MR10 */        max_k= CLL_k;
  141. /* MR10 */    };
  143. PREDENTRY_EXIT:
  144. return max_k;
  145. }
  147. /* Find all predicates in a block of alternatives.  DO NOT find predicates
  148.  * behind the block because that predicate could depend on things set in
  149.  * one of the nonoptional blocks
  150.  */
  152. Predicate *
  153. #ifdef __STDC__
  154. find_in_aSubBlk( Junction *alt )
  155. #else
  156. find_in_aSubBlk( alt )
  157. Junction *alt;
  158. #endif
  159. {
  160. Predicate *a, *head=NULL, *tail=NULL, *root=NULL;
  161. Junction *p = alt;
  163.     if (MRhoisting) {
  164.       return MR_find_in_aSubBlk(alt);
  165.     };
  166. for (; p!=NULL; p=(Junction *)p->p2)
  167. {
  168. /* ignore empty alts */
  169. if ( p->p1->ntype != nJunction ||
  170.  ((Junction *)p->p1)->jtype != EndBlk )
  171. {
  172. a = find_predicates(p->p1); /* get preds for this alt */
  173. if ( a==NULL ) continue;
  175. /* make an OR list of predicates */
  176. if ( head==NULL )
  177. {
  178. root = new_pred();
  179. root->expr = PRED_OR_LIST;
  180. head = tail = a;
  181. root->down = head;
  182. }
  183. else {
  184. tail->right = a;
  185. a->left = tail;
  186. a->up = tail->up;
  187. tail = a;
  188. }
  189. }
  190. }
  192. /* if just one pred, remove OR root */
  193. if ( root!=NULL && root->down->right == NULL )
  194. {
  195. Predicate *d = root->down;
  196. free( (char *) root);
  197. return d;
  198. }
  200. return root;
  201. }
  203. Predicate *
  204. #ifdef __STDC__
  205. find_in_aOptBlk( Junction *alt )
  206. #else
  207. find_in_aOptBlk( alt )
  208. Junction *alt;
  209. #endif
  210. {
  211. return find_in_aSubBlk( alt );
  212. }
  214. Predicate *
  215. #ifdef __STDC__
  216. find_in_aLoopBegin( Junction *alt )
  217. #else
  218. find_in_aLoopBegin( alt )
  219. Junction *alt;
  220. #endif
  221. {
  222. return find_in_aSubBlk( (Junction *) alt->p1 ); /* get preds in alts */
  223. }
  225. Predicate *
  226. #ifdef __STDC__
  227. find_in_aPlusBlk( Junction *alt )
  228. #else
  229. find_in_aPlusBlk( alt )
  230. Junction *alt;
  231. #endif
  232. {
  233. require(alt!=NULL&&alt->p2!=NULL, "invalid aPlusBlk");
  234. return find_in_aSubBlk( alt );
  235. }
  237. /* Look for a predicate;
  238.  *
  239.  * Do not pass anything but Junction nodes; no Actions, Tokens, RuleRefs.
  240.  * This means that a "hoisting distance" of zero is the only distance
  241.  * allowable.  Init actions are ignored.
  242.  *
  243.  * WARNING:
  244.  * Assumes no (..)? block after predicate for the moment.
  245.  * Does not check to see if pred is in production that can generate
  246.  * a sequence contained in the set of ambiguous tuples.
  247.  *
  248.  * Return the predicate found if any.
  249.  */
  252. Predicate *
  253. #ifdef __STDC__
  254. find_predicates( Node *alt )
  255. #else
  256. find_predicates( alt )
  257. Node *alt;
  258. #endif
  259. {
  260. #ifdef DBG_PRED
  261. Junction *j;
  262. RuleRefNode *r;
  263. TokNode *t;
  264. #endif
  265. Predicate *pred;
  267. if ( alt==NULL ) return NULL;
  269. #ifdef DBG_PRED
  270. switch ( alt->ntype )
  271. {
  272. case nJunction :
  273. j = (Junction *) alt;
  274. fprintf(stderr, "Junction(in %s)", j->rname);
  275. switch ( j->jtype )
  276. {
  277. case aSubBlk :
  278. fprintf(stderr,"aSubBlkn");
  279. break;
  280. case aOptBlk :
  281. fprintf(stderr,"aOptBlkn");
  282. break;
  283. case aLoopBegin :
  284. fprintf(stderr,"aLoopBeginBlkn");
  285. break;
  286. case aLoopBlk :
  287. fprintf(stderr,"aLoopBlkn");
  288. break;
  289. case aPlusBlk :
  290. fprintf(stderr,"aPlusBlkn");
  291. break;
  292. case EndBlk :
  293. fprintf(stderr,"EndBlkn");
  294. break;
  295. case RuleBlk :
  296. fprintf(stderr,"RuleBlkn");
  297. break;
  298. case Generic :
  299. fprintf(stderr,"Genericn");
  300. break;
  301. case EndRule :
  302. fprintf(stderr,"EndRulen");
  303. break;
  304. }
  305. break;
  306. case nRuleRef :
  307. r = (RuleRefNode *) alt;
  308. fprintf(stderr, "RuleRef(in %s)n", r->rname);
  309. break;
  310. case nToken :
  311. t = (TokNode *) alt;
  312. fprintf(stderr, "TokenNode(in %s)%sn", t->rname, TokenString(t->token));
  313. break;
  314. case nAction :
  315. fprintf(stderr, "Actionn");
  316. break;
  317. }
  318. #endif
  320. switch ( alt->ntype )
  321. {
  322. case nJunction :
  323. {
  324. Predicate *a, *b;
  325. Junction *p = (Junction *) alt;
  327. /* lock nodes */
  328. if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
  329.  p->jtype==aPlusBlk || p->jtype==EndRule )
  330. {
  331. require(p->pred_lock!=NULL, "rJunc: lock array is NULL");
  332. if ( p->pred_lock[1] )
  333. {
  334. return NULL;
  335. }
  336. p->pred_lock[1] = TRUE;
  337. }
  339. switch ( p->jtype )
  340. {
  341. case aSubBlk :
  342. a = find_in_aSubBlk(p);
  343. return a; /* nothing is visible past this guy */
  344. case aOptBlk :
  345. a = find_in_aOptBlk(p);
  346. return a;
  347. case aLoopBegin :
  348. a = find_in_aLoopBegin(p);
  349. return a;
  350. case aLoopBlk :
  351. a = find_in_aSubBlk(p);
  352. p->pred_lock[1] = FALSE;
  353. return a;
  354. case aPlusBlk :
  355. a = find_in_aPlusBlk(p);
  356. p->pred_lock[1] = FALSE;
  357. return a; /* nothing is visible past this guy */
  358. case RuleBlk :
  359. a = find_predicates(p->p1);
  360. p->pred_lock[1] = FALSE;
  361. return a;
  362. case Generic :
  363. a = find_predicates(p->p1);
  364. b = find_predicates(p->p2);
  365. if ( p->pred_lock!=NULL ) p->pred_lock[1] = FALSE;
  366. if ( a==NULL ) return b;
  367. if ( b==NULL ) return a;
  368. /* otherwise OR the two preds together */
  369. {
  370. fatal_internal("hit unknown situation during predicate hoisting");
  371. }
  372. case EndBlk :
  373. case EndRule : /* Find no predicates after a rule ref */
  374. return NULL;
  375. default:
  376. fatal_internal("this cannot be printedn");
  377. break;
  378. }
  379. }
  380. case nAction :
  381. {
  382. ActionNode *p = (ActionNode *) alt;
  383.             if ( p->noHoist) return NULL;                           /* MR12c */
  384. if ( p->init_action ) return find_predicates(p->next);
  385. if ( p->is_predicate )
  386. {
  387. Tree *t=NULL;
  388. #ifdef DBG_PRED
  389. fprintf(stderr, "predicate: <<%s>>?n", p->action);
  390. #endif
  391. if ( p->guardpred!=NULL )
  392. {
  393. pred = predicate_dup(p->guardpred);
  394.                     MR_guardPred_plainSet(p,pred);                  /* MR12c */
  395. }
  396. else
  397. {
  398. pred = new_pred();
  399. pred->k = predicateLookaheadDepth(p);
  400. pred->source = p;
  401. pred->expr = p->action;
  402. if ( HoistPredicateContext && pred->k > 1 )
  403. {
  404. if ( first_item_is_guess_block((Junction *)p->next) )
  405. {
  406.                             warnFL("cannot compute context of predicate in front of (..)? block",
  407.                             FileStr[p->file], p->line);
  408. }
  409. else
  410. {
  411. ConstrainSearch = 0;
  412. /* MR11 */                  if (p->ampersandPred != NULL) {
  413. /* MR11 */   TRAV(p,
  414. /* MR11 */  pred->k,
  415. /* MR11 */    &(pred->completionTree), t);
  416. /* MR11 */                  } else {
  417.      TRAV(p->next,
  418.       pred->k,
  419.       &(pred->completionTree), t);
  420.                             };
  421. pred->tcontext = t;
  422.                             MR_check_pred_too_long(pred,pred->completionTree);
  423. #ifdef DBG_PRED
  424. fprintf(stderr, "LL(%d) context:", pred->k);
  425. preorder(t);
  426. fprintf(stderr, "n");
  427. #endif
  428. }
  429. }
  430. else if ( HoistPredicateContext && pred->k == 1 )
  431. {
  432. pred->scontext[1] = empty;
  433. if ( first_item_is_guess_block((Junction *)p->next) )
  434. {
  435.                         warnFL("cannot compute context of predicate in front of (..)? block",
  436.                                              FileStr[p->file], p->line);
  437. }
  438. else
  439. {
  440. REACH((Junction *)p->next,
  441.   1,
  442.   &(pred->completionSet),
  443.   pred->scontext[1]);
  444.                             MR_check_pred_too_long(pred,pred->completionSet);
  445. #ifdef DBG_PRED
  446. fprintf(stderr, "LL(1) context:");
  447. s_fprT(stderr, pred->scontext[1]);
  448. fprintf(stderr, "n");
  449. #endif
  450. }
  451. }
  452. }
  453. {
  454. Predicate  *d = find_predicates(p->next);
  455.                     Predicate  *root;
  457. /* Warning: Doesn't seem like the up pointers will all be set correctly;
  458.  * TJP: that's ok, we're not using them now.
  459.  */
  460. if ( d!=NULL )
  461. {
  462. root = new_pred();
  463. root->expr = PRED_AND_LIST;
  464. root->down = pred;
  465. pred->right = d;
  466. pred->up = root;
  467. d->left = pred;
  468. d->up = pred->up;
  469. return root;
  470. }
  471. }
  472. return pred;
  473. }
  474. return NULL;
  475. }
  476. case nRuleRef :
  477. {
  478. Predicate   *a;
  479. RuleRefNode *p = (RuleRefNode *) alt;
  480. Junction    *r;
  481.             Junction    *save_MR_RuleBlkWithHalt;
  483. RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
  484. if ( q == NULL )
  485. {
  486. warnFL( eMsg1("rule %s not defined",p->text), FileStr[p->file], p->line );
  487. return NULL;
  488. }
  489. r = RulePtr[q->rulenum];
  490. if ( r->pred_lock[1] )
  491. {
  492. /* infinite left-recursion; ignore 'cause LL sup 1 (k) analysis
  493.  * must have seen it earlier.
  494.  */
  495. return NULL;
  496. }
  498.             /* MR10 There should only be one halt set at a time.        */
  499.             /* MR10 Life would have been easier with a global variable  */
  500.             /* MR10    (at least for this particular need)              */
  501.             /* MR10 Unset the old one and set the new one, later undo.  */
  503.             require(r->end->halt == FALSE,"should only have one halt at a time");
  505. /* MR10 */  require(MR_RuleBlkWithHalt == NULL ||
  506. /* MR10 */          (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == TRUE),
  507. /* MR10 */             "RuleBlkWithHalt->end not RuleBlk or does not have halt set");
  508. /* MR10 */  if (MR_RuleBlkWithHalt != NULL) {
  509. /* MR10 */    MR_RuleBlkWithHalt->end->halt=FALSE;
  510. /* MR10 */  };
  512. /***        fprintf(stderr,"nSetting halt on junction #%dn",r->end->seq);     ***/
  514.             require(r->end->halt == FALSE,"rule->end->halt already set");
  516.             save_MR_RuleBlkWithHalt=MR_RuleBlkWithHalt;
  518. /* MR10 */  MR_pointerStackPush(&MR_RuleBlkWithHaltStack,MR_RuleBlkWithHalt);
  519. /* MR10 */  MR_pointerStackPush(&MR_PredRuleRefStack,p);
  521. r->end->halt = TRUE;
  522. /* MR10 */  MR_RuleBlkWithHalt=r;
  524. a = find_predicates((Node *)r);
  526.             require(r->end->halt == TRUE,"rule->end->halt not set");
  527.             r->end->halt = FALSE;
  529. /* MR10 */  MR_pointerStackPop(&MR_PredRuleRefStack);
  530. /* MR10 */  MR_RuleBlkWithHalt=(Junction *) MR_pointerStackPop(&MR_RuleBlkWithHaltStack);
  532.             require (MR_RuleBlkWithHalt==save_MR_RuleBlkWithHalt,
  533.                     "RuleBlkWithHaltStack not consistent");
  535. /* MR10 */  require(MR_RuleBlkWithHalt == NULL ||
  536. /* MR10 */          (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == FALSE),
  537. /* MR10 */             "RuleBlkWithHalt->end not RuleBlk or has no halt set");
  538. /* MR10 */  if (MR_RuleBlkWithHalt != NULL) {
  539. /* MR10 */    MR_RuleBlkWithHalt->end->halt=TRUE;
  540. /* MR10 */  };
  542. /***        fprintf(stderr,"nRestoring halt on junction #%dn",r->end->seq);   ***/
  544. if ( a==NULL ) return NULL;
  546. /* attempt to compute the "local" FOLLOW just like in normal lookahead
  547.  * computation if needed
  548.  */
  550. complete_context_sets(p,a);
  551. complete_context_trees(p,a);
  553. /* MR10 */  MR_cleanup_pred_trees(a);
  555. return a;
  556. }
  557. case nToken :
  558. break;
  559. }
  561. return NULL;
  562. }
  564. #ifdef __STDC__
  565. Predicate *MR_find_predicates_and_supp(Node *alt)
  566. #else
  567. Predicate *MR_find_predicates_and_supp(alt)
  568.   Node      *alt;
  569. #endif
  570. {
  571.     Predicate   *p;
  573.     p=find_predicates(alt);
  574.     p=MR_suppressK(alt,p);
  575.     return p;
  576. }
  578. Predicate *
  579. #ifdef __STDC__
  580. new_pred( void )
  581. #else
  582. new_pred( )
  583. #endif
  584. {
  585. Predicate *p = (Predicate *) calloc(1,sizeof(Predicate)); /* MR10 */
  586. require(p!=NULL, "new_pred: cannot alloc predicate");
  587.     p->scontext[0]=empty;
  588.     p->scontext[1]=empty;
  589.     p->completionTree=empty;
  590.     p->completionSet=empty;
  591.     p->plainSet=empty;
  592. return p;
  593. }
  595. static void
  596. #ifdef __STDC__
  597. complete_context_sets( RuleRefNode *p, Predicate *a )
  598. #else
  599. complete_context_sets( p, a )
  600. RuleRefNode *p;
  601. Predicate *a;
  602. #endif
  603. {
  604. set rk2, b;
  605. int k2;
  607. #ifdef DBG_PRED
  608. fprintf(stderr, "enter complete_context_setsn");
  609. #endif
  610. for (; a!=NULL; a=a->right)
  611. {
  612. if ( a->expr == PRED_AND_LIST || a->expr == PRED_OR_LIST )
  613. {
  614. complete_context_sets(p,a->down);
  615. continue;
  616. }
  617. rk2 = b = empty;
  618. while ( !set_nil(a->completionSet) )
  619. {
  620. k2 = set_int(a->completionSet);
  621. set_rm(k2, a->completionSet);
  623.             REACH(p->next, k2, &rk2, b);
  624. set_orin(&(a->scontext[1]), b);
  625. set_free(b);
  626. }
  628. set_orin(&(a->completionSet), rk2);/* remember what we couldn't do */
  629. set_free(rk2);
  630. #ifdef DBG_PRED
  631. fprintf(stderr, "LL(1) context for %s(addr 0x%x) after ruleref:", a->expr, a);
  632. s_fprT(stderr, a->scontext[1]);
  633. fprintf(stderr, "n");
  634. #endif
  635. /* complete_context_sets(p, a->down);*/
  636. }
  637. #ifdef DBG_PRED
  638. fprintf(stderr, "exit complete_context_setsn");
  639. #endif
  640. }
  642. static void
  643. #ifdef __STDC__
  644. complete_context_trees( RuleRefNode *p, Predicate *a )
  645. #else
  646. complete_context_trees( p, a )
  647. RuleRefNode *p;
  648. Predicate *a;
  649. #endif
  650. {
  651. set rk2;
  652. int k2;
  653. Tree *u;
  655. #ifdef DBG_PRED
  656. fprintf(stderr, "enter complete_context_treesn");
  657. #endif
  658. for (; a!=NULL; a=a->right)
  659. {
  660. if ( a->expr == PRED_AND_LIST || a->expr == PRED_OR_LIST )
  661. {
  662. complete_context_trees(p, a->down);
  663. continue;
  664. }
  665. rk2 = empty;
  667. /* any k left to do? if so, link onto tree */
  668. while ( !set_nil(a->completionTree) )
  669. {
  670. k2 = set_int(a->completionTree);
  671. set_rm(k2, a->completionTree);
  672. u = NULL;
  674.             TRAV(p->next, k2, &rk2, u);
  676. /* any subtrees missing k2 tokens, add u onto end */
  677. a->tcontext = tlink(a->tcontext, u, k2);
  678.             Tfree(u);   /* MR10 */
  679. }
  680. set_orin(&(a->completionTree), rk2);/* remember what we couldn't do */
  681. set_free(rk2);
  682. #ifdef DBG_PRED
  683. fprintf(stderr, "LL(i<%d) context after ruleref:", LL_k);
  684. preorder(a->tcontext);
  685. fprintf(stderr, "n");
  686. #endif
  687. /* complete_context_trees(p, a->down);*/
  688. }
  689. #ifdef DBG_PRED
  690. fprintf(stderr, "exit complete_context_treesn");
  691. #endif
  692. }
  694. /* Walk a list of predicates and return the set of all tokens in scontext[1]'s */
  695. set
  696. #ifdef __STDC__
  697. covered_set( Predicate *p )
  698. #else
  699. covered_set( p )
  700. Predicate *p;
  701. #endif
  702. {
  703. set a;
  705. a = empty;
  706. for (; p!=NULL; p=p->right)
  707. {
  708. if ( p->expr == PRED_AND_LIST || p->expr == PRED_OR_LIST )
  709. {
  710. set_orin(&a, covered_set(p->down));
  711. continue;
  712. }
  713. set_orin(&a, p->scontext[1]);
  714. set_orin(&a, covered_set(p->down));
  715. }
  716. return a;
  717. }
  719. /* MR10 predicate_free()
  720.    MR10 Don't free the leaf nodes since they are part of the action node
  721. */
  723. #ifdef __STDC__
  724. void predicate_free(Predicate *p)
  725. #else
  726. void predicate_free(p)
  727.   Predicate     *p;
  728. #endif
  729. {
  730.   if (p == NULL) return;
  731.   predicate_free(p->right);
  732.   predicate_free(p->down);
  733.   if (p->cloned ||
  734.       p->source == NULL ||
  735.       p->source->guardpred == NULL ||
  736.       p->expr == PRED_AND_LIST ||
  737.       p->expr == PRED_OR_LIST) {
  738.     set_free(p->scontext[1]);
  739.     set_free(p->completionSet);
  740.     set_free(p->completionTree);
  741.     set_free(p->plainSet);
  742.     Tfree(p->tcontext);
  743.     free( (char *) p);
  744.   } else {
  745.     p->right=NULL;
  746.     p->down=NULL;  /* MR13 *** debug */
  747.   };
  748. }
  750. /* MR10 predicate_dup() */
  752. #ifdef __STDC__
  753. Predicate * predicate_dup_xxx(Predicate *p,int contextToo)
  754. #else
  755. Predicate * predicate_dup_xxx(p,contextToo)
  756.   Predicate     *p;
  757.   int           contextToo;
  758. #endif
  759. {
  760.   Predicate     *q;
  762.   if (p == NULL) return NULL;
  763.   q=new_pred();
  764.   q->down=predicate_dup(p->down);
  765.   q->right=predicate_dup(p->right);
  767.   /*
  768.      don't replicate expr - it is read-only
  769.      and address comparison is used to look
  770.      for identical predicates.
  771.   */
  773.   q->expr=p->expr;
  774.   q->k=p->k;
  775.   q->source=p->source;
  776.   q->cloned=1;
  777.   q->ampersandStyle=p->ampersandStyle;
  778.   q->inverted=p->inverted;
  779.   q->predEntry=p->predEntry;
  780.   q->plainSet=set_dup(p->plainSet);
  782.   if (contextToo) {
  783.     q->tcontext=tdup(p->tcontext);
  784.     q->scontext[0]=set_dup(p->scontext[0]);
  785.     q->scontext[1]=set_dup(p->scontext[1]);
  786.     q->completionTree=set_dup(p->completionTree);
  787.     q->completionSet=set_dup(p->completionSet);
  788.   };
  790.   /* don't need to dup "redundant" */
  792.   return q;
  794. }
  796. #ifdef __STDC__
  797. Predicate * predicate_dup_without_context(Predicate *p)
  798. #else
  799. Predicate * predicate_dup_without_context(p)
  800.   Predicate     *p;
  801. #endif
  802. {
  803.   return predicate_dup_xxx(p,0);
  804. }
  806. #ifdef __STDC__
  807. Predicate * predicate_dup(Predicate *p)
  808. #else
  809. Predicate * predicate_dup(p)
  810.   Predicate     *p;
  811. #endif
  812. {
  813.   return predicate_dup_xxx(p,1);
  814. }