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

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

编译器/解释器

开发平台：

Others

bits.c：源码内容
  1. /* bits.c -- manage creation and output of bit sets used by the parser.
  2.  *
  3.  * SOFTWARE RIGHTS
  4.  *
  5.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  6.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  7.  * company may do whatever they wish with source code distributed with
  8.  * PCCTS or the code generated by PCCTS, including the incorporation of
  9.  * PCCTS, or its output, into commerical software.
  10.  *
  11.  * We encourage users to develop software with PCCTS.  However, we do ask
  12.  * that credit is given to us for developing PCCTS.  By "credit",
  13.  * we mean that if you incorporate our source code into one of your
  14.  * programs (commercial product, research project, or otherwise) that you
  15.  * acknowledge this fact somewhere in the documentation, research report,
  16.  * etc...  If you like PCCTS and have developed a nice tool with the
  17.  * output, please mention that you developed it using PCCTS.  In
  18.  * addition, we ask that this header remain intact in our source code.
  19.  * As long as these guidelines are kept, we expect to continue enhancing
  20.  * this system and expect to make other tools available as they are
  21.  * completed.
  22.  *
  23.  * ANTLR 1.33
  24.  * Terence Parr
  25.  * Parr Research Corporation
  26.  * with Purdue University and AHPCRC, University of Minnesota
  27.  * 1989-1998
  28.  */
  30. #include <stdio.h>
  31. #include <ctype.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"
  43. /* char is only thing that is pretty much always known == 8 bits
  44.  * This allows output of antlr (set stuff, anyway) to be androgynous (portable)
  45.  */
  46. typedef unsigned char SetWordType;
  47. #define BitsPerByte 8
  48. #define BitsPerWord BitsPerByte*sizeof(SetWordType)
  50. static SetWordType *setwd = NULL;
  51. int setnum = -1;
  52. int wordnum = 0;
  54. int esetnum = 0;
  56. /* Used to convert native wordsize, which ANTLR uses (via set.c) to manipulate sets,
  57.    to bytes that are most portable size-wise.
  58.    */
  59. void
  60. #ifdef __STDC__
  61. DumpIntAsChars( FILE *f, char *format, unsigned wd )
  62. #else
  63. DumpIntAsChars( f, format, wd )
  64. FILE *f;
  65. char *format;
  66. unsigned wd;
  67. #endif
  68. {
  69. int i;
  70. /* uses max of 32 bit unsigned integer for the moment */
  71. static unsigned long byte_mask[sizeof(unsigned long)] =
  72. { 0xFF, 0xFF00, 0xFF0000, 0xFF000000 };
  73. /*   0xFF00000000, 0xFF0000000000, 0xFF000000000000, 0xFF00000000000000 };*/
  75. /* for each byte in the word */
  76. for (i=0; i<sizeof(unsigned); i++)
  77. {
  78. /* mask out the ith byte and shift down to the first 8 bits */
  79. fprintf(f, format, (wd&byte_mask[i])>>(i*BitsPerByte));
  80. if ( i<sizeof(unsigned)-1) fprintf(f, ",");
  81. }
  82. }
  84. /* Create a new setwd (ignoring [Ep] token on end) */
  85. void
  86. #ifdef __STDC__
  87. NewSetWd( void )
  88. #else
  89. NewSetWd( )
  90. #endif
  91. {
  92. SetWordType *p;
  94. if ( setwd == NULL )
  95. {
  96. setwd = (SetWordType *) calloc(TokenNum, sizeof(SetWordType));
  97. require(setwd!=NULL, "NewSetWd: cannot alloc set wdn");
  98. }
  99. for (p = setwd; p<&(setwd[TokenNum]); p++)  {*p=0;}
  100. wordnum++;
  101. }
  103. void
  104. #ifdef __STDC__
  105. DumpSetWd( void )
  106. #else
  107. DumpSetWd( )
  108. #endif
  109. {
  110. if ( GenCC ) DumpSetWdForCC();
  111. else DumpSetWdForC();
  112. }
  114. /* Dump the current setwd to ErrFile. 0..MaxTokenVal */
  115. void
  116. #ifdef __STDC__
  117. DumpSetWdForC( void )
  118. #else
  119. DumpSetWdForC( )
  120. #endif
  121. {
  122. int i,c=1;
  124. if ( setwd==NULL ) return;
  125. if ( !GenCC ) fprintf(DefFile, "extern SetWordType setwd%d[];n", wordnum);
  126. fprintf(ErrFile,
  127. "SetWordType setwd%d[%d] = {", wordnum, TokenNum-1);
  128. for (i=0; i<TokenNum-1; i++)
  129. {
  130. DAWDLE;
  131. if ( i!=0 ) fprintf(ErrFile, ",");
  132. if ( c == 8 ) {fprintf(ErrFile, "nt"); c=1;} else c++;
  133. fprintf(ErrFile, "0x%x", setwd[i]);
  134. }
  135. fprintf(ErrFile, "};n");
  136. }
  138. /* Dump the current setwd to Parser.C file. 0..MaxTokenVal;
  139.  * Only used if -CC on.
  140.  */
  141. void
  142. #ifdef __STDC__
  143. DumpSetWdForCC( void )
  144. #else
  145. DumpSetWdForCC( )
  146. #endif
  147. {
  148. int i,c=1;
  150. if ( setwd==NULL ) return;
  151. fprintf(Parser_h, "tstatic SetWordType setwd%d[%d];n", wordnum, TokenNum-1);
  152. fprintf(Parser_c,
  153. "SetWordType %s::setwd%d[%d] = {", CurrentClassName, wordnum,
  154. TokenNum-1);
  155. for (i=0; i<TokenNum-1; i++)
  156. {
  157. DAWDLE;
  158. if ( i!=0 ) fprintf(Parser_c, ",");
  159. if ( c == 8 ) {fprintf(Parser_c, "nt"); c=1;} else c++;
  160. fprintf(Parser_c, "0x%x", setwd[i]);
  161. }
  162. fprintf(Parser_c, "};n");
  163. }
  165. /* Make a new set.  Dump old setwd and create new setwd if current setwd is full */
  166. void
  167. #ifdef __STDC__
  168. NewSet( void )
  169. #else
  170. NewSet( )
  171. #endif
  172. {
  173. setnum++;
  174. if ( setnum==BitsPerWord ) /* is current setwd full? */
  175. {
  176. DumpSetWd(); NewSetWd(); setnum = 0;
  177. }
  178. }
  180. /* s is a set of tokens.  Turn on bit at each token position in set 'setnum' */
  181. void
  182. #ifdef __STDC__
  183. FillSet( set s )
  184. #else
  185. FillSet( s )
  186. set s;
  187. #endif
  188. {
  189. SetWordType mask=(((unsigned)1)<<setnum);
  190. unsigned int e;
  192. while ( !set_nil(s) )
  193. {
  194. e = set_int(s);
  195. set_rm(e, s);
  196. setwd[e] |= mask;
  197. }
  198. }
  200. /* E r r o r  C l a s s  S t u f f */
  202. /* compute the FIRST of a rule for the error class stuff */
  203. static set
  204. #ifdef __STDC__
  205. Efirst( char *rule, ECnode *eclass )
  206. #else
  207. Efirst( rule, eclass )
  208. char *rule;
  209. ECnode *eclass;
  210. #endif
  211. {
  212. set rk, a;
  213. Junction *r;
  214. RuleEntry *q = (RuleEntry *) hash_get(Rname, rule);
  216. if ( q == NULL )
  217. {
  218. warnNoFL(eMsg2("undefined rule '%s' referenced in errclass '%s'; ignored",
  219. rule, TokenString(eclass->tok)));
  220. return empty;
  221. }
  222. r = RulePtr[q->rulenum];
  223. r->end->halt = TRUE; /* don't let reach fall off end of rule here */
  224. rk = empty;
  225. REACH(r, 1, &rk, a);
  226. r->end->halt = FALSE;
  227. return a;
  228. }
  230. /*
  231.  * scan the list of tokens/eclasses/nonterminals filling the new eclass
  232.  * with the set described by the list.  Note that an eclass can be
  233.  * quoted to allow spaces etc... However, an eclass must not conflict
  234.  * with a reg expr found elsewhere.  The reg expr will be taken over
  235.  * the eclass name.
  236.  */
  237. static void
  238. #ifdef __STDC__
  239. doEclass( char *eclass )
  240. #else
  241. doEclass( eclass )
  242. char *eclass;
  243. #endif
  244. {
  245. TermEntry *q;
  246. ECnode *p;
  247. ListNode *e;
  248. unsigned int t;
  249. unsigned deg=0;
  250. set a;
  251. require(eclass!=NULL, "doEclass: NULL eset");
  253. p = (ECnode *) eclass;
  254. lexmode(p->lexclass); /* switch to lexclass where errclass is defined */
  255. p->eset = empty;
  256. for (e = (p->elist)->next; e!=NULL; e=e->next)
  257. {
  258. if ( islower( *((char *)e->elem) ) ) /* is it a rule ref? (alias FIRST request) */
  259. {
  260. a = Efirst((char *)e->elem, p);
  261. set_orin(&p->eset, a);
  262. deg += set_deg(a);
  263. set_free( a );
  264. continue;
  265. }
  266. else if ( *((char *)e->elem)=='"' )
  267. {
  268. t = 0;
  269. q = (TermEntry *) hash_get(Texpr, (char *) e->elem);
  270. if ( q == NULL )
  271. {
  272. /* if quoted and not an expr look for eclass name */
  273. q = (TermEntry *) hash_get(Tname, *((char **)&(e->elem))=StripQuotes((char *)e->elem));
  274. if ( q != NULL ) t = q->token;
  275. }
  276. else t = q->token;
  277. }
  278. else /* labelled token/eclass/tokclass */
  279. {
  280. q = (TermEntry *) hash_get(Tname, (char *)e->elem);
  281. if ( q != NULL )
  282. {
  283. if ( strcmp((char *)e->elem, TokenString(p->tok))==0 )
  284. {
  285. warnNoFL(eMsg1("self-referential error class '%s'; ignored",
  286.    (char *)e->elem));
  287. continue;
  288. }
  289. else
  290. t = q->token;
  291. }
  292. else t=0;
  293. }
  294. if ( t!=0 )
  295. {
  296. set_orel(t, &p->eset);
  297. deg++;
  298. }
  299. else warnNoFL(eMsg2("undefined token '%s' referenced in errclass '%s'; ignored",
  300. (char *)e->elem, TokenString(p->tok)));
  301. }
  302. p->setdeg = deg;
  303. }
  305. void
  306. #ifdef __STDC__
  307. ComputeErrorSets( void )
  308. #else
  309. ComputeErrorSets( )
  310. #endif
  311. {
  312. #ifdef __cplusplus
  313.     list_apply(eclasses, (void (*)(void *)) doEclass);
  314. #else
  315. #ifdef __STDC__
  316.     list_apply(eclasses, (void (*)(void *)) doEclass);
  317. #else
  318.     list_apply(eclasses, doEclass);
  319. #endif
  320. #endif
  321. }
  323. void
  324. #ifdef __STDC__
  325. ComputeTokSets( void )
  326. #else
  327. ComputeTokSets( )
  328. #endif
  329. {
  330. ListNode *t, *e = NULL, *e1, *e2;
  331. int something_changed;
  332.     int i;
  333. TCnode *p;
  334. TermEntry *q, *q1, *q2;
  336. if ( tclasses == NULL ) return;
  338. /* turn lists of token/tokclass references into sets */
  339. for (t = tclasses->next; t!=NULL; t=t->next)
  340. {
  341. p = (TCnode *) t->elem;
  343. /* if wild card, then won't have entries in tclass, assume all_tokens */
  344. if ( p->tok == WildCardToken )
  345. {
  346. p->tset = set_dup(all_tokens);
  347. continue;
  348. }
  350. lexmode(p->lexclass); /* switch to lexclass where tokclass is defined */
  351. p->tset = empty;
  353. /* instantiate all tokens/token_classes into the tset */
  354. for (e = (p->tlist)->next; e!=NULL; e=e->next)
  355. {
  356. char *tokstr;
  357. tokstr = (char *)e->elem;
  358. if ( *tokstr == '"' ) {
  359.                 q = (TermEntry *) hash_get(Texpr, tokstr);
  360.      require(q!=NULL, "ComputeTokSets: no token def");
  361.      set_orel(q->token, &p->tset);
  362. } else if (tokstr[0] == '.') {
  363.                 e1=e->next;
  364.                 e2=e1->next;
  365.                 e=e2;
  366.                 q1= (TermEntry *) hash_get(Tname, (char *)e1->elem);
  367.      require(q1!=NULL, "ComputeTokSets: no token def");
  368.                 q2= (TermEntry *) hash_get(Tname, (char *)e2->elem);
  369.      require(q2!=NULL, "ComputeTokSets: no token def");
  371.                 if (set_el(q1->token,imag_tokens)) {
  372. errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",
  373.                         TokenString(p->tok),(char *)e1->elem) );
  374.                 }
  375.                 if (set_el(q2->token,imag_tokens)) {
  376. errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",
  377.                         TokenString(p->tok),(char *)e2->elem) );
  378.                 }
  379.                 if (q1->token > q2->token) {
  380. errNoFL(eMsg3("for #tokclass %s %s..%s - first token number > second token number",
  381.                         TokenString(p->tok),(char *)e1->elem,(char *)e2->elem) );
  382.                   for (i=q2->token; i<=q1->token; i++) { set_orel(i, &p->tset); }
  383.                 } else {
  384.                   for (i=q1->token; i<=q2->token; i++) { set_orel(i, &p->tset); }
  385.                 }
  386.             } else {
  387.                 q = (TermEntry *) hash_get(Tname, tokstr);
  388.      require(q!=NULL, "ComputeTokSets: no token def");
  389.      set_orel(q->token, &p->tset);
  390.             }
  391. }
  392. }
  394. /* Go thru list of tokclasses again looking for tokclasses in sets */
  395. again:
  396. something_changed = 0;
  397. for (t = tclasses->next; t!=NULL; t=t->next)
  398. {
  399. set tcl;
  400. p = (TCnode *) t->elem;
  401. tcl = set_and(p->tset, tokclasses);
  402. if ( !set_nil(tcl) )
  403. {
  404. int tk;
  405. /* replace refs to tokclasses with the associated set of tokens */
  406. something_changed = 1;
  407. while ( !set_nil(tcl) )
  408. {
  409. tk = set_int(tcl); /* grab one of the tok class refs */
  410. set_rm(tk, tcl);
  411. if ( p->tok != tk ) /* tokclass ref to yourself? */
  412. {
  413. q = (TermEntry *) hash_get(Tname, TokenString(tk));
  414. require(q!=NULL, "#tokclass not in hash table");
  415. set_orin(&p->tset, q->tclass->tset);
  416. }
  417. set_rm(tk, p->tset); /* remove ref that we replaced */
  418. }
  419. }
  420. set_free(tcl);
  421. }
  422. if ( something_changed ) goto again;
  423. }
  425. void
  426. DumpRemainingTokSets()
  427. {
  428. TCnode *p;
  429. ListNode *t;
  431. /* Go thru tclasses (for the last time) and dump the sets not dumped
  432.  * during code gen; yes, this is a bogus way to do this, but ComputeTokSets()
  433.  * can't dump the defs as the error file and tok file has not been created
  434.  * yet etc...
  435.  */
  436. if ( tclasses==NULL ) return;
  437. for (t = tclasses->next; t!=NULL; t=t->next)
  438. {
  439. unsigned e;
  440. p = (TCnode *) t->elem;
  441. if ( p->dumped ) continue;
  442. e = DefErrSet(&(p->tset), 0, TokenString(p->tok));
  443. p->dumped = 1;
  444. p->setnum = e;
  445. }
  446. }
  449. /* replace a subset of an error set with an error class name if a subset is found
  450.  * repeat process until no replacements made
  451.  */
  452. void
  453. #ifdef __STDC__
  454. SubstErrorClass( set *f )
  455. #else
  456. SubstErrorClass( f )
  457. set *f;
  458. #endif
  459. {
  460. int max, done = 0;
  461. ListNode *p;
  462. ECnode *ec, *maxclass = NULL;
  463. set a;
  464. require(f!=NULL, "SubstErrorClass: NULL eset");
  466. if ( eclasses == NULL ) return;
  467. while ( !done )
  468. {
  469. max = 0;
  470. maxclass = NULL;
  471. for (p=eclasses->next; p!=NULL; p=p->next) /* chk all error classes */
  472. {
  473. ec = (ECnode *) p->elem;
  474. if ( ec->setdeg > max )
  475. {
  476. if ( set_sub(ec->eset, *f) || set_equ(ec->eset, *f) )
  477. {maxclass = ec; max=ec->setdeg;}
  478. }
  479. }
  480. if ( maxclass != NULL ) /* if subset found, replace with token */
  481. {
  482. a = set_dif(*f, maxclass->eset);
  483. set_orel((unsigned)maxclass->tok, &a);
  484. set_free(*f);
  485. *f = a;
  486. }
  487. else done = 1;
  488. }
  489. }
  491. int
  492. #ifdef __STDC__
  493. DefErrSet1(int nilOK, set *f, int subst, char *name )
  494. #else
  495. DefErrSet1(nilOK, f, subst, name )
  496. int nilOK;
  497. set *f;
  498. int subst; /* should be substitute error classes? */
  499. char *name;
  500. #endif
  501. {
  502. if ( GenCC ) return DefErrSetForCC1(nilOK, f, subst, name );
  503. else return DefErrSetForC1(nilOK, f, subst, name );
  504. }
  506. int
  507. #ifdef __STDC__
  508. DefErrSet( set *f, int subst, char *name )
  509. #else
  510. DefErrSet( f, subst, name )
  511. set *f;
  512. int subst; /* should be substitute error classes? */
  513. char *name;
  514. #endif
  515. {
  516.     return DefErrSet1(0,f,subst,name);
  517. }
  519. /* Define a new error set.  WARNING...set-implementation dependent.
  520.  */
  521. int
  522. #ifdef __STDC__
  523. DefErrSetForC1(int nilOK, set *f, int subst, char *name )
  524. #else
  525. DefErrSetForC1(nilOK, f, subst, name )
  526. int nilOK;          /* MR13 */
  527. set *f;
  528. int subst; /* should be substitute error classes? */
  529. char *name;
  530. #endif
  531. {
  532. unsigned *p, *endp;
  533. int e=1;
  535.     if (!nilOK) require(!set_nil(*f), "DefErrSet: nil set to dump?");
  537. if ( subst ) SubstErrorClass(f);
  538. p = f->setword;
  539. endp = &(f->setword[f->n]);
  540. esetnum++;
  541. if ( name!=NULL )
  542. fprintf(DefFile, "extern SetWordType %s_set[];n", name);
  543. else
  544. fprintf(DefFile, "extern SetWordType zzerr%d[];n", esetnum);
  545. if ( name!=NULL ) {
  546. fprintf(ErrFile, "SetWordType %s_set[%d] = {",
  547. name,
  548. NumWords(TokenNum-1)*sizeof(unsigned));
  549. }
  550. else {
  551. fprintf(ErrFile, "SetWordType zzerr%d[%d] = {",
  552. esetnum,
  553. NumWords(TokenNum-1)*sizeof(unsigned));
  554. }
  555. while ( p < endp )
  556. {
  557. if ( e > 1 ) fprintf(ErrFile, ", ");
  558. DumpIntAsChars(ErrFile, "0x%x", *p++);
  559. if ( e == 3 )
  560. {
  561. DAWDLE;
  562. if ( p < endp ) fprintf(ErrFile, ",");
  563. fprintf(ErrFile, "nt");
  564. e=1;
  565. }
  566. else e++;
  567. }
  568. fprintf(ErrFile, "};n");
  570. return esetnum;
  571. }
  573. int
  574. #ifdef __STDC__
  575. DefErrSetForC( set *f, int subst, char *name )
  576. #else
  577. DefErrSetForC( f, subst, name )
  578. set *f;
  579. int subst; /* should be substitute error classes? */
  580. char *name;
  581. #endif
  582. {
  583.   return DefErrSetForC1(0,f,subst,name);
  584. }
  586. /* Define a new error set.  WARNING...set-implementation dependent;
  587.  * Only used when -CC on.
  588.  */
  589. int
  590. #ifdef __STDC__
  591. DefErrSetForCC1(int nilOK, set *f, int subst, char *name )
  592. #else
  593. DefErrSetForCC1(nilOK, f, subst, name )
  594. int nilOK;          /* MR13 */
  595. set *f;
  596. int subst; /* should be substitute error classes? */
  597. char *name;
  598. #endif
  599. {
  600. unsigned *p, *endp;
  601. int e=1;
  603.     if (!nilOK) require(!set_nil(*f), "DefErrSet: nil set to dump?");
  605. if ( subst ) SubstErrorClass(f);
  606. p = f->setword;
  607. endp = &(f->setword[f->n]);
  608. esetnum++;
  610. if ( name!=NULL ) {
  611. fprintf(Parser_h, "tstatic SetWordType %s_set[%d];n", name,
  612. NumWords(TokenNum-1)*sizeof(unsigned));
  613. fprintf(Parser_c, "SetWordType %s::%s_set[%d] = {",
  614. CurrentClassName,
  615. name,
  616. NumWords(TokenNum-1)*sizeof(unsigned));
  617. }
  618. else {
  619. fprintf(Parser_c, "SetWordType %s::err%d[%d] = {",
  620. CurrentClassName,
  621. esetnum,
  622. NumWords(TokenNum-1)*sizeof(unsigned));
  623. fprintf(Parser_h, "tstatic SetWordType err%d[%d];n", esetnum,
  624. NumWords(TokenNum-1)*sizeof(unsigned));
  625. }
  627. while ( p < endp )
  628. {
  629. if ( e > 1 ) fprintf(Parser_c, ", ");
  630. DumpIntAsChars(Parser_c, "0x%x", *p++);
  631. if ( e == 3 )
  632. {
  633. if ( p < endp ) fprintf(Parser_c, ",");
  634. fprintf(Parser_c, "nt");
  635. e=1;
  636. }
  637. else e++;
  638. }
  639. fprintf(Parser_c, "};n");
  641. return esetnum;
  642. }
  644. int
  645. #ifdef __STDC__
  646. DefErrSetForCC( set *f, int subst, char *name )
  647. #else
  648. DefErrSetForCC( f, subst, name )
  649. set *f;
  650. int subst; /* should be substitute error classes? */
  651. char *name;
  652. #endif
  653. {
  654.   return DefErrSetForCC1(0,f,subst,name);
  655. }
  657. void
  658. #ifdef __STDC__
  659. GenParser_c_Hdr(void)
  660. #else
  661. GenParser_c_Hdr()
  662. #endif
  663. {
  664. int i,j;
  665.     TermEntry   *te;
  667. fprintf(Parser_c, "/*n");
  668. fprintf(Parser_c, " * %s: P a r s e r  S u p p o r tn", CurrentClassName);
  669. fprintf(Parser_c, " *n");
  670. fprintf(Parser_c, " * Generated from:");
  671. for (i=0; i<NumFiles; i++) fprintf(Parser_c, " %s", FileStr[i]);
  672. fprintf(Parser_c, "n");
  673. fprintf(Parser_c, " *n");
  674. fprintf(Parser_c, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-1998n");
  675. fprintf(Parser_c, " * Parr Research Corporationn");
  676. fprintf(Parser_c, " * with Purdue University Electrical Engineeringn");
  677. fprintf(Parser_c, " * with AHPCRC, University of Minnesotan");
  678. fprintf(Parser_c, " * ANTLR Version %sn", Version);
  679. fprintf(Parser_c, " */nn");
  681. fprintf(Parser_c, "#define ANTLR_VERSION %sn", VersionDef);
  683. if ( FirstAction != NULL ) dumpAction(FirstAction,Parser_c, 0, -1, 0, 1);    /* MR11 */
  685. fprintf(Parser_c, "#include "pcctscfg.h"n");
  686. fprintf(Parser_c, "#include PCCTS_STDIO_Hn");
  687. fprintf(Parser_c, "#define ANTLR_SUPPORT_CODEn");
  688. if ( UserTokenDefsFile != NULL )
  689.    fprintf(Parser_c, "#include %sn", UserTokenDefsFile);
  690. else
  691.    fprintf(Parser_c, "#include "%s"n", DefFileName);
  693. fprintf(Parser_c, "#include "%s.h"nn", CurrentClassName);
  695. fprintf(Parser_c, "const ANTLRChar *%s::tokenName(int tok) ",   /* MR1 */
  696. CurrentClassName);                           /* MR1 */
  697. fprintf(Parser_c, "  { return _token_tbl[tok]; }n");         /* MR1 */ /* MR10 */
  698. /* Dump a Parser::tokens for each automaton */
  699. fprintf(Parser_c, "nANTLRChar *%s::_token_tbl[]={n", CurrentClassName);
  700. fprintf(Parser_c, "t/* 00 */t"Invalid"");
  702. for (i=1; i<TokenNum-1; i++)
  703. {
  704. DAWDLE;
  705. if ( i == EpToken ) continue;
  706. /* remapped to invalid token? */
  707. if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )
  708. {
  709. fprintf(Parser_c, ",nt/* %02d */t"invalid"", i);
  710. continue;
  711. }
  712. if ( TokenString(i) != NULL ) {
  713.            te=(TermEntry *) hash_get(Tname,TokenString(i));                     /* MR11 */
  714.             if (te == NULL || te->akaString == NULL) {                          /* MR11 */
  715.              fprintf(Parser_c, ",nt/* %02d */t"%s"", i, TokenString(i));
  716.             } else {
  717.              fprintf(Parser_c, ",nt/* %02d */t"%s"", i, te->akaString);   /* MR11 */
  718.             }
  719.         }
  720. else
  721. {
  722. /* look in all lexclasses for the reg expr */
  723. for (j=0; j<NumLexClasses; j++)
  724. {
  725. lexmode(j);
  726. if ( ExprString(i) != NULL )
  727. {
  728. fprintf(Parser_c, ",nt/* %02d */t", i);
  729. dumpExpr(Parser_c, ExprString(i));
  730. break;
  731. }
  732. }
  733. if ( j>=NumLexClasses )
  734. {
  735. if ( UserDefdTokens )
  736. {
  737. fprintf(Parser_c, ",nt/* %02d */t""", i);
  738. }
  739. else
  740. fatal_internal(eMsgd("No label or expr for token %d",i));
  741. }
  742. }
  743. }
  744. fprintf(Parser_c, "n};n");
  746. /* Build constructors */
  747. fprintf(Parser_c, "n%s::", CurrentClassName);
  748. fprintf(Parser_c, "%s(ANTLRTokenBuffer *input) : ANTLRParser(input,%d,%d,%d,%d)n",
  749. CurrentClassName,
  750. OutputLL_k,
  751. FoundGuessBlk,
  752. DemandLookahead,
  753. NumWords(TokenNum-1)*sizeof(unsigned));
  754. fprintf(Parser_c, "{n");
  755. fprintf(Parser_c, "ttoken_tbl = _token_tbl;n");
  756.     if (TraceGen) {
  757.       fprintf(Parser_c, "ttraceOptionValueDefault=1;tt// MR10 turn trace ONn");
  758.     } else {
  759.       fprintf(Parser_c, "ttraceOptionValueDefault=0;tt// MR10 turn trace OFFn");
  760.     };
  761. fprintf(Parser_c, "}nn");
  762. }
  764. void
  765. #ifdef __STDC__
  766. GenParser_h_Hdr(void)
  767. #else
  768. GenParser_h_Hdr()
  769. #endif
  770. {
  771. int i;
  773. fprintf(Parser_h, "/*n");
  774. fprintf(Parser_h, " * %s: P a r s e r  H e a d e r n", CurrentClassName);
  775. fprintf(Parser_h, " *n");
  776. fprintf(Parser_h, " * Generated from:");
  777. for (i=0; i<NumFiles; i++) fprintf(Parser_h, " %s", FileStr[i]);
  778. fprintf(Parser_h, "n");
  779. fprintf(Parser_h, " *n");
  780. fprintf(Parser_h, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-1998n");
  781. fprintf(Parser_h, " * Parr Research Corporationn");
  782. fprintf(Parser_h, " * with Purdue University Electrical Engineeringn");
  783. fprintf(Parser_h, " * with AHPCRC, University of Minnesotan");
  784. fprintf(Parser_h, " * ANTLR Version %sn", Version);
  785. fprintf(Parser_h, " */nn");
  786. fprintf(Parser_h, "#ifndef %s_hn", CurrentClassName);
  787. fprintf(Parser_h, "#define %s_hnn", CurrentClassName);
  789.     fprintf(Parser_h, "#ifndef ANTLR_VERSIONn");
  790.     fprintf(Parser_h, "#define ANTLR_VERSION %sn",VersionDef);
  791.     fprintf(Parser_h, "#endifnn");
  793. if ( FirstAction != NULL ) dumpAction( FirstAction, Parser_h, 0, -1, 0, 1);         /* MR11 */
  795. if ( GenAST ) fprintf(Parser_h, "class ASTBase;n");
  796. fprintf(Parser_h, "#include "%s"nn", APARSER_H);
  798. if ( HdrAction != NULL ) dumpAction( HdrAction, Parser_h, 0, -1, 0, 1);
  800. /* MR10 */    if (ClassDeclStuff == NULL) {
  801. /* MR10 */   fprintf(Parser_h, "class %s : public ANTLRParser {n", CurrentClassName);
  802. /* MR10 */    } else {
  803. /* MR10 */      fprintf(Parser_h, "class %s %s {n",CurrentClassName,ClassDeclStuff);
  804. /* MR10 */    };
  806. fprintf(Parser_h, "public:n");           /* MR1 */
  807. fprintf(Parser_h, "tstatic  const ANTLRChar *tokenName(int tk);n"); /* MR1 */
  808. fprintf(Parser_h, "protected:n");
  809. fprintf(Parser_h, "tstatic  ANTLRChar *_token_tbl[];n");
  810. fprintf(Parser_h, "private:n");
  811. }
  813. /* Currently, this is only used in !GenCC mode */
  814. void
  815. #ifdef __STDC__
  816. GenErrHdr( void )
  817. #else
  818. GenErrHdr( )
  819. #endif
  820. {
  821. int i, j;
  822.     TermEntry   *te;
  824. fprintf(ErrFile, "/*n");
  825. fprintf(ErrFile, " * A n t l r  S e t s / E r r o r  F i l e  H e a d e rn");
  826. fprintf(ErrFile, " *n");
  827. fprintf(ErrFile, " * Generated from:");
  828. for (i=0; i<NumFiles; i++) fprintf(ErrFile, " %s", FileStr[i]);
  829. fprintf(ErrFile, "n");
  830. fprintf(ErrFile, " *n");
  831. fprintf(ErrFile, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-1998n");
  832. fprintf(ErrFile, " * Parr Research Corporationn");
  833. fprintf(ErrFile, " * with Purdue University Electrical Engineeringn");
  834. fprintf(ErrFile, " * With AHPCRC, University of Minnesotan");
  835. fprintf(ErrFile, " * ANTLR Version %sn", Version);
  836. fprintf(ErrFile, " */nn");
  837. fprintf(ErrFile, "#define ANTLR_VERSION %sn", VersionDef);
  838. if ( FirstAction != NULL ) dumpAction( FirstAction, ErrFile, 0, -1, 0, 1);         /* MR11 */
  839. fprintf(ErrFile, "#include "pcctscfg.h"n");
  840. fprintf(ErrFile, "#include PCCTS_STDIO_Hn");
  841. if ( strcmp(ParserName, DefaultParserName)!=0 )
  842. fprintf(ErrFile, "#define %s %sn", DefaultParserName, ParserName);
  843. if ( strcmp(ParserName, DefaultParserName)!=0 )
  844. fprintf(ErrFile, "#include "%s"n", RemapFileName);
  845. if ( HdrAction != NULL ) dumpAction( HdrAction, ErrFile, 0, -1, 0, 1 );
  846. if ( FoundGuessBlk )
  847. {
  848. fprintf(ErrFile, "#define ZZCAN_GUESSn");
  849. fprintf(ErrFile, "#include PCCTS_SETJMP_Hn");
  850. }
  851.     if (TraceGen) {
  852.       fprintf(ErrFile,"#define zzTRACE_RULESn");  /* MR10 */
  853.     };
  855. if ( OutputLL_k > 1 ) fprintf(ErrFile, "#define LL_K %dn", OutputLL_k);
  856. #ifdef DUM
  857. if ( LexGen ) fprintf(ErrFile, "#define zzEOF_TOKEN %dn", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
  858. #endif
  859. fprintf(ErrFile, "#define zzSET_SIZE %dn", NumWords(TokenNum-1)*sizeof(unsigned));
  860. if ( DemandLookahead ) fprintf(ErrFile, "#define DEMAND_LOOKn");
  861. fprintf(ErrFile, "#include "antlr.h"n");
  862. if ( GenAST ) fprintf(ErrFile, "#include "ast.h"n");
  864.     if ( UserDefdTokens ) fprintf(ErrFile, "#include %sn", UserTokenDefsFile);
  865. /* still need this one as it has the func prototypes */
  866. fprintf(ErrFile, "#include "%s"n", DefFileName);
  867. fprintf(ErrFile, "#include "dlgdef.h"n");
  868. fprintf(ErrFile, "#include "err.h"nn");
  870. /* Dump a zztokens for each automaton */
  871. if ( strcmp(ParserName, DefaultParserName)!=0 )
  872. {
  873. fprintf(ErrFile, "ANTLRChar *%s_zztokens[%d]={n", ParserName, TokenNum-1);
  874. }
  875. else
  876. {
  877. fprintf(ErrFile, "ANTLRChar *zztokens[%d]={n", TokenNum-1);
  878. }
  879. fprintf(ErrFile, "t/* 00 */t"Invalid"");
  880. for (i=1; i<TokenNum-1; i++)
  881. {
  882. DAWDLE;
  883. if ( i == EpToken ) continue;
  884. /* remapped to invalid token? */
  885. if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )
  886. {
  887. fprintf(ErrFile, ",nt/* %02d */t"invalid"", i);
  888. continue;
  889. }
  890. if ( TokenString(i) != NULL ) {
  891.             te=(TermEntry *) hash_get(Tname,TokenString(i));                     /* MR11 */
  892.             if (te == NULL || te->akaString == NULL) {                          /* MR11 */
  893.      fprintf(ErrFile, ",nt/* %02d */t"%s"", i, TokenString(i));
  894.             } else {
  895.      fprintf(ErrFile, ",nt/* %02d */t"%s"", i, te->akaString);    /* MR11 */
  896.             }
  897.         }
  898. else
  899. {
  900. /* look in all lexclasses for the reg expr */
  901. for (j=0; j<NumLexClasses; j++)
  902. {
  903. lexmode(j);
  904. if ( ExprString(i) != NULL )
  905. {
  906. fprintf(ErrFile, ",nt/* %02d */t", i);
  907. dumpExpr(ErrFile, ExprString(i));
  908. break;
  909. }
  910. }
  911. if ( j>=NumLexClasses )
  912. {
  913. if ( UserDefdTokens )
  914. {
  915. fprintf(ErrFile, ",nt/* %02d */t""", i);
  916. }
  917. else
  918. fatal_internal(eMsgd("No label or expr for token %d",i));
  919. }
  920. }
  921. }
  922. fprintf(ErrFile, "n};n");
  923. }
  925. void
  926. #ifdef __STDC__
  927. dumpExpr( FILE *f, char *e )
  928. #else
  929. dumpExpr( f, e )
  930. FILE *f;
  931. char *e;
  932. #endif
  933. {
  934. while ( *e!='' )
  935. {
  936. if ( *e=='\' && *(e+1)=='\' )
  937. {putc('\', f); putc('\', f); e+=2;}
  938. else if ( *e=='\' && *(e+1)=='"' )
  939. {putc('\', f); putc('"', f); e+=2;}
  940. else if ( *e=='\' ) {putc('\', f); putc('\', f); e++;}
  941. else {putc(*e, f); e++;}
  942. }
  943. }