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

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

编译器/解释器

开发平台：

Others

dlg_p.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 dlg_p.g
  10.  *
  11.  */
  13. #define ANTLR_VERSION 13314
  14. #include "pcctscfg.h"
  15. #include PCCTS_STDIO_H
  17. #include <ctype.h>
  18. #include "dlg.h"
  19. #ifdef MEMCHK
  20. #include "trax.h"
  21. #endif
  22. #define zzSET_SIZE 8
  23. #include "antlr.h"
  24. #include "tokens.h"
  25. #include "dlgdef.h"
  26. #include "mode.h"
  27. #ifndef PURIFY
  28. #define PURIFY(r,s) memset((char *) &(r),'',(s));
  29. #endif
  30. ANTLR_INFO
  32. int action_no = 0;    /* keep track of actions outputed */
  33. int nfa_allocated = 0; /* keeps track of number of nfa nodes */
  34. nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
  35. nfa_node nfa_model_node;   /* model to initialize new nodes */
  36. set used_chars;    /* used to label trans. arcs */
  37. set used_classes;    /* classes or chars used to label trans. arcs */
  38. set normal_chars;    /* mask to get rid elements that aren't used
  39. in set */
  40. int flag_paren = FALSE;
  41. int flag_brace = FALSE;
  42. int mode_counter = 0;  /* keep track of number of %%names */
  46. void
  47. #ifdef __USE_PROTOS
  48. grammar(void)
  49. #else
  50. grammar()
  51. #endif
  52. {
  53. zzRULE;
  54. zzBLOCK(zztasp1);
  55. zzMake0;
  56. {
  57. p_head(); p_class_hdr(); func_action = FALSE;
  58. {
  59. zzBLOCK(zztasp2);
  60. zzMake0;
  61. {
  62. while ( (setwd1[LA(1)]&0x1) ) {
  63. {
  64. zzBLOCK(zztasp3);
  65. zzMake0;
  66. {
  67. if ( (LA(1)==LEXACTION) ) {
  68. zzmatch(LEXACTION); zzCONSUME;
  69. }
  70. else {
  71. if ( (LA(1)==LEXMEMBER) ) {
  72. zzmatch(LEXMEMBER); zzCONSUME;
  73. }
  74. else {
  75. if ( (LA(1)==LEXPREFIX) ) {
  76. zzmatch(LEXPREFIX); zzCONSUME;
  77. }
  78. else {
  79. if ( (LA(1)==PARSERCLASS) ) {
  80. zzmatch(PARSERCLASS); zzCONSUME;
  81. }
  82. }
  83. }
  84. }
  85. zzEXIT(zztasp3);
  86. }
  87. }
  88. zzmatch(ACTION); zzCONSUME;
  89. zzLOOP(zztasp2);
  90. }
  91. zzEXIT(zztasp2);
  92. }
  93. }
  94. if ( gen_cpp ) p_includes();
  95. start_states();
  96. func_action = FALSE; p_tables(); p_tail();
  97. {
  98. zzBLOCK(zztasp2);
  99. zzMake0;
  100. {
  101. while ( (LA(1)==ACTION) ) {
  102. zzmatch(ACTION); zzCONSUME;
  103. zzLOOP(zztasp2);
  104. }
  105. zzEXIT(zztasp2);
  106. }
  107. }
  108. zzmatch(1);
  109. if (firstLexMember != 0) p_class_def1();
  110.  zzCONSUME;
  112. zzEXIT(zztasp1);
  113. return;
  114. fail:
  115. zzEXIT(zztasp1);
  116. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  117. zzresynch(setwd1, 0x2);
  118. }
  119. }
  121. void
  122. #ifdef __USE_PROTOS
  123. start_states(void)
  124. #else
  125. start_states()
  126. #endif
  127. {
  128. zzRULE;
  129. zzBLOCK(zztasp1);
  130. zzMake0;
  131. {
  132. {
  133. zzBLOCK(zztasp2);
  134. zzMake0;
  135. {
  136. if ( (LA(1)==PER_PER) ) {
  137. zzmatch(PER_PER); zzCONSUME;
  138. do_conversion();
  139. }
  140. else {
  141. if ( (LA(1)==NAME_PER_PER) ) {
  142. zzmatch(NAME_PER_PER); zzCONSUME;
  143. do_conversion();
  144. {
  145. zzBLOCK(zztasp3);
  146. zzMake0;
  147. {
  148. while ( (LA(1)==NAME_PER_PER) ) {
  149. zzmatch(NAME_PER_PER); zzCONSUME;
  150. do_conversion();
  151. zzLOOP(zztasp3);
  152. }
  153. zzEXIT(zztasp3);
  154. }
  155. }
  156. }
  157. else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  158. }
  159. zzEXIT(zztasp2);
  160. }
  161. }
  162. zzmatch(PER_PER); zzCONSUME;
  163. zzEXIT(zztasp1);
  164. return;
  165. fail:
  166. zzEXIT(zztasp1);
  167. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  168. zzresynch(setwd1, 0x4);
  169. }
  170. }
  172. void
  173. #ifdef __USE_PROTOS
  174. do_conversion(void)
  175. #else
  176. do_conversion()
  177. #endif
  178. {
  179. zzRULE;
  180. zzBLOCK(zztasp1);
  181. zzMake0;
  182. {
  183. new_automaton_mode(); func_action = TRUE;
  184. rule_list();
  186. dfa_class_nop[mode_counter] =
  187. relabel(zzaArg(zztasp1,1 ).l,comp_level);
  188. if (comp_level)
  189. p_shift_table(mode_counter);
  190. dfa_basep[mode_counter] = dfa_allocated+1;
  191. make_dfa_model_node(dfa_class_nop[mode_counter]);
  192. nfa_to_dfa(zzaArg(zztasp1,1 ).l);
  193. ++mode_counter;
  194. func_action = FALSE;
  195. #ifdef HASH_STAT
  196. fprint_hash_stats(stderr);
  197. #endif
  198. zzEXIT(zztasp1);
  199. return;
  200. fail:
  201. zzEXIT(zztasp1);
  202. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  203. zzresynch(setwd1, 0x8);
  204. }
  205. }
  207. void
  208. #ifdef __USE_PROTOS
  209. rule_list(void)
  210. #else
  211. rule_list()
  212. #endif
  213. {
  214. zzRULE;
  215. zzBLOCK(zztasp1);
  216. zzMake0;
  217. {
  218. if ( (setwd1[LA(1)]&0x10) ) {
  219. rule();
  220. zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
  221. {
  222. zzBLOCK(zztasp2);
  223. zzMake0;
  224. {
  225. while ( (setwd1[LA(1)]&0x20) ) {
  226. rule();
  227. {nfa_node *t1;
  228. t1 = new_nfa_node();
  229. (t1)->trans[0]=zzaRet.l;
  230. (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
  231. /* all accept nodes "dead ends" */
  232. zzaRet.l=t1; zzaRet.r=NULL;
  233. }
  234. zzLOOP(zztasp2);
  235. }
  236. zzEXIT(zztasp2);
  237. }
  238. }
  239. }
  240. else {
  241. if ( (setwd1[LA(1)]&0x40) ) {
  242. zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
  243. warning("no regular expressions", zzline);
  244. }
  245. else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  246. }
  247. zzEXIT(zztasp1);
  248. return;
  249. fail:
  250. zzEXIT(zztasp1);
  251. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  252. zzresynch(setwd1, 0x80);
  253. }
  254. }
  256. void
  257. #ifdef __USE_PROTOS
  258. rule(void)
  259. #else
  260. rule()
  261. #endif
  262. {
  263. zzRULE;
  264. zzBLOCK(zztasp1);
  265. zzMake0;
  266. {
  267. if ( (setwd2[LA(1)]&0x1) ) {
  268. reg_expr();
  269. zzmatch(ACTION);
  270. zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;
  271.  zzCONSUME;
  273. }
  274. else {
  275. if ( (LA(1)==ACTION) ) {
  276. zzmatch(ACTION);
  277. zzaRet.l = NULL; zzaRet.r = NULL;
  278. error("no expression for action  ", zzline);
  279.  zzCONSUME;
  281. }
  282. else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  283. }
  284. zzEXIT(zztasp1);
  285. return;
  286. fail:
  287. zzEXIT(zztasp1);
  288. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  289. zzresynch(setwd2, 0x2);
  290. }
  291. }
  293. void
  294. #ifdef __USE_PROTOS
  295. reg_expr(void)
  296. #else
  297. reg_expr()
  298. #endif
  299. {
  300. zzRULE;
  301. zzBLOCK(zztasp1);
  302. zzMake0;
  303. {
  304. and_expr();
  305. zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
  306. {
  307. zzBLOCK(zztasp2);
  308. zzMake0;
  309. {
  310. while ( (LA(1)==OR) ) {
  311. zzmatch(OR); zzCONSUME;
  312. and_expr();
  313. {nfa_node *t1, *t2;
  314. t1 = new_nfa_node(); t2 = new_nfa_node();
  315. (t1)->trans[0]=zzaRet.l;
  316. (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
  317. (zzaRet.r)->trans[1]=t2;
  318. (zzaArg(zztasp2,2 ).r)->trans[1]=t2;
  319. zzaRet.l=t1; zzaRet.r=t2;
  320. }
  321. zzLOOP(zztasp2);
  322. }
  323. zzEXIT(zztasp2);
  324. }
  325. }
  326. zzEXIT(zztasp1);
  327. return;
  328. fail:
  329. zzEXIT(zztasp1);
  330. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  331. zzresynch(setwd2, 0x4);
  332. }
  333. }
  335. void
  336. #ifdef __USE_PROTOS
  337. and_expr(void)
  338. #else
  339. and_expr()
  340. #endif
  341. {
  342. zzRULE;
  343. zzBLOCK(zztasp1);
  344. zzMake0;
  345. {
  346. repeat_expr();
  347. zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
  348. {
  349. zzBLOCK(zztasp2);
  350. zzMake0;
  351. {
  352. while ( (setwd2[LA(1)]&0x8) ) {
  353. repeat_expr();
  354. (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l; zzaRet.r=zzaArg(zztasp2,1 ).r;
  355. zzLOOP(zztasp2);
  356. }
  357. zzEXIT(zztasp2);
  358. }
  359. }
  360. zzEXIT(zztasp1);
  361. return;
  362. fail:
  363. zzEXIT(zztasp1);
  364. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  365. zzresynch(setwd2, 0x10);
  366. }
  367. }
  369. void
  370. #ifdef __USE_PROTOS
  371. repeat_expr(void)
  372. #else
  373. repeat_expr()
  374. #endif
  375. {
  376. zzRULE;
  377. zzBLOCK(zztasp1);
  378. zzMake0;
  379. {
  380. if ( (setwd2[LA(1)]&0x20) ) {
  381. expr();
  382. zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
  383. {
  384. zzBLOCK(zztasp2);
  385. zzMake0;
  386. {
  387. if ( (LA(1)==ZERO_MORE) ) {
  388. zzmatch(ZERO_MORE);
  389. { nfa_node *t1,*t2;
  390. (zzaRet.r)->trans[0] = zzaRet.l;
  391. t1 = new_nfa_node(); t2 = new_nfa_node();
  392. t1->trans[0]=zzaRet.l;
  393. t1->trans[1]=t2;
  394. (zzaRet.r)->trans[1]=t2;
  395. zzaRet.l=t1;zzaRet.r=t2;
  396. }
  397.  zzCONSUME;
  399. }
  400. else {
  401. if ( (LA(1)==ONE_MORE) ) {
  402. zzmatch(ONE_MORE);
  403. (zzaRet.r)->trans[0] = zzaRet.l;
  404.  zzCONSUME;
  406. }
  407. }
  408. zzEXIT(zztasp2);
  409. }
  410. }
  411. }
  412. else {
  413. if ( (LA(1)==ZERO_MORE) ) {
  414. zzmatch(ZERO_MORE);
  415. error("no expression for *", zzline);
  416.  zzCONSUME;
  418. }
  419. else {
  420. if ( (LA(1)==ONE_MORE) ) {
  421. zzmatch(ONE_MORE);
  422. error("no expression for +", zzline);
  423.  zzCONSUME;
  425. }
  426. else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  427. }
  428. }
  429. zzEXIT(zztasp1);
  430. return;
  431. fail:
  432. zzEXIT(zztasp1);
  433. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  434. zzresynch(setwd2, 0x40);
  435. }
  436. }
  438. void
  439. #ifdef __USE_PROTOS
  440. expr(void)
  441. #else
  442. expr()
  443. #endif
  444. {
  445. zzRULE;
  446. zzBLOCK(zztasp1);
  447. zzMake0;
  448. {
  449. zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  450. if ( (LA(1)==L_BRACK) ) {
  451. zzmatch(L_BRACK); zzCONSUME;
  452. atom_list();
  453. zzmatch(R_BRACK);
  455. (zzaRet.l)->trans[0] = zzaRet.r;
  456. (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
  457. set_orin(&used_chars,(zzaRet.l)->label);
  458.  zzCONSUME;
  460. }
  461. else {
  462. if ( (LA(1)==NOT) ) {
  463. zzmatch(NOT); zzCONSUME;
  464. zzmatch(L_BRACK); zzCONSUME;
  465. atom_list();
  466. zzmatch(R_BRACK);
  468. (zzaRet.l)->trans[0] = zzaRet.r;
  469. (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
  470. set_orin(&used_chars,(zzaRet.l)->label);
  471.  zzCONSUME;
  473. }
  474. else {
  475. if ( (LA(1)==L_PAR) ) {
  476. zzmatch(L_PAR); zzCONSUME;
  477. reg_expr();
  478. zzmatch(R_PAR);
  480. (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  481. (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  482.  zzCONSUME;
  484. }
  485. else {
  486. if ( (LA(1)==L_BRACE) ) {
  487. zzmatch(L_BRACE); zzCONSUME;
  488. reg_expr();
  489. zzmatch(R_BRACE);
  491. (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  492. (zzaRet.l)->trans[1] = zzaRet.r;
  493. (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  494.  zzCONSUME;
  496. }
  497. else {
  498. if ( (setwd2[LA(1)]&0x80) ) {
  499. atom();
  501. (zzaRet.l)->trans[0] = zzaRet.r;
  502. (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
  503. set_orin(&used_chars,(zzaRet.l)->label);
  504. }
  505. else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  506. }
  507. }
  508. }
  509. }
  510. zzEXIT(zztasp1);
  511. return;
  512. fail:
  513. zzEXIT(zztasp1);
  514. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  515. zzresynch(setwd3, 0x1);
  516. }
  517. }
  519. void
  520. #ifdef __USE_PROTOS
  521. atom_list(void)
  522. #else
  523. atom_list()
  524. #endif
  525. {
  526. zzRULE;
  527. zzBLOCK(zztasp1);
  528. zzMake0;
  529. {
  530. set_free(zzaRet.label);
  531. {
  532. zzBLOCK(zztasp2);
  533. zzMake0;
  534. {
  535. while ( (setwd3[LA(1)]&0x2) ) {
  536. near_atom();
  537. set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);
  538. zzLOOP(zztasp2);
  539. }
  540. zzEXIT(zztasp2);
  541. }
  542. }
  543. zzEXIT(zztasp1);
  544. return;
  545. fail:
  546. zzEXIT(zztasp1);
  547. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  548. zzresynch(setwd3, 0x4);
  549. }
  550. }
  552. void
  553. #ifdef __USE_PROTOS
  554. near_atom(void)
  555. #else
  556. near_atom()
  557. #endif
  558. {
  559. zzRULE;
  560. zzBLOCK(zztasp1);
  561. zzMake0;
  562. {
  563. register int i;
  564. register int i_prime;
  565. anychar();
  566. zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
  567. i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  568. if (case_insensitive && islower(i_prime))
  569. set_orel(toupper(i_prime)-MIN_CHAR,
  570. &(zzaRet.label));
  571. if (case_insensitive && isupper(i_prime))
  572. set_orel(tolower(i_prime)-MIN_CHAR,
  573. &(zzaRet.label));
  574. {
  575. zzBLOCK(zztasp2);
  576. zzMake0;
  577. {
  578. if ( (LA(1)==RANGE) ) {
  579. zzmatch(RANGE); zzCONSUME;
  580. anychar();
  581. if (case_insensitive){
  582. i_prime = zzaRet.letter+MIN_CHAR;
  583. zzaRet.letter = (islower(i_prime) ?
  584. toupper(i_prime) : i_prime)-MIN_CHAR;
  585. i_prime = zzaArg(zztasp2,2 ).letter+MIN_CHAR;
  586. zzaArg(zztasp2,2 ).letter = (islower(i_prime) ?
  587. toupper(i_prime) : i_prime)-MIN_CHAR;
  588. }
  589. /* check to see if range okay */
  590. if (zzaRet.letter > zzaArg(zztasp2,2 ).letter){
  591. error("invalid range  ", zzline);
  592. }
  593. for (i=zzaRet.letter; i<= (int)zzaArg(zztasp2,2 ).letter; ++i){
  594. set_orel(i,&(zzaRet.label));
  595. i_prime = i+MIN_CHAR;
  596. if (case_insensitive && islower(i_prime))
  597. set_orel(toupper(i_prime)-MIN_CHAR,
  598. &(zzaRet.label));
  599. if (case_insensitive && isupper(i_prime))
  600. set_orel(tolower(i_prime)-MIN_CHAR,
  601. &(zzaRet.label));
  602. }
  603. }
  604. zzEXIT(zztasp2);
  605. }
  606. }
  607. zzEXIT(zztasp1);
  608. return;
  609. fail:
  610. zzEXIT(zztasp1);
  611. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  612. zzresynch(setwd3, 0x8);
  613. }
  614. }
  616. void
  617. #ifdef __USE_PROTOS
  618. atom(void)
  619. #else
  620. atom()
  621. #endif
  622. {
  623. zzRULE;
  624. zzBLOCK(zztasp1);
  625. zzMake0;
  626. {
  627. register int i_prime;
  628. anychar();
  629. zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
  630. i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  631. if (case_insensitive && islower(i_prime))
  632. set_orel(toupper(i_prime)-MIN_CHAR,
  633. &(zzaRet.label));
  634. if (case_insensitive && isupper(i_prime))
  635. set_orel(tolower(i_prime)-MIN_CHAR,
  636. &(zzaRet.label));
  637. zzEXIT(zztasp1);
  638. return;
  639. fail:
  640. zzEXIT(zztasp1);
  641. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  642. zzresynch(setwd3, 0x10);
  643. }
  644. }
  646. void
  647. #ifdef __USE_PROTOS
  648. anychar(void)
  649. #else
  650. anychar()
  651. #endif
  652. {
  653. zzRULE;
  654. zzBLOCK(zztasp1);
  655. zzMake0;
  656. {
  657. if ( (LA(1)==REGCHAR) ) {
  658. zzmatch(REGCHAR);
  659. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  660.  zzCONSUME;
  662. }
  663. else {
  664. if ( (LA(1)==OCTAL_VALUE) ) {
  665. zzmatch(OCTAL_VALUE);
  666. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  667.  zzCONSUME;
  669. }
  670. else {
  671. if ( (LA(1)==HEX_VALUE) ) {
  672. zzmatch(HEX_VALUE);
  673. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  674.  zzCONSUME;
  676. }
  677. else {
  678. if ( (LA(1)==DEC_VALUE) ) {
  679. zzmatch(DEC_VALUE);
  680. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  681.  zzCONSUME;
  683. }
  684. else {
  685. if ( (LA(1)==TAB) ) {
  686. zzmatch(TAB);
  687. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  688.  zzCONSUME;
  690. }
  691. else {
  692. if ( (LA(1)==NL) ) {
  693. zzmatch(NL);
  694. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  695.  zzCONSUME;
  697. }
  698. else {
  699. if ( (LA(1)==CR) ) {
  700. zzmatch(CR);
  701. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  702.  zzCONSUME;
  704. }
  705. else {
  706. if ( (LA(1)==BS) ) {
  707. zzmatch(BS);
  708. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  709.  zzCONSUME;
  711. }
  712. else {
  713. if ( (LA(1)==LIT) ) {
  714. zzmatch(LIT);
  715. zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
  716.  zzCONSUME;
  718. }
  719. else {
  720. if ( (LA(1)==L_EOF) ) {
  721. zzmatch(L_EOF);
  722. zzaRet.letter = 0;
  723.  zzCONSUME;
  725. }
  726. else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  727. }
  728. }
  729. }
  730. }
  731. }
  732. }
  733. }
  734. }
  735. }
  736. zzEXIT(zztasp1);
  737. return;
  738. fail:
  739. zzEXIT(zztasp1);
  740. /* empty action */
  741. zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  742. zzresynch(setwd3, 0x20);
  743. }
  744. }
  746. /* adds a new nfa to the binary tree and returns a pointer to it */
  747. nfa_node *new_nfa_node()
  748. {
  749. register nfa_node *t;
  750. static int nfa_size=0; /* elements nfa_array[] can hold */
  752. ++nfa_allocated;
  753. if (nfa_size<=nfa_allocated){
  754. /* need to redo array */
  755. if (!nfa_array){
  756. /* need some to do inital allocation */
  757. nfa_size=nfa_allocated+NFA_MIN;
  758. nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
  759. nfa_size);
  760. }else{
  761. /* need more space */
  762. nfa_size=2*(nfa_allocated+1);
  763. nfa_array=(nfa_node **) realloc(nfa_array,
  764. sizeof(nfa_node*)*nfa_size);
  765. }
  766. }
  767. /* fill out entry in array */
  768. t = (nfa_node*) malloc(sizeof(nfa_node));
  769. nfa_array[nfa_allocated] = t;
  770. *t = nfa_model_node;
  771. t->node_no = nfa_allocated;
  772. return t;
  773. }
  776. /* initialize the model node used to fill in newly made nfa_nodes */
  777. void
  778. make_nfa_model_node()
  779. {
  780. nfa_model_node.node_no = -1; /* impossible value for real nfa node */
  781. nfa_model_node.nfa_set = 0;
  782. nfa_model_node.accept = 0;   /* error state default*/
  783. nfa_model_node.trans[0] = NULL;
  784. nfa_model_node.trans[1] = NULL;
  785. nfa_model_node.label = empty;
  786. }
  788. #ifdef DEBUG
  790. /* print out the pointer value and the node_number */
  791. fprint_dfa_pair(f, p)
  792. FILE *f;
  793. nfa_node *p;
  794. {
  795. if (p){
  796. fprintf(f, "%x (%d)", p, p->node_no);
  797. }else{
  798. fprintf(f, "(nil)");
  799. }
  800. }
  802. /* print out interest information on a set */
  803. fprint_set(f,s)
  804. FILE *f;
  805. set s;
  806. {
  807. unsigned int *x;
  809. fprintf(f, "n = %d,", s.n);
  810. if (s.setword){
  811. fprintf(f, "setword = %x,   ", s.setword);
  812. /* print out all the elements in the set */
  813. x = set_pdq(s);
  814. while (*x!=nil){
  815. fprintf(f, "%d ", *x);
  816. ++x;
  817. }
  818. }else{
  819. fprintf(f, "setword = (nil)");
  820. }
  821. }
  823. /* code to be able to dump out the nfas
  824. return 0 if okay dump
  825. return 1 if screwed up
  826. */
  827. int dump_nfas(first_node, last_node)
  828. int first_node;
  829. int last_node;
  830. {
  831. register int i;
  832. nfa_node *t;
  834. for (i=first_node; i<=last_node; ++i){
  835. t = NFA(i);
  836. if (!t) break;
  837. fprintf(stderr, "nfa_node %d {n", t->node_no);
  838. fprintf(stderr, "ntnfa_set = %dn", t->nfa_set);
  839. fprintf(stderr, "tacceptt=t%dn", t->accept);
  840. fprintf(stderr, "ttranst=t(");
  841. fprint_dfa_pair(stderr, t->trans[0]);
  842. fprintf(stderr, ",");
  843. fprint_dfa_pair(stderr, t->trans[1]);
  844. fprintf(stderr, ")n");
  845. fprintf(stderr, "tlabelt=t{ ");
  846. fprint_set(stderr, t->label);
  847. fprintf(stderr, "t}n");
  848. fprintf(stderr, "}nn");
  849. }
  850. return 0;
  851. }
  852. #endif
  854. /* DLG-specific syntax error message generator
  855. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  856. */
  857. void
  858. #ifdef __USE_PROTOS
  859. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  860. #else
  861. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  862. char *text, *egroup, *bad_text;
  863. int tok;
  864. int etok;
  865. int k;
  866. SetWordType *eset;
  867. #endif
  868. {
  869. fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
  870. fprintf(stderr, " syntax error at "%s"", (tok==zzEOF_TOKEN)?"EOF":text);
  871. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  872. if ( k==1 ) fprintf(stderr, " missing");
  873. else
  874. {
  875. fprintf(stderr, "; "%s" not", bad_text);
  876. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  877. }
  878. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  879. else fprintf(stderr, " %s", zztokens[etok]);
  880. if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
  881. fprintf(stderr, "n");
  882. }