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

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

编译器/解释器

开发平台：

Others

build.c：源码内容
  1. /*
  2.  * build.c -- functions associated with building syntax diagrams.
  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. #include <ctype.h>
  33. #ifdef __cplusplus
  34. #ifndef __STDC__
  35. #define __STDC__
  36. #endif
  37. #endif
  38. #include "set.h"
  39. #include "syn.h"
  40. #include "hash.h"
  41. #include "generic.h"
  42. #include "dlgdef.h"
  44. #define SetBlk(g, t, approx) {    
  45. ((Junction *)g.left)->jtype = t;
  46. ((Junction *)g.left)->approx = approx;
  47. ((Junction *)g.left)->end = (Junction *) g.right;
  48. ((Junction *)g.right)->jtype = EndBlk;}
  50. /* Add the parameter string 'parm' to the parms field of a block-type junction
  51.  * g.left points to the sentinel node on a block.  i.e. g.left->p1 points to
  52.  * the actual junction with its jtype == some block-type.
  53.  */
  54. void
  55. #ifdef __STDC__
  56. addParm( Node *p, char *parm )
  57. #else
  58. addParm( p, parm )
  59. Node *p;
  60. char *parm;
  61. #endif
  62. {
  63. char *q = (char *) malloc( strlen(parm) + 1 );
  64. require(p!=NULL, "addParm: NULL objectn");
  65. require(q!=NULL, "addParm: unable to alloc parametern");
  67. strcpy(q, parm);
  68. if ( p->ntype == nRuleRef )
  69. {
  70. ((RuleRefNode *)p)->parms = q;
  71. }
  72. else if ( p->ntype == nJunction )
  73. {
  74. ((Junction *)p)->parm = q; /* only one parameter allowed on subrules */
  75. }
  76. else fatal_internal("addParm: invalid node for adding parm");
  77. }
  79. /*
  80.  * Build an action node for the syntax diagram
  81.  *
  82.  * buildAction(ACTION) ::= --o-->ACTION-->o--
  83.  *
  84.  * Where o is a junction node.
  85.  */
  86. Graph
  87. #ifdef __STDC__
  88. buildAction( char *action, int file, int line, int is_predicate )
  89. #else
  90. buildAction( action, file, line, is_predicate )
  91. char *action;
  92. int file;
  93. int line;
  94. int is_predicate;
  95. #endif
  96. {
  97. Junction *j1, *j2;
  98. Graph g;
  99. ActionNode *a;
  100. require(action!=NULL, "buildAction: invalid action");
  102. j1 = newJunction();
  103. j2 = newJunction();
  104. a = newActionNode();
  105. a->action = (char *) malloc( strlen(action)+1 );
  106. require(a->action!=NULL, "buildAction: cannot alloc space for actionn");
  107. strcpy(a->action, action);
  108. j1->p1 = (Node *) a;
  109. a->next = (Node *) j2;
  110. a->is_predicate = is_predicate;
  112.     if (is_predicate) {
  113.         PredEntry   *predEntry;
  114.         char        *t;
  115.         char        *key;
  116.         char        *u;
  117.         int         inverted=0;
  119.         t=key=(char *)calloc(1,strlen(a->action)+1);
  121.         for (u=a->action; *u != '' ; u++) {
  122.           if (*u != ' ') {
  123.             if (t==key && *u=='!') {
  124.               inverted=!inverted;
  125.             } else {
  126.               *t++=*u;
  127.             };
  128.           };
  129.         };
  131.         *t='';
  134.         predEntry=(PredEntry *)hash_get(Pname,key);
  135.         a->predEntry=predEntry;
  136.         if (predEntry != NULL) a->inverted=inverted;
  137.     } else {
  138. /* MR12c */      char  *strStart=a->action;
  139. /* MR12c */      char  *strEnd;
  140. /* MR12c */      strEnd=strStart+strlen(strStart)-1;
  141. /* MR12c */      for ( ; strEnd >= strStart &&  isspace(*strEnd); strEnd--) *strEnd=0;
  142. /* MR12c */      while (*strStart != '' && isspace(*strStart)) strStart++;
  143. /* MR12c */      if (ci_strequ(strStart,"nohoist")) {
  144. /* MR12c */        a->noHoist=1;
  145. /* MR12c */      }
  146.     };
  148. g.left = (Node *) j1; g.right = (Node *) j2;
  149. a->file = file;
  150. a->line = line;
  151. a->rname = CurRule;     /* MR10 */
  152. return g;
  153. }
  155. /*
  156.  * Build a token node for the syntax diagram
  157.  *
  158.  * buildToken(TOKEN) ::= --o-->TOKEN-->o--
  159.  *
  160.  * Where o is a junction node.
  161.  */
  162. Graph
  163. #ifdef __STDC__
  164. buildToken( char *text )
  165. #else
  166. buildToken( text )
  167. char *text;
  168. #endif
  169. {
  170. Junction *j1, *j2;
  171. Graph g;
  172. TokNode *t;
  173. require(text!=NULL, "buildToken: invalid token name");
  175. j1 = newJunction();
  176. j2 = newJunction();
  177. t = newTokNode();
  178. t->altstart = CurAltStart;
  179. if ( *text == '"' ) {t->label=FALSE; t->token = addTexpr( text );}
  180. else {t->label=TRUE; t->token = addTname( text );}
  181. j1->p1 = (Node *) t;
  182. t->next = (Node *) j2;
  183. g.left = (Node *) j1; g.right = (Node *) j2;
  184. return g;
  185. }
  187. /*
  188.  * Build a wild-card node for the syntax diagram
  189.  *
  190.  * buildToken(TOKEN) ::= --o-->'.'-->o--
  191.  *
  192.  * Where o is a junction node.
  193.  */
  194. Graph
  195. #ifdef __STDC__
  196. buildWildCard( char *text )
  197. #else
  198. buildWildCard( text )
  199. char *text;
  200. #endif
  201. {
  202. Junction *j1, *j2;
  203. Graph g;
  204. TokNode *t;
  205. TCnode *w;
  206. TermEntry *p;
  207. require(text!=NULL, "buildWildCard: invalid token name");
  209. j1 = newJunction();
  210. j2 = newJunction();
  211. t = newTokNode();
  213. /* If the ref a wild card, make a token class for it */
  214. if ( Tnum(WildCardString) == 0 )
  215. {
  216. w = newTCnode;
  217.    w->tok = addTname( WildCardString );
  218. set_orel(w->tok, &imag_tokens);
  219. set_orel(w->tok, &tokclasses);
  220. WildCardToken = w->tok;
  221. require((p=(TermEntry *)hash_get(Tname, WildCardString)) != NULL,
  222. "hash table mechanism is broken");
  223. p->classname = 1; /* entry is class name, not token */
  224. p->tclass = w; /* save ptr to this tclass def */
  225. list_add(&tclasses, (char *)w);
  226. }
  227. else {
  228. p=(TermEntry *)hash_get(Tname, WildCardString);
  229. require( p!= NULL, "hash table mechanism is broken");
  230. w = p->tclass;
  231. }
  233. t->token = w->tok;
  234. t->wild_card = 1;
  235. t->tclass = w;
  237. t->altstart = CurAltStart;
  238. j1->p1 = (Node *) t;
  239. t->next = (Node *) j2;
  240. g.left = (Node *) j1; g.right = (Node *) j2;
  241. return g;
  242. }
  244. void
  245. #ifdef __STDC__
  246. setUpperRange(TokNode *t, char *text)
  247. #else
  248. setUpperRange(t, text)
  249. TokNode *t;
  250. char *text;
  251. #endif
  252. {
  253. require(t!=NULL, "setUpperRange: NULL token node");
  254. require(text!=NULL, "setUpperRange: NULL token string");
  256. if ( *text == '"' ) {t->upper_range = addTexpr( text );}
  257. else {t->upper_range = addTname( text );}
  258. }
  260. /*
  261.  * Build a rule reference node of the syntax diagram
  262.  *
  263.  * buildRuleRef(RULE) ::= --o-->RULE-->o--
  264.  *
  265.  * Where o is a junction node.
  266.  *
  267.  * If rule 'text' has been defined already, don't alloc new space to store string.
  268.  * Set r->text to point to old copy in string table.
  269.  */
  270. Graph
  271. #ifdef __STDC__
  272. buildRuleRef( char *text )
  273. #else
  274. buildRuleRef( text )
  275. char *text;
  276. #endif
  277. {
  278. Junction *j1, *j2;
  279. Graph g;
  280. RuleRefNode *r;
  281. RuleEntry *p;
  282. require(text!=NULL, "buildRuleRef: invalid rule name");
  284. j1 = newJunction();
  285. j2 = newJunction();
  286. r = newRNode();
  287. r->altstart = CurAltStart;
  288. r->assign = NULL;
  289. if ( (p=(RuleEntry *)hash_get(Rname, text)) != NULL ) r->text = p->str;
  290. else r->text = mystrdup( text );
  291. j1->p1  = (Node *) r;
  292. r->next = (Node *) j2;
  293. g.left = (Node *) j1; g.right = (Node *) j2;
  294. return g;
  295. }
  297. /*
  298.  * Or two subgraphs into one graph via:
  299.  *
  300.  * Or(G1, G2) ::= --o-G1-o--
  301.  *                  |    ^
  302.  * v    |
  303.  *                  o-G2-o
  304.  *
  305.  * Set the altnum of junction starting G2 to 1 + altnum of junction starting G1.
  306.  * If, however, the G1 altnum is 0, make it 1 and then
  307.  * make G2 altnum = G1 altnum + 1.
  308.  */
  309. Graph
  310. #ifdef __STDC__
  311. Or( Graph g1, Graph g2 )
  312. #else
  313. Or( g1, g2 )
  314. Graph g1;
  315. Graph g2;
  316. #endif
  317. {
  318. Graph g;
  319. require(g1.left != NULL, "Or: invalid graph");
  320. require(g2.left != NULL && g2.right != NULL, "Or: invalid graph");
  322. ((Junction *)g1.left)->p2 = g2.left;
  323. ((Junction *)g2.right)->p1 = g1.right;
  324. /* set altnums */
  325. if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
  326. ((Junction *)g2.left)->altnum = ((Junction *)g1.left)->altnum + 1;
  327. g.left = g2.left;
  328. g.right = g1.right;
  329. return g;
  330. }
  332. /*
  333.  * Catenate two subgraphs
  334.  *
  335.  * Cat(G1, G2) ::= --o-G1-o-->o-G2-o--
  336.  * Cat(NULL,G2)::= --o-G2-o--
  337.  * Cat(G1,NULL)::= --o-G1-o--
  338.  */
  339. Graph
  340. #ifdef __STDC__
  341. Cat( Graph g1, Graph g2 )
  342. #else
  343. Cat( g1, g2 )
  344. Graph g1;
  345. Graph g2;
  346. #endif
  347. {
  348. Graph g;
  350. if ( g1.left == NULL && g1.right == NULL ) return g2;
  351. if ( g2.left == NULL && g2.right == NULL ) return g1;
  352. ((Junction *)g1.right)->p1 = g2.left;
  353. g.left = g1.left;
  354. g.right = g2.right;
  355. return g;
  356. }
  358. /*
  359.  * Make a subgraph an optional block
  360.  *
  361.  * makeOpt(G) ::= --o-->o-G-o-->o--
  362.  *                      |      ^
  363.  * v       |
  364.  *     o-------o
  365.  *
  366.  * Note that this constructs {A|B|...|Z} as if (A|B|...|Z|) was found.
  367.  *
  368.  * The node on the far right is added so that every block owns its own
  369.  * EndBlk node.
  370.  */
  371. Graph
  372. #ifdef __STDC__
  373. makeOpt( Graph g1, int approx )
  374. #else
  375. makeOpt( g1, approx )
  376. Graph g1;
  377. int approx;
  378. #endif
  379. {
  380. Junction *j1,*j2,*p;
  381. Graph g;
  382. require(g1.left != NULL && g1.right != NULL, "makeOpt: invalid graph");
  384. j1 = newJunction();
  385. j2 = newJunction();
  386. ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
  387. g = emptyAlt();
  388. if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
  389. ((Junction *)g.left)->altnum = ((Junction *)g1.left)->altnum + 1;
  390. for(p=(Junction *)g1.left; p->p2!=NULL; p=(Junction *)p->p2)
  391. {;} /* find last alt */
  392. p->p2 = g.left; /* add optional alternative */
  393. ((Junction *)g.right)->p1 = (Node *)j2; /* opt alt points to EndBlk */
  394. g1.right = (Node *)j2;
  395. SetBlk(g1, aOptBlk, approx);
  396. j1->p1 = g1.left; /* add generic node in front */
  397. g.left = (Node *) j1;
  398. g.right = g1.right;
  400. return g;
  401. }
  403. /*
  404.  * Make a graph into subblock
  405.  *
  406.  * makeBlk(G) ::= --o-->o-G-o-->o--
  407.  *
  408.  * The node on the far right is added so that every block owns its own
  409.  * EndBlk node.
  410.  */
  411. Graph
  412. #ifdef __STDC__
  413. makeBlk( Graph g1, int approx )
  414. #else
  415. makeBlk( g1, approx )
  416. Graph g1;
  417. int approx;
  418. #endif
  419. {
  420. Junction *j,*j2;
  421. Graph g;
  422. require(g1.left != NULL && g1.right != NULL, "makeBlk: invalid graph");
  424. j = newJunction();
  425. j2 = newJunction();
  426. ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
  427. g1.right = (Node *)j2;
  428. SetBlk(g1, aSubBlk, approx);
  429. j->p1 = g1.left; /* add node in front */
  430. g.left = (Node *) j;
  431. g.right = g1.right;
  433. return g;
  434. }
  436. /*
  437.  * Make a subgraph into a loop (closure) block -- (...)*
  438.  *
  439.  * makeLoop(G) ::=       |---|
  440.  *      v   |
  441.  *    --o-->o-->o-G-o-->o--
  442.  *                   |           ^
  443.  *                   v           |
  444.  *  o-----------o
  445.  *
  446.  * After making loop, always place generic node out front.  It becomes
  447.  * the start of enclosing block.  The aLoopBlk is the target of the loop.
  448.  *
  449.  * Loop blks have TWO EndBlk nodes--the far right and the node that loops back
  450.  * to the aLoopBlk node.  Node with which we can branch past loop == aLoopBegin and
  451.  * one which is loop target == aLoopBlk.
  452.  * The branch-past (initial) aLoopBegin node has end
  453.  * pointing to the last EndBlk node.  The loop-target node has end==NULL.
  454.  *
  455.  * Loop blocks have a set of locks (from 1..CLL_k) on the aLoopBlk node.
  456.  */
  457. Graph
  458. #ifdef __STDC__
  459. makeLoop( Graph g1, int approx )
  460. #else
  461. makeLoop( g1, approx )
  462. Graph g1;
  463. int approx;
  464. #endif
  465. {
  466. Junction *back, *front, *begin;
  467. Graph g;
  468. require(g1.left != NULL && g1.right != NULL, "makeLoop: invalid graph");
  470. back = newJunction();
  471. front = newJunction();
  472. begin = newJunction();
  473. g = emptyAlt();
  474. ((Junction *)g1.right)->p2 = g1.left; /* add loop branch to G */
  475. ((Junction *)g1.right)->p1 = (Node *) back; /* add node to G at end */
  476. ((Junction *)g1.right)->jtype = EndBlk; /* mark 1st EndBlk node */
  477. ((Junction *)g1.left)->jtype = aLoopBlk; /* mark 2nd aLoopBlk node */
  478. ((Junction *)g1.left)->end = (Junction *) g1.right;
  479. ((Junction *)g1.left)->lock = makelocks();
  480. ((Junction *)g1.left)->pred_lock = makelocks();
  481. g1.right = (Node *) back;
  482. begin->p1 = (Node *) g1.left;
  483. g1.left = (Node *) begin;
  484. begin->p2 = (Node *) g.left; /* make bypass arc */
  485. ((Junction *)g.right)->p1 = (Node *) back;
  486. SetBlk(g1, aLoopBegin, approx);
  487. front->p1 = g1.left; /* add node to front */
  488. g1.left = (Node *) front;
  490. return g1;
  491. }
  493. /*
  494.  * Make a subgraph into a plus block -- (...)+ -- 1 or more times
  495.  *
  496.  * makePlus(G) ::=  |---|
  497.  *  v   |
  498.  *    --o-->o-G-o-->o--
  499.  *
  500.  * After making loop, always place generic node out front.  It becomes
  501.  * the start of enclosing block.  The aPlusBlk is the target of the loop.
  502.  *
  503.  * Plus blks have TWO EndBlk nodes--the far right and the node that loops back
  504.  * to the aPlusBlk node.
  505.  *
  506.  * Plus blocks have a set of locks (from 1..CLL_k) on the aPlusBlk node.
  507.  */
  508. Graph
  509. #ifdef __STDC__
  510. makePlus( Graph g1, int approx )
  511. #else
  512. makePlus( g1, approx )
  513. Graph g1;
  514. int approx;
  515. #endif
  516. {
  517. int has_empty_alt_already = 0;
  518. Graph g;
  519. Junction *j2, *j3, *first_alt;
  520. Junction *last_alt=NULL, *p;
  521. require(g1.left != NULL && g1.right != NULL, "makePlus: invalid graph");
  523. first_alt = (Junction *)g1.left;
  524. j2 = newJunction();
  525. j3 = newJunction();
  526. if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
  527. ((Junction *)g1.right)->p2 = g1.left; /* add loop branch to G */
  528. ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
  529. ((Junction *)g1.right)->jtype = EndBlk; /* mark 1st EndBlk node */
  530. g1.right = (Node *) j2;
  531. SetBlk(g1, aPlusBlk, approx);
  532. ((Junction *)g1.left)->lock = makelocks();
  533. ((Junction *)g1.left)->pred_lock = makelocks();
  534. j3->p1 = g1.left; /* add node to front */
  535. g1.left = (Node *) j3;
  537. /* add an optional branch which is the "exit" branch of loop */
  538. /* FIRST, check to ensure that there does not already exist
  539.  * an optional path.
  540.  */
  541. /* find last alt */
  542. for(p=first_alt; p!=NULL; p=(Junction *)p->p2)
  543. {
  544. if ( p->p1->ntype == nJunction &&
  545.  p->p1!=NULL &&
  546.  ((Junction *)p->p1)->jtype==Generic &&
  547.  ((Junction *)p->p1)->p1!=NULL &&
  548.  ((Junction *)((Junction *)p->p1)->p1)->jtype==EndBlk )
  549. {
  550. has_empty_alt_already = 1;
  551. }
  552. last_alt = p;
  553. }
  554. if ( !has_empty_alt_already )
  555. {
  556. require(last_alt!=NULL, "last_alt==NULL; bad (..)+");
  557. g = emptyAlt();
  558. last_alt->p2 = g.left;
  559. ((Junction *)g.right)->p1 = (Node *) j2;
  561. /* make sure lookahead computation ignores this alt for
  562. * FIRST("(..)+"); but it's still used for computing the FIRST
  563. * of each alternative.
  564. */
  565. ((Junction *)g.left)->ignore = 1;
  566. }
  568. return g1;
  569. }
  571. /*
  572.  * Return an optional path:  --o-->o--
  573.  */
  574. Graph
  575. #ifdef __STDC__
  576. emptyAlt( void )
  577. #else
  578. emptyAlt( )
  579. #endif
  580. {
  581. Junction *j1, *j2;
  582. Graph g;
  584. j1 = newJunction();
  585. j2 = newJunction();
  586. j1->p1 = (Node *) j2;
  587. g.left = (Node *) j1;
  588. g.right = (Node *) j2;
  590. return g;
  591. }
  593. /* N o d e  A l l o c a t i o n */
  595. TokNode *
  596. #ifdef __STDC__
  597. newTokNode( void )
  598. #else
  599. newTokNode( )
  600. #endif
  601. {
  602. static TokNode *FreeList = NULL;
  603. TokNode *p, *newblk;
  605. if ( FreeList == NULL )
  606. {
  607. newblk = (TokNode *)calloc(TokenBlockAllocSize, sizeof(TokNode));
  608. if ( newblk == NULL )
  609. fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
  610. for (p=newblk; p<&(newblk[TokenBlockAllocSize]); p++)
  611. {
  612. p->next = (Node *)FreeList; /* add all new token nodes to FreeList */
  613. FreeList = p;
  614. }
  615. }
  616. p = FreeList;
  617. FreeList = (TokNode *)FreeList->next;/* remove a TokNode node */
  618. p->next = NULL; /* NULL the ptr we used */
  619.     memset( (char *) p, 0, sizeof(TokNode));        /* MR10 */
  620. p->ntype = nToken;
  621. p->rname = CurRule;
  622. p->file = CurFile;
  623. p->line = zzline;
  624. p->altstart = NULL;
  626. return p;
  627. }
  629. RuleRefNode *
  630. #ifdef __STDC__
  631. newRNode( void )
  632. #else
  633. newRNode( )
  634. #endif
  635. {
  636. static RuleRefNode *FreeList = NULL;
  637. RuleRefNode *p, *newblk;
  639. if ( FreeList == NULL )
  640. {
  641. newblk = (RuleRefNode *)calloc(RRefBlockAllocSize, sizeof(RuleRefNode));
  642. if ( newblk == NULL )
  643. fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
  644. for (p=newblk; p<&(newblk[RRefBlockAllocSize]); p++)
  645. {
  646. p->next = (Node *)FreeList; /* add all new rref nodes to FreeList */
  647. FreeList = p;
  648. }
  649. }
  650. p = FreeList;
  651. FreeList = (RuleRefNode *)FreeList->next;/* remove a Junction node */
  652. p->next = NULL; /* NULL the ptr we used */
  653.     memset( (char *) p, 0, sizeof(RuleRefNode));        /* MR10 */
  654. p->ntype = nRuleRef;
  655. p->rname = CurRule;
  656. p->file = CurFile;
  657. p->line = zzline;
  658. p->astnode = ASTinclude;
  659. p->altstart = NULL;
  661. return p;
  662. }
  664. static int junctionSeqNumber=0;         /* MR10 */
  666. Junction *
  667. #ifdef __STDC__
  668. newJunction( void )
  669. #else
  670. newJunction( )
  671. #endif
  672. {
  673. static Junction *FreeList = NULL;
  674. Junction *p, *newblk;
  676. if ( FreeList == NULL )
  677. {
  678. newblk = (Junction *)calloc(JunctionBlockAllocSize, sizeof(Junction));
  679. if ( newblk == NULL )
  680. fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
  681. for (p=newblk; p<&(newblk[JunctionBlockAllocSize]); p++)
  682. {
  683. p->p1 = (Node *)FreeList; /* add all new Junction nodes to FreeList */
  684. FreeList = p;
  685. }
  686. }
  687. p = FreeList;
  688. FreeList = (Junction *)FreeList->p1;/* remove a Junction node */
  689. p->p1 = NULL; /* NULL the ptr we used */
  690.     memset( (char *) p, 0, sizeof(Junction));       /* MR10 */
  691. p->ntype = nJunction;
  692. p->visited = 0;
  693. p->jtype = Generic;
  694. p->rname = CurRule;
  695. p->file = CurFile;
  696. p->line = zzline;
  697. p->exception_label = NULL;
  698. p->fset = (set *) calloc(CLL_k+1, sizeof(set));
  699. require(p->fset!=NULL, "cannot allocate fset in newJunction");
  700.     p->seq=++junctionSeqNumber;     /* MR10 */
  702. return p;
  703. }
  705. ActionNode *
  706. #ifdef __STDC__
  707. newActionNode( void )
  708. #else
  709. newActionNode( )
  710. #endif
  711. {
  712. static ActionNode *FreeList = NULL;
  713. ActionNode *p, *newblk;
  715. if ( FreeList == NULL )
  716. {
  717. newblk = (ActionNode *)calloc(ActionBlockAllocSize, sizeof(ActionNode));
  718. if ( newblk == NULL )
  719. fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
  720. for (p=newblk; p<&(newblk[ActionBlockAllocSize]); p++)
  721. {
  722. p->next = (Node *)FreeList; /* add all new Action nodes to FreeList */
  723. FreeList = p;
  724. }
  725. }
  726. p = FreeList;
  727. FreeList = (ActionNode *)FreeList->next;/* remove an Action node */
  728.     memset( (char *) p, 0, sizeof(ActionNode));     /* MR10 */
  729. p->ntype = nAction;
  730. p->next = NULL; /* NULL the ptr we used */
  731. p->done = 0;
  732. p->pred_fail = NULL;
  733. p->guardpred = NULL;
  734.     p->ampersandPred = NULL;
  735. return p;
  736. }
  738. /*
  739.  * allocate the array of locks (1..CLL_k) used to inhibit infinite recursion.
  740.  * Infinite recursion can occur in (..)* blocks, FIRST calcs and FOLLOW calcs.
  741.  * Therefore, we need locks on aLoopBlk, RuleBlk, EndRule nodes.
  742.  *
  743.  * if ( lock[k]==TRUE ) then we have been here before looking for k tokens
  744.  * of lookahead.
  745.  */
  746. char *
  747. #ifdef __STDC__
  748. makelocks( void )
  749. #else
  750. makelocks( )
  751. #endif
  752. {
  753. char *p = (char *) calloc(CLL_k+1, sizeof(char));
  754. require(p!=NULL, "cannot allocate lock array");
  756. return p;
  757. }
  759. #if 0
  760. ** #ifdef __STDC__
  761. ** void my_memset(char *p,char value,int count)
  762. ** #else
  763. ** void my_memset(p,value,count)
  764. **   char      *p;
  765. **   char      value;
  766. **   int       count;
  767. ** #endif
  768. ** {
  769. **    int      i;
  770. **
  771. **    for (i=0; i<count; i++) {
  772. **     p[i]=value;
  773. **   };
  774. ** }
  775. #endif