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

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

编译器/解释器

开发平台：

Others

dlg_p.g：源码内容
  1. /*  This is the parser for the dlg
  2.  *  This is a part of the Purdue Compiler Construction Tool Set
  3.  *
  4.  * SOFTWARE RIGHTS
  5.  *
  6.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  7.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  8.  * company may do whatever they wish with source code distributed with
  9.  * PCCTS or the code generated by PCCTS, including the incorporation of
  10.  * PCCTS, or its output, into commerical software.
  11.  *
  12.  * We encourage users to develop software with PCCTS.  However, we do ask
  13.  * that credit is given to us for developing PCCTS.  By "credit",
  14.  * we mean that if you incorporate our source code into one of your
  15.  * programs (commercial product, research project, or otherwise) that you
  16.  * acknowledge this fact somewhere in the documentation, research report,
  17.  * etc...  If you like PCCTS and have developed a nice tool with the
  18.  * output, please mention that you developed it using PCCTS.  In
  19.  * addition, we ask that this header remain intact in our source code.
  20.  * As long as these guidelines are kept, we expect to continue enhancing
  21.  * this system and expect to make other tools available as they are
  22.  * completed.
  23.  *
  24.  * DLG 1.33
  25.  * Will Cohen
  26.  * With mods by Terence Parr; AHPCRC, University of Minnesota
  27.  * 1989-1995
  28.  */
  30. #header <<
  31. #include <ctype.h>
  32. #include "dlg.h"
  33. #ifdef MEMCHK
  34. #include "trax.h"
  35. #endif
  36. >>
  38. <<
  39. int action_no = 0;    /* keep track of actions outputed */
  40. int nfa_allocated = 0; /* keeps track of number of nfa nodes */
  41. nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
  42. nfa_node nfa_model_node;   /* model to initialize new nodes */
  43. set used_chars;    /* used to label trans. arcs */
  44. set used_classes;    /* classes or chars used to label trans. arcs */
  45. set normal_chars;    /* mask to get rid elements that aren't used
  46.       in set */
  47. int flag_paren = FALSE;
  48. int flag_brace = FALSE;
  49. int mode_counter = 0;  /* keep track of number of %%names */
  51. >>
  53. #lexaction <<
  54. int func_action; /* should actions be turned into functions?*/
  55. int lex_mode_counter = 0; /* keeps track of the number of %%names */
  56. /* MR1     */
  57. /* MR1  11-Apr-97 Provide mechanism for inserting code into DLG class */
  58. /* MR1 via <<%%lexmember...>>     */
  59. /* MR1     */
  60. int lexMember = 0; /* <<%%lexmemeber ...>>     MR1 */
  61. int lexAction = 0; /* <<%%lexaction ...>> MR1 */
  62. int parserClass = 0; /* <<%%parserclass ...>>        MR1 */
  63. int lexPrefix = 0; /* <<%%lexprefix ...>> MR1 */
  64. char theClassName[100];      /* MR11 */
  65. char *pClassName=theClassName;  /* MR11 */
  66. int firstLexMember=1;              /* MR1 */
  68. #ifdef __USE_PROTOS
  69. void  xxputc(int c) { /* MR1 */
  70. #else
  71. void xxputc(c) /* MR1 */
  72.   int c; /* MR1 */
  73. { /* MR1 */
  74. #endif
  75.   if (parserClass) { /* MR1 */
  76.     *pClassName++=c; /* MR1 */
  77.     *pClassName=0; /* MR1 */
  78.   } else if (lexMember || lexPrefix) { /* MR1 */
  79.     if (class_stream != NULL) fputc(c,class_stream); /* MR1 */
  80.   } else { /* MR1 */
  81.     fputc(c,OUT); /* MR1 */
  82.   }; /* MR1 */
  83. }   /* MR1 */
  85. #ifdef __USE_PROTOS
  86. void xxprintf(char *format,char *string) { /* MR1 */
  87. #else
  88. void xxprintf(format,string)  /* MR1 */
  89.   char *format; /* MR1 */
  90.   char *string; /* MR1 */
  91. { /* MR1 */
  92. #endif
  93.   if (lexMember || lexPrefix || parserClass) { /* MR1 */
  94.     if (class_stream != NULL) /* MR1 */
  95.  fprintf(class_stream,format,string); /* MR1 */
  96.   } else { /* MR1 */
  97.     fprintf(OUT,format,string); /* MR1 */
  98.   }; /* MR1 */
  99. }   /* MR1 */
  100. >>
  102. #token "[rt ]+" << zzskip(); >> /* Ignore white */
  103. #token "n" << zzline++; zzskip(); DAWDLE; >> /* Track Line # */
  104. #token L_EOF "@"
  105. #token PER_PER "%%"
  106. #token NAME_PER_PER "%%[a-zA-Z_][a-zA-Z0-9_]*"
  107. << p_mode_def(&zzlextext[2],lex_mode_counter++); >>
  109. #token LEXMEMBER "<<%%lexmember" /* MR1 */
  110. <<lexMember=1; /* MR1 */
  111.           if (firstLexMember != 0) { /* MR1 */
  112.             firstLexMember=0; /* MR1 */
  113.             p_class_def1(); /* MR1 */
  114.   }; /* MR1 */
  115.           zzmode(ACT); /* MR1 */
  116.                 >> /* MR1 */
  117. #token LEXACTION "<<%%lexaction" /* MR1 */
  118. <<lexAction=1;zzmode(ACT);>> /* MR1 */
  119. #token PARSERCLASS "<<%%parserclass" /* MR1 */
  120. <<parserClass=1; /* MR1 */
  121.   zzmode(ACT); /* MR1 */
  122. >> /* MR1 */
  123. #token LEXPREFIX "<<%%lexprefix" /* MR1 */
  124. <<lexPrefix=1;zzmode(ACT);>> /* MR1 */
  126. #token ACTION "<<"
  127. << if (func_action)
  128. fprintf(OUT,"n%s %sact%d()n{ ",
  129. gen_cpp?"ANTLRTokenType":"static void",
  130. gen_cpp?ClassName("::"):"", ++action_no);
  131.    zzmode(ACT); zzskip();
  132. >>
  133. #token GREAT_GREAT ">>"
  134. #token L_BRACE "{"
  135. #token R_BRACE "}"
  136. #token L_PAR "("
  137. #token R_PAR ")"
  138. #token L_BRACK "["
  139. #token R_BRACK "]"
  140. #token ZERO_MORE "*"
  141. #token ONE_MORE "+"
  142. #token OR "|"
  143. #token RANGE "-"
  144. #token NOT "~"
  145. #token OCTAL_VALUE "\0[0-7]*"
  146. << {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}>>
  147. #token HEX_VALUE   "\0[Xx][0-9a-fA-F]+"
  148. << {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}>>
  149. #token DEC_VALUE   "\[1-9][0-9]*"
  150. << {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}>>
  151. #token TAB "\t" << zzlextext[0] = 't';>>
  152. #token NL "\n" << zzlextext[0] = 'n';>>
  153. #token CR "\r" << zzlextext[0] = 'r';>>
  154. #token BS "\b" << zzlextext[0] = 'b';>>
  156. /* MR1 */
  157. /* MR1 10-Apr-97 MR1 Allow #token regular expressions to cross lines */
  158. /* MR1 */
  159. #token CONTINUATION "\ n" << zzline++; zzskip();>> /* MR1 */
  161. /* NOTE: this takes ANYTHING after the  */
  162. #token LIT "\~[tnrb]" << zzlextext[0] = zzlextext[1];>>
  164. /* NOTE: this takes ANYTHING that doesn't match the other tokens */
  165. #token REGCHAR "~[\]"
  168. grammar :   << p_head(); p_class_hdr(); func_action = FALSE;>>
  169.  ( {LEXACTION | LEXMEMBER | LEXPREFIX | PARSERCLASS } ACTION)* /* MR1 */
  170.     <<if ( gen_cpp ) p_includes();>>
  171.     start_states
  172.     << func_action = FALSE; p_tables(); p_tail(); >>
  173.     (ACTION)* "@"
  174. << if (firstLexMember != 0) p_class_def1(); >>  /* MR1 */
  175. ;
  177. start_states : ( PER_PER do_conversion
  178.   | NAME_PER_PER do_conversion (NAME_PER_PER do_conversion)*)
  179.     PER_PER
  180. ;
  182. do_conversion : <<new_automaton_mode(); func_action = TRUE;>>
  183. rule_list
  184. <<
  185. dfa_class_nop[mode_counter] =
  186. relabel($1.l,comp_level);
  187. if (comp_level)
  188. p_shift_table(mode_counter);
  189. dfa_basep[mode_counter] = dfa_allocated+1;
  190. make_dfa_model_node(dfa_class_nop[mode_counter]);
  191. nfa_to_dfa($1.l);
  192. ++mode_counter;
  193.      func_action = FALSE;
  194. #ifdef HASH_STAT
  195. fprint_hash_stats(stderr);
  196. #endif
  197. >>
  198. ;
  200. rule_list : rule <<$$.l=$1.l; $$.r=$1.r;>>
  201. (rule
  202. <<{nfa_node *t1;
  203.    t1 = new_nfa_node();
  204.    (t1)->trans[0]=$$.l;
  205.    (t1)->trans[1]=$1.l;
  206.    /* all accept nodes "dead ends" */
  207.    $$.l=t1; $$.r=NULL;
  208.    }
  209. >>
  210. )*
  211. | /* empty */
  212. <<$$.l = new_nfa_node(); $$.r = NULL;
  213.    warning("no regular expressions", zzline);
  214. >>
  215. ;
  217. rule : reg_expr ACTION
  218. <<$$.l=$1.l; $$.r=$1.r; ($1.r)->accept=action_no;>>
  219. | ACTION
  220. <<$$.l = NULL; $$.r = NULL;
  221.   error("no expression for action  ", zzline);
  222. >>
  223. ;
  225. reg_expr : and_expr <<$$.l=$1.l; $$.r=$1.r;>>
  226. (OR and_expr
  227. <<{nfa_node *t1, *t2;
  228.    t1 = new_nfa_node(); t2 = new_nfa_node();
  229.    (t1)->trans[0]=$$.l;
  230.    (t1)->trans[1]=$2.l;
  231.    ($$.r)->trans[1]=t2;
  232.    ($2.r)->trans[1]=t2;
  233.    $$.l=t1; $$.r=t2;
  234.   }
  235. >>
  236. )*
  237. ;
  239. and_expr : repeat_expr <<$$.l=$1.l; $$.r=$1.r;>>
  240. (repeat_expr <<($$.r)->trans[1]=$1.l; $$.r=$1.r;>>)*
  241. ;
  243. repeat_expr : expr <<$$.l=$1.l; $$.r=$1.r;>>
  244. { ZERO_MORE
  245. <<{ nfa_node *t1,*t2;
  246. ($$.r)->trans[0] = $$.l;
  247. t1 = new_nfa_node(); t2 = new_nfa_node();
  248. t1->trans[0]=$$.l;
  249. t1->trans[1]=t2;
  250. ($$.r)->trans[1]=t2;
  251. $$.l=t1;$$.r=t2;
  252.   }
  253. >>
  254. | ONE_MORE
  255. <<($$.r)->trans[0] = $$.l;>>
  256. }
  257. | ZERO_MORE
  258. << error("no expression for *", zzline);>>
  259. | ONE_MORE
  260. << error("no expression for +", zzline);>>
  261. ;
  263. expr : << $$.l = new_nfa_node(); $$.r = new_nfa_node(); >>
  264.   L_BRACK atom_list R_BRACK
  265. <<
  266. ($$.l)->trans[0] = $$.r;
  267. ($$.l)->label = set_dup($2.label);
  268. set_orin(&used_chars,($$.l)->label);
  269. >>
  270. | NOT L_BRACK atom_list R_BRACK
  271. <<
  272. ($$.l)->trans[0] = $$.r;
  273. ($$.l)->label = set_dif(normal_chars,$3.label);
  274. set_orin(&used_chars,($$.l)->label);
  275. >>
  276. | L_PAR reg_expr R_PAR
  277. <<
  278. ($$.l)->trans[0] = $2.l;
  279. ($2.r)->trans[1] = $$.r;
  280. >>
  281. | L_BRACE reg_expr R_BRACE
  282. <<
  283. ($$.l)->trans[0] = $2.l;
  284. ($$.l)->trans[1] = $$.r;
  285. ($2.r)->trans[1] = $$.r;
  286. >>
  287. | atom
  288. <<
  289. ($$.l)->trans[0] = $$.r;
  290. ($$.l)->label = set_dup($1.label);
  291. set_orin(&used_chars,($$.l)->label);
  292. >>
  293. ;
  295. atom_list : << set_free($$.label); >>
  296. (near_atom <<set_orin(&($$.label),$1.label);>>)*
  297. ;
  299. near_atom : << register int i;
  300.      register int i_prime;
  301.   >>
  302.   anychar
  303. <<$$.letter=$1.letter; $$.label=set_of($1.letter);
  304. i_prime = $1.letter + MIN_CHAR;
  305. if (case_insensitive && islower(i_prime))
  306. set_orel(toupper(i_prime)-MIN_CHAR,
  307. &($$.label));
  308. if (case_insensitive && isupper(i_prime))
  309.   set_orel(tolower(i_prime)-MIN_CHAR,
  310. &($$.label));
  311. >>
  312. { RANGE anychar
  313. << if (case_insensitive){
  314. i_prime = $$.letter+MIN_CHAR;
  315. $$.letter = (islower(i_prime) ?
  316. toupper(i_prime) : i_prime)-MIN_CHAR;
  317. i_prime = $2.letter+MIN_CHAR;
  318. $2.letter = (islower(i_prime) ?
  319. toupper(i_prime) : i_prime)-MIN_CHAR;
  320.    }
  321.    /* check to see if range okay */
  322.    if ($$.letter > $2.letter){
  323.   error("invalid range  ", zzline);
  324.    }
  325.    for (i=$$.letter; i<= (int)$2.letter; ++i){
  326. set_orel(i,&($$.label));
  327. i_prime = i+MIN_CHAR;
  328. if (case_insensitive && islower(i_prime))
  329. set_orel(toupper(i_prime)-MIN_CHAR,
  330. &($$.label));
  331. if (case_insensitive && isupper(i_prime))
  332.   set_orel(tolower(i_prime)-MIN_CHAR,
  333. &($$.label));
  334. }
  335. >>
  336. }
  337. ;
  339. atom : << register int i_prime;>>
  340.   anychar
  341.   <<$$.label = set_of($1.letter);
  342.     i_prime = $1.letter + MIN_CHAR;
  343.     if (case_insensitive && islower(i_prime))
  344. set_orel(toupper(i_prime)-MIN_CHAR,
  345. &($$.label));
  346.     if (case_insensitive && isupper(i_prime))
  347.   set_orel(tolower(i_prime)-MIN_CHAR,
  348. &($$.label));
  349.   >>
  350. ;
  352. anychar : REGCHAR <<$$.letter = $1.letter - MIN_CHAR;>>
  353. | OCTAL_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
  354. | HEX_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
  355. | DEC_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
  356. | TAB <<$$.letter = $1.letter - MIN_CHAR;>>
  357. | NL <<$$.letter = $1.letter - MIN_CHAR;>>
  358. | CR <<$$.letter = $1.letter - MIN_CHAR;>>
  359. | BS <<$$.letter = $1.letter - MIN_CHAR;>>
  360. | LIT <<$$.letter = $1.letter - MIN_CHAR;>>
  361. /* NOTE: LEX_EOF is ALWAYS shifted to 0 = MIN_CHAR - MIN_CHAR*/
  362. | L_EOF <<$$.letter = 0;>>
  363. ;
  365. <</* empty action */>>
  367. #lexclass ACT
  368. #token "@" << error("unterminated action", zzline); zzmode(START); >>
  369. #token ACTION ">>"
  370. << if (func_action) fprintf(OUT,"}nn");
  371.    zzmode(START);
  372. /* MR1     */
  373. /* MR1  11-Apr-97 Provide mechanism for inserting code into DLG class */
  374. /* MR1 via <<%%lexmember ...>>     */
  375. /* MR1 This is a consequence of not saving actions         */
  376. /* MR1     */
  377. /* MR1 */    parserClass=0;
  378. /* MR1 */    lexPrefix=0;
  379. /* MR1 */    lexAction=0;
  380. /* MR1 */    lexMember=0;
  381. >>
  382. #token ">" << xxputc(zzlextext[0]); zzskip(); >> /* MR1 */
  383. #token "\>" << xxputc('>'); zzskip(); >> /* MR1 */
  384. #token "\" << xxputc('\'); zzskip(); >> /* MR1 */
  385. #token "n" << xxputc(zzlextext[0]); ++zzline; zzskip(); >> /* MR1 */
  386. #token "/*" << zzmode(ACTION_COMMENTS); /* MR1 */
  387.    xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
  388. >> /* MR1 */
  389. #token "//" << zzmode(ACTION_CPP_COMMENTS); /* MR1 */
  390.    xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
  391. >> /* MR1 */
  392. #token "~[]" << xxputc(zzlextext[0]); zzskip(); >> /* MR1 */
  393. /* MR1 */
  394. #lexclass ACTION_COMMENTS /* MR1 */
  395. #token "*/" << zzmode(ACT); /* MR1 */
  396.    xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
  397. >> /* MR1 */
  398. #token "[nr]" << zzline++; xxputc(zzlextext[0]); zzskip();>> /* MR1 */
  399. #token "~[]" << xxputc(zzlextext[0]); zzskip();>> /* MR1 */
  400. /* MR1 */
  401. #lexclass ACTION_CPP_COMMENTS /* MR1 */
  402. #token "[nr]" << zzmode(ACT); zzline++; /* MR1 */
  403.    xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
  404. >> /* MR1 */
  405. #token "~[]" << xxputc(zzlextext[0]); zzskip();>> /* MR1 */
  407. <<
  408. /* adds a new nfa to the binary tree and returns a pointer to it */
  409. nfa_node *new_nfa_node()
  410. {
  411. register nfa_node *t;
  412. static int nfa_size=0; /* elements nfa_array[] can hold */
  414. ++nfa_allocated;
  415. if (nfa_size<=nfa_allocated){
  416. /* need to redo array */
  417. if (!nfa_array){
  418. /* need some to do inital allocation */
  419. nfa_size=nfa_allocated+NFA_MIN;
  420. nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
  421. nfa_size);
  422. }else{
  423. /* need more space */
  424. nfa_size=2*(nfa_allocated+1);
  425. nfa_array=(nfa_node **) realloc(nfa_array,
  426. sizeof(nfa_node*)*nfa_size);
  427. }
  428. }
  429. /* fill out entry in array */
  430. t = (nfa_node*) malloc(sizeof(nfa_node));
  431. nfa_array[nfa_allocated] = t;
  432. *t = nfa_model_node;
  433. t->node_no = nfa_allocated;
  434. return t;
  435. }
  438. /* initialize the model node used to fill in newly made nfa_nodes */
  439. void
  440. make_nfa_model_node()
  441. {
  442. nfa_model_node.node_no = -1; /* impossible value for real nfa node */
  443. nfa_model_node.nfa_set = 0;
  444. nfa_model_node.accept = 0;   /* error state default*/
  445. nfa_model_node.trans[0] = NULL;
  446. nfa_model_node.trans[1] = NULL;
  447. nfa_model_node.label = empty;
  448. }
  449. >>
  451. <<
  452. #ifdef DEBUG
  454. /* print out the pointer value and the node_number */
  455. fprint_dfa_pair(f, p)
  456. FILE *f;
  457. nfa_node *p;
  458. {
  459. if (p){
  460. fprintf(f, "%x (%d)", p, p->node_no);
  461. }else{
  462. fprintf(f, "(nil)");
  463. }
  464. }
  466. /* print out interest information on a set */
  467. fprint_set(f,s)
  468. FILE *f;
  469. set s;
  470. {
  471. unsigned int *x;
  473. fprintf(f, "n = %d,", s.n);
  474. if (s.setword){
  475. fprintf(f, "setword = %x,   ", s.setword);
  476. /* print out all the elements in the set */
  477. x = set_pdq(s);
  478. while (*x!=nil){
  479. fprintf(f, "%d ", *x);
  480. ++x;
  481. }
  482. }else{
  483. fprintf(f, "setword = (nil)");
  484. }
  485. }
  487. /* code to be able to dump out the nfas
  488. return 0 if okay dump
  489. return 1 if screwed up
  490.  */
  491. int dump_nfas(first_node, last_node)
  492. int first_node;
  493. int last_node;
  494. {
  495. register int i;
  496. nfa_node *t;
  498. for (i=first_node; i<=last_node; ++i){
  499. t = NFA(i);
  500. if (!t) break;
  501. fprintf(stderr, "nfa_node %d {n", t->node_no);
  502. fprintf(stderr, "ntnfa_set = %dn", t->nfa_set);
  503. fprintf(stderr, "tacceptt=t%dn", t->accept);
  504. fprintf(stderr, "ttranst=t(");
  505. fprint_dfa_pair(stderr, t->trans[0]);
  506. fprintf(stderr, ",");
  507. fprint_dfa_pair(stderr, t->trans[1]);
  508. fprintf(stderr, ")n");
  509. fprintf(stderr, "tlabelt=t{ ");
  510. fprint_set(stderr, t->label);
  511. fprintf(stderr, "t}n");
  512. fprintf(stderr, "}nn");
  513. }
  514. return 0;
  515. }
  516. #endif
  517. >>
  519. <<
  520. /* DLG-specific syntax error message generator
  521.  * (define USER_ZZSYN when compiling so don't get 2 definitions)
  522.  */
  523. void
  524. #ifdef __USE_PROTOS
  525. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  526. #else
  527. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  528. char *text, *egroup, *bad_text;
  529. int tok;
  530. int etok;
  531. int k;
  532. SetWordType *eset;
  533. #endif
  534. {
  535. fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
  536. fprintf(stderr, " syntax error at "%s"", (tok==zzEOF_TOKEN)?"EOF":text);
  537. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  538. if ( k==1 ) fprintf(stderr, " missing");
  539. else
  540. {
  541. fprintf(stderr, "; "%s" not", bad_text);
  542. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  543. }
  544. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  545. else fprintf(stderr, " %s", zztokens[etok]);
  546. if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
  547. fprintf(stderr, "n");
  548. }
  549. >>