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

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

编译器/解释器

开发平台：

Others

antlr.c：源码内容
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.33MR14
  8.  *
  9.  *   ../bin/antlr -gh antlr.g
  10.  *
  11.  */
  13. #define ANTLR_VERSION 13314
  14. #include "pcctscfg.h"
  15. #include PCCTS_STDIO_H
  17. #include "set.h"
  18. #include <ctype.h>
  19. #include "syn.h"
  20. #include "hash.h"
  21. #include "generic.h"
  22. #define zzcr_attr(attr,tok,t)
  23. #define zzSET_SIZE 20
  24. #include "antlr.h"
  25. #include "tokens.h"
  26. #include "dlgdef.h"
  27. #include "mode.h"
  28. #ifndef PURIFY
  29. #define PURIFY(r,s) memset((char *) &(r),'',(s));
  30. #endif
  31. ANTLR_INFO
  33. #ifdef __USE_PROTOS
  34. static void chkToken(char *, char *, char *, int);
  35. #else
  36. static void chkToken();
  37. #endif
  39. #ifdef __USE_PROTOS
  40. static int isDLGmaxToken(char *Token);      /* MR3 */
  41. #else
  42. static int isDLGmaxToken();                              /* MR3 */
  43. #endif
  45. static int class_nest_level = 0;
  46. extern int inAlt;
  47. extern set attribsRefdFromAction;
  48. extern int UsedOldStyleAttrib;
  49. extern int UsedNewStyleLabel;
  51. void
  52. #ifdef __USE_PROTOS
  53. grammar(void)
  54. #else
  55. grammar()
  56. #endif
  57. {
  58. zzRULE;
  59. zzBLOCK(zztasp1);
  60. zzMake0;
  61. {
  62. Graph g;
  63. {
  64. zzBLOCK(zztasp2);
  65. zzMake0;
  66. {
  67. while ( 1 ) {
  68. if ( !((setwd1[LA(1)]&0x1))) break;
  69. if ( (LA(1)==92) ) {
  70. zzmatch(92); zzCONSUME;
  71. zzmatch(Action);
  73. if ( HdrAction==NULL ) {
  74. HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  75. require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  76. strcpy(HdrAction, LATEXT(1));
  77. }
  78. else warn("additional #header statement ignored");
  79.  zzCONSUME;
  81. }
  82. else {
  83. if ( (LA(1)==93) ) {
  84. zzmatch(93); zzCONSUME;
  85. zzmatch(Action);
  87. if ( FirstAction==NULL ) {
  88. FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  89. require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
  90. strcpy(FirstAction, LATEXT(1));
  91. } else {
  92. warn("additional #first statement ignored");
  93. };
  94.  zzCONSUME;
  96. }
  97. else {
  98. if ( (LA(1)==94) ) {
  99. zzmatch(94); zzCONSUME;
  100. zzmatch(QuotedTerm);
  102. if ( GenCC ) {
  103. warn("#parser meta-op incompatible with -CC; ignored");
  104. }
  105. else {
  106. if ( strcmp(ParserName,"zzparser")==0 ) {
  107. ParserName=StripQuotes(mystrdup(LATEXT(1)));
  108. if ( RulePrefix[0]!='' )
  109. {
  110. warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  111. RulePrefix[0]='';
  112. }
  113. }
  114. else warn("additional #parser statement ignored");
  115. }
  116.  zzCONSUME;
  118. }
  119. else {
  120. if ( (LA(1)==95) ) {
  121. zzmatch(95); zzCONSUME;
  122. zzmatch(QuotedTerm);
  123. {
  124. char *fname;
  125. zzantlr_state st; FILE *f; struct zzdlg_state dst;
  126. UserTokenDefsFile = mystrdup(LATEXT(1));
  127. zzsave_antlr_state(&st);
  128. zzsave_dlg_state(&dst);
  129. fname = mystrdup(LATEXT(1));
  130. f = fopen(StripQuotes(fname), "r");
  131. if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
  132. else {
  133. ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
  134. UserDefdTokens = 1;
  135. }
  136. zzrestore_antlr_state(&st);
  137. zzrestore_dlg_state(&dst);
  138. }
  139.  zzCONSUME;
  141. }
  142. else break; /* MR6 code for exiting loop "for sure" */
  143. }
  144. }
  145. }
  146. zzLOOP(zztasp2);
  147. }
  148. zzEXIT(zztasp2);
  149. }
  150. }
  151. {
  152. zzBLOCK(zztasp2);
  153. zzMake0;
  154. {
  155. while ( 1 ) {
  156. if ( !((setwd1[LA(1)]&0x2))) break;
  157. if ( (LA(1)==Action) ) {
  158. zzmatch(Action);
  159. {
  160. UserAction *ua = newUserAction(LATEXT(1));
  161. ua->file = action_file; ua->line = action_line;
  162. if ( class_nest_level>0 ) list_add(&class_before_actions, ua);
  163. else list_add(&BeforeActions, ua);
  164. }
  165.  zzCONSUME;
  167. }
  168. else {
  169. if ( (LA(1)==106) ) {
  170. laction();
  171. }
  172. else {
  173. if ( (LA(1)==107) ) {
  174. lmember();
  175. }
  176. else {
  177. if ( (LA(1)==108) ) {
  178. lprefix();
  179. }
  180. else {
  181. if ( (LA(1)==114) ) {
  182. aLexclass();
  183. }
  184. else {
  185. if ( (LA(1)==118) ) {
  186. token();
  187. }
  188. else {
  189. if ( (LA(1)==115) ) {
  190. error();
  191. }
  192. else {
  193. if ( (LA(1)==116) ) {
  194. tclass();
  195. }
  196. else {
  197. if ( (LA(1)==109) ) {
  198. aPred();
  199. }
  200. else {
  201. if ( (LA(1)==132) ) {
  202. default_exception_handler();
  203. }
  204. else {
  205. if ( (LA(1)==97) ) {
  206. class_def();
  207. }
  208. else {
  209. if ( (LA(1)==96) ) {
  210. zzmatch(96);
  212. if ( class_nest_level==0 )
  213. warn("missing class definition for trailing '}'");
  214. class_nest_level--;
  215.  zzCONSUME;
  217. }
  218. else break; /* MR6 code for exiting loop "for sure" */
  219. }
  220. }
  221. }
  222. }
  223. }
  224. }
  225. }
  226. }
  227. }
  228. }
  229. }
  230. zzLOOP(zztasp2);
  231. }
  232. zzEXIT(zztasp2);
  233. }
  234. }
  235. rule();
  236. g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;
  237. {
  238. zzBLOCK(zztasp2);
  239. zzMake0;
  240. {
  241. while ( 1 ) {
  242. if ( !((setwd1[LA(1)]&0x4))) break;
  243. if ( (LA(1)==NonTerminal) ) {
  244. rule();
  245. if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}
  246. }
  247. else {
  248. if ( (LA(1)==114) ) {
  249. aLexclass();
  250. }
  251. else {
  252. if ( (LA(1)==118) ) {
  253. token();
  254. }
  255. else {
  256. if ( (LA(1)==115) ) {
  257. error();
  258. }
  259. else {
  260. if ( (LA(1)==116) ) {
  261. tclass();
  262. }
  263. else {
  264. if ( (LA(1)==109) ) {
  265. aPred();
  266. }
  267. else {
  268. if ( (LA(1)==97) ) {
  269. class_def();
  270. }
  271. else {
  272. if ( (LA(1)==96) ) {
  273. zzmatch(96);
  275. if ( class_nest_level==0 )
  276. warn("missing class definition for trailing '}'");
  277. class_nest_level--;
  278.  zzCONSUME;
  280. }
  281. else break; /* MR6 code for exiting loop "for sure" */
  282. }
  283. }
  284. }
  285. }
  286. }
  287. }
  288. }
  289. zzLOOP(zztasp2);
  290. }
  291. zzEXIT(zztasp2);
  292. }
  293. }
  294. {
  295. zzBLOCK(zztasp2);
  296. zzMake0;
  297. {
  298. while ( 1 ) {
  299. if ( !((setwd1[LA(1)]&0x8))) break;
  300. if ( (LA(1)==Action) ) {
  301. zzmatch(Action);
  302. {
  303. UserAction *ua = newUserAction(LATEXT(1));
  304. ua->file = action_file; ua->line = action_line;
  305. if ( class_nest_level>0 ) list_add(&class_after_actions, ua);
  306. else list_add(&AfterActions, ua);
  307. }
  308.  zzCONSUME;
  310. }
  311. else {
  312. if ( (LA(1)==106) ) {
  313. laction();
  314. }
  315. else {
  316. if ( (LA(1)==107) ) {
  317. lmember();
  318. }
  319. else {
  320. if ( (LA(1)==108) ) {
  321. lprefix();
  322. }
  323. else {
  324. if ( (LA(1)==115) ) {
  325. error();
  326. }
  327. else {
  328. if ( (LA(1)==116) ) {
  329. tclass();
  330. }
  331. else {
  332. if ( (LA(1)==97) ) {
  333. class_def();
  334. }
  335. else {
  336. if ( (LA(1)==109) ) {
  337. aPred();
  338. }
  339. else {
  340. if ( (LA(1)==96) ) {
  341. zzmatch(96);
  343. if ( class_nest_level==0 )
  344. warn("missing class definition for trailing '}'");
  345. class_nest_level--;
  346.  zzCONSUME;
  348. }
  349. else break; /* MR6 code for exiting loop "for sure" */
  350. }
  351. }
  352. }
  353. }
  354. }
  355. }
  356. }
  357. }
  358. zzLOOP(zztasp2);
  359. }
  360. zzEXIT(zztasp2);
  361. }
  362. }
  363. zzmatch(Eof); zzCONSUME;
  364. zzEXIT(zztasp1);
  365. return;
  366. fail:
  367. zzEXIT(zztasp1);
  368. CannotContinue=TRUE;
  369. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  370. zzresynch(setwd1, 0x10);
  371. }
  372. }
  374. void
  375. #ifdef __USE_PROTOS
  376. class_def(void)
  377. #else
  378. class_def()
  379. #endif
  380. {
  381. zzRULE;
  382. zzBLOCK(zztasp1);
  383. zzMake0;
  384. {
  385. int go=1; char name[MaxRuleName+1];
  386. zzmatch(97); zzCONSUME;
  387. {
  388. zzBLOCK(zztasp2);
  389. zzMake0;
  390. {
  391. if ( (LA(1)==NonTerminal) ) {
  392. zzmatch(NonTerminal);
  393. if(go) strncpy(name,LATEXT(1),MaxRuleName);
  394.  zzCONSUME;
  396. }
  397. else {
  398. if ( (LA(1)==TokenTerm) ) {
  399. zzmatch(TokenTerm);
  400. if(go) strncpy(name,LATEXT(1),MaxRuleName);
  401.  zzCONSUME;
  403. }
  404. else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  405. }
  406. zzEXIT(zztasp2);
  407. }
  408. }
  410. if ( CurrentClassName[0]!='' && strcmp(CurrentClassName,name)!=0
  411. && GenCC ) {
  412. err("only one grammar class allowed in this release");
  413. go = 0;
  414. }
  415. else strcpy(CurrentClassName, name);
  416. if ( !GenCC ) { err("class meta-op used without C++ option"); }
  417. {
  418. zzBLOCK(zztasp2);
  419. zzMake0;
  420. {
  421. while ( (setwd1[LA(1)]&0x20) ) {
  422. zzsetmatch(zzerr2);
  423. if (ClassDeclStuff == NULL) {
  424. /* MR10 */                   ClassDeclStuff=(char *)calloc(MaxClassDeclStuff+1,sizeof(char));
  425. /* MR10 */              };
  426. /* MR10 */              strncat(ClassDeclStuff," ",MaxClassDeclStuff);
  427. /* MR10 */              strncat(ClassDeclStuff,LATEXT(1),MaxClassDeclStuff);
  428. /* MR10 */
  429.  zzCONSUME;
  431. zzLOOP(zztasp2);
  432. }
  433. zzEXIT(zztasp2);
  434. }
  435. }
  436. zzmatch(100);
  438. no_classes_found = 0;
  439. if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
  440. else class_nest_level++;
  441.  zzCONSUME;
  443. zzEXIT(zztasp1);
  444. return;
  445. fail:
  446. zzEXIT(zztasp1);
  447. CannotContinue=TRUE;
  448. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  449. zzresynch(setwd1, 0x40);
  450. }
  451. }
  453. void
  454. #ifdef __USE_PROTOS
  455. rule(void)
  456. #else
  457. rule()
  458. #endif
  459. {
  460. zzRULE;
  461. zzBLOCK(zztasp1);
  462. zzMake0;
  463. {
  465. ListNode *ex_groups = NULL;
  466. ExceptionGroup *eg;
  467. RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  468. set toksrefd, rulesrefd;
  469. char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  470. CurExGroups = NULL;
  471. CurElementLabels = NULL;
  472. /* We want a new element label hash table for each rule */
  473. if ( Elabel!=NULL ) killHashTable(Elabel);
  474. Elabel = newHashTable();
  475. attribsRefdFromAction = empty;
  476. zzmatch(NonTerminal);
  477. q=NULL;
  478. if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  479. err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
  480. CannotContinue=TRUE;
  481. }
  482. else
  483. {
  484. q = (RuleEntry *)hash_add(Rname,
  485. LATEXT(1),
  486. (Entry *)newRuleEntry(LATEXT(1)));
  487. CurRule = q->str;
  488. }
  489. CurRuleNode = q;
  490. f = CurFile; l = zzline;
  491. NumRules++;
  492.  zzCONSUME;
  494. {
  495. zzBLOCK(zztasp2);
  496. zzMake0;
  497. {
  498. if ( (LA(1)==101) ) {
  499. zzmatch(101);
  500. if ( q!=NULL ) q->noAST = TRUE;
  501.  zzCONSUME;
  503. }
  504. zzEXIT(zztasp2);
  505. }
  506. }
  507. {
  508. zzBLOCK(zztasp2);
  509. zzMake0;
  510. {
  511. ;
  512. if ( (setwd1[LA(1)]&0x80) ) {
  513. {
  514. zzBLOCK(zztasp3);
  515. zzMake0;
  516. {
  517. if ( (LA(1)==102) ) {
  518. zzmatch(102); zzCONSUME;
  519. }
  520. zzEXIT(zztasp3);
  521. }
  522. }
  523. zzmatch(PassAction);
  524. pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  525. require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  526. strcpy(pdecl, LATEXT(1));
  527. CurParmDef = pdecl;
  528.  zzCONSUME;
  530. }
  531. zzEXIT(zztasp2);
  532. }
  533. }
  534. {
  535. zzBLOCK(zztasp2);
  536. zzMake0;
  537. {
  538. if ( (LA(1)==103) ) {
  539. zzmatch(103); zzCONSUME;
  540. zzmatch(PassAction);
  541. ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  542. require(ret!=NULL, "rule rule: cannot allocate ret type");
  543. strcpy(ret, LATEXT(1));
  544. CurRetDef = ret;
  545.  zzCONSUME;
  547. }
  548. zzEXIT(zztasp2);
  549. }
  550. }
  551. {
  552. zzBLOCK(zztasp2);
  553. zzMake0;
  554. {
  555. if ( (LA(1)==QuotedTerm) ) {
  556. zzmatch(QuotedTerm);
  557. if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));
  558.  zzCONSUME;
  560. }
  561. zzEXIT(zztasp2);
  562. }
  563. }
  565. if ( GenEClasseForRules && q!=NULL ) {
  566. e = newECnode;
  567. require(e!=NULL, "cannot allocate error class node");
  568. if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  569. else a = q->egroup;
  570. if ( Tnum( a ) == 0 )
  571. {
  572. e->tok = addTname( a );
  573. list_add(&eclasses, (char *)e);
  574. if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  575. /* refers to itself */
  576. list_add(&(e->elist), mystrdup(q->str));
  577. }
  578. else {
  579. warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
  580. if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  581. free((char *)e);
  582. }
  583. }
  584. BlkLevel++;
  585. zzmatch(104);
  586. inAlt=1;
  587.  zzCONSUME;
  589. block( &toksrefd, &rulesrefd );
  590. r = makeBlk(zzaArg(zztasp1,7),0);
  591. CurRuleBlk = (Junction *)r.left;
  592. CurRuleBlk->blockid = CurBlockID;
  593. CurRuleBlk->jtype = RuleBlk;
  594. if ( q!=NULL ) CurRuleBlk->rname = q->str;
  595. CurRuleBlk->file = f;
  596. CurRuleBlk->line = l;
  597. CurRuleBlk->pdecl = pdecl;
  598. CurRuleBlk->ret = ret;
  599. CurRuleBlk->lock = makelocks();
  600. CurRuleBlk->pred_lock = makelocks();
  601. CurRuleBlk->tokrefs = toksrefd;
  602. CurRuleBlk->rulerefs = rulesrefd;
  603. p = newJunction(); /* add EndRule Node */
  604. ((Junction *)r.right)->p1 = (Node *)p;
  605. r.right = (Node *) p;
  606. p->jtype = EndRule;
  607. p->lock = makelocks();
  608. p->pred_lock = makelocks();
  609. CurRuleBlk->end = p;
  610. if ( q!=NULL ) q->rulenum = NumRules;
  611. zzaArg(zztasp1,7) = r;
  612. --BlkLevel;
  613. altFixup();leFixup();egFixup();
  614. zzmatch(105);
  615. inAlt=0;
  616.  zzCONSUME;
  618. {
  619. zzBLOCK(zztasp2);
  620. zzMake0;
  621. {
  622. if ( (LA(1)==Action) ) {
  623. zzmatch(Action);
  624. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  625. require(a!=NULL, "rule rule: cannot allocate error action");
  626. strcpy(a, LATEXT(1));
  627. CurRuleBlk->erraction = a;
  628.  zzCONSUME;
  630. }
  631. zzEXIT(zztasp2);
  632. }
  633. }
  634. {
  635. zzBLOCK(zztasp2);
  636. zzMake0;
  637. {
  638. while ( (LA(1)==132) ) {
  639.  eg  = exception_group();
  641. if ( eg!=NULL ) {
  642. list_add(&CurExGroups, (void *)eg);
  643. if (eg->label == NULL || *eg->label=='' ) q->has_rule_exception = 1;
  644. }
  645. zzLOOP(zztasp2);
  646. }
  647. zzEXIT(zztasp2);
  648. }
  649. }
  650. if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);
  651. CurRuleNode = NULL;
  652. CurRuleBlk->exceptions = CurExGroups;
  653. CurRuleBlk->el_labels = CurElementLabels;
  654. zzEXIT(zztasp1);
  655. return;
  656. fail:
  657. zzEXIT(zztasp1);
  658. CannotContinue=TRUE;
  659. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  660. zzresynch(setwd2, 0x1);
  661. }
  662. }
  664. void
  665. #ifdef __USE_PROTOS
  666. laction(void)
  667. #else
  668. laction()
  669. #endif
  670. {
  671. zzRULE;
  672. zzBLOCK(zztasp1);
  673. zzMake0;
  674. {
  675. char *a;
  676. zzmatch(106); zzCONSUME;
  677. zzmatch(Action);
  679. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  680. require(a!=NULL, "rule laction: cannot allocate action");
  681. strcpy(a, LATEXT(1));
  682. list_add(&LexActions, a);
  683.  zzCONSUME;
  685. zzEXIT(zztasp1);
  686. return;
  687. fail:
  688. zzEXIT(zztasp1);
  689. CannotContinue=TRUE;
  690. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  691. zzresynch(setwd2, 0x2);
  692. }
  693. }
  695. void
  696. #ifdef __USE_PROTOS
  697. lmember(void)
  698. #else
  699. lmember()
  700. #endif
  701. {
  702. zzRULE;
  703. zzBLOCK(zztasp1);
  704. zzMake0;
  705. {
  706. char *a;
  707. zzmatch(107); zzCONSUME;
  708. zzmatch(Action);
  710. /* MR1 */ if (! GenCC) {
  711. /* MR1 */   err("Use #lexmember only in C++ mode (to insert code in DLG class header");
  712. /* MR1 */         } else {
  713. /* MR1 */   a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  714. /* MR1 */   require(a!=NULL, "rule lmember: cannot allocate action");
  715. /* MR1 */   strcpy(a, LATEXT(1));
  716. /* MR1 */   list_add(&LexMemberActions, a);
  717. /* MR1 */ };
  718. /* MR1 */
  719.  zzCONSUME;
  721. zzEXIT(zztasp1);
  722. return;
  723. fail:
  724. zzEXIT(zztasp1);
  725. CannotContinue=TRUE;
  726. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  727. zzresynch(setwd2, 0x4);
  728. }
  729. }
  731. void
  732. #ifdef __USE_PROTOS
  733. lprefix(void)
  734. #else
  735. lprefix()
  736. #endif
  737. {
  738. zzRULE;
  739. zzBLOCK(zztasp1);
  740. zzMake0;
  741. {
  742. char *a;
  743. zzmatch(108); zzCONSUME;
  744. zzmatch(Action);
  746. /* MR1 */ if (! GenCC) {
  747. /* MR1 */   err("Use #lexprefixr only in C++ mode (to insert code in DLG class header");
  748. /* MR1 */         } else {
  749. /* MR1 */   a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  750. /* MR1 */   require(a!=NULL, "rule lprefix: cannot allocate action");
  751. /* MR1 */   strcpy(a, LATEXT(1));
  752. /* MR1 */   list_add(&LexPrefixActions, a);
  753. /* MR1 */ };
  754. /* MR1 */
  755.  zzCONSUME;
  757. zzEXIT(zztasp1);
  758. return;
  759. fail:
  760. zzEXIT(zztasp1);
  761. CannotContinue=TRUE;
  762. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  763. zzresynch(setwd2, 0x8);
  764. }
  765. }
  767. void
  768. #ifdef __USE_PROTOS
  769. aPred(void)
  770. #else
  771. aPred()
  772. #endif
  773. {
  774. zzRULE;
  775. zzBLOCK(zztasp1);
  776. zzMake0;
  777. {
  778. PredEntry     *predEntry=NULL;
  779. char          *name=NULL;
  780. Predicate     *predExpr=NULL;
  781. char          *predLiteral=NULL;
  782. int           save_file;
  783. int           save_line;
  784. int           predExprPresent=0;
  785. zzmatch(109);
  787. MR_usingPredNames=1;      /* will need to use -mrhoist version of genPredTree */
  788.  zzCONSUME;
  790. zzmatch(TokenTerm);
  791. name=mystrdup(LATEXT(1));
  792.  zzCONSUME;
  795. /* don't free - referenced in predicates */
  797.             CurPredName=(char *)calloc(1,strlen(name) + 10);
  798. strcat("#pred ",CurPredName);
  799. strcat(name,CurPredName);
  801.             predEntry=(PredEntry *) hash_get(Pname,name);
  802. if (predEntry != NULL) {
  803. warnFL(eMsg1("#pred %s previously defined - ignored",name),
  804. FileStr[action_file],action_line);
  805. name=NULL;
  806. };
  807. {
  808. zzBLOCK(zztasp2);
  809. zzMake0;
  810. {
  811. if ( (LA(1)==Pred) ) {
  812. zzmatch(Pred);
  813. predLiteral=mystrdup(LATEXT(1));
  814. save_line=action_line;
  815. save_file=action_file;
  816.  zzCONSUME;
  818. {
  819. zzBLOCK(zztasp3);
  820. zzMake0;
  821. {
  822. if ( (setwd2[LA(1)]&0x10) ) {
  823.  predExpr  = predOrExpr();
  825. predExprPresent=1;
  826. }
  827. zzEXIT(zztasp3);
  828. }
  829. }
  830. if (predLiteral != NULL && name != NULL) {
  832.                       /*
  833. *  predExpr may be NULL due to syntax errors
  834. *    or simply omitted by the user
  835. */
  837.                       predEntry=newPredEntry(name);
  838. predEntry->file=save_file;
  839. predEntry->line=save_line;
  840. predExpr=MR_predFlatten(predExpr);
  841. predEntry->predLiteral=predLiteral;
  842. if (! predExprPresent || predExpr == NULL) {
  843. predExpr=new_pred();
  844. predExpr->expr=predLiteral;
  845. predExpr->source=newActionNode();
  846. predExpr->source->action=predExpr->expr;
  847. predExpr->source->rname=CurPredName;
  848. predExpr->source->line=action_line;
  849. predExpr->source->file=action_file;
  850. predExpr->source->is_predicate=1;
  851. predExpr->k=predicateLookaheadDepth(predExpr->source);
  852. };
  853. predEntry->pred=predExpr;
  854. hash_add(Pname,name,(Entry *)predEntry);
  855. predExpr=NULL;
  856. };
  857. predicate_free(predExpr);
  858. }
  859. else {
  860. if ( (setwd2[LA(1)]&0x20) ) {
  861. save_line=zzline; save_file=CurFile;
  862.  predExpr  = predOrExpr();
  864. if (predExpr != NULL && name != NULL) {
  865. predEntry=newPredEntry(name);
  866. predEntry->file=CurFile;
  867. predEntry->line=zzline;
  868. predExpr=MR_predFlatten(predExpr);
  869. predEntry->pred=predExpr;
  870. hash_add(Pname,name,(Entry *)predEntry);
  871. predExpr=NULL;
  872. };
  873. predicate_free(predExpr);
  874. }
  875. else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  876. }
  877. zzEXIT(zztasp2);
  878. }
  879. }
  880. {
  881. zzBLOCK(zztasp2);
  882. zzMake0;
  883. {
  884. if ( (LA(1)==105) ) {
  885. zzmatch(105); zzCONSUME;
  886. }
  887. zzEXIT(zztasp2);
  888. }
  889. }
  890. zzEXIT(zztasp1);
  891. return;
  892. fail:
  893. zzEXIT(zztasp1);
  894. predicate_free(predExpr);
  895. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  896. zzresynch(setwd2, 0x40);
  897. }
  898. }
  900.  Predicate *
  901. #ifdef __USE_PROTOS
  902. predOrExpr(void)
  903. #else
  904. predOrExpr()
  905. #endif
  906. {
  907.  Predicate *   _retv;
  908. zzRULE;
  909. zzBLOCK(zztasp1);
  910. PURIFY(_retv,sizeof( Predicate *  ))
  911. zzMake0;
  912. {
  913. Predicate     *ORnode;
  914. Predicate     *predExpr;
  915. Predicate     **tail=NULL;
  916.  predExpr  = predAndExpr();
  919. ORnode=new_pred();
  920. ORnode->expr=PRED_OR_LIST;
  921. if (predExpr != NULL) {
  922. ORnode->down=predExpr;
  923. tail=&predExpr->right;
  924. };
  925. {
  926. zzBLOCK(zztasp2);
  927. zzMake0;
  928. {
  929. while ( (LA(1)==110) ) {
  930. zzmatch(110); zzCONSUME;
  931.  predExpr  = predAndExpr();
  934. if (predExpr != NULL) {
  935. *tail=predExpr;
  936. tail=&predExpr->right;
  937. };
  938. zzLOOP(zztasp2);
  939. }
  940. zzEXIT(zztasp2);
  941. }
  942. }
  944. _retv=ORnode;
  945. ORnode=NULL;
  946. zzEXIT(zztasp1);
  947. return _retv;
  948. fail:
  949. zzEXIT(zztasp1);
  950. predicate_free(ORnode);
  951. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  952. zzresynch(setwd2, 0x80);
  953. return _retv;
  954. }
  955. }
  957.  Predicate *
  958. #ifdef __USE_PROTOS
  959. predAndExpr(void)
  960. #else
  961. predAndExpr()
  962. #endif
  963. {
  964.  Predicate *   _retv;
  965. zzRULE;
  966. zzBLOCK(zztasp1);
  967. PURIFY(_retv,sizeof( Predicate *  ))
  968. zzMake0;
  969. {
  970. Predicate     *ANDnode;
  971. Predicate     *predExpr;
  972. Predicate     **tail=NULL;
  973.  predExpr  = predPrimary();
  976. ANDnode=new_pred();
  977. ANDnode->expr=PRED_AND_LIST;
  978. if (predExpr != NULL) {
  979. ANDnode->down=predExpr;
  980. tail=&predExpr->right;
  981. };
  982. {
  983. zzBLOCK(zztasp2);
  984. zzMake0;
  985. {
  986. while ( (LA(1)==111) ) {
  987. zzmatch(111); zzCONSUME;
  988.  predExpr  = predPrimary();
  991. if (predExpr != NULL) {
  992. *tail=predExpr;
  993. tail=&predExpr->right;
  994. };
  995. zzLOOP(zztasp2);
  996. }
  997. zzEXIT(zztasp2);
  998. }
  999. }
  1001. _retv=ANDnode;
  1002. ANDnode=NULL;
  1003. zzEXIT(zztasp1);
  1004. return _retv;
  1005. fail:
  1006. zzEXIT(zztasp1);
  1007. predicate_free(ANDnode);
  1008. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1009. zzresynch(setwd3, 0x1);
  1010. return _retv;
  1011. }
  1012. }
  1014.  Predicate *
  1015. #ifdef __USE_PROTOS
  1016. predPrimary(void)
  1017. #else
  1018. predPrimary()
  1019. #endif
  1020. {
  1021.  Predicate *   _retv;
  1022. zzRULE;
  1023. zzBLOCK(zztasp1);
  1024. PURIFY(_retv,sizeof( Predicate *  ))
  1025. zzMake0;
  1026. {
  1028. char          *name=NULL;
  1029. PredEntry     *predEntry=NULL;
  1030. Predicate     *predExpr=NULL;
  1031. int           inverted=0;
  1032. if ( (LA(1)==TokenTerm) ) {
  1033. zzmatch(TokenTerm);
  1034. name=mystrdup(LATEXT(1));
  1035.  zzCONSUME;
  1038. predEntry=(PredEntry *) hash_get(Pname,name);
  1039. if (predEntry == NULL) {
  1040. warnFL(eMsg1("no previously defined #pred with name "%s"",name),
  1041. FileStr[CurFile],zzline);
  1042. name=NULL;
  1043. _retv=NULL;
  1044. } else {
  1045. predExpr=predicate_dup(predEntry->pred);
  1046. predExpr->predEntry=predEntry;
  1047. _retv=predExpr;
  1048. };
  1049. }
  1050. else {
  1051. if ( (LA(1)==112) ) {
  1052. zzmatch(112); zzCONSUME;
  1053.  predExpr  = predOrExpr();
  1055. zzmatch(113);
  1057. _retv=predExpr;
  1058.  zzCONSUME;
  1060. }
  1061. else {
  1062. if ( (LA(1)==101) ) {
  1063. zzmatch(101); zzCONSUME;
  1064.  predExpr  = predPrimary();
  1067. predExpr->inverted=!predExpr->inverted;
  1068. _retv=predExpr;
  1069. }
  1070. else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1071. }
  1072. }
  1073. zzEXIT(zztasp1);
  1074. return _retv;
  1075. fail:
  1076. zzEXIT(zztasp1);
  1078. predicate_free(predExpr);
  1079. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1080. zzresynch(setwd3, 0x2);
  1081. return _retv;
  1082. }
  1083. }
  1085. void
  1086. #ifdef __USE_PROTOS
  1087. aLexclass(void)
  1088. #else
  1089. aLexclass()
  1090. #endif
  1091. {
  1092. zzRULE;
  1093. zzBLOCK(zztasp1);
  1094. zzMake0;
  1095. {
  1096. zzmatch(114); zzCONSUME;
  1097. zzmatch(TokenTerm);
  1098. lexclass(mystrdup(LATEXT(1)));
  1099.  zzCONSUME;
  1101. zzEXIT(zztasp1);
  1102. return;
  1103. fail:
  1104. zzEXIT(zztasp1);
  1105. CannotContinue=TRUE;
  1106. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1107. zzresynch(setwd3, 0x4);
  1108. }
  1109. }
  1111. void
  1112. #ifdef __USE_PROTOS
  1113. error(void)
  1114. #else
  1115. error()
  1116. #endif
  1117. {
  1118. zzRULE;
  1119. zzBLOCK(zztasp1);
  1120. zzMake0;
  1121. {
  1122. char *t=NULL; ECnode *e; int go=1; TermEntry *p;
  1123. zzmatch(115); zzCONSUME;
  1124. {
  1125. zzBLOCK(zztasp2);
  1126. zzMake0;
  1127. {
  1128. ;
  1129. if ( (LA(1)==TokenTerm) ) {
  1130. zzmatch(TokenTerm);
  1131. t=mystrdup(LATEXT(1));
  1132.  zzCONSUME;
  1134. }
  1135. else {
  1136. if ( (LA(1)==QuotedTerm) ) {
  1137. zzmatch(QuotedTerm);
  1138. t=mystrdup(LATEXT(1));
  1139.  zzCONSUME;
  1141. }
  1142. else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1143. }
  1144. zzEXIT(zztasp2);
  1145. }
  1146. }
  1147. e = newECnode;
  1148. require(e!=NULL, "cannot allocate error class node");
  1149. e->lexclass = CurrentLexClass;
  1150. if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  1151. {
  1152. if ( hash_get(Texpr, t) != NULL )
  1153. warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  1154. e->tok = addTname( t );
  1155. set_orel(e->tok, &imag_tokens);
  1156. require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  1157. "hash table mechanism is broken");
  1158. p->classname = 1; /* entry is errclass name, not token */
  1159. list_add(&eclasses, (char *)e);
  1160. }
  1161. else
  1162. {
  1163. warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
  1164. free( (char *)e );
  1165. go=0;
  1166. }
  1167. zzmatch(100); zzCONSUME;
  1168. {
  1169. zzBLOCK(zztasp2);
  1170. zzMake0;
  1171. {
  1172. if ( (LA(1)==NonTerminal) ) {
  1173. zzmatch(NonTerminal);
  1174. if ( go ) t=mystrdup(LATEXT(1));
  1175.  zzCONSUME;
  1177. }
  1178. else {
  1179. if ( (LA(1)==TokenTerm) ) {
  1180. zzmatch(TokenTerm);
  1181. if ( go ) t=mystrdup(LATEXT(1));
  1182.  zzCONSUME;
  1184. }
  1185. else {
  1186. if ( (LA(1)==QuotedTerm) ) {
  1187. zzmatch(QuotedTerm);
  1188. if ( go ) t=mystrdup(LATEXT(1));
  1189.  zzCONSUME;
  1191. }
  1192. else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1193. }
  1194. }
  1195. zzEXIT(zztasp2);
  1196. }
  1197. }
  1198. if ( go ) list_add(&(e->elist), t);
  1199. {
  1200. zzBLOCK(zztasp2);
  1201. zzMake0;
  1202. {
  1203. while ( (setwd3[LA(1)]&0x8) ) {
  1204. {
  1205. zzBLOCK(zztasp3);
  1206. zzMake0;
  1207. {
  1208. if ( (LA(1)==NonTerminal) ) {
  1209. zzmatch(NonTerminal);
  1210. if ( go ) t=mystrdup(LATEXT(1));
  1211.  zzCONSUME;
  1213. }
  1214. else {
  1215. if ( (LA(1)==TokenTerm) ) {
  1216. zzmatch(TokenTerm);
  1217. if ( go ) t=mystrdup(LATEXT(1));
  1218.  zzCONSUME;
  1220. }
  1221. else {
  1222. if ( (LA(1)==QuotedTerm) ) {
  1223. zzmatch(QuotedTerm);
  1224. if ( go ) t=mystrdup(LATEXT(1));
  1225.  zzCONSUME;
  1227. }
  1228. else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1229. }
  1230. }
  1231. zzEXIT(zztasp3);
  1232. }
  1233. }
  1234. if ( go ) list_add(&(e->elist), t);
  1235. zzLOOP(zztasp2);
  1236. }
  1237. zzEXIT(zztasp2);
  1238. }
  1239. }
  1240. zzmatch(96); zzCONSUME;
  1241. zzEXIT(zztasp1);
  1242. return;
  1243. fail:
  1244. zzEXIT(zztasp1);
  1245. CannotContinue=TRUE;
  1246. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1247. zzresynch(setwd3, 0x10);
  1248. }
  1249. }
  1251. void
  1252. #ifdef __USE_PROTOS
  1253. tclass(void)
  1254. #else
  1255. tclass()
  1256. #endif
  1257. {
  1258. zzRULE;
  1259. zzBLOCK(zztasp1);
  1260. zzMake0;
  1261. {
  1262. char *t=NULL; TCnode *e; int go=1,tok,totok; TermEntry *p, *term, *toterm;
  1263. char *totext=NULL;
  1264. zzmatch(116); zzCONSUME;
  1265. zzmatch(TokenTerm);
  1266. t=mystrdup(LATEXT(1));
  1267.  zzCONSUME;
  1269. e = newTCnode;
  1270. require(e!=NULL, "cannot allocate token class node");
  1271. e->lexclass = CurrentLexClass;
  1272. if ( Tnum( t ) == 0 )
  1273. {
  1274. e->tok = addTname( t );
  1275. set_orel(e->tok, &imag_tokens);
  1276. set_orel(e->tok, &tokclasses);
  1277. require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  1278. "hash table mechanism is broken");
  1279. p->classname = 1; /* entry is class name, not token */
  1280. p->tclass = e; /* save ptr to this tclass def */
  1281. list_add(&tclasses, (char *)e);
  1282. }
  1283. else
  1284. {
  1285. warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
  1286. free( (char *)e );
  1287. go=0;
  1288. }
  1289. zzmatch(100); zzCONSUME;
  1290. {
  1291. zzBLOCK(zztasp2);
  1292. zzMake0;
  1293. {
  1294. while ( (setwd3[LA(1)]&0x20) ) {
  1295. {
  1296. zzBLOCK(zztasp3);
  1297. zzMake0;
  1298. {
  1299. if ( (LA(1)==TokenTerm) ) {
  1300. zzmatch(TokenTerm);
  1301. if ( go ) {
  1302. term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1303. if ( term==NULL && UserDefdTokens ) {
  1304. err("implicit token definition not allowed with #tokdefs");
  1305. go = 0;
  1306. }
  1307. else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
  1308. }
  1309.  zzCONSUME;
  1311. {
  1312. zzBLOCK(zztasp4);
  1313. zzMake0;
  1314. {
  1315. if ( (LA(1)==117) ) {
  1316. zzmatch(117); zzCONSUME;
  1317. zzmatch(TokenTerm);
  1318. if ( go ) {
  1319. toterm = (TermEntry *) hash_get(Tname, LATEXT(1));
  1320. if ( toterm==NULL && UserDefdTokens ) {
  1321. err("implicit token definition not allowed with #tokdefs");
  1322. go = 0;
  1323. } else {
  1324. totext=mystrdup(LATEXT(1)); totok=addTname(LATEXT(1));
  1325. }
  1326. }
  1327.  zzCONSUME;
  1329. }
  1330. zzEXIT(zztasp4);
  1331. }
  1332. }
  1333. }
  1334. else {
  1335. if ( (LA(1)==QuotedTerm) ) {
  1336. zzmatch(QuotedTerm);
  1337. if ( go ) {
  1338. term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1339. if ( term==NULL && UserDefdTokens ) {
  1340. err("implicit token definition not allowed with #tokdefs");
  1341. go = 0;
  1342. }
  1343. else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
  1344. }
  1345.  zzCONSUME;
  1347. }
  1348. else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1349. }
  1350. zzEXIT(zztasp3);
  1351. }
  1352. }
  1353. if ( go ) {
  1354. if (totext == NULL) {
  1355. list_add(&(e->tlist), t);
  1356. } else {
  1357. list_add(&(e->tlist),"..");
  1358. list_add(&(e->tlist),t);
  1359. list_add(&(e->tlist),totext);
  1360. }
  1361. totext=NULL;
  1362. }
  1363. zzLOOP(zztasp2);
  1364. }
  1365. zzEXIT(zztasp2);
  1366. }
  1367. }
  1368. zzmatch(96); zzCONSUME;
  1369. zzEXIT(zztasp1);
  1370. return;
  1371. fail:
  1372. zzEXIT(zztasp1);
  1373. CannotContinue=TRUE;
  1374. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1375. zzresynch(setwd3, 0x40);
  1376. }
  1377. }
  1379. void
  1380. #ifdef __USE_PROTOS
  1381. token(void)
  1382. #else
  1383. token()
  1384. #endif
  1385. {
  1386. zzRULE;
  1387. zzBLOCK(zztasp1);
  1388. zzMake0;
  1389. {
  1390. char *t=NULL, *e=NULL, *a=NULL; int tnum=0;
  1391. char *akaString=NULL; TermEntry *te;int save_file=0,save_line=0;
  1392. zzmatch(118);
  1393. tokenActionActive=1;
  1394.  zzCONSUME;
  1396. {
  1397. zzBLOCK(zztasp2);
  1398. zzMake0;
  1399. {
  1400. if ( (LA(1)==TokenTerm) ) {
  1401. zzmatch(TokenTerm);
  1402. t=mystrdup(LATEXT(1));
  1403.  zzCONSUME;
  1405. {
  1406. zzBLOCK(zztasp3);
  1407. zzMake0;
  1408. {
  1409. if ( (LA(1)==112) ) {
  1410. zzmatch(112); zzCONSUME;
  1411. zzmatch(QuotedTerm);
  1412. akaString=mystrdup(StripQuotes(LATEXT(1)));
  1413. /* MR11 */                   save_file=CurFile;save_line=zzline;
  1414. /* MR11 */
  1415.  zzCONSUME;
  1417. zzmatch(113); zzCONSUME;
  1418. }
  1419. zzEXIT(zztasp3);
  1420. }
  1421. }
  1422. {
  1423. zzBLOCK(zztasp3);
  1424. zzMake0;
  1425. {
  1426. if ( (LA(1)==119) ) {
  1427. zzmatch(119); zzCONSUME;
  1428. zzmatch(120);
  1429. tnum = atoi(LATEXT(1));
  1430.  zzCONSUME;
  1432. }
  1433. zzEXIT(zztasp3);
  1434. }
  1435. }
  1436. }
  1437. zzEXIT(zztasp2);
  1438. }
  1439. }
  1440. {
  1441. zzBLOCK(zztasp2);
  1442. zzMake0;
  1443. {
  1444. if ( (LA(1)==QuotedTerm) ) {
  1445. zzmatch(QuotedTerm);
  1446. e=mystrdup(LATEXT(1));
  1447.  zzCONSUME;
  1449. }
  1450. zzEXIT(zztasp2);
  1451. }
  1452. }
  1453. {
  1454. zzBLOCK(zztasp2);
  1455. zzMake0;
  1456. {
  1457. if ( (LA(1)==Action) ) {
  1458. zzmatch(Action);
  1460. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1461. require(a!=NULL, "rule token: cannot allocate action");
  1462. strcpy(a, LATEXT(1));
  1463.  zzCONSUME;
  1465. }
  1466. zzEXIT(zztasp2);
  1467. }
  1468. }
  1469. {
  1470. zzBLOCK(zztasp2);
  1471. zzMake0;
  1472. {
  1473. if ( (LA(1)==105) ) {
  1474. zzmatch(105); zzCONSUME;
  1475. }
  1476. zzEXIT(zztasp2);
  1477. }
  1478. }
  1479. chkToken(t, e, a, tnum);
  1480. if (t != NULL) {
  1481. te=(TermEntry *)hash_get(Tname,t);
  1482. if (te != NULL && akaString != NULL) {
  1483. if (te->akaString != NULL) {
  1484. if (strcmp(te->akaString,akaString) != 0) {
  1485. warnFL(eMsg2("this #token statment conflicts with a previous #token %s("%s") statement",
  1486. t,te->akaString),
  1487. FileStr[save_file],save_line);
  1488. };
  1489. } else {
  1490. te->akaString=akaString;
  1491. };
  1492. };
  1493. };
  1494. zzEXIT(zztasp1);
  1495. return;
  1496. fail:
  1497. zzEXIT(zztasp1);
  1498. CannotContinue=TRUE;
  1499. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1500. zzresynch(setwd3, 0x80);
  1501. }
  1502. }
  1504. void
  1505. #ifdef __USE_PROTOS
  1506. block( set *toksrefd, set *rulesrefd )
  1507. #else
  1508. block(toksrefd,rulesrefd)
  1509.  set *toksrefd;
  1510. set *rulesrefd ;
  1511. #endif
  1512. {
  1513. zzRULE;
  1514. zzBLOCK(zztasp1);
  1515. zzMake0;
  1516. {
  1518. Graph g, b;
  1519. set saveblah;
  1520. int saveinalt = inAlt;
  1521. ExceptionGroup *eg;
  1522. * toksrefd = empty;
  1523. * rulesrefd = empty;
  1524. set_clr(AST_nodes_refd_in_actions);
  1525. CurBlockID++;
  1526. CurAltNum = 1;
  1527. saveblah = attribsRefdFromAction;
  1528. attribsRefdFromAction = empty;
  1529. alt( toksrefd,rulesrefd );
  1530. b = g = zzaArg(zztasp1,1);
  1532. if ( ((Junction *)g.left)->p1->ntype == nAction )
  1533. {
  1534. ActionNode *actionNode=(ActionNode *)
  1535. ( ( (Junction *)g.left) ->p1);
  1536. if (!actionNode->is_predicate )
  1537. {
  1538. actionNode->init_action = TRUE;
  1539. /* MR12c */   if (actionNode->noHoist) {
  1540. /* MR12c */           errFL("<<nohoist>> appears as init-action - use <<>> <<nohoist>>",
  1541. /* MR12c */                       FileStr[actionNode->file],actionNode->line);
  1542. /* MR12c */         };
  1543. }
  1544. }
  1545. ((Junction *)g.left)->blockid = CurBlockID;
  1546. {
  1547. zzBLOCK(zztasp2);
  1548. zzMake0;
  1549. {
  1550. while ( (LA(1)==132) ) {
  1551.  eg  = exception_group();
  1554. if ( eg!=NULL ) {
  1555. /* MR7 *****        eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
  1556. /* MR7 ***** CurAltStart->exception_label = eg->altID;           *****/
  1557. list_add(&CurExGroups, (void *)eg);
  1558. }
  1559. zzLOOP(zztasp2);
  1560. }
  1561. zzEXIT(zztasp2);
  1562. }
  1563. }
  1564. CurAltNum++;
  1565. {
  1566. zzBLOCK(zztasp2);
  1567. zzMake0;
  1568. {
  1569. while ( (LA(1)==121) ) {
  1570. zzmatch(121);
  1571. inAlt=1;
  1572.  zzCONSUME;
  1574. alt( toksrefd,rulesrefd );
  1575. g = Or(g, zzaArg(zztasp2,2));
  1577. ((Junction *)g.left)->blockid = CurBlockID;
  1578. {
  1579. zzBLOCK(zztasp3);
  1580. zzMake0;
  1581. {
  1582. while ( (LA(1)==132) ) {
  1583.  eg  = exception_group();
  1586. if ( eg!=NULL ) {
  1587. /* MR7 *****        eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
  1588. /* MR7 ***** CurAltStart->exception_label = eg->altID;           *****/
  1589. list_add(&CurExGroups, (void *)eg);
  1590. }
  1591. zzLOOP(zztasp3);
  1592. }
  1593. zzEXIT(zztasp3);
  1594. }
  1595. }
  1596. CurAltNum++;
  1597. zzLOOP(zztasp2);
  1598. }
  1599. zzEXIT(zztasp2);
  1600. }
  1601. }
  1602. zzaArg(zztasp1,0) = b;
  1603. attribsRefdFromAction = saveblah; inAlt = saveinalt;
  1604. zzEXIT(zztasp1);
  1605. return;
  1606. fail:
  1607. zzEXIT(zztasp1);
  1608. CannotContinue=TRUE;
  1609. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1610. zzresynch(setwd4, 0x1);
  1611. }
  1612. }
  1614. void
  1615. #ifdef __USE_PROTOS
  1616. alt( set *toksrefd, set *rulesrefd )
  1617. #else
  1618. alt(toksrefd,rulesrefd)
  1619.  set *toksrefd;
  1620. set *rulesrefd ;
  1621. #endif
  1622. {
  1623. zzRULE;
  1624. zzBLOCK(zztasp1);
  1625. zzMake0;
  1626. {
  1627. int n=0,ne=0; Graph g; int e_num=0, not=0; Node *node; set elems, dif;
  1628. int first_on_line = 1, use_def_MT_handler = 0;
  1629. g.left=NULL; g.right=NULL;
  1631. CurAltStart = NULL;
  1632. elems = empty;
  1633. inAlt = 1;
  1634. {
  1635. zzBLOCK(zztasp2);
  1636. zzMake0;
  1637. {
  1638. if ( (LA(1)==88) ) {
  1639. zzmatch(88);
  1640. use_def_MT_handler = 1;
  1641.  zzCONSUME;
  1643. }
  1644. zzEXIT(zztasp2);
  1645. }
  1646. }
  1647. {
  1648. zzBLOCK(zztasp2);
  1649. zzMake0;
  1650. {
  1651. ;
  1652. while ( (setwd4[LA(1)]&0x2) ) {
  1653. {
  1654. zzBLOCK(zztasp3);
  1655. zzMake0;
  1656. {
  1657. not=0;
  1658. if ( (LA(1)==122) ) {
  1659. zzmatch(122);
  1660. not=1;
  1661.  zzCONSUME;
  1663. }
  1664. zzEXIT(zztasp3);
  1665. }
  1666. }
  1667.  node  = element( not, first_on_line, use_def_MT_handler );
  1669. if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;
  1671. if ( zzaArg(zztasp2,2 ).left!=NULL ) {
  1672. g = Cat(g, zzaArg(zztasp2,2));
  1673. n++;
  1674. if ( node!=NULL ) {
  1675. if ( node->ntype!=nAction ) e_num++;
  1676. /* record record number of all rule and token refs */
  1677. if ( node->ntype==nToken ) {
  1678. TokNode *tk = (TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
  1679. tk->elnum = e_num;
  1680. set_orel(e_num, &elems);
  1681. }
  1682. else if ( node->ntype==nRuleRef ) {
  1683. RuleRefNode *rn = (RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
  1684. rn->elnum = e_num;
  1685. set_orel(e_num,  rulesrefd);
  1686. }
  1687. }
  1688. }
  1689. zzLOOP(zztasp2);
  1690. }
  1691. zzEXIT(zztasp2);
  1692. }
  1693. }
  1694. if ( n == 0 ) g = emptyAlt();
  1695. zzaArg(zztasp1,0) = g;
  1696. /* We want to reduce number of LT(i) calls and the number of
  1697. * local attribute variables in C++ mode (for moment, later we'll
  1698. * do for C also).  However, if trees are being built, they
  1699. * require most of the attrib variables to create the tree nodes
  1700. * with; therefore, we gen a token ptr for each token ref in C++
  1701. */
  1702. if ( GenCC && !GenAST )
  1703. {
  1704. /* This now free's the temp set -ATG 5/6/95 */
  1705. set temp;
  1706. temp = set_and(elems, attribsRefdFromAction);
  1707. set_orin( toksrefd, temp);
  1708. set_free(temp);
  1709. }
  1710. else set_orin( toksrefd, elems);
  1711. if ( GenCC ) {
  1712. dif = set_dif(attribsRefdFromAction, elems);
  1713. if ( set_deg(dif)>0 )
  1714. err("one or more $i in action(s) refer to non-token elements");
  1715. set_free(dif);
  1716. }
  1717. set_free(elems);
  1718. set_free(attribsRefdFromAction);
  1719. inAlt = 0;
  1720. zzEXIT(zztasp1);
  1721. return;
  1722. fail:
  1723. zzEXIT(zztasp1);
  1724. CannotContinue=TRUE;
  1725. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1726. zzresynch(setwd4, 0x4);
  1727. }
  1728. }
  1730.  LabelEntry *
  1731. #ifdef __USE_PROTOS
  1732. element_label(void)
  1733. #else
  1734. element_label()
  1735. #endif
  1736. {
  1737.  LabelEntry *   _retv;
  1738. zzRULE;
  1739. zzBLOCK(zztasp1);
  1740. PURIFY(_retv,sizeof( LabelEntry *  ))
  1741. zzMake0;
  1742. {
  1743. TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;
  1744. zzmatch(LABEL);
  1745. lab = mystrdup(LATEXT(1));
  1746.  zzCONSUME;
  1749. UsedNewStyleLabel = 1;
  1750. if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
  1751. t = (TermEntry *) hash_get(Tname, lab);
  1752. if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
  1753. if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
  1754. if ( t!=NULL ) {
  1755. err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
  1756. _retv = NULL;
  1757. }
  1758. else if ( r!=NULL ) {
  1759. err(eMsg1("label definition clashes with rule definition: '%s'", lab));
  1760. _retv = NULL;
  1761. }
  1762. else {
  1763. /* we don't clash with anybody else */
  1764. l = (LabelEntry *) hash_get(Elabel, lab);
  1765. if ( l==NULL ) { /* ok to add new element label */
  1766. l = (LabelEntry *)hash_add(Elabel,
  1767. lab,
  1768. (Entry *)newLabelEntry(lab));
  1769. /* add to list of element labels for this rule */
  1770. list_add(&CurElementLabels, (void *)lab);
  1771. /* MR7 */       leAdd(l);  /* list of labels waiting for exception group definitions */
  1772. _retv = l;
  1773. }
  1774. else {
  1775. err(eMsg1("label definitions must be unique per rule: '%s'", lab));
  1776. _retv = NULL;
  1777. }
  1778. }
  1779. zzmatch(104); zzCONSUME;
  1780. zzEXIT(zztasp1);
  1781. return _retv;
  1782. fail:
  1783. zzEXIT(zztasp1);
  1784. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1785. zzresynch(setwd4, 0x8);
  1786. return _retv;
  1787. }
  1788. }
  1790.  Node *
  1791. #ifdef __USE_PROTOS
  1792. element( int not, int first_on_line, int use_def_MT_handler )
  1793. #else
  1794. element(not,first_on_line,use_def_MT_handler)
  1795.  int not;
  1796. int first_on_line;
  1797. int use_def_MT_handler ;
  1798. #endif
  1799. {
  1800.  Node *   _retv;
  1801. zzRULE;
  1802. zzBLOCK(zztasp1);
  1803. PURIFY(_retv,sizeof( Node *  ))
  1804. zzMake0;
  1805. {
  1807. Attrib blk;
  1808. Predicate *pred = NULL;
  1809. int local_use_def_MT_handler=0;
  1810. ActionNode *act;
  1811. RuleRefNode *rr;
  1812. set toksrefd, rulesrefd;
  1813. TermEntry *term;
  1814. TokNode *p=NULL; RuleRefNode *q; int approx=0;
  1815. LabelEntry *label=NULL;
  1816. int predMsgDone=0;
  1817. int semDepth=0;
  1818. int   ampersandStyle;
  1819. int   height;         /* MR11 */
  1820. int   equal_height;   /* MR11 */
  1822.   _retv = NULL;
  1823. if ( (setwd4[LA(1)]&0x10) ) {
  1824. {
  1825. zzBLOCK(zztasp2);
  1826. zzMake0;
  1827. {
  1828. if ( (LA(1)==LABEL) ) {
  1829.  label  = element_label();
  1831. }
  1832. zzEXIT(zztasp2);
  1833. }
  1834. }
  1835. {
  1836. zzBLOCK(zztasp2);
  1837. zzMake0;
  1838. {
  1839. if ( (LA(1)==TokenTerm) ) {
  1840. zzmatch(TokenTerm);
  1842. term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1843. if ( term==NULL && UserDefdTokens ) {
  1844. err("implicit token definition not allowed with #tokdefs");
  1845. zzaRet.left = zzaRet.right = NULL;
  1846. }
  1847. else {
  1848. zzaRet = buildToken(LATEXT(1));
  1849. p=((TokNode *)((Junction *)zzaRet.left)->p1);
  1850. term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1851. require( term!= NULL, "hash table mechanism is broken");
  1852. p->tclass = term->tclass;
  1853. p->complement =  not;
  1854. if ( label!=NULL ) {
  1855. p->el_label = label->str;
  1856. label->elem = (Node *)p;
  1857. }
  1858. }
  1859.  zzCONSUME;
  1861. {
  1862. zzBLOCK(zztasp3);
  1863. zzMake0;
  1864. {
  1865. if ( (LA(1)==117) ) {
  1866. zzmatch(117); zzCONSUME;
  1867. {
  1868. zzBLOCK(zztasp4);
  1869. zzMake0;
  1870. {
  1871. if ( (LA(1)==QuotedTerm) ) {
  1872. zzmatch(QuotedTerm);
  1873. if ( p!=NULL ) setUpperRange(p, LATEXT(1));
  1874.  zzCONSUME;
  1876. }
  1877. else {
  1878. if ( (LA(1)==TokenTerm) ) {
  1879. zzmatch(TokenTerm);
  1880. if ( p!=NULL ) setUpperRange(p, LATEXT(1));
  1881.  zzCONSUME;
  1883. }
  1884. else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1885. }
  1886. zzEXIT(zztasp4);
  1887. }
  1888. }
  1889. }
  1890. zzEXIT(zztasp3);
  1891. }
  1892. }
  1894. if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1895. list_add(&MetaTokenNodes, (void *)p);
  1896. {
  1897. zzBLOCK(zztasp3);
  1898. zzMake0;
  1899. {
  1900. if ( (LA(1)==123) ) {
  1901. zzmatch(123);
  1902. if ( p!=NULL ) p->astnode=ASTroot;
  1903.  zzCONSUME;
  1905. }
  1906. else {
  1907. if ( (setwd4[LA(1)]&0x20) ) {
  1908. if ( p!=NULL ) p->astnode=ASTchild;
  1909. }
  1910. else {
  1911. if ( (LA(1)==101) ) {
  1912. zzmatch(101);
  1913. if ( p!=NULL ) p->astnode=ASTexclude;
  1914.  zzCONSUME;
  1916. }
  1917. else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1918. }
  1919. }
  1920. zzEXIT(zztasp3);
  1921. }
  1922. }
  1923. {
  1924. zzBLOCK(zztasp3);
  1925. zzMake0;
  1926. {
  1927. if ( (LA(1)==88) ) {
  1928. zzmatch(88);
  1929. local_use_def_MT_handler = 1;
  1930.  zzCONSUME;
  1932. }
  1933. zzEXIT(zztasp3);
  1934. }
  1935. }
  1937. if ( p!=NULL &&  first_on_line ) {
  1938. CurAltStart = (Junction *)zzaRet.left;
  1939. altAdd(CurAltStart);                                 /* MR7 */
  1940. p->altstart = CurAltStart;
  1941. }
  1942. if ( p!=NULL )
  1943. p->use_def_MT_handler =  use_def_MT_handler || local_use_def_MT_handler;
  1944. _retv = (Node *)p;
  1945. }
  1946. else {
  1947. if ( (LA(1)==QuotedTerm) ) {
  1948. zzmatch(QuotedTerm);
  1950. term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1951. if ( term==NULL && UserDefdTokens ) {
  1952. err("implicit token definition not allowed with #tokdefs");
  1953. zzaRet.left = zzaRet.right = NULL;
  1954. }
  1955. else {
  1956. zzaRet = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);
  1957. p->complement =  not;
  1958. if ( label!=NULL ) {
  1959. p->el_label = label->str;
  1960. label->elem = (Node *)p;
  1961. }
  1962. }
  1963.  zzCONSUME;
  1965. {
  1966. zzBLOCK(zztasp3);
  1967. zzMake0;
  1968. {
  1969. if ( (LA(1)==117) ) {
  1970. zzmatch(117); zzCONSUME;
  1971. {
  1972. zzBLOCK(zztasp4);
  1973. zzMake0;
  1974. {
  1975. if ( (LA(1)==QuotedTerm) ) {
  1976. zzmatch(QuotedTerm);
  1977. if ( p!=NULL ) setUpperRange(p, LATEXT(1));
  1978.  zzCONSUME;
  1980. }
  1981. else {
  1982. if ( (LA(1)==TokenTerm) ) {
  1983. zzmatch(TokenTerm);
  1984. if ( p!=NULL ) setUpperRange(p, LATEXT(1));
  1985.  zzCONSUME;
  1987. }
  1988. else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1989. }
  1990. zzEXIT(zztasp4);
  1991. }
  1992. }
  1993. }
  1994. zzEXIT(zztasp3);
  1995. }
  1996. }
  1997. {
  1998. zzBLOCK(zztasp3);
  1999. zzMake0;
  2000. {
  2001. if ( (LA(1)==123) ) {
  2002. zzmatch(123);
  2003. if ( p!=NULL ) p->astnode=ASTroot;
  2004.  zzCONSUME;
  2006. }
  2007. else {
  2008. if ( (setwd4[LA(1)]&0x40) ) {
  2009. if ( p!=NULL ) p->astnode=ASTchild;
  2010. }
  2011. else {
  2012. if ( (LA(1)==101) ) {
  2013. zzmatch(101);
  2014. if ( p!=NULL ) p->astnode=ASTexclude;
  2015.  zzCONSUME;
  2017. }
  2018. else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2019. }
  2020. }
  2021. zzEXIT(zztasp3);
  2022. }
  2023. }
  2024. {
  2025. zzBLOCK(zztasp3);
  2026. zzMake0;
  2027. {
  2028. if ( (LA(1)==88) ) {
  2029. zzmatch(88);
  2030. local_use_def_MT_handler = 1;
  2031.  zzCONSUME;
  2033. }
  2034. zzEXIT(zztasp3);
  2035. }
  2036. }
  2038. if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  2039. list_add(&MetaTokenNodes, (void *)p);
  2041. if (  first_on_line ) {
  2042. CurAltStart = (Junction *)zzaRet.left;
  2043. altAdd(CurAltStart);                                 /* MR7 */
  2044. p->altstart = CurAltStart;
  2045. }
  2046. if ( p!=NULL )
  2047. p->use_def_MT_handler =  use_def_MT_handler || local_use_def_MT_handler;
  2048. _retv = (Node *)p;
  2049. }
  2050. else {
  2051. if ( (LA(1)==WildCard) ) {
  2052. if (  not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");
  2053. zzmatch(WildCard);
  2054. zzaRet = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);
  2055.  zzCONSUME;
  2057. {
  2058. zzBLOCK(zztasp3);
  2059. zzMake0;
  2060. {
  2061. if ( (LA(1)==123) ) {
  2062. zzmatch(123);
  2063. p->astnode=ASTroot;
  2064.  zzCONSUME;
  2066. }
  2067. else {
  2068. if ( (setwd4[LA(1)]&0x80) ) {
  2069. p->astnode=ASTchild;
  2070. }
  2071. else {
  2072. if ( (LA(1)==101) ) {
  2073. zzmatch(101);
  2074. p->astnode=ASTexclude;
  2075.  zzCONSUME;
  2077. }
  2078. else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2079. }
  2080. }
  2081. zzEXIT(zztasp3);
  2082. }
  2083. }
  2084. list_add(&MetaTokenNodes, (void *)p);
  2086. if (  first_on_line ) {
  2087. CurAltStart = (Junction *)zzaRet.left;
  2088. altAdd(CurAltStart);                                 /* MR7 */
  2089. p->altstart = CurAltStart;
  2090. if ( label!=NULL ) {
  2091. p->el_label = label->str;
  2092. label->elem = (Node *)p;
  2093. }
  2094. }
  2095. _retv = (Node *)p;
  2096. }
  2097. else {
  2098. if ( (LA(1)==NonTerminal) ) {
  2099. if (  not ) warn("~ NONTERMINAL is an undefined operation");
  2100. zzmatch(NonTerminal);
  2101. zzaRet = buildRuleRef(LATEXT(1));
  2102.  zzCONSUME;
  2104. {
  2105. zzBLOCK(zztasp3);
  2106. zzMake0;
  2107. {
  2108. if ( (LA(1)==101) ) {
  2109. zzmatch(101);
  2110. q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  2111. q->astnode=ASTexclude;
  2112.  zzCONSUME;
  2114. }
  2115. zzEXIT(zztasp3);
  2116. }
  2117. }
  2118. {
  2119. zzBLOCK(zztasp3);
  2120. zzMake0;
  2121. {
  2122. if ( (setwd5[LA(1)]&0x1) ) {
  2123. {
  2124. zzBLOCK(zztasp4);
  2125. zzMake0;
  2126. {
  2127. if ( (LA(1)==102) ) {
  2128. zzmatch(102); zzCONSUME;
  2129. }
  2130. zzEXIT(zztasp4);
  2131. }
  2132. }
  2133. zzmatch(PassAction);
  2134. addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));
  2135.  zzCONSUME;
  2137. }
  2138. zzEXIT(zztasp3);
  2139. }
  2140. }
  2141. rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  2142. {
  2143. zzBLOCK(zztasp3);
  2144. zzMake0;
  2145. {
  2146. char *a;
  2147. if ( (LA(1)==103) ) {
  2148. zzmatch(103); zzCONSUME;
  2149. zzmatch(PassAction);
  2151. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2152. require(a!=NULL, "rule element: cannot allocate assignment");
  2153. strcpy(a, LATEXT(1));
  2154. rr->assign = a;
  2155.  zzCONSUME;
  2157. }
  2158. zzEXIT(zztasp3);
  2159. }
  2160. }
  2162. if ( label!=NULL ) {
  2163. rr->el_label = label->str;
  2164. label->elem = (Node *)rr;
  2165. }
  2166. if (  first_on_line ) {
  2167. CurAltStart = (Junction *)zzaRet.left;
  2168. altAdd(CurAltStart);                                 /* MR7 */
  2169. ((RuleRefNode *)((Junction *)zzaRet.left)->p1)->altstart = CurAltStart;
  2170. }
  2171. _retv = (Node *)rr;
  2172. }
  2173. else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2174. }
  2175. }
  2176. }
  2177. zzEXIT(zztasp2);
  2178. }
  2179. }
  2180. }
  2181. else {
  2182. if ( (LA(1)==Action) ) {
  2183. if (  not ) warn("~ ACTION is an undefined operation");
  2184. zzmatch(Action);
  2185. zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);
  2186.  zzCONSUME;
  2188. if (  first_on_line ) {                                /* MR7 */
  2189. CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left;                   /* MR7 */
  2190. altAdd(CurAltStart);                                 /* MR7 */
  2191. };
  2192. _retv = (Node *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;
  2193. }
  2194. else {
  2195. if ( (LA(1)==Pred) ) {
  2196. if (  not ) warn("~ SEMANTIC-PREDICATE is an undefined operation");
  2197. zzmatch(Pred);
  2198. zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);
  2199.  zzCONSUME;
  2201. act = (ActionNode *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;
  2202. if (numericActionLabel) {             /* MR10 */
  2203. list_add(&NumericPredLabels,act);   /* MR10 */
  2204. numericActionLabel=0;               /* MR10 */
  2205. };                                    /* MR10 */
  2206. {
  2207. zzBLOCK(zztasp2);
  2208. zzMake0;
  2209. {
  2210. char *a;
  2211. if ( (LA(1)==PassAction) ) {
  2212. zzmatch(PassAction);
  2214. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2215. require(a!=NULL, "rule element: cannot allocate predicate fail action");
  2216. strcpy(a, LATEXT(1));
  2217. act->pred_fail = a;
  2218.  zzCONSUME;
  2220. }
  2221. zzEXIT(zztasp2);
  2222. }
  2223. }
  2224. if (  first_on_line ) {                                /* MR7 */
  2225. CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left;                   /* MR7 */
  2226. altAdd(CurAltStart);                                 /* MR7 */
  2227. };
  2228. _retv = (Node *)act;
  2229. }
  2230. else {
  2231. if ( (setwd5[LA(1)]&0x2) ) {
  2232. if (  not ) warn("~ BLOCK is an undefined operation");
  2233. BlkLevel++;
  2234. {
  2235. zzBLOCK(zztasp2);
  2236. zzMake0;
  2237. {
  2238. if ( (LA(1)==124) ) {
  2239. zzmatch(124); zzCONSUME;
  2240. {
  2241. zzBLOCK(zztasp3);
  2242. zzMake0;
  2243. {
  2244. if ( (LA(1)==125) ) {
  2245. zzmatch(125);
  2246. approx=LL_k;
  2247.  zzCONSUME;
  2249. }
  2250. else {
  2251. if ( (LA(1)==126) ) {
  2252. zzmatch(126);
  2253. approx = 1;
  2254.  zzCONSUME;
  2256. }
  2257. else {
  2258. if ( (LA(1)==127) ) {
  2259. zzmatch(127);
  2260. approx = 2;
  2261.  zzCONSUME;
  2263. }
  2264. else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2265. }
  2266. }
  2267. zzEXIT(zztasp3);
  2268. }
  2269. }
  2270. }
  2271. zzEXIT(zztasp2);
  2272. }
  2273. }
  2274. {
  2275. zzBLOCK(zztasp2);
  2276. zzMake0;
  2277. {
  2278. if ( (LA(1)==112) ) {
  2279. zzmatch(112); zzCONSUME;
  2280. block( &toksrefd,&rulesrefd );
  2281. zzmatch(113);
  2282. blk = zzaRet = zzaArg(zztasp2,2); --BlkLevel;
  2283.  zzCONSUME;
  2285. {
  2286. zzBLOCK(zztasp3);
  2287. zzMake0;
  2288. {
  2289. if ( (LA(1)==128) ) {
  2290. zzmatch(128);
  2291. zzaRet = makeLoop(zzaRet,approx);
  2292.  zzCONSUME;
  2294. }
  2295. else {
  2296. if ( (LA(1)==129) ) {
  2297. zzmatch(129);
  2298. zzaRet = makePlus(zzaRet,approx);
  2299.  zzCONSUME;
  2301. }
  2302. else {
  2303. if ( (LA(1)==130) ) {
  2304. zzmatch(130); zzCONSUME;
  2305. {
  2306. zzBLOCK(zztasp4);
  2307. zzMake0;
  2308. {
  2309. if ( (setwd5[LA(1)]&0x4) ) {
  2310. {
  2311. zzBLOCK(zztasp5);
  2312. zzMake0;
  2313. {
  2314. if ( (LA(1)==131) ) {
  2315. zzmatch(131);
  2316. ampersandStyle=0;
  2317.  zzCONSUME;
  2319. }
  2320. else {
  2321. if ( (LA(1)==111) ) {
  2322. zzmatch(111);
  2323. ampersandStyle=1;
  2324.  zzCONSUME;
  2326. }
  2327. else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2328. }
  2329. zzEXIT(zztasp5);
  2330. }
  2331. }
  2332. zzmatch(Pred);
  2333. zzaRet = buildAction(LATEXT(1),action_file,action_line,1);
  2334.  zzCONSUME;
  2336. act = (ActionNode *) ((Junction *)zzaRet.left)->p1;
  2337. semDepth=predicateLookaheadDepth(act);
  2338. if (numericActionLabel) {             /* MR10 */
  2339. list_add(&NumericPredLabels,act);   /* MR10 */
  2340. numericActionLabel=0;               /* MR10 */
  2341. };                                    /* MR10 */
  2342. {
  2343. zzBLOCK(zztasp5);
  2344. zzMake0;
  2345. {
  2346. char *a;
  2347. if ( (LA(1)==PassAction) ) {
  2348. zzmatch(PassAction);
  2350. a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
  2351. require(a!=NULL, "rule element: cannot allocate predicate fail action");
  2352. strcpy(a, LATEXT(1));
  2353. act->pred_fail = a;
  2354.  zzCONSUME;
  2356. }
  2357. zzEXIT(zztasp5);
  2358. }
  2359. }
  2360. if ( first_on_line) {                      /* MR7 */
  2361. CurAltStart=(Junction *)zzaRet.left;         /* MR7 */
  2362. altAdd(CurAltStart);                     /* MR7 */
  2363. };
  2364. _retv = (Node *)act;
  2366. pred = computePredicateFromContextGuard(blk,&predMsgDone);      /* MR10 */
  2367. if ( pred==NULL) {                                              /* MR10 */
  2368. if ( !predMsgDone) err("invalid or missing context guard");   /* MR10 */
  2369. predMsgDone=1;                                                /* MR10 */
  2370. } else {                                                        /* MR10 */
  2371. act->guardNodes=(Junction *)blk.left;                       /* MR11 */
  2372. pred->expr = act->action;
  2373. pred->source = act;
  2374. /* MR10 */                  pred->ampersandStyle = ampersandStyle;  /* 0 means (g)? => ... 1 means (g)? && ... */
  2375. /* MR13 */                  if (pred->tcontext != NULL) {
  2376. /* MR13 */                    height=MR_max_height_of_tree(pred->tcontext);
  2377. /* MR13 */                    equal_height=MR_all_leaves_same_height(pred->tcontext,height);
  2378. /* MR13 */                    if (! equal_height) {
  2379. /* MR13 */                       errFL("in guarded predicates all tokens in the guard must be at the same height",
  2380. /* MR13 */                              FileStr[act->file],act->line);
  2381. /* MR13 */                    };
  2382. /* MR13 */                  }
  2383. /* MR10 */                  if (ampersandStyle) {
  2384. /* MR10 */      act->ampersandPred = pred;
  2385. /* MR11 */                    if (! HoistPredicateContext) {
  2386. /* MR11 */                      errFL("without "-prc on" (guard)? && <<pred>>? ... doesn't make sense",
  2387. /* MR11 */                              FileStr[act->file],act->line);
  2388. /* MR11 */                    };
  2389. /* MR10 */                  } else {
  2390. /* MR10 */      act->guardpred = pred;
  2391. /* MR10 */                  };
  2392. /* MR10 */                  if (pred->k != semDepth) {
  2393. /* MR10 */                     warn(eMsgd2("length of guard (%d) does not match the length of semantic predicate (%d)",
  2394. /* MR10 */                                  pred->k,semDepth));
  2395. /* MR10 */                  };
  2396. }
  2397. }
  2398. else {
  2399. if ( (setwd5[LA(1)]&0x8) ) {
  2400. zzaRet = makeBlk(zzaRet,approx);
  2401. FoundGuessBlk = 1;
  2402. ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
  2403. if ( ! first_on_line ) {
  2404. err("(...)? predicate must be first element of production");
  2405. }
  2406. }
  2407. else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2408. }
  2409. zzEXIT(zztasp4);
  2410. }
  2411. }
  2412. }
  2413. else {
  2414. if ( (setwd5[LA(1)]&0x10) ) {
  2415. zzaRet = makeBlk(zzaRet,approx);
  2416. }
  2417. else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2418. }
  2419. }
  2420. }
  2421. zzEXIT(zztasp3);
  2422. }
  2423. }
  2425. if ( pred==NULL && !predMsgDone) {                                      /* MR10 */
  2426. ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
  2427. ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  2428. ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  2429. if (  first_on_line ) {                         /* MR7 */
  2430. CurAltStart = (Junction *)((Junction *)((Junction *)zzaRet.left)->p1);  /* MR7 */
  2431. altAdd(CurAltStart);                         /* MR7 */
  2432. };                                              /* MR7 */
  2433. _retv = (Node *) ((Junction *)zzaRet.left)->p1;
  2434. }
  2435. }
  2436. else {
  2437. if ( (LA(1)==100) ) {
  2438. zzmatch(100); zzCONSUME;
  2439. block( &toksrefd,&rulesrefd );
  2440. zzaRet = makeOpt(zzaArg(zztasp2,2),approx); --BlkLevel;
  2441. zzmatch(96);
  2443. ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
  2444. ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  2445. ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  2446.  zzCONSUME;
  2448. if (  first_on_line ) {                            /* MR7 */
  2449. CurAltStart = (Junction *) ((Junction *)((Junction *)zzaRet.left)->p1);  /* MR7 */
  2450. altAdd(CurAltStart);                             /* MR7 */
  2451. };
  2452. _retv = (Node *) ((Junction *)zzaRet.left)->p1;
  2453. }
  2454. else {zzFAIL(1,zzerr19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2455. }
  2456. zzEXIT(zztasp2);
  2457. }
  2458. }
  2459. }
  2460. else {
  2461. if ( (LA(1)==128) ) {
  2462. zzmatch(128);
  2463. warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;
  2464.  zzCONSUME;
  2466. }
  2467. else {
  2468. if ( (LA(1)==129) ) {
  2469. zzmatch(129);
  2470. warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;
  2471.  zzCONSUME;
  2473. }
  2474. else {
  2475. if ( (LA(1)==103) ) {
  2476. zzmatch(103);
  2477. warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;
  2478.  zzCONSUME;
  2480. }
  2481. else {
  2482. if ( (LA(1)==PassAction) ) {
  2483. zzmatch(PassAction);
  2484. warn("[...] out of context 'rule > [...]'");
  2485. CannotContinue=TRUE;
  2486.  zzCONSUME;
  2488. }
  2489. else {zzFAIL(1,zzerr20,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2490. }
  2491. }
  2492. }
  2493. }
  2494. }
  2495. }
  2496. }
  2497. zzEXIT(zztasp1);
  2498. return _retv;
  2499. fail:
  2500. zzEXIT(zztasp1);
  2501. CannotContinue=TRUE;
  2502. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2503. zzresynch(setwd5, 0x20);
  2504. return _retv;
  2505. }
  2506. }
  2508. void
  2509. #ifdef __USE_PROTOS
  2510. default_exception_handler(void)
  2511. #else
  2512. default_exception_handler()
  2513. #endif
  2514. {
  2515. zzRULE;
  2516. zzBLOCK(zztasp1);
  2517. zzMake0;
  2518. {
  2519.  DefaultExGroup  = exception_group();
  2521. zzEXIT(zztasp1);
  2522. return;
  2523. fail:
  2524. zzEXIT(zztasp1);
  2525. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2526. zzresynch(setwd5, 0x40);
  2527. }
  2528. }
  2530.  ExceptionGroup *
  2531. #ifdef __USE_PROTOS
  2532. exception_group(void)
  2533. #else
  2534. exception_group()
  2535. #endif
  2536. {
  2537.  ExceptionGroup *   _retv;
  2538. zzRULE;
  2539. zzBLOCK(zztasp1);
  2540. PURIFY(_retv,sizeof( ExceptionGroup *  ))
  2541. zzMake0;
  2542. {
  2543. ExceptionHandler *h; LabelEntry *label=NULL;   /* MR6 */
  2544. FoundException = 1; FoundExceptionGroup = 1;
  2545. zzmatch(132);
  2546. _retv = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));
  2547.  zzCONSUME;
  2549. {
  2550. zzBLOCK(zztasp2);
  2551. zzMake0;
  2552. {
  2553. char *p;
  2554. if ( (LA(1)==PassAction) ) {
  2555. zzmatch(PassAction);
  2557. p = LATEXT(1)+1;
  2558. p[strlen(p)-1] = ''; /* kill trailing space */
  2559. label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
  2560. if ( label==NULL )
  2561. {
  2562. err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
  2563. }
  2564.  zzCONSUME;
  2566. }
  2567. zzEXIT(zztasp2);
  2568. }
  2569. }
  2570. {
  2571. zzBLOCK(zztasp2);
  2572. zzMake0;
  2573. {
  2574. while ( (LA(1)==134) ) {
  2575.  h  = exception_handler();
  2577. list_add(&(_retv->handlers), (void *)h);
  2578. zzLOOP(zztasp2);
  2579. }
  2580. zzEXIT(zztasp2);
  2581. }
  2582. }
  2583. {
  2584. zzBLOCK(zztasp2);
  2585. zzMake0;
  2586. {
  2587. if ( (LA(1)==133) ) {
  2588. zzmatch(133); zzCONSUME;
  2589. zzmatch(104); zzCONSUME;
  2590. zzmatch(Action);
  2591. {
  2592. ExceptionHandler *eh = (ExceptionHandler *)
  2593. calloc(1, sizeof(ExceptionHandler));
  2594. char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2595. require(eh!=NULL, "exception: cannot allocate handler");
  2596. require(a!=NULL, "exception: cannot allocate action");
  2597. strcpy(a, LATEXT(1));
  2598. eh->action = a;
  2599. eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
  2600. require(eh->signalname!=NULL, "exception: cannot allocate sig name");
  2601. strcpy(eh->signalname, "default");
  2602. list_add(&(_retv->handlers), (void *)eh);
  2603. }
  2604.  zzCONSUME;
  2606. }
  2607. zzEXIT(zztasp2);
  2608. }
  2609. }
  2611. if ( label!=NULL ) {
  2612. /* Record ex group in sym tab for this label */
  2613. if ( label->ex_group!=NULL ) {
  2614. err(eMsg1("duplicate exception handler for label '%s'",label->str));
  2615. } else {
  2616. label->ex_group = _retv;
  2617. /* Label the exception group itself */
  2618. _retv->label = label->str;
  2619. /* Make the labelled element pt to the exception also */
  2620. /* MR6 */   if (label->elem == NULL) {
  2621. /* MR6 */      err(eMsg1("reference in exception handler to undefined label '%s'",label->str));
  2622. /* MR6 */   } else {
  2623. switch ( label->elem->ntype ) {
  2624. case nRuleRef :
  2625. {
  2626. RuleRefNode *r = (RuleRefNode *)label->elem;
  2627. r->ex_group = _retv;
  2628. break;
  2629. }
  2630. case nToken :
  2631. {
  2632. TokNode *t = (TokNode *)label->elem;
  2633. t->ex_group = _retv;
  2634. break;
  2635. }
  2636. } /* end switch */
  2637. /* MR6 */   }; /* end test on label->elem */
  2638. } /* end test on label->ex_group */
  2640. } /* end test on exception label */
  2642. /* MR7 */
  2643. /* MR7 */   if (BlkLevel == 1 && label == NULL) {
  2644. /* MR7 */     _retv->forRule=1;
  2645. /* MR7 */   } else if (label == NULL) {
  2646. /* MR7 */     _retv->altID = makeAltID(CurBlockID,CurAltNum);
  2647. /* MR7 */     egAdd(_retv);
  2648. /* MR7 */   } else {
  2649. /* MR7 */     _retv->labelEntry=label;
  2650. /* MR7 */   };
  2651. /* MR7 */
  2652. /* MR7 */     /* You may want to remove this exc from the rule list  */
  2653. /* MR7 */ /* and handle at the labeled element site.             */
  2654. /* MR7 */
  2655. /* MR7 */   if (label != NULL) {
  2656. /* MR7 */     _retv = NULL;
  2657. /* MR7 */   };
  2658. zzEXIT(zztasp1);
  2659. return _retv;
  2660. fail:
  2661. zzEXIT(zztasp1);
  2662. CannotContinue=TRUE;
  2663. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2664. zzresynch(setwd5, 0x80);
  2665. return _retv;
  2666. }
  2667. }
  2669.  ExceptionHandler *
  2670. #ifdef __USE_PROTOS
  2671. exception_handler(void)
  2672. #else
  2673. exception_handler()
  2674. #endif
  2675. {
  2676.  ExceptionHandler *   _retv;
  2677. zzRULE;
  2678. zzBLOCK(zztasp1);
  2679. PURIFY(_retv,sizeof( ExceptionHandler *  ))
  2680. zzMake0;
  2681. {
  2682. ;
  2683. zzmatch(134);
  2685. _retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
  2686. require(_retv!=NULL, "exception: cannot allocate handler");
  2687.  zzCONSUME;
  2689. {
  2690. zzBLOCK(zztasp2);
  2691. zzMake0;
  2692. {
  2693. if ( (LA(1)==NonTerminal) ) {
  2694. zzmatch(NonTerminal);
  2696. _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2697. require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
  2698. strcpy(_retv->signalname, LATEXT(1));
  2699.  zzCONSUME;
  2701. }
  2702. else {
  2703. if ( (LA(1)==TokenTerm) ) {
  2704. zzmatch(TokenTerm);
  2706. _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2707. require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
  2708. strcpy(_retv->signalname, LATEXT(1));
  2709.  zzCONSUME;
  2711. }
  2712. else {zzFAIL(1,zzerr21,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2713. }
  2714. zzEXIT(zztasp2);
  2715. }
  2716. }
  2717. zzmatch(104); zzCONSUME;
  2718. {
  2719. zzBLOCK(zztasp2);
  2720. zzMake0;
  2721. {
  2722. _retv->action = NULL;
  2723. if ( (LA(1)==Action) ) {
  2724. zzmatch(Action);
  2726. _retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2727. require(_retv->action!=NULL, "exception: cannot allocate action");
  2728. strcpy(_retv->action, LATEXT(1));
  2729.  zzCONSUME;
  2731. }
  2732. zzEXIT(zztasp2);
  2733. }
  2734. }
  2735. zzEXIT(zztasp1);
  2736. return _retv;
  2737. fail:
  2738. zzEXIT(zztasp1);
  2739. CannotContinue=TRUE;
  2740. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2741. zzresynch(setwd6, 0x1);
  2742. return _retv;
  2743. }
  2744. }
  2746. void
  2747. #ifdef __USE_PROTOS
  2748. enum_file( char *fname )
  2749. #else
  2750. enum_file(fname)
  2751.  char *fname ;
  2752. #endif
  2753. {
  2754. zzRULE;
  2755. zzBLOCK(zztasp1);
  2756. zzMake0;
  2757. {
  2758. if ( (setwd6[LA(1)]&0x2) ) {
  2759. {
  2760. zzBLOCK(zztasp2);
  2761. zzMake0;
  2762. {
  2763. if ( (LA(1)==142) ) {
  2764. zzmatch(142); zzCONSUME;
  2765. zzmatch(ID); zzCONSUME;
  2766. {
  2767. zzBLOCK(zztasp3);
  2768. zzMake0;
  2769. {
  2770. if ( (LA(1)==148) ) {
  2771. zzmatch(148); zzCONSUME;
  2772. zzmatch(ID); zzCONSUME;
  2773. }
  2774. zzEXIT(zztasp3);
  2775. }
  2776. }
  2777. }
  2778. zzEXIT(zztasp2);
  2779. }
  2780. }
  2781. {
  2782. zzBLOCK(zztasp2);
  2783. zzMake0;
  2784. {
  2785. if ( (LA(1)==150) ) {
  2786. {
  2787. zzBLOCK(zztasp3);
  2788. int zzcnt=1;
  2789. zzMake0;
  2790. {
  2791. do {
  2792. enum_def(  fname );
  2793. zzLOOP(zztasp3);
  2794. } while ( (LA(1)==150) );
  2795. zzEXIT(zztasp3);
  2796. }
  2797. }
  2798. }
  2799. else {
  2800. if ( (LA(1)==148) ) {
  2801. defines(  fname );
  2802. }
  2803. else {zzFAIL(1,zzerr22,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2804. }
  2805. zzEXIT(zztasp2);
  2806. }
  2807. }
  2808. }
  2809. else {
  2810. if ( (LA(1)==Eof) ) {
  2811. }
  2812. else {zzFAIL(1,zzerr23,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2813. }
  2814. zzEXIT(zztasp1);
  2815. return;
  2816. fail:
  2817. zzEXIT(zztasp1);
  2818. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2819. zzresynch(setwd6, 0x4);
  2820. }
  2821. }
  2823. void
  2824. #ifdef __USE_PROTOS
  2825. defines( char *fname )
  2826. #else
  2827. defines(fname)
  2828.  char *fname ;
  2829. #endif
  2830. {
  2831. zzRULE;
  2832. zzBLOCK(zztasp1);
  2833. zzMake0;
  2834. {
  2835. int v; int maxt=(-1); char *t;
  2836. {
  2837. zzBLOCK(zztasp2);
  2838. int zzcnt=1;
  2839. zzMake0;
  2840. {
  2841. do {
  2842. zzmatch(148); zzCONSUME;
  2843. zzmatch(ID);
  2844. t = mystrdup(LATEXT(1));
  2845.  zzCONSUME;
  2847. zzmatch(INT);
  2849. v = atoi(LATEXT(1));
  2850. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2852. /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
  2853. /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
  2854. /* MR2 Don't let #tokdefs be confused by  */
  2855. /* MR2   DLGminToken and DLGmaxToken      */
  2857. if ( ! isDLGmaxToken(t)) { /* MR2 */
  2858. TokenNum = v;
  2859. if ( v>maxt ) maxt=v;
  2860. if ( Tnum( t ) == 0 ) {
  2861. addForcedTname( t, v );
  2862. } else {
  2863. warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2864. };
  2865. };
  2866.  zzCONSUME;
  2868. zzLOOP(zztasp2);
  2869. } while ( (LA(1)==148) );
  2870. zzEXIT(zztasp2);
  2871. }
  2872. }
  2873. TokenNum = maxt + 1;
  2874. zzEXIT(zztasp1);
  2875. return;
  2876. fail:
  2877. zzEXIT(zztasp1);
  2878. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2879. zzresynch(setwd6, 0x8);
  2880. }
  2881. }
  2883. void
  2884. #ifdef __USE_PROTOS
  2885. enum_def( char *fname )
  2886. #else
  2887. enum_def(fname)
  2888.  char *fname ;
  2889. #endif
  2890. {
  2891. zzRULE;
  2892. zzBLOCK(zztasp1);
  2893. zzMake0;
  2894. {
  2895. int v= 0; int maxt=(-1); char *t;
  2896. zzmatch(150); zzCONSUME;
  2897. zzmatch(ID); zzCONSUME;
  2898. zzmatch(151); zzCONSUME;
  2899. zzmatch(ID);
  2900. t = mystrdup(LATEXT(1));
  2901.  zzCONSUME;
  2903. {
  2904. zzBLOCK(zztasp2);
  2905. zzMake0;
  2906. {
  2907. if ( (LA(1)==152) ) {
  2908. zzmatch(152); zzCONSUME;
  2909. zzmatch(INT);
  2910. v=atoi(LATEXT(1));
  2911.  zzCONSUME;
  2913. }
  2914. else {
  2915. if ( (setwd6[LA(1)]&0x10) ) {
  2916. v++;
  2917. }
  2918. else {zzFAIL(1,zzerr24,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2919. }
  2920. zzEXIT(zztasp2);
  2921. }
  2922. }
  2924. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2925. TokenNum = v;
  2926. if ( v>maxt ) maxt=v; /* MR3 */
  2927. if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2928. else {
  2929. warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2930. }
  2931. {
  2932. zzBLOCK(zztasp2);
  2933. zzMake0;
  2934. {
  2935. while ( (LA(1)==153) ) {
  2936. zzmatch(153); zzCONSUME;
  2937. {
  2938. zzBLOCK(zztasp3);
  2939. zzMake0;
  2940. {
  2941. if ( (LA(1)==ID)&&(isDLGmaxToken(LATEXT(1))) ) {
  2942. if (!(isDLGmaxToken(LATEXT(1)))) {zzfailed_pred("  isDLGmaxToken(LATEXT(1))");}
  2943. zzmatch(ID); zzCONSUME;
  2944. {
  2945. zzBLOCK(zztasp4);
  2946. zzMake0;
  2947. {
  2948. if ( (LA(1)==152) ) {
  2949. zzmatch(152); zzCONSUME;
  2950. zzmatch(INT); zzCONSUME;
  2951. }
  2952. zzEXIT(zztasp4);
  2953. }
  2954. }
  2955. }
  2956. else {
  2957. if ( (LA(1)==ID) ) {
  2958. zzmatch(ID);
  2959. t = mystrdup(LATEXT(1));
  2960.  zzCONSUME;
  2962. {
  2963. zzBLOCK(zztasp4);
  2964. zzMake0;
  2965. {
  2966. if ( (LA(1)==152) ) {
  2967. zzmatch(152); zzCONSUME;
  2968. zzmatch(INT);
  2969. v=atoi(LATEXT(1));
  2970.  zzCONSUME;
  2972. }
  2973. else {
  2974. if ( (setwd6[LA(1)]&0x20) ) {
  2975. v++;
  2976. }
  2977. else {zzFAIL(1,zzerr25,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2978. }
  2979. zzEXIT(zztasp4);
  2980. }
  2981. }
  2983. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2984. TokenNum = v;
  2985. if ( v>maxt ) maxt=v; /* MR3 */
  2986. if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2987. else {
  2988. warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2989. }
  2990. }
  2991. }
  2992. zzEXIT(zztasp3);
  2993. }
  2994. }
  2995. zzLOOP(zztasp2);
  2996. }
  2997. zzEXIT(zztasp2);
  2998. }
  2999. }
  3000. zzmatch(154); zzCONSUME;
  3001. zzmatch(155);
  3002. TokenNum = maxt + 1;
  3003.  zzCONSUME;
  3005. zzEXIT(zztasp1);
  3006. return;
  3007. fail:
  3008. zzEXIT(zztasp1);
  3009. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  3010. zzresynch(setwd6, 0x40);
  3011. }
  3012. }
  3015. /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
  3016. /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
  3017. /* MR2 Don't let #tokdefs be confused by  */
  3018. /* MR2   DLGminToken and DLGmaxToken      */
  3020. /* semantic check on DLGminToken and DLGmaxmaxToken in #tokdefs */
  3022. #ifdef __USE_PROTOS
  3023. static int isDLGmaxToken(char *Token)
  3024. #else
  3025. static int isDLGmaxToken(Token)
  3026. char * Token;
  3027. #endif
  3028. {
  3029. static char checkStr1[] = "DLGmaxToken";
  3030. static char checkStr2[] = "DLGminToken";
  3032.    if (strcmp(Token, checkStr1) == 0)
  3033. return 1;
  3034. else if (strcmp(Token, checkStr2) == 0)
  3035. return 1;
  3036. else
  3037. return 0;
  3038. }
  3040. /* semantics of #token */
  3041. static void
  3042. #ifdef __USE_PROTOS
  3043. chkToken(char *t, char *e, char *a, int tnum)
  3044. #else
  3045. chkToken(t,e,a,tnum)
  3046. char *t, *e, *a;
  3047. int tnum;
  3048. #endif
  3049. {
  3050. TermEntry *p;
  3052. /* check to see that they don't try to redefine a token as a token class */
  3053. if ( t!=NULL ) {
  3054. p = (TermEntry *) hash_get(Tname, t);
  3055. if ( p!=NULL && p->classname ) {
  3056. err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
  3057. if ( a!=NULL ) free((char *)a);
  3058. return;
  3059. }
  3060. }
  3062. if ( t==NULL && e==NULL ) { /* none found */
  3063. err("#token requires at least token name or rexpr");
  3064. }
  3065. else if ( t!=NULL && e!=NULL ) { /* both found */
  3066. if ( UserDefdTokens ) { /* if #tokdefs, must not define new */
  3067. p = (TermEntry *) hash_get(Tname, t);
  3068. if ( p == NULL) {
  3069. err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
  3070. return;
  3071. };
  3072. }
  3073. Tklink(t, e);
  3074. if ( a!=NULL ) {
  3075. if ( hasAction(e) ) {
  3076. err(eMsg1("redefinition of action for %s; ignored",e));
  3077. }
  3078. else setHasAction(e, a);
  3079. }
  3080. }
  3081. else if ( t!=NULL ) { /* only one found */
  3082. if ( UserDefdTokens ) {
  3083. p = (TermEntry *) hash_get(Tname, t);
  3084. if (p == NULL) {
  3085. err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
  3086. };
  3087. return;
  3088. }
  3089. if ( Tnum( t ) == 0 ) addTname( t );
  3090. else {
  3091. err(eMsg1("redefinition of token %s; ignored",t));
  3092. }
  3093. if ( a!=NULL ) {
  3094. err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  3095. free((char *)a);
  3096. }
  3097. }
  3098. else if ( e!=NULL ) {
  3099. if ( Tnum( e ) == 0 ) addTexpr( e );
  3100. else {
  3101. if ( hasAction(e) ) {
  3102. err(eMsg1("redefinition of action for expr %s; ignored",e));
  3103. }
  3104. else if ( a==NULL ) {
  3105. err(eMsg1("redefinition of expr %s; ignored",e));
  3106. }
  3107. }
  3108. if ( a!=NULL ) setHasAction(e, a);
  3109. }
  3111. /* if a token type number was specified, then add the token ID and 'tnum'
  3112. * pair to the ForcedTokens list.  (only applies if an id was given)
  3113. */
  3114. if ( t!=NULL && tnum>0 )
  3115. {
  3116. if ( set_el(tnum, reserved_positions) )
  3117. {
  3118. err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
  3119. }
  3120. else
  3121. {
  3122. list_add(&ForcedTokens, newForcedToken(t,tnum));
  3123. set_orel(tnum, &reserved_positions);
  3124. }
  3125. }
  3126. }
  3128. static int
  3129. #ifdef __USE_PROTOS
  3130. match_token(char *s, char **nxt)
  3131. #else
  3132. match_token(s,nxt)
  3133. char *s;
  3134. char **nxt;
  3135. #endif
  3136. {
  3137. if ( !(*s>='A' && *s<='Z') ) return 0;
  3138. s++;
  3139. while ( (*s>='a' && *s<='z') ||
  3140. (*s>='A' && *s<='Z') ||
  3141. (*s>='0' && *s<='9') ||
  3142. *s=='_' )
  3143. {
  3144. s++;
  3145. }
  3146. if ( *s!=' ' && *s!='}' ) return 0;
  3147. *nxt = s;
  3148. return 1;
  3149. }
  3151. static int
  3152. #ifdef __USE_PROTOS
  3153. match_rexpr(char *s, char **nxt)
  3154. #else
  3155. match_rexpr(s,nxt)
  3156. char *s;
  3157. char **nxt;
  3158. #endif
  3159. {
  3160. if ( *s!='"' ) return 0;
  3161. s++;
  3162. while ( *s!='"' )
  3163. {
  3164. if ( *s=='n' || *s=='r' )                   /* MR13 */
  3165. warn("eoln found in regular expression");
  3166. if ( *s=='\' ) s++;
  3167. s++;
  3168. }
  3169. *nxt = s+1;
  3170. return 1;
  3171. }
  3173. /*
  3174. * Walk a string "{ A .. Z }" where A..Z is a space separated list
  3175. * of token references (either labels or reg exprs).  Return a
  3176. * string "inlineX_set" for some unique integer X.  Basically,
  3177. * we pretend as if we had seen "#tokclass inlineX { A .. Z }"
  3178. * on the input stream outside of an action.
  3179. */
  3180. char *
  3181. #ifdef __USE_PROTOS
  3182. inline_set(char *s)
  3183. #else
  3184. inline_set(s)
  3185. char *s;
  3186. #endif
  3187. {
  3188. char *nxt;
  3189. fprintf(stderr, "found consumeUntil( {...} )n");
  3190. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  3191. if ( *s!='{' )
  3192. {
  3193. err("malformed consumeUntil( {...} ); missing '{'");
  3194. return "bad_set";
  3195. }
  3196. s++;
  3197. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  3198. while ( *s!='}' )
  3199. {
  3200. if ( match_token(s,&nxt) ) fprintf(stderr, "found token %sn", s);
  3201. else if ( match_rexpr(s,&nxt) ) fprintf(stderr, "found rexpr %sn", s);
  3202. else {
  3203. err("invalid element in consumeUntil( {...} )");
  3204. return "bad_set";
  3205. }
  3206. s = nxt;
  3207. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  3208. }
  3209. return "inlineX_set";
  3210. }
  3212. /* ANTLR-specific syntax error message generator
  3213. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  3214. */
  3215. void
  3216. #ifdef __USE_PROTOS
  3217. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok,
  3218. int k, char *bad_text)
  3219. #else
  3220. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  3221. char *text, *egroup, *bad_text;
  3222. int tok;
  3223. int etok;
  3224. int k;
  3225. SetWordType *eset;
  3226. #endif
  3227. {
  3228. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  3229. fprintf(stderr, " syntax error at "%s"", (tok==zzEOF_TOKEN)?"EOF":text);
  3230. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  3231. if ( k==1 ) fprintf(stderr, " missing");
  3232. else
  3233. {
  3234. fprintf(stderr, "; "%s" not", bad_text);
  3235. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  3236. }
  3237. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  3238. else fprintf(stderr, " %s", zztokens[etok]);
  3239. if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
  3240. fprintf(stderr, "n");
  3241. }