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

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

编译器/解释器

开发平台：

Others

misc.c：源码内容
  1. /*
  2.  * misc.c
  3.  *
  4.  * Manage tokens, regular expressions.
  5.  * Print methods for debugging
  6.  * Compute follow lists onto tail ends of rules.
  7.  *
  8.  * The following functions are visible:
  9.  *
  10.  * int addTname(char *); Add token name
  11.  * int addTexpr(char *); Add token expression
  12.  * int Tnum(char *); Get number of expr/token
  13.  * void Tklink(char *, char *); Link a name with an expression
  14.  * int hasAction(expr); Does expr already have action assigned?
  15.  * void setHasAction(expr); Indicate that expr now has an action
  16.  * Entry *newEntry(char *,int); Create new table entry with certain size
  17.  * void list_add(ListNode **list, char *e)
  18.  *      void    list_free(ListNode **list, int freeData);   *** MR10 ***
  19.  * void list_apply(ListNode *list, void (*f)())
  20.  * void lexclass(char *m); switch to new/old lexical class
  21.  * void lexmode(int i); switch to old lexical class i
  22.  *
  23.  * SOFTWARE RIGHTS
  24.  *
  25.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  26.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  27.  * company may do whatever they wish with source code distributed with
  28.  * PCCTS or the code generated by PCCTS, including the incorporation of
  29.  * PCCTS, or its output, into commerical software.
  30.  *
  31.  * We encourage users to develop software with PCCTS.  However, we do ask
  32.  * that credit is given to us for developing PCCTS.  By "credit",
  33.  * we mean that if you incorporate our source code into one of your
  34.  * programs (commercial product, research project, or otherwise) that you
  35.  * acknowledge this fact somewhere in the documentation, research report,
  36.  * etc...  If you like PCCTS and have developed a nice tool with the
  37.  * output, please mention that you developed it using PCCTS.  In
  38.  * addition, we ask that this header remain intact in our source code.
  39.  * As long as these guidelines are kept, we expect to continue enhancing
  40.  * this system and expect to make other tools available as they are
  41.  * completed.
  42.  *
  43.  * ANTLR 1.33
  44.  * Terence Parr
  45.  * Parr Research Corporation
  46.  * with Purdue University and AHPCRC, University of Minnesota
  47.  * 1989-1998
  48.  */
  50. #include <stdio.h>
  51. #ifdef __cplusplus
  52. #ifndef __STDC__
  53. #define __STDC__
  54. #endif
  55. #endif
  56. #include "set.h"
  57. #include "syn.h"
  58. #include "hash.h"
  59. #include "generic.h"
  60. #include "dlgdef.h"
  62. static int tsize=TSChunk; /* size of token str arrays */
  64. static void
  65. #ifdef __STDC__
  66. RemapForcedTokensInSyntaxDiagram(Node *);
  67. #else
  68. RemapForcedTokensInSyntaxDiagram();
  69. #endif
  71. /* T o k e n  M a n i p u l a t i o n */
  73. /*
  74.  * add token 't' to the TokenStr/Expr array.  Make more room if necessary.
  75.  * 't' is either an expression or a token name.
  76.  *
  77.  * There is only one TokenStr array, but multiple ExprStr's.  Therefore,
  78.  * for each lex class (element of lclass) we must extend the ExprStr array.
  79.  * ExprStr's and TokenStr are always all the same size.
  80.  *
  81.  * Also, there is a Texpr hash table for each automaton.
  82.  */
  83. static void
  84. #ifdef __STDC__
  85. Ttrack( char *t )
  86. #else
  87. Ttrack( t )
  88. char *t;
  89. #endif
  90. {
  91. if ( TokenNum >= tsize ) /* terminal table overflow? */
  92. {
  93. char **p;
  94. int i, more, j;
  96. more = TSChunk * (1 + ((TokenNum-tsize) / TSChunk));
  97. tsize += more;
  98. TokenStr = (char **) realloc((char *)TokenStr, tsize*sizeof(char *));
  99. require(TokenStr != NULL, "Ttrack: can't extend TokenStr");
  100. for (i=0; i<NumLexClasses; i++)
  101. {
  102. lclass[i].exprs = (char **)
  103.   realloc((char *)lclass[i].exprs, tsize*sizeof(char *));
  104. require(lclass[i].exprs != NULL, "Ttrack: can't extend ExprStr");
  105. for (p= &lclass[i].exprs[tsize-more],j=1; j<=more; j++) *p++ = NULL;
  106. }
  107. for (p= &TokenStr[tsize-more],i=1; i<=more; i++) *p++ = NULL;
  108. lexmode( CurrentLexClass ); /* reset ExprStr in case table moved */
  109. }
  110. /* note: we use the actual ExprStr/TokenStr array
  111.  * here as TokenInd doesn't exist yet
  112.  */
  113. if ( *t == '"' ) ExprStr[TokenNum] = t;
  114. else TokenStr[TokenNum] = t;
  115. }
  117. static Expr *
  118. #ifdef __STDC__
  119. newExpr( char *e )
  120. #else
  121. newExpr( e )
  122. char *e;
  123. #endif
  124. {
  125. Expr *p = (Expr *) calloc(1, sizeof(Expr));
  126. require(p!=NULL, "newExpr: cannot alloc Expr node");
  128. p->expr = e;
  129. p->lclass = CurrentLexClass;
  130. return p;
  131. }
  133. /* switch to lexical class/mode m.  This amounts to creating a new
  134.  * lex mode if one does not already exist and making ExprStr point
  135.  * to the correct char string array.  We must also switch Texpr tables.
  136.  *
  137.  * BTW, we need multiple ExprStr arrays because more than one automaton
  138.  * may have the same label for a token, but with different expressions.
  139.  * We need to track an expr for each automaton.  If we disallowed this
  140.  * feature, only one ExprStr would be required.
  141.  */
  142. void
  143. #ifdef __STDC__
  144. lexclass( char *m )
  145. #else
  146. lexclass( m )
  147. char *m;
  148. #endif
  149. {
  150. int i;
  151. TermEntry *p;
  152. static char EOFSTR[] = ""@"";
  154. if ( hash_get(Tname, m) != NULL )
  155. {
  156. warn(eMsg1("lexclass name conflicts with token/errclass label '%s'",m));
  157. }
  158. /* does m already exist? */
  159. i = LexClassIndex(m);
  160. if ( i != -1 ) {lexmode(i); return;}
  161. /* must make new one */
  162. NumLexClasses++;
  163. CurrentLexClass = NumLexClasses-1;
  164. require(NumLexClasses<=MaxLexClasses, "number of allowable lexclasses exceedednIncrease MaxLexClasses in generic.h and recompile all C files");
  165. lclass[CurrentLexClass].classnum = m;
  166. lclass[CurrentLexClass].exprs = (char **) calloc(tsize, sizeof(char *));
  167. require(lclass[CurrentLexClass].exprs!=NULL,
  168. "lexclass: cannot allocate ExprStr");
  169. lclass[CurrentLexClass].htable = newHashTable();
  170. ExprStr = lclass[CurrentLexClass].exprs;
  171. Texpr = lclass[CurrentLexClass].htable;
  172. /* define EOF for each automaton */
  173. p = newTermEntry( EOFSTR );
  174. p->token = EofToken; /* couldn't have remapped tokens yet, use EofToken */
  175. hash_add(Texpr, EOFSTR, (Entry *)p);
  176. list_add(&ExprOrder, (void *)newExpr(EOFSTR));
  177. /* note: we use the actual ExprStr array
  178.  * here as TokenInd doesn't exist yet
  179.  */
  180. ExprStr[EofToken] = EOFSTR;
  181. }
  183. void
  184. #ifdef __STDC__
  185. lexmode( int i )
  186. #else
  187. lexmode( i )
  188. int i;
  189. #endif
  190. {
  191. require(i<NumLexClasses, "lexmode: invalid mode");
  192. ExprStr = lclass[i].exprs;
  193. Texpr = lclass[i].htable;
  194. CurrentLexClass = i;
  195. }
  197. /* return index into lclass array of lexical class. return -1 if nonexistent */
  198. int
  199. #ifdef __STDC__
  200. LexClassIndex( char *cl )
  201. #else
  202. LexClassIndex( cl )
  203. char *cl;
  204. #endif
  205. {
  206. int i;
  208. for (i=0; i<NumLexClasses; i++)
  209. {
  210. if ( strcmp(lclass[i].classnum, cl) == 0 ) return i;
  211. }
  212. return -1;
  213. }
  215. int
  216. #ifdef __STDC__
  217. hasAction( char *expr )
  218. #else
  219. hasAction( expr )
  220. char *expr;
  221. #endif
  222. {
  223. TermEntry *p;
  224. require(expr!=NULL, "hasAction: invalid expr");
  226. p = (TermEntry *) hash_get(Texpr, expr);
  227. require(p!=NULL, eMsg1("hasAction: expr '%s' doesn't exist",expr));
  228. return (p->action!=NULL);
  229. }
  231. void
  232. #ifdef __STDC__
  233. setHasAction( char *expr, char *action )
  234. #else
  235. setHasAction( expr, action )
  236. char *expr;
  237. char *action;
  238. #endif
  239. {
  240. TermEntry *p;
  241. require(expr!=NULL, "setHasAction: invalid expr");
  243. p = (TermEntry *) hash_get(Texpr, expr);
  244. require(p!=NULL, eMsg1("setHasAction: expr '%s' doesn't exist",expr));
  245. p->action = action;
  246. }
  248. ForcedToken *
  249. #ifdef __STDC__
  250. newForcedToken(char *token, int tnum)
  251. #else
  252. newForcedToken(token, tnum)
  253. char *token;
  254. int tnum;
  255. #endif
  256. {
  257. ForcedToken *ft = (ForcedToken *) calloc(1, sizeof(ForcedToken));
  258. require(ft!=NULL, "out of memory");
  259. ft->token = token;
  260. ft->tnum = tnum;
  261. return ft;
  262. }
  264. /*
  265.  * Make a token indirection array that remaps token numbers and then walk
  266.  * the appropriate symbol tables and SynDiag to change token numbers
  267.  */
  268. void
  269. #ifdef __STDC__
  270. RemapForcedTokens(void)
  271. #else
  272. RemapForcedTokens()
  273. #endif
  274. {
  275. ListNode *p;
  276. ForcedToken *q;
  277. int max_token_number=0;     /* MR9 23-Sep-97 Removed "unsigned" */
  278. int i;
  280. if ( ForcedTokens == NULL ) return;
  282. /* find max token num */
  283. for (p = ForcedTokens->next; p!=NULL; p=p->next)
  284. {
  285. q = (ForcedToken *) p->elem;
  286. if ( q->tnum > max_token_number ) max_token_number = q->tnum;
  287. }
  288. fprintf(stderr, "max token number is %dn", max_token_number);
  290. /* make token indirection array */
  291. TokenInd = (int *) calloc(max_token_number+1, sizeof(int));
  292. LastTokenCounted = TokenNum;
  293. TokenNum = max_token_number+1;
  294. require(TokenInd!=NULL, "RemapForcedTokens: cannot allocate TokenInd");
  296. /* fill token indirection array and change token id htable ; swap token indices */
  297. for (i=1; i<TokenNum; i++) TokenInd[i] = i;
  298. for (p = ForcedTokens->next; p!=NULL; p=p->next)
  299. {
  300. TermEntry *te;
  301. int old_pos, t;
  303. q = (ForcedToken *) p->elem;
  304. fprintf(stderr, "%s forced to %dn", q->token, q->tnum);
  305. te = (TermEntry *) hash_get(Tname, q->token);
  306. require(te!=NULL, "RemapForcedTokens: token not in hash table");
  307. old_pos = te->token;
  308. fprintf(stderr, "Before: TokenInd[old_pos==%d] is %dn", old_pos, TokenInd[old_pos]);
  309. fprintf(stderr, "Before: TokenInd[target==%d] is %dn", q->tnum, TokenInd[q->tnum]);
  310. q = (ForcedToken *) p->elem;
  311. t = TokenInd[old_pos];
  312. TokenInd[old_pos] = q->tnum;
  313. TokenInd[q->tnum] = t;
  314. te->token = q->tnum; /* update token type id symbol table */
  315. fprintf(stderr, "After: TokenInd[old_pos==%d] is %dn", old_pos, TokenInd[old_pos]);
  316. fprintf(stderr, "After: TokenInd[target==%d] is %dn", q->tnum, TokenInd[q->tnum]);
  318. /* Change the token number in the sym tab entry for the exprs
  319.  * at the old position of the token id and the target position
  320.  */
  321. /* update expr at target (if any) of forced token id */
  322. if ( q->tnum < TokenNum ) /* is it a valid position? */
  323. {
  324. for (i=0; i<NumLexClasses; i++)
  325. {
  326. if ( lclass[i].exprs[q->tnum]!=NULL )
  327. {
  328. /* update the symbol table for this expr */
  329. TermEntry *e = (TermEntry *) hash_get(lclass[i].htable, lclass[i].exprs[q->tnum]);
  330. require(e!=NULL, "RemapForcedTokens: expr not in hash table");
  331. e->token = old_pos;
  332. fprintf(stderr, "found expr '%s' at target %d in lclass[%d]; changed to %dn",
  333. lclass[i].exprs[q->tnum], q->tnum, i, old_pos);
  334. }
  335. }
  336. }
  337. /* update expr at old position (if any) of forced token id */
  338. for (i=0; i<NumLexClasses; i++)
  339. {
  340. if ( lclass[i].exprs[old_pos]!=NULL )
  341. {
  342. /* update the symbol table for this expr */
  343. TermEntry *e = (TermEntry *) hash_get(lclass[i].htable, lclass[i].exprs[old_pos]);
  344. require(e!=NULL, "RemapForcedTokens: expr not in hash table");
  345. e->token = q->tnum;
  346. fprintf(stderr, "found expr '%s' for id %s in lclass[%d]; changed to %dn",
  347. lclass[i].exprs[old_pos], q->token, i, q->tnum);
  348. }
  349. }
  350. }
  352. /* Update SynDiag */
  353. RemapForcedTokensInSyntaxDiagram((Node *)SynDiag);
  354. }
  356. static void
  357. #ifdef __STDC__
  358. RemapForcedTokensInSyntaxDiagram(Node *p)
  359. #else
  360. RemapForcedTokensInSyntaxDiagram(p)
  361. Node *p;
  362. #endif
  363. {
  364. Junction *j = (Junction *) p;
  365. RuleRefNode *r = (RuleRefNode *) p;
  366. TokNode *t = (TokNode *)p;
  368. if ( p==NULL ) return;
  369. require(p->ntype>=1 && p->ntype<=NumNodeTypes, "Remap...: invalid diagram node");
  370. switch ( p->ntype )
  371. {
  372. case nJunction :
  373. if ( j->visited ) return;
  374. if ( j->jtype == EndRule ) return;
  375. j->visited = TRUE;
  376. RemapForcedTokensInSyntaxDiagram( j->p1 );
  377. RemapForcedTokensInSyntaxDiagram( j->p2 );
  378. j->visited = FALSE;
  379. return;
  380. case nRuleRef :
  381. RemapForcedTokensInSyntaxDiagram( r->next );
  382. return;
  383. case nToken :
  384. if ( t->remapped ) return; /* we've been here before */
  385. t->remapped = 1;
  386. fprintf(stderr, "remapping %d to %dn", t->token, TokenInd[t->token]);
  387. t->token = TokenInd[t->token];
  388. RemapForcedTokensInSyntaxDiagram( t->next );
  389. return;
  390. case nAction :
  391. RemapForcedTokensInSyntaxDiagram( ((ActionNode *)p)->next );
  392. return;
  393. default :
  394. fatal_internal("invalid node type");
  395. }
  396. }
  398. /*
  399.  * Add a token name.  Return the token number associated with it.  If it already
  400.  * exists, then return the token number assigned to it.
  401.  *
  402.  * Track the order in which tokens are found so that the DLG output maintains
  403.  * that order.  It also lets us map token numbers to strings.
  404.  */
  405. int
  406. #ifdef __STDC__
  407. addTname( char *token )
  408. #else
  409. addTname( token )
  410. char *token;
  411. #endif
  412. {
  413. TermEntry *p;
  414. require(token!=NULL, "addTname: invalid token name");
  416. if ( (p=(TermEntry *)hash_get(Tname, token)) != NULL ) return p->token;
  417. p = newTermEntry( token );
  418. Ttrack( p->str );
  419. p->token = TokenNum++;
  420. hash_add(Tname, token, (Entry *)p);
  421. return p->token;
  422. }
  424. /* This is the same as addTname except we force the TokenNum to be tnum.
  425.  * We don't have to use the Forced token stuff as no tokens will have
  426.  * been defined with #tokens when this is called.  This is only called
  427.  * when a #tokdefs meta-op is used.
  428.  */
  429. int
  430. #ifdef __STDC__
  431. addForcedTname( char *token, int tnum )
  432. #else
  433. addForcedTname( token, tnum )
  434. char *token;
  435. int tnum;
  436. #endif
  437. {
  438. TermEntry *p;
  439. require(token!=NULL, "addTname: invalid token name");
  441. if ( (p=(TermEntry *)hash_get(Tname, token)) != NULL ) return p->token;
  442. p = newTermEntry( token );
  443. Ttrack( p->str );
  444. p->token = tnum;
  445. hash_add(Tname, token, (Entry *)p);
  446. return p->token;
  447. }
  449. /*
  450.  * Add a token expr.  Return the token number associated with it.  If it already
  451.  * exists, then return the token number assigned to it.
  452.  */
  453. int
  454. #ifdef __STDC__
  455. addTexpr( char *expr )
  456. #else
  457. addTexpr( expr )
  458. char *expr;
  459. #endif
  460. {
  461. TermEntry *p;
  462. require(expr!=NULL, "addTexpr: invalid regular expression");
  464. if ( (p=(TermEntry *)hash_get(Texpr, expr)) != NULL ) return p->token;
  465. p = newTermEntry( expr );
  466. Ttrack( p->str );
  467. /* track the order in which they occur */
  468. list_add(&ExprOrder, (void *)newExpr(p->str));
  469. p->token = TokenNum++;
  470. hash_add(Texpr, expr, (Entry *)p);
  471. return p->token;
  472. }
  474. /* return the token number of 'term'.  Return 0 if no 'term' exists */
  475. int
  476. #ifdef __STDC__
  477. Tnum( char *term )
  478. #else
  479. Tnum( term )
  480. char *term;
  481. #endif
  482. {
  483. TermEntry *p;
  484. require(term!=NULL, "Tnum: invalid terminal");
  486. if ( *term=='"' ) p = (TermEntry *) hash_get(Texpr, term);
  487. else p = (TermEntry *) hash_get(Tname, term);
  488. if ( p == NULL ) return 0;
  489. else return p->token;
  490. }
  492. /* associate a Name with an expr.  If both have been already assigned
  493.  * token numbers, then an error is reported.  Add the token or expr
  494.  * that has not been added if no error.  This 'represents' the #token
  495.  * ANTLR pseudo-op.  If both have not been defined, define them both
  496.  * linked to same token number.
  497.  */
  498. void
  499. #ifdef __STDC__
  500. Tklink( char *token, char *expr )
  501. #else
  502. Tklink( token, expr )
  503. char *token;
  504. char *expr;
  505. #endif
  506. {
  507. TermEntry *p, *q;
  508. require(token!=NULL && expr!=NULL, "Tklink: invalid token name and/or expr");
  510. p = (TermEntry *) hash_get(Tname, token);
  511. q = (TermEntry *) hash_get(Texpr, expr);
  512. if ( p != NULL && q != NULL ) /* both defined */
  513. {
  514. warn( eMsg2("token name %s and rexpr %s already defined; ignored",
  515. token, expr) );
  516. return;
  517. }
  518. if ( p==NULL && q==NULL ) /* both not defined */
  519. {
  520. int t = addTname( token );
  521. q = newTermEntry( expr );
  522. hash_add(Texpr, expr, (Entry *)q);
  523. q->token = t;
  524. /* note: we use the actual ExprStr array
  525.  * here as TokenInd doesn't exist yet
  526.  */
  527. ExprStr[t] = q->str;
  528. /* track the order in which they occur */
  529. list_add(&ExprOrder, (void *)newExpr(q->str));
  530. return;
  531. }
  532. if ( p != NULL ) /* one is defined, one is not */
  533. {
  534. q = newTermEntry( expr );
  535. hash_add(Texpr, expr, (Entry *)q);
  536. q->token = p->token;
  537. ExprStr[p->token] = q->str; /* both expr and token str defined now */
  538. list_add(&ExprOrder, (void *)newExpr(q->str));
  539. }
  540. else /* trying to associate name with expr here*/
  541. {
  542. p = newTermEntry( token );
  543. hash_add(Tname, token, (Entry *)p);
  544. p->token = q->token;
  545. TokenStr[p->token] = p->str;/* both expr and token str defined now */
  546. }
  547. }
  549. /*
  550.  * Given a string, this function allocates and returns a pointer to a
  551.  * hash table record of size 'sz' whose "str" pointer is reset to a position
  552.  * in the string table.
  553.  */
  554. Entry *
  555. #ifdef __STDC__
  556. newEntry( char *text, int sz )
  557. #else
  558. newEntry( text, sz )
  559. char *text;
  560. int sz;
  561. #endif
  562. {
  563. Entry *p;
  564. require(text!=NULL, "new: NULL terminal");
  566. if ( (p = (Entry *) calloc(1,sz)) == 0 )
  567. {
  568. fatal_internal("newEntry: out of memory for terminalsn");
  569. exit(PCCTS_EXIT_FAILURE);
  570. }
  571. p->str = mystrdup(text);
  573. return(p);
  574. }
  576. /*
  577.  * add an element to a list.
  578.  *
  579.  * Any non-empty list has a sentinel node whose 'elem' pointer is really
  580.  * a pointer to the last element.  (i.e. length(list) = #elemIn(list)+1).
  581.  * Elements are appended to the list.
  582.  */
  583. void
  584. #ifdef __STDC__
  585. list_add( ListNode **list, void *e )
  586. #else
  587. list_add( list, e )
  588. ListNode **list;
  589. void *e;
  590. #endif
  591. {
  592. ListNode *p, *tail;
  593. require(e!=NULL, "list_add: attempting to add NULL list element");
  595. p = newListNode;
  596. require(p!=NULL, "list_add: cannot alloc new list node");
  597. p->elem = e;
  598. if ( *list == NULL )
  599. {
  600. ListNode *sentinel = newListNode;
  601. require(sentinel!=NULL, "list_add: cannot alloc sentinel node");
  602. *list=sentinel;
  603. sentinel->next = p;
  604. sentinel->elem = (char *)p; /* set tail pointer */
  605. }
  606. else /* find end of list */
  607. {
  608. tail = (ListNode *) (*list)->elem; /* get tail pointer */
  609. tail->next = p;
  610. (*list)->elem = (char *) p; /* reset tail */
  611. }
  612. }
  614. /* MR10 list_free() frees the ListNode elements in the list       */
  615. /* MR10   if freeData then free the data elements of the list too */
  617. void
  618. #ifdef __STDC__
  619. list_free(ListNode **list,int freeData)
  620. #else
  621. list_free(list,freeData)
  622.   ListNode      **list;
  623.   int           freeData;
  624. #endif
  625. {
  626. ListNode *p;
  627.     ListNode *next;
  629. if (list == NULL) return;
  630.     if (*list == NULL) return;
  631. for (p=*list; p != NULL; p=next) {
  632.       next=p->next;
  633.       if (freeData && p->elem != NULL) {
  634.         free( (char *) p->elem);
  635.       };
  636.       free( (char *) p);
  637.     };
  638.     *list=NULL;
  639. }
  641. void
  642. #ifdef __STDC__
  643. list_apply( ListNode *list, void (*f)(void *) )
  644. #else
  645. list_apply( list, f )
  646. ListNode *list;
  647. void (*f)();
  648. #endif
  649. {
  650. ListNode *p;
  651. require(f!=NULL, "list_apply: NULL function to apply");
  653. if ( list == NULL ) return;
  654. for (p = list->next; p!=NULL; p=p->next) (*f)( p->elem );
  655. }
  657. /* F O L L O W  C y c l e  S t u f f */
  659. /* make a key based upon (rulename, computation, k value).
  660.  * Computation values are 'i'==FIRST, 'o'==FOLLOW.
  661.  */
  663. /* MR10  Make the key all characters so it can be read easily   */
  664. /* MR10    by a simple dump program.  Also, separates           */
  665. /* MR10   'o' and 'i' from rule name                            */
  667. char *
  668. #ifdef __STDC__
  669. Fkey( char *rule, int computation, int k )
  670. #else
  671. Fkey( rule, computation, k )
  672. char *rule;
  673. int computation;
  674. int k;
  675. #endif
  676. {
  677. static char key[MaxRuleName+2+2+1];                                 /* MR10 */
  678. int i;
  680. if ( k > 99 )                                                       /* MR10 */
  681. fatal("k>99 is too big for this implementation of ANTLR!n");   /* MR10 */
  682. if ( (i=strlen(rule)) > MaxRuleName )                               /* MR10 */
  683. fatal( eMsgd("rule name > max of %dn", MaxRuleName) );         /* MR10 */
  684. strcpy(key,rule);
  686. /* MR10 */     key[i]='*';
  687. /* MR10 */     key[i+1] = (int) computation;
  688. /* MR10 */     if (k < 10) {
  689. /* MR10 */       key[i+2] = (char) ( '0' + k);
  690. /* MR10 */    key[i+3] = '';
  691. /* MR10 */     } else {
  692. /* MR10 */       key[i+2] = (char) ( '0' + k/10);
  693. /* MR10 */       key[i+3] = (char) ( '0' + k % 10);
  694. /* MR10 */       key[i+4] = '';
  695. /* MR10 */     };
  697. return key;
  698. }
  700. /* Push a rule onto the kth FOLLOW stack */
  701. void
  702. #ifdef __STDC__
  703. FoPush( char *rule, int k )
  704. #else
  705. FoPush( rule, k )
  706. char *rule;
  707. int k;
  708. #endif
  709. {
  710. RuleEntry *r;
  711. require(rule!=NULL, "FoPush: tried to push NULL rule");
  712. require(k<=CLL_k, "FoPush: tried to access non-existent stack");
  714. /*fprintf(stderr, "FoPush(%s)n", rule);*/
  715. r = (RuleEntry *) hash_get(Rname, rule);
  716. if ( r == NULL ) {fatal_internal( eMsg1("rule %s must be defined but isn't", rule) );}
  717. if ( FoStack[k] == NULL ) /* Does the kth stack exist yet? */
  718. {
  719. /*fprintf(stderr, "allocating FoStackn");*/
  720. FoStack[k] = (int *) calloc(FoStackSize, sizeof(int));
  721. require(FoStack[k]!=NULL, "FoPush: cannot allocate FOLLOW stackn");
  722. }
  723. if ( FoTOS[k] == NULL )
  724. {
  725. FoTOS[k]=FoStack[k];
  726. *(FoTOS[k]) = r->rulenum;
  727. }
  728. else
  729. {
  730. #ifdef MEMCHK
  731. require(valid(FoStack[k]), "FoPush: invalid FoStack");
  732. #endif
  733. if ( FoTOS[k] >= &(FoStack[k][FoStackSize-1]) )
  734. fatal( eMsgd("exceeded max depth of FOLLOW recursion (%d)n",
  735. FoStackSize) );
  736. require(FoTOS[k]>=FoStack[k],
  737. eMsg1("FoPush: FoStack stack-ptr is playing out of its sandbox",
  738.   rule));
  739. ++(FoTOS[k]);
  740. *(FoTOS[k]) = r->rulenum;
  741. }
  742. {
  743. /*
  744. **** int *p;
  745. **** fprintf(stderr, "FoStack[k=%d]:n", k);
  746. **** for (p=FoStack[k]; p<=FoTOS[k]; p++)
  747. **** {
  748. **** fprintf(stderr, "t%sn", RulePtr[*p]->rname);
  749. **** }
  750. */
  751. }
  752. }
  754. /* Pop one rule off of the FOLLOW stack.  TOS ptr is NULL if empty. */
  755. void
  756. #ifdef __STDC__
  757. FoPop( int k )
  758. #else
  759. FoPop( k )
  760. int k;
  761. #endif
  762. {
  763. require(k<=CLL_k, "FoPop: tried to access non-existent stack");
  764. /*fprintf(stderr, "FoPopn");*/
  765. require(FoTOS[k]>=FoStack[k]&&FoTOS[k]<=&(FoStack[k][FoStackSize-1]),
  766. "FoPop: FoStack stack-ptr is playing out of its sandbox");
  767. if ( FoTOS[k] == FoStack[k] ) FoTOS[k] = NULL;
  768. else (FoTOS[k])--;
  769. }
  771. /* Compute FOLLOW cycle.
  772.  * Mark all FOLLOW sets for rules in cycle as incomplete.
  773.  * Then, save cycle on the cycle list (Cycles) for later resolution.
  774.  * The Cycle is stored in the form:
  775.  * (head of cycle==croot, rest of rules in cycle==cyclicDep)
  776.  *
  777.  * e.g. (Fo means "FOLLOW of", "-->" means requires or depends on)
  778.  *
  779.  * Fo(x)-->Fo(a)-->Fo(b)-->Fo(c)-->Fo(x)
  780.  *    ^----Infinite recursion (cycle)
  781.  *
  782.  * the cycle would be: x -> {a,b,c} or stored as (x,{a,b,c}).  Fo(x) depends
  783.  * on the FOLLOW of a,b, and c.  The root of a cycle is always complete after
  784.  * Fo(x) finishes.  Fo(a,b,c) however are not.  It turns out that all rules
  785.  * in a FOLLOW cycle have the same FOLLOW set.
  786.  */
  787. void
  788. #ifdef __STDC__
  789. RegisterCycle( char *rule, int k )
  790. #else
  791. RegisterCycle( rule, k )
  792. char *rule;
  793. int k;
  794. #endif
  795. {
  796. CacheEntry *f;
  797. Cycle *c;
  798. int *p;
  799. RuleEntry *r;
  800. require(rule!=NULL, "RegisterCycle: tried to register NULL rule");
  801. require(k<=CLL_k, "RegisterCycle: tried to access non-existent stack");
  803. /*fprintf(stderr, "RegisterCycle(%s)n", rule);*/
  804. /* Find cycle start */
  805. r = (RuleEntry *) hash_get(Rname, rule);
  806. require(r!=NULL,eMsg1("rule %s must be defined but isn't", rule));
  807. require(FoTOS[k]>=FoStack[k]&&FoTOS[k]<=&(FoStack[k][FoStackSize-1]),
  808. eMsg1("RegisterCycle(%s): FoStack stack-ptr is playing out of its sandbox",
  809.   rule));
  810. /*** if ( FoTOS[k]<FoStack[k]||FoTOS[k]>&(FoStack[k][FoStackSize-1]) )
  811. **** {
  812. **** fprintf(stderr, "RegisterCycle(%s): FoStack stack-ptr is playing out of its sandboxn",
  813. **** rule);
  814. **** fprintf(stderr, "RegisterCycle: sp==0x%x out of bounds 0x%x...0x%xn",
  815. **** FoTOS[k], FoStack[k], &(FoStack[k][FoStackSize-1]));
  816. **** exit(PCCTS_EXIT_FAILURE);
  817. **** }
  818. ****/
  820. #ifdef MEMCHK
  821. require(valid(FoStack[k]), "RegisterCycle: invalid FoStack");
  822. #endif
  823. for (p=FoTOS[k]; *p != r->rulenum && p >= FoStack[k]; --p) {;}
  824. require(p>=FoStack[k], "RegisterCycle: FoStack is screwed up beyond belief");
  825. if ( p == FoTOS[k] ) return; /* don't worry about cycles to oneself */
  827. /* compute cyclic dependents (rules in cycle except head) */
  828. c = newCycle;
  829. require(c!=NULL, "RegisterCycle: couldn't alloc new cycle");
  830. c->cyclicDep = empty;
  831. c->croot = *p++; /* record root of cycle */
  832. for (; p<=FoTOS[k]; p++)
  833. {
  834. /* Mark all dependent rules as incomplete */
  835. f = (CacheEntry *) hash_get(Fcache, Fkey(RulePtr[*p]->rname,'o',k));
  836. if ( f==NULL )
  837. {
  838. f = newCacheEntry( Fkey(RulePtr[*p]->rname,'o',k) );
  839. hash_add(Fcache, Fkey(RulePtr[*p]->rname,'o',k), (Entry *)f);
  840. }
  841. f->incomplete = TRUE;
  843. set_orel(*p, &(c->cyclicDep)); /* mark rule as dependent of croot */
  844. }
  845. list_add(&(Cycles[k]), (void *)c);
  846. }
  848. /* make all rules in cycle complete
  849.  *
  850.  * while ( some set has changed ) do
  851.  * for each cycle do
  852.  * if degree of FOLLOW set for croot > old degree then
  853.  * update all FOLLOW sets for rules in cyclic dependency
  854.  * change = TRUE
  855.  * endif
  856.  * endfor
  857.  * endwhile
  858.  */
  859. void
  860. #ifdef __STDC__
  861. ResolveFoCycles( int k )
  862. #else
  863. ResolveFoCycles( k )
  864. int k;
  865. #endif
  866. {
  867. ListNode *p, *q;
  868. Cycle *c;
  869. int changed = 1;
  870. CacheEntry *f,*g;
  871. int r;
  872. /*  int i;  */  /* MR10 not useful */
  873. unsigned d;
  875.     unsigned    *cursor;        /* MR10 */
  876.     unsigned    *origin;        /* MR10 */
  878. /*fprintf(stderr, "Resolving following cycles for %dn", k);*/
  879. while ( changed )
  880. {
  881. changed = 0;
  882. /* MR10 i = 0;  */
  883. for (p = Cycles[k]->next; p!=NULL; p=p->next)
  884. {
  885. c = (Cycle *) p->elem;
  886. /*fprintf(stderr, "cycle %d: %s -->", i++, RulePtr[c->croot]->rname);*/
  887. /*s_fprT(stderr, c->cyclicDep);*/
  888. /*fprintf(stderr, "n");*/
  889. f = (CacheEntry *)
  890. hash_get(Fcache, Fkey(RulePtr[c->croot]->rname,'o',k));
  891. require(f!=NULL, eMsg1("FOLLOW(%s) must be in cache but isn't", RulePtr[c->croot]->rname) );
  892. if ( (d=set_deg(f->fset)) > c->deg )
  893. {
  894. /*fprintf(stderr, "Fo(%s) has changedn", RulePtr[c->croot]->rname);*/
  895. changed = 1;
  896. c->deg = d; /* update cycle FOLLOW set degree */
  898. /* MR10 */      origin=set_pdq(c->cyclicDep);
  899. /* MR10 */      for (cursor=origin; *cursor != nil; cursor++) {
  900. /* MR10 */         r=*cursor;
  902. /******** while ( !set_nil(c->cyclicDep) ) {      *****/
  903. /******** r = set_int(c->cyclicDep);  *****/
  904. /******** set_rm(r, c->cyclicDep);    *****/
  906. /*fprintf(stderr, "updating Fo(%s)n", RulePtr[r]->rname);*/
  907. g = (CacheEntry *)
  908. hash_get(Fcache, Fkey(RulePtr[r]->rname,'o',k));
  909. require(g!=NULL, eMsg1("FOLLOW(%s) must be in cache but isn't", RulePtr[r]->rname) );
  910. set_orin(&(g->fset), f->fset);
  911. g->incomplete = FALSE;
  912. }
  913. /* MR10 */      free( (char *) origin);
  914. /* MR10 */      origin=NULL;
  915. }
  916. }
  917. /* MR10 - this if statement appears to be meaningless since i is always 0 */
  918. /* MR10 if ( i == 1 ) changed = 0; */ /* if only 1 cycle, no need to repeat */
  919. }
  920. /* kill Cycle list */
  921. for (q = Cycles[k]->next; q != NULL; q=p)
  922. {
  923. p = q->next;
  924. set_free( ((Cycle *)q->elem)->cyclicDep );
  925. free((char *)q);
  926. }
  927. free( (char *)Cycles[k] );
  928. Cycles[k] = NULL;
  929. }
  932. /* P r i n t i n g  S y n t a x  D i a g r a m s */
  934. static void
  935. #ifdef __STDC__
  936. pBlk( Junction *q, int btype )
  937. #else
  938. pBlk( q, btype )
  939. Junction *q;
  940. int btype;
  941. #endif
  942. {
  943. int k,a;
  944. Junction *alt, *p;
  946. q->end->pvisited = TRUE;
  947. if ( btype == aLoopBegin )
  948. {
  949. require(q->p2!=NULL, "pBlk: invalid ()* block");
  950. PRINT(q->p1);
  951. alt = (Junction *)q->p2;
  952. PRINT(alt->p1);
  953. if ( PrintAnnotate )
  954. {
  955. printf(" /* Opt ");
  956. k = 1;
  957. while ( !set_nil(alt->fset[k]) )
  958. {
  959. s_fprT(stdout, alt->fset[k]);
  960. if ( k++ == CLL_k ) break;
  961. if ( !set_nil(alt->fset[k]) ) printf(", ");
  962. }
  963. printf(" */n");
  964. }
  965. return;
  966. }
  967. for (a=1,alt=q; alt != NULL; alt= (Junction *) alt->p2, a++)
  968. {
  969. if ( alt->p1 != NULL ) PRINT(alt->p1);
  970. if ( PrintAnnotate )
  971. {
  972. printf( " /* [%d] ", alt->altnum);
  973. k = 1;
  974. while ( !set_nil(alt->fset[k]) )
  975. {
  976. s_fprT(stdout, alt->fset[k]);
  977. if ( k++ == CLL_k ) break;
  978. if ( !set_nil(alt->fset[k]) ) printf(", ");
  979. }
  980. if ( alt->p2 == NULL && btype == aOptBlk )
  981. printf( " (optional branch) */n");
  982. else printf( " */n");
  983. }
  985. /* ignore implied empty alt of Plus blocks */
  986. if ( alt->p2 != NULL && ((Junction *)alt->p2)->ignore ) break;
  988. if ( alt->p2 != NULL && !(((Junction *)alt->p2)->p2==NULL && btype == aOptBlk) )
  989. {
  990. if ( pLevel == 1 )
  991. {
  992. printf("n");
  993. if ( a+1==pAlt1 || a+1==pAlt2 ) printf("=>");
  994. printf("t");
  995. }
  996. else printf(" ");
  997. printf("|");
  998. if ( pLevel == 1 )
  999. {
  1000. p = (Junction *) ((Junction *)alt->p2)->p1;
  1001. while ( p!=NULL )
  1002. {
  1003. if ( p->ntype==nAction )
  1004. {
  1005. p=(Junction *)((ActionNode *)p)->next;
  1006. continue;
  1007. }
  1008. if ( p->ntype!=nJunction )
  1009. {
  1010. break;
  1011. }
  1012. if ( p->jtype==EndBlk || p->jtype==EndRule )
  1013. {
  1014. p = NULL;
  1015. break;
  1016. }
  1017. p = (Junction *)p->p1;
  1018. }
  1019. if ( p==NULL ) printf("nt"); /* Empty alt? */
  1020. }
  1021. }
  1022. }
  1023. q->end->pvisited = FALSE;
  1024. }
  1026. /* How to print out a junction */
  1027. void
  1028. #ifdef __STDC__
  1029. pJunc( Junction *q )
  1030. #else
  1031. pJunc( q )
  1032. Junction *q;
  1033. #endif
  1034. {
  1035. int dum_k;
  1036. int doing_rule;
  1037. require(q!=NULL, "pJunc: NULL node");
  1038. require(q->ntype==nJunction, "pJunc: not junction");
  1040. if ( q->pvisited == TRUE ) return;
  1041. q->pvisited = TRUE;
  1042. switch ( q->jtype )
  1043. {
  1044. case aSubBlk :
  1045. if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
  1046. if ( q->end->p1 != NULL && ((Junction *)q->end->p1)->ntype==nJunction &&
  1047.  ((Junction *)q->end->p1)->jtype == EndRule ) doing_rule = 1;
  1048. else doing_rule = 0;
  1049. pLevel++;
  1050. if ( pLevel==1 )
  1051. {
  1052. if ( pAlt1==1 ) printf("=>");
  1053. printf("t");
  1054. }
  1055. else printf(" ");
  1056. if ( doing_rule )
  1057. {
  1058. if ( pLevel==1 ) printf(" ");
  1059. pBlk(q,q->jtype);
  1060. }
  1061. else {
  1062. printf("(");
  1063. if ( pLevel==1 ) printf(" ");
  1064. pBlk(q,q->jtype);
  1065. if ( pLevel>1 ) printf(" ");
  1066. printf(")");
  1067. }
  1068. if ( q->guess ) printf("?");
  1069. pLevel--;
  1070. if ( PrintAnnotate ) freeBlkFsets(q);
  1071. if ( q->end->p1 != NULL ) PRINT(q->end->p1);
  1072. break;
  1073. case aOptBlk :
  1074. if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
  1075. pLevel++;
  1076. if ( pLevel==1 )
  1077. {
  1078. if ( pAlt1==1 ) printf("=>");
  1079. printf("t");
  1080. }
  1081. else printf(" ");
  1082. printf("{");
  1083. if ( pLevel==1 ) printf(" ");
  1084. pBlk(q,q->jtype);
  1085. if ( pLevel>1 ) printf(" ");
  1086. else printf("nt");
  1087. printf("}");
  1088. pLevel--;
  1089. if ( PrintAnnotate ) freeBlkFsets(q);
  1090. if ( q->end->p1 != NULL ) PRINT(q->end->p1);
  1091. break;
  1092. case aLoopBegin :
  1093. if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
  1094. pLevel++;
  1095. if ( pLevel==1 )
  1096. {
  1097. if ( pAlt1==1 ) printf("=>");
  1098. printf("t");
  1099. }
  1100. else printf(" ");
  1101. printf("(");
  1102. if ( pLevel==1 ) printf(" ");
  1103. pBlk(q,q->jtype);
  1104. if ( pLevel>1 ) printf(" ");
  1105. else printf("nt");
  1106. printf(")*");
  1107. pLevel--;
  1108. if ( PrintAnnotate ) freeBlkFsets(q);
  1109. if ( q->end->p1 != NULL ) PRINT(q->end->p1);
  1110. break;
  1111. case aLoopBlk :
  1112. if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
  1113. pBlk(q,q->jtype);
  1114. if ( PrintAnnotate ) freeBlkFsets(q);
  1115. break;
  1116. case aPlusBlk :
  1117. if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
  1118. pLevel++;
  1119. if ( pLevel==1 )
  1120. {
  1121. if ( pAlt1==1 ) printf("=>");
  1122. printf("t");
  1123. }
  1124. else printf(" ");
  1125. printf("(");
  1126. if ( pLevel==1 ) printf(" ");
  1127. pBlk(q,q->jtype);
  1128. if ( pLevel>1 ) printf(" ");
  1129. printf(")+");
  1130. pLevel--;
  1131. if ( PrintAnnotate ) freeBlkFsets(q);
  1132. if ( q->end->p1 != NULL ) PRINT(q->end->p1);
  1133. break;
  1134. case EndBlk :
  1135. break;
  1136. case RuleBlk :
  1137. printf( "n%s :n", q->rname);
  1138. PRINT(q->p1);
  1139. if ( q->p2 != NULL ) PRINT(q->p2);
  1140. break;
  1141. case Generic :
  1142. if ( q->p1 != NULL ) PRINT(q->p1);
  1143. q->pvisited = FALSE;
  1144. if ( q->p2 != NULL ) PRINT(q->p2);
  1145. break;
  1146. case EndRule :
  1147. printf( "nt;n");
  1148. break;
  1149. }
  1150. q->pvisited = FALSE;
  1151. }
  1153. /* How to print out a rule reference node */
  1154. void
  1155. #ifdef __STDC__
  1156. pRuleRef( RuleRefNode *p )
  1157. #else
  1158. pRuleRef( p )
  1159. RuleRefNode *p;
  1160. #endif
  1161. {
  1162. require(p!=NULL, "pRuleRef: NULL node");
  1163. require(p->ntype==nRuleRef, "pRuleRef: not rule ref node");
  1165. printf( " %s", p->text);
  1166. PRINT(p->next);
  1167. }
  1169. /* How to print out a terminal node */
  1170. void
  1171. #ifdef __STDC__
  1172. pToken( TokNode *p )
  1173. #else
  1174. pToken( p )
  1175. TokNode *p;
  1176. #endif
  1177. {
  1178. require(p!=NULL, "pToken: NULL node");
  1179. require(p->ntype==nToken, "pToken: not token node");
  1181. if ( p->wild_card ) printf(" .");
  1182. printf( " %s", TerminalString(p->token));
  1183. PRINT(p->next);
  1184. }
  1186. /* How to print out a terminal node */
  1187. void
  1188. #ifdef __STDC__
  1189. pAction( ActionNode *p )
  1190. #else
  1191. pAction( p )
  1192. ActionNode *p;
  1193. #endif
  1194. {
  1195. require(p!=NULL, "pAction: NULL node");
  1196. require(p->ntype==nAction, "pAction: not action node");
  1198. PRINT(p->next);
  1199. }
  1201. /* F i l l  F o l l o w  L i s t s */
  1203. /*
  1204.  * Search all rules for all rule reference nodes, q to rule, r.
  1205.  * Add q->next to follow list dangling off of rule r.
  1206.  * i.e.
  1207.  *
  1208.  * r: -o-R-o-->o--> Ptr to node following rule r in another rule
  1209.  * |
  1210.  * o--> Ptr to node following another reference to r.
  1211.  *
  1212.  * This is the data structure employed to avoid FOLLOW set computation.  We
  1213.  * simply compute the FIRST (reach) of the EndRule Node which follows the
  1214.  * list found at the end of all rules which are referenced elsewhere.  Rules
  1215.  * not invoked by other rules have no follow list (r->end->p1==NULL).
  1216.  * Generally, only start symbols are not invoked by another rule.
  1217.  *
  1218.  * Note that this mechanism also gives a free cross-reference mechanism.
  1219.  *
  1220.  * The entire syntax diagram is layed out like this:
  1221.  *
  1222.  * SynDiag
  1223.  * |
  1224.  * v
  1225.  * o-->R1--o
  1226.  * |
  1227.  * o-->R2--o
  1228.  * |
  1229.  * ...
  1230.  * |
  1231.  * o-->Rn--o
  1232.  *
  1233.  */
  1234. void
  1235. #ifdef __STDC__
  1236. FoLink( Node *p )
  1237. #else
  1238. FoLink( p )
  1239. Node *p;
  1240. #endif
  1241. {
  1242. RuleEntry *q;
  1243. Junction *j = (Junction *) p;
  1244. RuleRefNode *r = (RuleRefNode *) p;
  1246. if ( p==NULL ) return;
  1247. require(p->ntype>=1 && p->ntype<=NumNodeTypes,
  1248. eMsgd("FoLink: invalid diagram node: ntype==%d",p->ntype));
  1249. switch ( p->ntype )
  1250. {
  1251. case nJunction :
  1252. if ( j->fvisited ) return;
  1253. if ( j->jtype == EndRule ) return;
  1254. j->fvisited = TRUE;
  1255. FoLink( j->p1 );
  1256. FoLink( j->p2 );
  1257. /* MR14 */
  1258. /* MR14 */  /* Need to determine whether the guess block is an         */
  1259. /* MR14 */  /* of the form (alpha)? beta before follow sets are        */
  1260. /* MR14 */  /* computed.  This is necessary to solve problem           */
  1261. /* MR14 */  /* of doing follow on the alpha of an (alpha)? beta block. */
  1262. /* MR14 */
  1263. /* MR14 */  /* This is performed by analysis_point as a side-effect.   */
  1264. /* MR14 */
  1265. /* MR14 */
  1266. /* MR14 */  if (j->jtype == aSubBlk && j->guess) {
  1267. /* MR14 */    Junction *ignore;
  1268. /* MR14 */    ignore=analysis_point(j);
  1269. /* MR14 */  }
  1270. /* MR14 */
  1271. return;
  1272. case nRuleRef :
  1273. if ( r->linked ) return;
  1274. q = (RuleEntry *) hash_get(Rname, r->text);
  1275. if ( q == NULL )
  1276. {
  1277. warnFL( eMsg1("rule %s not defined",r->text), FileStr[r->file], r->line );
  1278. }
  1279. else
  1280. {
  1281. if ( r->parms!=NULL && RulePtr[q->rulenum]->pdecl==NULL )
  1282. {
  1283. warnFL( eMsg1("rule %s accepts no parameter(s)", r->text),
  1284. FileStr[r->file], r->line );
  1285. }
  1286. if ( r->parms==NULL && RulePtr[q->rulenum]->pdecl!=NULL )
  1287. {
  1288. warnFL( eMsg1("rule %s requires parameter(s)", r->text),
  1289. FileStr[r->file], r->line );
  1290. }
  1291. if ( r->assign!=NULL && RulePtr[q->rulenum]->ret==NULL )
  1292. {
  1293. warnFL( eMsg1("rule %s yields no return value(s)", r->text),
  1294. FileStr[r->file], r->line );
  1295. }
  1296. if ( r->assign==NULL && RulePtr[q->rulenum]->ret!=NULL )
  1297. {
  1298. warnFL( eMsg1("rule %s returns a value(s)", r->text),
  1299. FileStr[r->file], r->line );
  1300. }
  1301. if ( !r->linked )
  1302. {
  1303. addFoLink( r->next, r->rname, RulePtr[q->rulenum] );
  1304. r->linked = TRUE;
  1305. }
  1306. }
  1307. FoLink( r->next );
  1308. return;
  1309. case nToken :
  1310. FoLink( ((TokNode *)p)->next );
  1311. return;
  1312. case nAction :
  1313. FoLink( ((ActionNode *)p)->next );
  1314. return;
  1315. default :
  1316. fatal_internal("invalid node type");
  1317. }
  1318. }
  1320. /*
  1321.  * Add a reference to the end of a rule.
  1322.  *
  1323.  * 'r' points to the RuleBlk node in a rule.  r->end points to the last node
  1324.  * (EndRule jtype) in a rule.
  1325.  *
  1326.  * Initial:
  1327.  * r->end -->  o
  1328.  *
  1329.  * After:
  1330.  * r->end -->  o-->o--> Ptr to node following rule r in another rule
  1331.  * |
  1332.  * o--> Ptr to node following another reference to r.
  1333.  *
  1334.  * Note that the links are added to the head of the list so that r->end->p1
  1335.  * always points to the most recently added follow-link.  At the end, it should
  1336.  * point to the last reference found in the grammar (starting from the 1st rule).
  1337.  */
  1338. void
  1339. #ifdef __STDC__
  1340. addFoLink( Node *p, char *rname, Junction *r )
  1341. #else
  1342. addFoLink( p, rname, r )
  1343. Node *p;
  1344. char *rname;
  1345. Junction *r;
  1346. #endif
  1347. {
  1348. Junction *j;
  1349. require(r!=NULL, "addFoLink: incorrect rule graph");
  1350. require(r->end!=NULL, "addFoLink: incorrect rule graph");
  1351. require(r->end->jtype==EndRule, "addFoLink: incorrect rule graph");
  1352. require(p!=NULL, "addFoLink: NULL FOLLOW link");
  1354. j = newJunction();
  1355. j->rname = rname; /* rname on follow links point to target rule */
  1356. j->p1 = p; /* link to other rule */
  1357. j->p2 = (Node *) r->end->p1;/* point to head of list */
  1358. r->end->p1 = (Node *) j; /* reset head to point to new node */
  1359. }
  1361. void
  1362. #ifdef __STDC__
  1363. GenCrossRef( Junction *p )
  1364. #else
  1365. GenCrossRef( p )
  1366. Junction *p;
  1367. #endif
  1368. {
  1369. set a;
  1370. Junction *j;
  1371. RuleEntry *q;
  1372. unsigned e;
  1373. require(p!=NULL, "GenCrossRef: why are you passing me a null grammar?");
  1375. printf("Cross Reference:nn");
  1376. a = empty;
  1377. for (; p!=NULL; p = (Junction *)p->p2)
  1378. {
  1379. printf("Rule %20s referenced by {", p->rname);
  1380. /* make a set of rules for uniqueness */
  1381. for (j = (Junction *)(p->end)->p1; j!=NULL; j = (Junction *)j->p2)
  1382. {
  1383. q = (RuleEntry *) hash_get(Rname, j->rname);
  1384. require(q!=NULL, "GenCrossRef: FoLinks are screwed up");
  1385. set_orel(q->rulenum, &a);
  1386. }
  1387. for (; !set_nil(a); set_rm(e, a))
  1388. {
  1389. e = set_int(a);
  1390. printf(" %s", RulePtr[e]->rname);
  1391. }
  1392. printf(" }n");
  1393. }
  1394. set_free( a );
  1395. }