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

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

编译器/解释器

开发平台：

Others

antlr.g：源码内容
  1. /*
  2.  * antlr.g -- PCCTS Version 1.xx ANTLR
  3.  *
  4.  * Parse an antlr input grammar and build a syntax-diagram.
  5.  *
  6.  * Written in itself (needs at least 1.06 to work)
  7.  *
  8.  * SOFTWARE RIGHTS
  9.  *
  10.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  11.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  12.  * company may do whatever they wish with source code distributed with
  13.  * PCCTS or the code generated by PCCTS, including the incorporation of
  14.  * PCCTS, or its output, into commerical software.
  15.  *
  16.  * We encourage users to develop software with PCCTS.  However, we do ask
  17.  * that credit is given to us for developing PCCTS.  By "credit",
  18.  * we mean that if you incorporate our source code into one of your
  19.  * programs (commercial product, research project, or otherwise) that you
  20.  * acknowledge this fact somewhere in the documentation, research report,
  21.  * etc...  If you like PCCTS and have developed a nice tool with the
  22.  * output, please mention that you developed it using PCCTS.  In
  23.  * addition, we ask that this header remain intact in our source code.
  24.  * As long as these guidelines are kept, we expect to continue enhancing
  25.  * this system and expect to make other tools available as they are
  26.  * completed.
  27.  *
  28.  * ANTLR 1.33
  29.  * Terence Parr
  30.  * Parr Research Corporation
  31.  * with Purdue University and AHPCRC, University of Minnesota
  32.  * 1989-1995
  33.  */
  35. /* MR1 */
  36. /* MR1 10-Apr-97 MR1 Replace #if logic with #include "pcctscfg.h" */
  37. /* MR1 */
  39. #header <<
  40. #include "set.h"
  41. #include <ctype.h>
  42. #include "syn.h"
  43. #include "hash.h"
  44. #include "generic.h"
  45. #define zzcr_attr(attr,tok,t)
  46. >>
  48. <<
  49. #ifdef __USE_PROTOS
  50. static void chkToken(char *, char *, char *, int);
  51. #else
  52. static void chkToken();
  53. #endif
  55. #ifdef __USE_PROTOS
  56. static int isDLGmaxToken(char *Token);      /* MR3 */
  57. #else
  58. static int isDLGmaxToken();                              /* MR3 */
  59. #endif
  61. static int class_nest_level = 0;
  62. extern int inAlt;
  63. extern set attribsRefdFromAction;
  64. extern int UsedOldStyleAttrib;
  65. extern int UsedNewStyleLabel;
  66. >>
  68. #lexaction <<
  69. /* maintained, but not used for now */
  70. set AST_nodes_refd_in_actions = set_init;
  71. int inAlt = 0;
  72. set attribsRefdFromAction;
  73. int UsedOldStyleAttrib = 0;
  74. int UsedNewStyleLabel = 0;
  75. #ifdef __USE_PROTOS
  76. char *inline_set(char *);
  77. #else
  78. char *inline_set();
  79. #endif
  81. /* MR1 10-Apr-97  MR1  Previously unable to put right shift operator     */
  82. /* MR1 in DLG action                     */
  84. int tokenActionActive=0;                                            /* MR1 */
  86. >>
  88. #lexclass STRINGS
  89. #token QuotedTerm """ << zzmode(START); >>
  90. #token "n|r|rn"      <<
  91. zzline++;
  92. warn("eoln found in string");
  93. zzskip();
  94. >>
  95. #token "\(n|r|rn)" << zzline++; zzmore(); >>
  96. #token "\~[]" << zzmore(); >>
  97. #token "~[nr"\]+" << zzmore(); >>
  99. #lexclass ACTION_STRINGS
  100. #token """ << zzmode(ACTIONS); zzmore(); >>
  101. #token "n|r|rn" <<
  102. zzline++;
  103. warn("eoln found in string (in user action)");
  104. zzskip();
  105. >>
  106. #token "\(n|r|rn)" << zzline++; zzmore(); >>
  107. #token "\~[]" << zzmore(); >>
  108. #token "~[nr"\]+" << zzmore(); >>
  110. #lexclass ACTION_CHARS
  111. #token "'" << zzmode(ACTIONS); zzmore(); >>
  112. #token "n|r|rn" <<
  113. zzline++;
  114. warn("eoln found in char literal (in user action)");
  115. zzskip();
  116. >>
  117. #token "\~[]" << zzmore(); >>
  118. #token "~[nr'\]+" << zzmore(); >>
  120. #lexclass ACTION_COMMENTS
  121. #token "*/" << zzmode(ACTIONS); zzmore(); >>
  122. #token "*" << zzmore(); >>
  123. #token "n|r|rn" << zzline++; zzmore(); DAWDLE; >>
  124. #token "~[nr*]+" << zzmore(); >>
  126. #lexclass TOK_DEF_COMMENTS
  127. #token "*/" << zzmode(PARSE_ENUM_FILE);
  128.                               zzmore(); >>
  129. #token "*" << zzmore(); >>
  130. #token "n|r|rn" << zzline++; zzmore(); DAWDLE; >>
  131. #token "~[nr*]+" << zzmore(); >>
  133. #lexclass TOK_DEF_CPP_COMMENTS
  134. #token "n|r|rn" << zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE; >>
  135. #token "~[nr]+" << zzskip(); >>
  137. #lexclass ACTION_CPP_COMMENTS
  138. #token "n|r|rn" << zzline++; zzmode(ACTIONS); zzmore(); DAWDLE; >>
  139. #token "~[nr]+" << zzmore(); >>
  141. #lexclass CPP_COMMENTS
  142. #token "n|r|rn" << zzline++; zzmode(START); zzskip(); DAWDLE; >>
  143. #token "~[nr]+" << zzskip(); >>
  145. #lexclass COMMENTS
  146. #token "*/" << zzmode(START); zzskip(); >>
  147. #token "*" << zzskip(); >>
  148. #token "n|r|rn" << zzline++; zzskip(); DAWDLE; >>
  149. #token "~[nr*]+" << zzskip(); >>
  151. /*
  152.  * This lexical class accepts actions of type [..] and <<..>>
  153.  *
  154.  * It translates the following special items for C:
  155.  *
  156.  * $j --> "zzaArg(current zztasp, j)"
  157.  * $i.j --> "zzaArg(zztaspi, j)"
  158.  * $i.nondigit> "zzaArg(current zztasp, i).nondigit"
  159.  * $$ --> "zzaRet"
  160.  * $alnum --> "alnum" (used to ref parameters)
  161.  * $rule --> "zzaRet"
  162.  * $retval --> "_retv.retval" if > 1 return values else "_retv"
  163.  * $[token, text] --> "zzconstr_attr(token, text)"
  164.  * $[] --> "zzempty_attr()"
  165.  *
  166.  * It translates the following special items for C++:
  167.  * (attributes are now stored with 'Token' and $i's are only
  168.  *  pointers to the Tokens.  Rules don't have attributes now.)
  169.  *
  170.  * $j --> "_tbj" where b is the block level
  171.  * $i.j --> "_tij"
  172.  * $j->nondigit> "_tbj->nondigit"
  173.  * $$ --> "$$"
  174.  * $alnum --> "alnum" (used to ref parameters)
  175.  * $rule --> "$rule"
  176.  * $retval --> "_retv.retval" if > 1 return values else "_retv"
  177.  * $[token, text] --> invalid
  178.  * $[] --> invalid
  179.  *
  180.  * And, for trees:
  181.  *
  182.  * #0 --> "(*_root)"
  183.  * #i --> "zzastArg(i)"
  184.  * #[args] --> "zzmk_ast(zzastnew(), args)"
  185.  * #[] --> "zzastnew()"
  186.  * #( root, child1, ..., childn )
  187.  * --> "zztmake(root, child1, ...., childn, NULL)"
  188.  * #() --> "NULL"
  189.  *
  190.  * For C++, ...
  191.  *
  192.  * #0 --> "(*_root)"
  193.  * #i --> "_astbi" where b is the block level
  194.  * #alnum --> "alnum_ast" (used to ref #label)
  195.  * #[args] --> "new AST(args)"
  196.  * #[] --> "new AST"
  197.  * #( root, child1, ..., childn )
  198.  * --> "AST::tmake(root, child1, ...., childn, NULL)"
  199.  * #() --> "NULL"
  200.  *
  201.  * To escape,
  202.  *
  203.  * ] --> ]
  204.  * ) --> )
  205.  * $ --> $
  206.  * # --> #
  207.  *
  208.  * A stack is used to nest action terminators because they can be nested
  209.  * like crazy:  << #[$[..],..] >>
  210.  */
  211. #lexclass ACTIONS
  212. #token Action ">>"        << /* these do not nest */
  213.                               zzmode(START);
  214.                               NLATEXT[0] = ' ';
  215.                               NLATEXT[1] = ' ';
  216.                               zzbegexpr[0] = ' ';
  217.                               zzbegexpr[1] = ' ';
  218.   if ( zzbufovf ) {
  219. err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
  220.   }
  222. /* MR1 10-Apr-97  MR1  Previously unable to put right shift operator */
  223. /* MR1 in DLG action */
  224. /* MR1 Doesn't matter what kind of action it is - reset*/
  226.       tokenActionActive=0;  /* MR1 */
  227.                             >>
  228. #token Pred ">>?" << /* these do not nest */
  229.                               zzmode(START);
  230.                               NLATEXT[0] = ' ';
  231.                               NLATEXT[1] = ' ';
  232.                               zzbegexpr[0] = '';
  233.   if ( zzbufovf ) {
  234. err( eMsgd("predicate buffer overflow; size %d",ZZLEXBUFSIZE));
  235.   };
  236. #ifdef __cplusplus__
  237. /* MR10 */                    list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
  238. #else
  239. #ifdef __STDC__
  240. /* MR10 */                    list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
  241. #else
  242. /* MR10 */                    list_apply(CurActionLabels,mark_label_used_in_sem_pred);
  243. #endif
  244. #endif
  245.                             >>
  246. #token PassAction "]" << if ( topint() == ']' ) {
  247.   popint();
  248.   if ( istackempty() ) /* terminate action */
  249.   {
  250.   zzmode(START);
  251.   NLATEXT[0] = ' ';
  252.   zzbegexpr[0] = ' ';
  253.   if ( zzbufovf ) {
  254. err( eMsgd("parameter buffer overflow; size %d",ZZLEXBUFSIZE));
  255.   }
  256.   }
  257.   else {
  258.   /* terminate $[..] and #[..] */
  259.   if ( GenCC ) zzreplstr("))");
  260.   else zzreplstr(")");
  261.   zzmore();
  262.   }
  263.    }
  264.    else if ( topint() == '|' ) { /* end of simple [...] */
  265.   popint();
  266.   zzmore();
  267.    }
  268.    else zzmore();
  269. >>
  270. #token "consumeUntil( [ t]* {~[}]+} [ t]* )"
  271.     <<
  272.     zzmore();
  273. zzreplstr(inline_set(zzbegexpr+
  274.   strlen("consumeUntil(")));
  275. >>
  276. #token "consumeUntil( ~[)]+ )"
  277. << zzmore(); >>
  278. #token "n|r|rn" << zzline++; zzmore(); DAWDLE; >>
  279. #token ">" << zzmore(); >>
  280. #token "$" << zzmore(); >>
  281. #token "$$" << if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
  282.    else err("$$ use invalid in C++ mode"); >>
  284. #token "$[]" << if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
  285.    else err("$[] use invalid in C++ mode"); >>
  286. #token "$[" <<
  287. pushint(']');
  288. if ( !GenCC ) zzreplstr("zzconstr_attr(");
  289. else err("$[..] use invalid in C++ mode");
  290. zzmore();
  291. >>
  292. #token "$[0-9]+" <<{
  293. static char buf[100];
  294.                             numericActionLabel=1;       /* MR10 */
  295. if ( strlen(zzbegexpr)>(size_t)85 )
  296. fatal("$i attrib ref too big");
  297. set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
  298. if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s)",
  299. BlkLevel-1,zzbegexpr+1);
  300. else sprintf(buf,"_t%d%s",
  301. BlkLevel-1,zzbegexpr+1);
  302. zzreplstr(buf);
  303. zzmore();
  304. UsedOldStyleAttrib = 1;
  305. if ( UsedNewStyleLabel )
  306. err("cannot mix old-style $i with new-style labels");
  307. }
  308. >>
  309. #token "$[0-9]+." <<{
  310. static char buf[100];
  311.                             numericActionLabel=1;       /* MR10 */
  312. if ( strlen(zzbegexpr)>(size_t)85 )
  313. fatal("$i.field attrib ref too big");
  314. zzbegexpr[strlen(zzbegexpr)-1] = ' ';
  315. set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
  316. if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s).",
  317. BlkLevel-1,zzbegexpr+1);
  318. else sprintf(buf,"_t%d%s.",
  319. BlkLevel-1,zzbegexpr+1);
  320. zzreplstr(buf);
  321. zzmore();
  322. UsedOldStyleAttrib = 1;
  323. if ( UsedNewStyleLabel )
  324. err("cannot mix old-style $i with new-style labels");
  325. }
  326. >>
  327. #token "$[0-9]+.[0-9]+" <<{
  328. static char buf[100];
  329. static char i[20], j[20];
  330. char *p,*q;
  331.                             numericActionLabel=1;       /* MR10 */
  332. if (strlen(zzbegexpr)>(size_t)85) fatal("$i.j attrib ref too big");
  333. for (p=zzbegexpr+1,q= &i[0]; *p!='.'; p++) {
  334. if ( q == &i[20] )
  335.  fatalFL("i of $i.j attrib ref too big",
  336.  FileStr[CurFile], zzline );
  337. *q++ = *p;
  338. }
  339. *q = '';
  340. for (p++, q= &j[0]; *p!=''; p++) {
  341. if ( q == &j[20] )
  342. fatalFL("j of $i.j attrib ref too big",
  343. FileStr[CurFile], zzline );
  344. *q++ = *p;
  345. }
  346. *q = '';
  347. if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%s,%s)",i,j);
  348. else sprintf(buf,"_t%s%s",i,j);
  349. zzreplstr(buf);
  350. zzmore();
  351. UsedOldStyleAttrib = 1;
  352. if ( UsedNewStyleLabel )
  353. err("cannot mix old-style $i with new-style labels");
  354. }
  355. >>
  356. #token "$[_a-zA-Z][_a-zA-Z0-9]*"
  357. <<{ static char buf[300]; LabelEntry *el;
  358. zzbegexpr[0] = ' ';
  359. if ( CurRule != NULL &&
  360.  strcmp(CurRule, &zzbegexpr[1])==0 ) {
  361. if ( !GenCC ) zzreplstr("zzaRet");
  362. }
  363. else if ( CurRetDef != NULL &&
  364.   strmember(CurRetDef, &zzbegexpr[1])) {
  365.  if ( HasComma( CurRetDef ) ) {
  366. require (strlen(zzbegexpr)<=(size_t)285,
  367.  "$retval attrib ref too big");
  368. sprintf(buf,"_retv.%s",&zzbegexpr[1]);
  369. zzreplstr(buf);
  370. }
  371. else zzreplstr("_retv");
  372. }
  373. else if ( CurParmDef != NULL &&
  374.   strmember(CurParmDef, &zzbegexpr[1])) {
  375. ;
  376. }
  377. else if ( Elabel==NULL ) {
  378. { err("$-variables in actions outside of rules are not allowed"); }
  379. } else if ( (el=(LabelEntry *)hash_get(Elabel, &zzbegexpr[1]))!=NULL ) {
  380. /* MR10 */
  381. /* MR10 */                      /* element labels might exist without an elem when */
  382. /* MR10 */                      /*  it is a forward reference (to a rule)          */
  383. /* MR10 */
  384. /* MR10 */ if ( GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) )
  385. /* MR10 */ { err(eMsg1("There are no token ptrs for rule references: '$%s'",&zzbegexpr[1])); }
  386. /* MR10 */
  387. /* MR10 */ if ( !GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) && GenAST) {
  388. /* MR10 */                          err("You can no longer use attributes returned by rules when also using ASTs");
  389. /* MR10 */                          err("   Use upward inheritance ("rule >[Attrib a] : ... <<$a=...>>")");
  390. /* MR10 */                      };
  391. /* MR10 */
  392. /* MR10 */                      /* keep track of <<... $label ...>> for semantic predicates in guess mode */
  393. /* MR10 */                      /* element labels contain pointer to the owners node                      */
  394. /* MR10 */
  395. /* MR10 */                      if (el->elem != NULL && el->elem->ntype == nToken) {
  396. /* MR10 */                        list_add(&CurActionLabels,el);
  397. /* MR10 */                      };
  398. }
  399. else
  400. warn(eMsg1("$%s not parameter, return value, (defined) element label",&zzbegexpr[1]));
  401. }
  402. zzmore();
  403. >>
  404. #token "#0" << zzreplstr("(*_root)"); zzmore(); chkGTFlag(); >>
  405. #token "#[]" << if ( GenCC ) {
  406.                                     if (NewAST) zzreplstr("(newAST)");
  407.                                         else zzreplstr("(new AST)");}
  408.    else {zzreplstr("zzastnew()");} zzmore();
  409.    chkGTFlag();
  410. >>
  411. #token "#()" << zzreplstr("NULL"); zzmore(); chkGTFlag(); >>
  412. #token "#[0-9]+" <<{
  413. static char buf[100];
  414. if ( strlen(zzbegexpr)>(size_t)85 )
  415. fatal("#i AST ref too big");
  416. if ( GenCC ) sprintf(buf,"_ast%d%s",BlkLevel-1,zzbegexpr+1);
  417. else sprintf(buf,"zzastArg(%s)",zzbegexpr+1);
  418. zzreplstr(buf);
  419. zzmore();
  420. set_orel(atoi(zzbegexpr+1), &AST_nodes_refd_in_actions);
  421. chkGTFlag();
  422.   }
  423. >>
  425. /* MR14 Arpad Beszedes  26-May-98
  426.         Add support for #line directives when antlr source is pre-processed
  427.         #lexclass ACTIONS
  428. */
  430. #token "#line[ t]* [0-9]+ {[ t]* "~["]+" ([ t]* [0-9]*)* } (n|r|rn)"
  431.         <<
  432.         zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
  433.         getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
  434.         >>
  436. #token "#line ~[nr]* (n|r|rn)"
  437.         <<
  438.         zzline++; zzmore();
  439.         >>
  441. /* MR14 end of a block to support #line in antlr source code */
  443. #token "#[_a-zA-Z][_a-zA-Z0-9]*"
  444. <<
  445. if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
  446.  strcmp(zzbegexpr, "#if")==0 ||
  447.  strcmp(zzbegexpr, "#else")==0 ||
  448.  strcmp(zzbegexpr, "#endif")==0 ||
  449.  strcmp(zzbegexpr, "#ifndef")==0 ||
  450.  strcmp(zzbegexpr, "#define")==0 ||
  451.  strcmp(zzbegexpr, "#pragma")==0 ||
  452.  strcmp(zzbegexpr, "#undef")==0 ||
  453.  strcmp(zzbegexpr, "#import")==0 ||
  454.  strcmp(zzbegexpr, "#line")==0 ||
  455.  strcmp(zzbegexpr, "#include")==0 ||
  456.  strcmp(zzbegexpr, "#error")==0) )
  457. {
  458. static char buf[100];
  459. sprintf(buf, "%s_ast", zzbegexpr+1);
  460. zzreplstr(buf);
  461. chkGTFlag();
  462. }
  463. zzmore();
  464. >>
  465. #token "#[" <<
  466. pushint(']');
  467. if ( GenCC ) {
  468.                                 if (NewAST) zzreplstr("(newAST(");
  469.                                     else zzreplstr("(new AST("); }
  470. else zzreplstr("zzmk_ast(zzastnew(),");
  471. zzmore();
  472. chkGTFlag();
  473. >>
  474. #token "#(" <<
  475. pushint('}');
  476. if ( GenCC )
  477.     zzreplstr("ASTBase::tmake(");
  478. else zzreplstr("zztmake(");
  479. zzmore();
  480. chkGTFlag();
  481. >>
  482. #token "#" << zzmore(); >>
  483. #token ")" <<
  484. if ( istackempty() )
  485. zzmore();
  486. else if ( topint()==')' ) {
  487. popint();
  488. }
  489. else if ( topint()=='}' ) {
  490. popint();
  491. /* terminate #(..) */
  492. zzreplstr(", NULL)");
  493. }
  494. zzmore();
  495. >>
  496. #token "[" <<
  497. pushint('|'); /* look for '|' to terminate simple [...] */
  498. zzmore();
  499. >>
  500. #token "(" <<
  501. pushint(')');
  502. zzmore();
  503. >>
  505. #token "\]" << zzreplstr("]");  zzmore(); >>
  506. #token "\)" << zzreplstr(")");  zzmore(); >>
  508. /* MR1 10-Apr-97  MR1  Previously unable to put right shift operator */
  509. /* MR1 in DLG action */
  511. #token "\>" << if (! tokenActionActive) zzreplstr(">");  /* MR1 */
  512.    zzmore();          /* MR1 */
  513. >>          /* MR1 */
  516. #token "'" << zzmode(ACTION_CHARS); zzmore();>>
  517. #token """ << zzmode(ACTION_STRINGS); zzmore();>>
  518. #token "\$" << zzreplstr("$");  zzmore(); >>
  519. #token "\#" << zzreplstr("#");  zzmore(); >>
  520. #token "\(n|r|rn)" << zzline++; zzmore(); >>
  521. #token "\~[])>$#]" << zzmore(); >> /* escaped char, always ignore */
  522. #token "/" << zzmore(); >>
  523. #token "/*" << zzmode(ACTION_COMMENTS); zzmore(); >>
  524. #token "*/" << warn("Missing /*; found dangling */ in action"); zzmore(); >>
  525. #token "//" << zzmode(ACTION_CPP_COMMENTS); zzmore(); >>
  526. #token "~[nr)(\$#>]["'/]+" << zzmore(); >>
  528. #lexclass START
  529. #token "[t ]+" << zzskip(); >> /* Ignore White */
  530. #token "n|r|rn"     << zzline++; zzskip(); >> /* Track Line # */
  531. #token "["                 << zzmode(ACTIONS); zzmore();
  532.                                istackreset();
  533.                                pushint(']'); >>
  534. #token "<<"               << action_file=CurFile; action_line=zzline;
  535.                                zzmode(ACTIONS); zzmore();
  536.                                list_free(&CurActionLabels,0);       /* MR10 */
  537.                                numericActionLabel=0;                /* MR10 */
  538.                                istackreset();
  539.                                pushint('>'); >>
  540. #token """ << zzmode(STRINGS); zzmore(); >>
  541. #token "/*" << zzmode(COMMENTS); zzskip(); >>
  542. #token "*/" << warn("Missing /*; found dangling */"); zzskip(); >>
  543. #token "//" << zzmode(CPP_COMMENTS); zzskip(); >>
  545. /* MR14 Arpad Beszedes  26-May-98
  546.         Add support for #line directives when antlr source is pre-processed
  547.         #lexclass START
  548. */
  550. #token "#line[ t]* [0-9]+ {[ t]* "~["]+" ([ t]* [0-9]*)* } (n|r|rn)"
  551.         <<
  552.         zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
  553.         getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
  554.         >>
  556. #token "#line ~[nr]* (n|r|rn)"
  557.         <<
  558.         zzline++; zzmore();
  559.         >>
  561. /* MR14 end of a block to support #line in antlr source code */
  563. /*                                                                          */
  564. /*  8-Apr-97 Regularize escape sequence for ">>"                         */
  565. /* appearing in string literals                                    */
  566. /*                                                                          */
  568. #token ">>" << warn("Missing <<; found dangling >>"); zzskip(); >> /* MR1 */
  569. #token WildCard "."
  570. #token "@" <<FoundException = 1; /* MR6 */
  571.        FoundAtOperator = 1;>> /* MR6 */
  572. #token Eof "@"
  573. << /* L o o k  F o r  A n o t h e r  F i l e */
  574. {
  575. FILE *new_input;
  576. new_input = NextFile();
  577. if ( new_input == NULL ) { NLA=Eof; return; }
  578. fclose( input );
  579. input = new_input;
  580. zzrdstream( input );
  581. zzskip(); /* Skip the Eof (@) char i.e continue */
  582. }
  583. >>
  585. #token LABEL
  587. #errclass "grammar-element" { element }
  588. #errclass "meta-symbol" { "}" "!" ";" "|" "~" "^" ")" }
  590. /*
  591.  * Get a grammar -- Build a list of rules like:
  592.  *
  593.  * o-->Rule1--o
  594.  * |
  595.  * o-->Rule2--o
  596.  * |
  597.  * ...
  598.  * |
  599.  * o-->RuleN--o
  600.  */
  601. grammar : <<Graph g;>>
  602. ( "{\}#header" Action    /* MR13 */
  603. <<
  604. if ( HdrAction==NULL ) {
  605. HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  606. require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  607. strcpy(HdrAction, LATEXT(1));
  608. }
  609. else warn("additional #header statement ignored");
  610. >>
  611.             |   "{\}#first" Action
  612. <<
  613.      if ( FirstAction==NULL ) {
  614.          FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  615.          require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
  616.          strcpy(FirstAction, LATEXT(1));
  617.      } else {
  618.                         warn("additional #first statement ignored");
  619.                     };
  620. >>
  622. | "{\}#parser" QuotedTerm
  623. <<
  624. if ( GenCC ) {
  625. warn("#parser meta-op incompatible with -CC; ignored");
  626. }
  627. else {
  628. if ( strcmp(ParserName,"zzparser")==0 ) {
  629. ParserName=StripQuotes(mystrdup(LATEXT(1)));
  630. if ( RulePrefix[0]!='' )
  631. {
  632. warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  633. RulePrefix[0]='';
  634. }
  635. }
  636. else warn("additional #parser statement ignored");
  637. }
  638. >>
  639. | "{\}#tokdefs" QuotedTerm
  640. <<{
  641. char *fname;
  642. zzantlr_state st; FILE *f; struct zzdlg_state dst;
  643. UserTokenDefsFile = mystrdup(LATEXT(1));
  644. zzsave_antlr_state(&st);
  645. zzsave_dlg_state(&dst);
  646. fname = mystrdup(LATEXT(1));
  647. f = fopen(StripQuotes(fname), "r");
  648. if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
  649. else {
  650. ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
  651. UserDefdTokens = 1;
  652. }
  653. zzrestore_antlr_state(&st);
  654. zzrestore_dlg_state(&dst);
  655. }>>
  656. )*
  657. ( Action
  658. <<{
  659. UserAction *ua = newUserAction(LATEXT(1));
  660. ua->file = action_file; ua->line = action_line;
  661. if ( class_nest_level>0 ) list_add(&class_before_actions, ua);
  662. else list_add(&BeforeActions, ua);
  663. }>>
  664. | laction
  665. | lmember /* MR1 */
  666. | lprefix /* MR1 */
  667. | aLexclass
  668. | token
  669. | error
  670. | tclass
  671.             |   aPred               /* MR11 */
  672. | default_exception_handler
  673. | class_def
  674. | "}"
  675. <<
  676. if ( class_nest_level==0 )
  677. warn("missing class definition for trailing '}'");
  678. class_nest_level--;
  679. >>
  680. )*
  681. rule <<g=$3; SynDiag = (Junction *) $3.left;>>
  682. ( rule <<if ( $1.left!=NULL ) {g.right = NULL; g = Or(g, $1);}>>
  683. | aLexclass
  684. | token
  685. | error
  686. | tclass
  687.             |   aPred               /* MR11 */
  688. | class_def
  689. | "}"
  690. <<
  691. if ( class_nest_level==0 )
  692. warn("missing class definition for trailing '}'");
  693. class_nest_level--;
  694. >>
  695. )*
  696. ( Action
  697. <<{
  698. UserAction *ua = newUserAction(LATEXT(1));
  699. ua->file = action_file; ua->line = action_line;
  700. if ( class_nest_level>0 ) list_add(&class_after_actions, ua);
  701. else list_add(&AfterActions, ua);
  702. }>>
  703. | laction
  704. | lmember /* MR1 */
  705. | lprefix /* MR1 */
  706. | error
  707. | tclass
  708. | class_def
  709.             |   aPred               /* MR11 */
  710. | "}"
  711. <<
  712. if ( class_nest_level==0 )
  713. warn("missing class definition for trailing '}'");
  714. class_nest_level--;
  715. >>
  716. )*
  717. Eof
  718. ;
  719. <<CannotContinue=TRUE;>>
  721. class_def
  722. : <<int go=1; char name[MaxRuleName+1];>>
  723. "class"
  724. ( NonTerminal <<if(go) strncpy(name,LATEXT(1),MaxRuleName);>>
  725. | TokenTerm <<if(go) strncpy(name,LATEXT(1),MaxRuleName);>>
  726. )
  727. <<
  728. if ( CurrentClassName[0]!='' && strcmp(CurrentClassName,name)!=0
  729.  && GenCC ) {
  730. err("only one grammar class allowed in this release");
  731. go = 0;
  732. }
  733. else strcpy(CurrentClassName, name);
  734. >>
  735. <<if ( !GenCC ) { err("class meta-op used without C++ option"); }>>
  737. /* MR10 */  (~ "{"
  738. /* MR10 */            <<if (ClassDeclStuff == NULL) {
  739. /* MR10 */                   ClassDeclStuff=(char *)calloc(MaxClassDeclStuff+1,sizeof(char));
  740. /* MR10 */              };
  741. /* MR10 */              strncat(ClassDeclStuff," ",MaxClassDeclStuff);
  742. /* MR10 */              strncat(ClassDeclStuff,LATEXT(1),MaxClassDeclStuff);
  743. /* MR10 */            >>
  744. /* MR10 */  )*
  746. "{"
  747. <<
  748. no_classes_found = 0;
  749. if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
  750. else class_nest_level++;
  751. >>
  752. ;
  753. <<CannotContinue=TRUE;>>
  755. /*
  756.  * Build -o-->o-R-o-->o- where -o-R-o- is the block from rule 'block'.
  757.  * Construct the RuleBlk front and EndRule node on the end of the
  758.  * block.  This is used to add FOLLOW pointers to the rule end.  Add the
  759.  * new rule name to the Rname hash table and sets its rulenum.
  760.  * Store the parameter definitions if any are found.
  761.  *
  762.  * Note that locks are required on the RuleBlk and EndRule nodes to thwart
  763.  * infinite recursion.
  764.  *
  765.  * Return the left graph pointer == NULL to indicate error/dupl rule def.
  766.  */
  767. rule : <<
  768. ListNode *ex_groups = NULL;
  769. ExceptionGroup *eg;
  770. RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  771. set toksrefd, rulesrefd;
  772. char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  773. CurExGroups = NULL;
  774. CurElementLabels = NULL;
  775. /* We want a new element label hash table for each rule */
  776. if ( Elabel!=NULL ) killHashTable(Elabel);
  777. Elabel = newHashTable();
  778. attribsRefdFromAction = empty;
  779. >>
  780. NonTerminal
  781. <<q=NULL;
  782.   if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  783.   err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
  784.   CannotContinue=TRUE;
  785.   }
  786.   else
  787.   {
  788.      q = (RuleEntry *)hash_add(Rname,
  789. LATEXT(1),
  790. (Entry *)newRuleEntry(LATEXT(1)));
  791.       CurRule = q->str;
  792.   }
  793.   CurRuleNode = q;
  794.   f = CurFile; l = zzline;
  795.   NumRules++;
  796. >>
  797. { "!"  <<if ( q!=NULL ) q->noAST = TRUE;>> }
  798. { <<;>>
  799. {"<"}
  800. PassAction
  801. << pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  802. require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  803. strcpy(pdecl, LATEXT(1));
  804. CurParmDef = pdecl;
  805. >>
  806. }
  807. { ">"
  808. PassAction
  809. << ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  810.     require(ret!=NULL, "rule rule: cannot allocate ret type");
  811. strcpy(ret, LATEXT(1));
  812.   CurRetDef = ret;
  813. >>
  814. }
  815. { QuotedTerm <<if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));>> }
  816. <<
  817. if ( GenEClasseForRules && q!=NULL ) {
  818. e = newECnode;
  819. require(e!=NULL, "cannot allocate error class node");
  820. if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  821. else a = q->egroup;
  822. if ( Tnum( a ) == 0 )
  823. {
  824. e->tok = addTname( a );
  825. list_add(&eclasses, (char *)e);
  826. if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  827. /* refers to itself */
  828. list_add(&(e->elist), mystrdup(q->str));
  829. }
  830. else {
  831. warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
  832. if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  833. free((char *)e);
  834. }
  835. }
  836. >>
  837. <<BlkLevel++;>>
  838. ":" <<inAlt=1;>>
  839. block[&toksrefd, &rulesrefd]
  840. <<r = makeBlk($7,0);
  841.   CurRuleBlk = (Junction *)r.left;
  842.   CurRuleBlk->blockid = CurBlockID;
  843.   CurRuleBlk->jtype = RuleBlk;
  844.   if ( q!=NULL ) CurRuleBlk->rname = q->str;
  845.   CurRuleBlk->file = f;
  846.   CurRuleBlk->line = l;
  847.   CurRuleBlk->pdecl = pdecl;
  848.   CurRuleBlk->ret = ret;
  849.   CurRuleBlk->lock = makelocks();
  850.   CurRuleBlk->pred_lock = makelocks();
  851.   CurRuleBlk->tokrefs = toksrefd;
  852.   CurRuleBlk->rulerefs = rulesrefd;
  853.   p = newJunction(); /* add EndRule Node */
  854.   ((Junction *)r.right)->p1 = (Node *)p;
  855.   r.right = (Node *) p;
  856.   p->jtype = EndRule;
  857.   p->lock = makelocks();
  858.   p->pred_lock = makelocks();
  859.   CurRuleBlk->end = p;
  860.   if ( q!=NULL ) q->rulenum = NumRules;
  861.   $7 = r;
  862. >>
  863. <<--BlkLevel;>>
  864.             <<altFixup();leFixup();egFixup();>>                      /* MR7 */
  865. ";" <<inAlt=0;>>
  866. { Action
  867. << a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  868. require(a!=NULL, "rule rule: cannot allocate error action");
  869. strcpy(a, LATEXT(1));
  870. CurRuleBlk->erraction = a;
  871. >>
  872. }
  873. ( exception_group > [eg]
  874. <<if ( eg!=NULL ) {
  875. list_add(&CurExGroups, (void *)eg);
  876. if (eg->label == NULL || *eg->label=='' ) q->has_rule_exception = 1;
  877.     }
  878. >>
  879. )*
  880. <<if ( q==NULL ) $0.left = NULL; else $0 = $7;>>
  881. <<CurRuleNode = NULL;>>
  882. <<CurRuleBlk->exceptions = CurExGroups;>>
  883. <<CurRuleBlk->el_labels = CurElementLabels;>>
  884. ;
  885. <<CannotContinue=TRUE;>>
  887. /*
  888. pragma : "{\}#pragma" "dup-labeled-tokens"
  889. <<Pragma_DupLabeledTokens=1;>>
  890. ;
  891. */
  893. laction : <<char *a;>>
  894. "{\}#lexaction"
  895. Action
  896. <<
  897. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  898. require(a!=NULL, "rule laction: cannot allocate action");
  899. strcpy(a, LATEXT(1));
  900. list_add(&LexActions, a);
  901. >>
  902. ;
  903. <<CannotContinue=TRUE;>>
  905. /* MR1     */
  906. /* MR1  11-Apr-97 Provide mechanism for inserting code into DLG class */
  907. /* MR1   via #lexmember <<....>> & #lexprefix <<...>>      */
  908. /* MR1     */
  910. lmember: <<char *a;>>      /* MR1 */
  911. /* MR1 */ "{\}#lexmember"
  912. /* MR1 */ Action
  913. /* MR1 */ <<
  914. /* MR1 */ if (! GenCC) {
  915. /* MR1 */   err("Use #lexmember only in C++ mode (to insert code in DLG class header");
  916. /* MR1 */         } else {
  917. /* MR1 */   a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  918. /* MR1 */   require(a!=NULL, "rule lmember: cannot allocate action");
  919. /* MR1 */   strcpy(a, LATEXT(1));
  920. /* MR1 */   list_add(&LexMemberActions, a);
  921. /* MR1 */ };
  922. /* MR1 */ >>
  923. /* MR1 */ ;
  924. /* MR1 */ <<CannotContinue=TRUE;>>
  926. lprefix: <<char *a;>>      /* MR1 */
  927. /* MR1 */ "{\}#lexprefix"
  928. /* MR1 */ Action
  929. /* MR1 */ <<
  930. /* MR1 */ if (! GenCC) {
  931. /* MR1 */   err("Use #lexprefixr only in C++ mode (to insert code in DLG class header");
  932. /* MR1 */         } else {
  933. /* MR1 */   a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  934. /* MR1 */   require(a!=NULL, "rule lprefix: cannot allocate action");
  935. /* MR1 */   strcpy(a, LATEXT(1));
  936. /* MR1 */   list_add(&LexPrefixActions, a);
  937. /* MR1 */ };
  938. /* MR1 */ >>
  939. /* MR1 */ ;
  940. /* MR1 */ <<CannotContinue=TRUE;>>
  942. /*
  943.  #pred upper        <<isupper()>>?            predicate literal
  944.  #pred lower        <<islower()>>?            predicate literal
  945.  #pred up_or_low    upper || lower            predicate expression
  946.                                                 concealed interdependence
  947.  #pred up_or_low_2  <<isletter()>>?  A || B   predicate literal equals predicate expr
  948.                                                 analyze using lower||upper
  949.                                                 generate using isLetter()
  950. */
  952. aPred:  <<PredEntry     *predEntry=NULL;
  953.           char          *name=NULL;
  954.           Predicate     *predExpr=NULL;
  955.           char          *predLiteral=NULL;
  956.           int           save_file;
  957.           int           save_line;
  958.           int           predExprPresent=0;
  959.         >>
  961.         "{\}#pred"
  963.         <<
  964.           MR_usingPredNames=1;      /* will need to use -mrhoist version of genPredTree */
  965.         >>
  967.                                     /* used to allow NonTerminal but it caused problems
  968.                                        when a rule name immediately followed a #pred statement */
  970.         TokenTerm     <<name=mystrdup(LATEXT(1));>>
  972.           <<
  973.             /* don't free - referenced in predicates */
  975.             CurPredName=(char *)calloc(1,strlen(name) + 10);
  976.             strcat("#pred ",CurPredName);
  977.             strcat(name,CurPredName);
  979.             predEntry=(PredEntry *) hash_get(Pname,name);
  980.             if (predEntry != NULL) {
  981.               warnFL(eMsg1("#pred %s previously defined - ignored",name),
  982.                                               FileStr[action_file],action_line);
  983.               name=NULL;
  984.             };
  985.           >>
  987.         (
  989.             Pred    <<predLiteral=mystrdup(LATEXT(1));
  990.                       save_line=action_line;
  991.                       save_file=action_file;
  992.                     >>
  994.               {
  995.                     predOrExpr>[predExpr]   <<predExprPresent=1;>>
  996.               }
  998.               <<if (predLiteral != NULL && name != NULL) {
  1000.                       /*
  1001.                        *  predExpr may be NULL due to syntax errors
  1002.                        *    or simply omitted by the user
  1003.                       */
  1005.                       predEntry=newPredEntry(name);
  1006.                       predEntry->file=save_file;
  1007.                       predEntry->line=save_line;
  1008.                       predExpr=MR_predFlatten(predExpr);
  1009.                       predEntry->predLiteral=predLiteral;
  1010.                       if (! predExprPresent || predExpr == NULL) {
  1011.                         predExpr=new_pred();
  1012.                         predExpr->expr=predLiteral;
  1013.                         predExpr->source=newActionNode();
  1014.                         predExpr->source->action=predExpr->expr;
  1015.                         predExpr->source->rname=CurPredName;
  1016.                         predExpr->source->line=action_line;
  1017.                         predExpr->source->file=action_file;
  1018.                         predExpr->source->is_predicate=1;
  1019.                         predExpr->k=predicateLookaheadDepth(predExpr->source);
  1020.                       };
  1021.                       predEntry->pred=predExpr;
  1022.                       hash_add(Pname,name,(Entry *)predEntry);
  1023.                       predExpr=NULL;
  1024.                 };
  1025.                 predicate_free(predExpr);
  1026.               >>
  1028.             |
  1029.                <<save_line=zzline; save_file=CurFile;>>
  1031.                 predOrExpr>[predExpr]
  1033.               <<if (predExpr != NULL && name != NULL) {
  1034.                   predEntry=newPredEntry(name);
  1035.                   predEntry->file=CurFile;
  1036.                   predEntry->line=zzline;
  1037.                   predExpr=MR_predFlatten(predExpr);
  1038.                   predEntry->pred=predExpr;
  1039.                   hash_add(Pname,name,(Entry *)predEntry);
  1040.                   predExpr=NULL;
  1041.                 };
  1042.                 predicate_free(predExpr);
  1043.               >>
  1044.         )
  1045.         {";"}
  1046. ;
  1048. /* fail */
  1050. <<predicate_free(predExpr);
  1051. >>
  1053. predOrExpr>[Predicate *result] :
  1054.             <<Predicate     *ORnode;
  1055.               Predicate     *predExpr;
  1056.               Predicate     **tail=NULL;
  1057.             >>
  1058.         predAndExpr>[predExpr]
  1059.             <<
  1060.                 ORnode=new_pred();
  1061.                 ORnode->expr=PRED_OR_LIST;
  1062.                 if (predExpr != NULL) {
  1063.                     ORnode->down=predExpr;
  1064.                     tail=&predExpr->right;
  1065.                 };
  1066.             >>
  1067.         ( "||"  predAndExpr>[predExpr]
  1068.             <<
  1069.                 if (predExpr != NULL) {
  1070.                     *tail=predExpr;
  1071.                     tail=&predExpr->right;
  1072.                 };
  1073.             >>
  1074.         )*
  1075.         <<
  1076.             $result=ORnode;
  1077.             ORnode=NULL;
  1078.         >>
  1079. ;
  1081. /* fail */
  1083. <<predicate_free(ORnode);>>
  1085. predAndExpr>[Predicate *result] :
  1086.             <<Predicate     *ANDnode;
  1087.               Predicate     *predExpr;
  1088.               Predicate     **tail=NULL;
  1089.             >>
  1090.         predPrimary>[predExpr]
  1091.             <<
  1092.                 ANDnode=new_pred();
  1093.                 ANDnode->expr=PRED_AND_LIST;
  1094.                 if (predExpr != NULL) {
  1095.                     ANDnode->down=predExpr;
  1096.                     tail=&predExpr->right;
  1097.                 };
  1098.             >>
  1099.         ( "&&"  predPrimary>[predExpr]
  1100.             <<
  1101.                 if (predExpr != NULL) {
  1102.                     *tail=predExpr;
  1103.                     tail=&predExpr->right;
  1104.                 };
  1105.             >>
  1106.         )*
  1107.         <<
  1108.             $result=ANDnode;
  1109.             ANDnode=NULL;
  1110.         >>
  1111. ;
  1113. /* fail */
  1115. <<predicate_free(ANDnode);>>
  1118. predPrimary>[Predicate *result] :
  1119.             <<
  1120.               char          *name=NULL;
  1121.               PredEntry     *predEntry=NULL;
  1122.               Predicate     *predExpr=NULL;
  1123.               int           inverted=0;
  1124.             >>
  1126.         TokenTerm            <<name=mystrdup(LATEXT(1));>>
  1128.             <<
  1129.                 predEntry=(PredEntry *) hash_get(Pname,name);
  1130.                 if (predEntry == NULL) {
  1131.                   warnFL(eMsg1("no previously defined #pred with name "%s"",name),
  1132.                         FileStr[CurFile],zzline);
  1133.                   name=NULL;
  1134.                   $result=NULL;
  1135.                 } else {
  1136.                   predExpr=predicate_dup(predEntry->pred);
  1137.                   predExpr->predEntry=predEntry;
  1138.                   $result=predExpr;
  1139.                 };
  1140.             >>
  1142.         | "(" predOrExpr>[predExpr] ")"
  1143.             <<
  1144.                 $result=predExpr;
  1145.             >>
  1147.         | "!" predPrimary>[predExpr]
  1148.             <<
  1149.                 predExpr->inverted=!predExpr->inverted;
  1150.                 $result=predExpr;
  1151.             >>
  1152. ;
  1154. /* fail */  <<
  1155.               predicate_free(predExpr);
  1156.             >>
  1158. aLexclass: "{\}#lexclass" TokenTerm <<lexclass(mystrdup(LATEXT(1)));>>
  1159. ;
  1160. <<CannotContinue=TRUE;>>
  1162. error : <<char *t=NULL; ECnode *e; int go=1; TermEntry *p;>>
  1163. "{\}#errclass"
  1164. (<<;>> TokenTerm  <<t=mystrdup(LATEXT(1));>>
  1165. | QuotedTerm <<t=mystrdup(LATEXT(1));>>
  1166. )
  1167. <<e = newECnode;
  1168.   require(e!=NULL, "cannot allocate error class node");
  1169.   e->lexclass = CurrentLexClass;
  1170.   if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  1171.   {
  1172. if ( hash_get(Texpr, t) != NULL )
  1173. warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  1174.    e->tok = addTname( t );
  1175. set_orel(e->tok, &imag_tokens);
  1176. require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  1177. "hash table mechanism is broken");
  1178. p->classname = 1; /* entry is errclass name, not token */
  1179. list_add(&eclasses, (char *)e);
  1180.   }
  1181.   else
  1182.   {
  1183.    warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
  1184. free( (char *)e );
  1185. go=0;
  1186.   }
  1187. >>
  1188. "{"
  1189. ( NonTerminal <<if ( go ) t=mystrdup(LATEXT(1));>>
  1190. | TokenTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
  1191. | QuotedTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
  1192. )
  1193. <<if ( go ) list_add(&(e->elist), t);>>
  1194. (
  1195. ( NonTerminal <<if ( go ) t=mystrdup(LATEXT(1));>>
  1196. | TokenTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
  1197. | QuotedTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
  1198. )
  1199. <<if ( go ) list_add(&(e->elist), t);>>
  1200. )*
  1201. "}"
  1202. ;
  1203. <<CannotContinue=TRUE;>>
  1205. tclass : <<char *t=NULL; TCnode *e; int go=1,tok,totok; TermEntry *p, *term, *toterm;>>
  1206.             <<char *totext=NULL; >>
  1207. "{\}#tokclass" TokenTerm <<t=mystrdup(LATEXT(1));>>
  1208. <<e = newTCnode;
  1209.   require(e!=NULL, "cannot allocate token class node");
  1210.   e->lexclass = CurrentLexClass;
  1211.   if ( Tnum( t ) == 0 )
  1212.   {
  1213.    e->tok = addTname( t );
  1214. set_orel(e->tok, &imag_tokens);
  1215. set_orel(e->tok, &tokclasses);
  1216. require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  1217. "hash table mechanism is broken");
  1218. p->classname = 1; /* entry is class name, not token */
  1219. p->tclass = e; /* save ptr to this tclass def */
  1220. list_add(&tclasses, (char *)e);
  1221.   }
  1222.   else
  1223.   {
  1224.    warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
  1225. free( (char *)e );
  1226. go=0;
  1227.   }
  1228. >>
  1229. "{"
  1230. (
  1231.      ( TokenTerm
  1232.        <<if ( go ) {
  1233.      term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1234.      if ( term==NULL && UserDefdTokens ) {
  1235.      err("implicit token definition not allowed with #tokdefs");
  1236.      go = 0;
  1237.      }
  1238.      else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
  1239.      }>>
  1241.                         {
  1242.                             ".."
  1243.                             TokenTerm
  1245.                <<if ( go ) {
  1246.                  toterm = (TermEntry *) hash_get(Tname, LATEXT(1));
  1247.                  if ( toterm==NULL && UserDefdTokens ) {
  1248.                  err("implicit token definition not allowed with #tokdefs");
  1249.                  go = 0;
  1250.                  } else {
  1251.                                         totext=mystrdup(LATEXT(1)); totok=addTname(LATEXT(1));
  1252.                                     }
  1253.                  }
  1254.                               >>
  1255.                         }
  1257.      | QuotedTerm
  1258.        <<if ( go ) {
  1259.      term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1260.      if ( term==NULL && UserDefdTokens ) {
  1261.      err("implicit token definition not allowed with #tokdefs");
  1262.      go = 0;
  1263.          }
  1264.      else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
  1265.      }>>
  1266.      )
  1267.      <<if ( go ) {
  1268.                         if (totext == NULL) {
  1269.                             list_add(&(e->tlist), t);
  1270.                         } else {
  1271.                             list_add(&(e->tlist),"..");
  1272.                             list_add(&(e->tlist),t);
  1273.                             list_add(&(e->tlist),totext);
  1274.                         }
  1275.                         totext=NULL;
  1276.                       }
  1277.                     >>
  1278. )*
  1279. "}"
  1280. ;
  1281. <<CannotContinue=TRUE;>>
  1283. token : <<char *t=NULL, *e=NULL, *a=NULL; int tnum=0;>>
  1284.             <<char *akaString=NULL; TermEntry *te;int save_file=0,save_line=0;>>           /* MR11 */
  1285. "{\}#token"
  1287. /* MR1 10-Apr-97 MR1 Allow shift right operator in DLG actions    */
  1288. /* MR1 Danger when parser feedback to lexer            */
  1289. /* MR1                                                                */
  1291. <<tokenActionActive=1;>>                     /* MR1 */
  1292. { TokenTerm  <<t=mystrdup(LATEXT(1));>>
  1294. /* MR11 */      {
  1295. /* MR11 */          "("
  1296. /* MR11 */          QuotedTerm
  1297. /* MR11 */                 <<akaString=mystrdup(StripQuotes(LATEXT(1)));
  1298. /* MR11 */                   save_file=CurFile;save_line=zzline;
  1299. /* MR11 */                 >>
  1300. /* MR11 */          ")"
  1301. /* MR11 */      }
  1303. { "=" "[0-9]+" /* define the token type number */
  1304. <<tnum = atoi(LATEXT(1));>>
  1305. }
  1306. }
  1307. { QuotedTerm <<e=mystrdup(LATEXT(1));>> }
  1308. { Action
  1309. <<
  1310. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1311. require(a!=NULL, "rule token: cannot allocate action");
  1312. strcpy(a, LATEXT(1));
  1313. >>
  1314. }
  1316.             { ";" }     /* MR11 */
  1318. <<chkToken(t, e, a, tnum);>>
  1320.             <<if (t != NULL) {
  1321.                 te=(TermEntry *)hash_get(Tname,t);
  1322.                 if (te != NULL && akaString != NULL) {
  1323.                   if (te->akaString != NULL) {
  1324.                     if (strcmp(te->akaString,akaString) != 0) {
  1325.                       warnFL(eMsg2("this #token statment conflicts with a previous #token %s("%s") statement",
  1326.                                     t,te->akaString),
  1327.                         FileStr[save_file],save_line);
  1328.                     };
  1329.                   } else {
  1330.                     te->akaString=akaString;
  1331.                   };
  1332.                 };
  1333.               };
  1334.             >>
  1335. ;
  1336. <<CannotContinue=TRUE;>>
  1338. block[set *toksrefd, set *rulesrefd]
  1339. : <<
  1340. Graph g, b;
  1341. set saveblah;
  1342. int saveinalt = inAlt;
  1343. ExceptionGroup *eg;
  1344. *$toksrefd = empty;
  1345. *$rulesrefd = empty;
  1346. set_clr(AST_nodes_refd_in_actions);
  1347. CurBlockID++;
  1348. CurAltNum = 1;
  1349. saveblah = attribsRefdFromAction;
  1350. attribsRefdFromAction = empty;
  1351. >>
  1352. alt[toksrefd,rulesrefd] <<b = g = $1;>>
  1353. <<
  1354. if ( ((Junction *)g.left)->p1->ntype == nAction )
  1355. {
  1356.                 ActionNode *actionNode=(ActionNode *)
  1357.                                          ( ( (Junction *)g.left) ->p1);
  1358. if (!actionNode->is_predicate )
  1359. {
  1360. actionNode->init_action = TRUE;
  1361. /* MR12c */   if (actionNode->noHoist) {
  1362. /* MR12c */           errFL("<<nohoist>> appears as init-action - use <<>> <<nohoist>>",
  1363. /* MR12c */                       FileStr[actionNode->file],actionNode->line);
  1364. /* MR12c */         };
  1365. }
  1366. }
  1367. ((Junction *)g.left)->blockid = CurBlockID;
  1368. >>
  1370. ( exception_group > [eg]
  1371. <<
  1372. if ( eg!=NULL ) {
  1373. /* MR7 *****        eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
  1374. /* MR7 ***** CurAltStart->exception_label = eg->altID;           *****/
  1375. list_add(&CurExGroups, (void *)eg);
  1376. }
  1377. >>
  1378. )*
  1379. <<CurAltNum++;>>
  1381. ( "|" <<inAlt=1;>>
  1382. alt[toksrefd,rulesrefd] <<g = Or(g, $2);>>
  1383. <<
  1384. ((Junction *)g.left)->blockid = CurBlockID;
  1385. >>
  1387. ( exception_group > [eg]
  1388. <<
  1389. if ( eg!=NULL ) {
  1390. /* MR7 *****        eg->altID = makeAltID(CurBlockID,CurAltNum);        *****/
  1391. /* MR7 ***** CurAltStart->exception_label = eg->altID;           *****/
  1392. list_add(&CurExGroups, (void *)eg);
  1393. }
  1394. >>
  1395. )*
  1397. <<CurAltNum++;>>
  1399. )*
  1400. <<$0 = b;>>
  1401. <<attribsRefdFromAction = saveblah; inAlt = saveinalt;>>
  1402. ;
  1403. <<CannotContinue=TRUE;>>
  1405. alt[set *toksrefd, set *rulesrefd]
  1406. : <<int n=0,ne=0; Graph g; int e_num=0, not=0; Node *node; set elems, dif;
  1407. int first_on_line = 1, use_def_MT_handler = 0;
  1408. g.left=NULL; g.right=NULL;
  1410. CurAltStart = NULL;
  1411. elems = empty;
  1412. inAlt = 1;
  1413. >>
  1414. { "@" /* handle MismatchedToken signals with default handler */
  1415. <<use_def_MT_handler = 1;>>
  1416. }
  1417. ( <<;>>       /* MR9 Removed unreferenced variable "tok" */
  1418. { <<not=0;>> "~" <<not=1;>> }
  1419. element[not, first_on_line, use_def_MT_handler] > [node]
  1420. <<if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;>>
  1421. <<
  1422. if ( $2.left!=NULL ) {
  1423. g = Cat(g, $2);
  1424. n++;
  1425. if ( node!=NULL ) {
  1426. if ( node->ntype!=nAction ) e_num++;
  1427. /* record record number of all rule and token refs */
  1428. if ( node->ntype==nToken ) {
  1429. TokNode *tk = (TokNode *)((Junction *)$2.left)->p1;
  1430. tk->elnum = e_num;
  1431. set_orel(e_num, &elems);
  1432. }
  1433. else if ( node->ntype==nRuleRef ) {
  1434. RuleRefNode *rn = (RuleRefNode *)((Junction *)$2.left)->p1;
  1435. rn->elnum = e_num;
  1436. set_orel(e_num, $rulesrefd);
  1437. }
  1438. }
  1439. }
  1440. >>
  1441. )*
  1442. <<if ( n == 0 ) g = emptyAlt();
  1443.   $0 = g;
  1444.   /* We want to reduce number of LT(i) calls and the number of
  1445.    * local attribute variables in C++ mode (for moment, later we'll
  1446.    * do for C also).  However, if trees are being built, they
  1447.    * require most of the attrib variables to create the tree nodes
  1448.    * with; therefore, we gen a token ptr for each token ref in C++
  1449.    */
  1450.   if ( GenCC && !GenAST )
  1451.   {
  1452.   /* This now free's the temp set -ATG 5/6/95 */
  1453.   set temp;
  1454.   temp = set_and(elems, attribsRefdFromAction);
  1455.   set_orin($toksrefd, temp);
  1456.   set_free(temp);
  1457.   }
  1458.   else set_orin($toksrefd, elems);
  1459.   if ( GenCC ) {
  1460. dif = set_dif(attribsRefdFromAction, elems);
  1461.    if ( set_deg(dif)>0 )
  1462. err("one or more $i in action(s) refer to non-token elements");
  1463. set_free(dif);
  1464.   }
  1465.   set_free(elems);
  1466.   set_free(attribsRefdFromAction);
  1467.   inAlt = 0;
  1468.     >>
  1469. ;
  1470. <<CannotContinue=TRUE;>>
  1472. element_label > [LabelEntry *label]
  1473. : <<TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;>>
  1474. LABEL <<lab = mystrdup(LATEXT(1));>>
  1475. <<
  1476. UsedNewStyleLabel = 1;
  1477. if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
  1478. t = (TermEntry *) hash_get(Tname, lab);
  1479. if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
  1480. if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
  1481. if ( t!=NULL ) {
  1482. err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
  1483. $label = NULL;
  1484. }
  1485. else if ( r!=NULL ) {
  1486. err(eMsg1("label definition clashes with rule definition: '%s'", lab));
  1487. $label = NULL;
  1488. }
  1489. else {
  1490. /* we don't clash with anybody else */
  1491. l = (LabelEntry *) hash_get(Elabel, lab);
  1492.   if ( l==NULL ) { /* ok to add new element label */
  1493. l = (LabelEntry *)hash_add(Elabel,
  1494.    lab,
  1495.    (Entry *)newLabelEntry(lab));
  1496. /* add to list of element labels for this rule */
  1497. list_add(&CurElementLabels, (void *)lab);
  1498. /* MR7 */       leAdd(l);  /* list of labels waiting for exception group definitions */
  1499. $label = l;
  1500. }
  1501. else {
  1502. err(eMsg1("label definitions must be unique per rule: '%s'", lab));
  1503. $label = NULL;
  1504. }
  1505. }
  1506. >>
  1507. ":"
  1508. ;
  1510. element[int not, int first_on_line, int use_def_MT_handler] > [Node *node]
  1511. : <<
  1512.   Attrib blk;
  1513.   Predicate *pred = NULL;
  1514.   int local_use_def_MT_handler=0;
  1515.   ActionNode *act;
  1516.   RuleRefNode *rr;
  1517.   set toksrefd, rulesrefd;
  1518.   TermEntry *term;
  1519.   TokNode *p=NULL; RuleRefNode *q; int approx=0;
  1520.   LabelEntry *label=NULL;
  1521.           int predMsgDone=0;
  1522.           int semDepth=0;
  1523.           int   ampersandStyle;
  1524.           int   height;         /* MR11 */
  1525.           int   equal_height;   /* MR11 */
  1527.   $node = NULL;
  1528.   >>
  1529.   {element_label>[label]}
  1530.   ( TokenTerm
  1531. <<
  1532. term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1533. if ( term==NULL && UserDefdTokens ) {
  1534. err("implicit token definition not allowed with #tokdefs");
  1535. $$.left = $$.right = NULL;
  1536. }
  1537. else {
  1538. $$ = buildToken(LATEXT(1));
  1539. p=((TokNode *)((Junction *)$$.left)->p1);
  1540. term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1541. require( term!= NULL, "hash table mechanism is broken");
  1542. p->tclass = term->tclass;
  1543. p->complement = $not;
  1544. if ( label!=NULL ) {
  1545. p->el_label = label->str;
  1546. label->elem = (Node *)p;
  1547. }
  1548. }
  1549. >>
  1550. { ".."
  1551. ( QuotedTerm
  1552. <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
  1553. | TokenTerm
  1554. <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
  1555. )
  1556. }
  1557. <<
  1558. if ( p!=NULL && (p->upper_range!=0 || p->tclass || $not) )
  1559. list_add(&MetaTokenNodes, (void *)p);
  1560. >>
  1561. ( "^" <<if ( p!=NULL ) p->astnode=ASTroot;>>
  1562. | <<if ( p!=NULL ) p->astnode=ASTchild;>>
  1563. | "!" <<if ( p!=NULL ) p->astnode=ASTexclude;>>
  1564. )
  1565. { "@" <<local_use_def_MT_handler = 1;>> }
  1566. <<
  1567. if ( p!=NULL && $first_on_line ) {
  1568. CurAltStart = (Junction *)$$.left;
  1569.                 altAdd(CurAltStart);                                 /* MR7 */
  1570. p->altstart = CurAltStart;
  1571. }
  1572.     if ( p!=NULL )
  1573. p->use_def_MT_handler = $use_def_MT_handler || local_use_def_MT_handler;
  1574. $node = (Node *)p;
  1575. >>
  1576.   | QuotedTerm
  1577. <<
  1578. term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1579. if ( term==NULL && UserDefdTokens ) {
  1580. err("implicit token definition not allowed with #tokdefs");
  1581. $$.left = $$.right = NULL;
  1582. }
  1583. else {
  1584. $$ = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)$$.left)->p1);
  1585. p->complement = $not;
  1586. if ( label!=NULL ) {
  1587. p->el_label = label->str;
  1588.     label->elem = (Node *)p;
  1589. }
  1590. }
  1591. >>
  1592. { ".."
  1593. ( QuotedTerm
  1594. <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
  1595. | TokenTerm
  1596. <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
  1597. )
  1598. }
  1599. ( "^" <<if ( p!=NULL ) p->astnode=ASTroot;>>
  1600. | <<if ( p!=NULL ) p->astnode=ASTchild;>>
  1601. | "!" <<if ( p!=NULL ) p->astnode=ASTexclude;>>
  1602. )
  1603. { "@" <<local_use_def_MT_handler = 1;>> }
  1604. <<
  1605. if ( p!=NULL && (p->upper_range!=0 || p->tclass || $not) )
  1606. list_add(&MetaTokenNodes, (void *)p);
  1607. >>
  1608. <<
  1609. if ( $first_on_line ) {
  1610. CurAltStart = (Junction *)$$.left;
  1611.                 altAdd(CurAltStart);                                 /* MR7 */
  1612. p->altstart = CurAltStart;
  1613. }
  1614.     if ( p!=NULL )
  1615. p->use_def_MT_handler = $use_def_MT_handler || local_use_def_MT_handler;
  1616. $node = (Node *)p;
  1617. >>
  1619.   | <<if ( $not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");>>
  1620. "."
  1621. <<$$ = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)$$.left)->p1);>>
  1622. ( "^" <<p->astnode=ASTroot;>>
  1623. | <<p->astnode=ASTchild;>>
  1624. | "!" <<p->astnode=ASTexclude;>>
  1625. )
  1626. <<list_add(&MetaTokenNodes, (void *)p);>>
  1627. <<
  1628. if ( $first_on_line ) {
  1629. CurAltStart = (Junction *)$$.left;
  1630.                 altAdd(CurAltStart);                                 /* MR7 */
  1631. p->altstart = CurAltStart;
  1632. if ( label!=NULL ) {
  1633. p->el_label = label->str;
  1634. label->elem = (Node *)p;
  1635. }
  1636. }
  1637. $node = (Node *)p;
  1638. >>
  1640.   | <<if ( $not ) warn("~ NONTERMINAL is an undefined operation");>>
  1641. NonTerminal
  1642. <<$$ = buildRuleRef(LATEXT(1));>>
  1643. { "!" <<q = (RuleRefNode *) ((Junction *)$$.left)->p1;
  1644. q->astnode=ASTexclude;>>
  1645. }
  1646. { {"<"}
  1647. PassAction <<addParm(((Junction *)$$.left)->p1, LATEXT(1));>>
  1648. }
  1649. <<rr=(RuleRefNode *) ((Junction *)$$.left)->p1;>>
  1650. { <<char *a;>>
  1651. ">"
  1652. PassAction
  1653. <<
  1654. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1655. require(a!=NULL, "rule element: cannot allocate assignment");
  1656. strcpy(a, LATEXT(1));
  1657. rr->assign = a;
  1658. >>
  1659. }
  1660. <<
  1661. if ( label!=NULL ) {
  1662. rr->el_label = label->str;
  1663. label->elem = (Node *)rr;
  1664. }
  1665. if ( $first_on_line ) {
  1666. CurAltStart = (Junction *)$$.left;
  1667.                 altAdd(CurAltStart);                                 /* MR7 */
  1668. ((RuleRefNode *)((Junction *)$$.left)->p1)->altstart = CurAltStart;
  1669. }
  1670. $node = (Node *)rr;
  1671. >>
  1672.   )
  1674. | <<if ( $not ) warn("~ ACTION is an undefined operation");>>
  1675. Action <<$0 = buildAction(LATEXT(1),action_file,action_line, 0);>>
  1676. <<if ( $first_on_line ) {                                /* MR7 */
  1677.                 CurAltStart = (Junction *)$0.left;                   /* MR7 */
  1678.                 altAdd(CurAltStart);                                 /* MR7 */
  1679.               };>>                                                   /* MR7 */
  1680. <<$node = (Node *) ((Junction *)$0.left)->p1;>>
  1682. | <<if ( $not ) warn("~ SEMANTIC-PREDICATE is an undefined operation");>>
  1683. Pred   <<$0 = buildAction(LATEXT(1),action_file,action_line, 1);>>
  1684. <<act = (ActionNode *) ((Junction *)$0.left)->p1;>>
  1685.             <<if (numericActionLabel) {             /* MR10 */
  1686.                 list_add(&NumericPredLabels,act);   /* MR10 */
  1687.                 numericActionLabel=0;               /* MR10 */
  1688.               };                                    /* MR10 */
  1689.             >>
  1690. { <<char *a;>>
  1691. PassAction
  1692. <<
  1693. a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1694. require(a!=NULL, "rule element: cannot allocate predicate fail action");
  1695. strcpy(a, LATEXT(1));
  1696. act->pred_fail = a;
  1697. >>
  1698. }
  1699. <<if ( $first_on_line ) {                                /* MR7 */
  1700.                 CurAltStart = (Junction *)$0.left;                   /* MR7 */
  1701.                 altAdd(CurAltStart);                                 /* MR7 */
  1702.               };>>                                                    /* MR7 */
  1703. <<$node = (Node *)act;>>
  1705. | <<if ( $not ) warn("~ BLOCK is an undefined operation");>>
  1706. <<BlkLevel++;>>
  1707. { "{\}#pragma"
  1708. ( "approx" <<approx=LL_k;>>
  1709. | "LL(1)"  <<approx = 1;>>
  1710. | "LL(2)"  <<approx = 2;>>
  1711. )
  1712. }
  1713. ( "(" block[&toksrefd,&rulesrefd] ")"
  1714. <<blk = $$ = $2; --BlkLevel;>>
  1715. ( "*" <<$$ = makeLoop($$,approx);>>
  1716. | "+" <<$$ = makePlus($$,approx);>>
  1717. | "?"
  1718. (
  1719.                         ( "=>" <<ampersandStyle=0;>>
  1720.                         | "&&" <<ampersandStyle=1;>>  /* MR10 (g)? && <<p>>? */
  1721.                         )
  1722.                         Pred /* generalized predicate */
  1723. /* first make into a predicate */
  1724.     <<$$ = buildAction(LATEXT(1),action_file,action_line,1);>>
  1725.     <<act = (ActionNode *) ((Junction *)$$.left)->p1;>>
  1726.                         <<semDepth=predicateLookaheadDepth(act);>>  /* MR10 */
  1727.                         <<if (numericActionLabel) {             /* MR10 */
  1728.                             list_add(&NumericPredLabels,act);   /* MR10 */
  1729.                             numericActionLabel=0;               /* MR10 */
  1730.                           };                                    /* MR10 */
  1731.                         >>
  1732. { <<char *a;>>
  1733. PassAction
  1734. <<
  1735. a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
  1736. require(a!=NULL, "rule element: cannot allocate predicate fail action");
  1737. strcpy(a, LATEXT(1));
  1738. act->pred_fail = a;
  1739. >>
  1740. }
  1741. <<if ($first_on_line) {                      /* MR7 */
  1742.                             CurAltStart=(Junction *)$$.left;         /* MR7 */
  1743.                             altAdd(CurAltStart);                     /* MR7 */
  1744.                           };>>
  1745. <<$node = (Node *)act;>>
  1747. /* for now, just snag context */
  1748. <<
  1749. pred = computePredicateFromContextGuard(blk,&predMsgDone);      /* MR10 */
  1750. if ( pred==NULL) {                                              /* MR10 */
  1751.                           if ( !predMsgDone) err("invalid or missing context guard");   /* MR10 */
  1752.                           predMsgDone=1;                                                /* MR10 */
  1753. } else {                                                        /* MR10 */
  1754.                             act->guardNodes=(Junction *)blk.left;                       /* MR11 */
  1755. pred->expr = act->action;
  1756. pred->source = act;
  1757. /* MR10 */                  pred->ampersandStyle = ampersandStyle;  /* 0 means (g)? => ... 1 means (g)? && ... */
  1758. /* MR13 */                  if (pred->tcontext != NULL) {
  1759. /* MR13 */                    height=MR_max_height_of_tree(pred->tcontext);
  1760. /* MR13 */                    equal_height=MR_all_leaves_same_height(pred->tcontext,height);
  1761. /* MR13 */                    if (! equal_height) {
  1762. /* MR13 */                       errFL("in guarded predicates all tokens in the guard must be at the same height",
  1763. /* MR13 */                              FileStr[act->file],act->line);
  1764. /* MR13 */                    };
  1765. /* MR13 */                  }
  1766. /* MR10 */                  if (ampersandStyle) {
  1767. /* MR10 */      act->ampersandPred = pred;
  1768. /* MR11 */                    if (! HoistPredicateContext) {
  1769. /* MR11 */                      errFL("without "-prc on" (guard)? && <<pred>>? ... doesn't make sense",
  1770. /* MR11 */                              FileStr[act->file],act->line);
  1771. /* MR11 */                    };
  1772. /* MR10 */                  } else {
  1773. /* MR10 */      act->guardpred = pred;
  1774. /* MR10 */                  };
  1775. /* MR10 */                  if (pred->k != semDepth) {
  1776. /* MR10 */                     warn(eMsgd2("length of guard (%d) does not match the length of semantic predicate (%d)",
  1777. /* MR10 */                                  pred->k,semDepth));
  1778. /* MR10 */                  };
  1779. }
  1780. >>
  1781. | <<$$ = makeBlk($$,approx);
  1782.   FoundGuessBlk = 1;
  1783.   ((Junction *) ((Junction *)$$.left)->p1)->guess=1;
  1784.   if ( !$first_on_line ) {
  1785. err("(...)? predicate must be first element of production");
  1786.   }
  1787. >>
  1788. )
  1789. | <<$$ = makeBlk($$,approx);>>
  1790. )
  1791. <<
  1792. if ( pred==NULL && !predMsgDone) {                                      /* MR10 */
  1793. ((Junction *)((Junction *)$$.left)->p1)->blockid = CurBlockID;
  1794. ((Junction *)((Junction *)$$.left)->p1)->tokrefs = toksrefd;
  1795. ((Junction *)((Junction *)$$.left)->p1)->rulerefs = rulesrefd;
  1796. if ( $first_on_line ) {                         /* MR7 */
  1797.    CurAltStart = (Junction *)((Junction *)((Junction *)$$.left)->p1);  /* MR7 */
  1798.                        altAdd(CurAltStart);                         /* MR7 */
  1799.                     };                                              /* MR7 */
  1800. $node = (Node *) ((Junction *)$$.left)->p1;
  1801. }
  1802. >>
  1804. | "{" block[&toksrefd,&rulesrefd]
  1805. <<$$ = makeOpt($2,approx); --BlkLevel;>>
  1806. "}"
  1807. <<
  1808. ((Junction *)((Junction *)$$.left)->p1)->blockid = CurBlockID;
  1809. ((Junction *)((Junction *)$$.left)->p1)->tokrefs = toksrefd;
  1810. ((Junction *)((Junction *)$$.left)->p1)->rulerefs = rulesrefd;
  1811. >>
  1812. <<if ( $first_on_line ) {                            /* MR7 */
  1813. CurAltStart = (Junction *) ((Junction *)((Junction *)$$.left)->p1);  /* MR7 */
  1814.                     altAdd(CurAltStart);                             /* MR7 */
  1815.                   };
  1816. >>
  1817. <<$node = (Node *) ((Junction *)$$.left)->p1;>>
  1819. )
  1821. /* Error catching alternatives */
  1822. | "*" <<warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;>>
  1823. | "+" <<warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;>>
  1824. | ">" <<warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;>>
  1825. | PassAction <<warn("[...] out of context 'rule > [...]'");
  1826.  CannotContinue=TRUE;>>
  1827. ;
  1828. <<CannotContinue=TRUE;>>
  1830. default_exception_handler
  1831. : exception_group > [DefaultExGroup]
  1832. ;
  1834. exception_group > [ExceptionGroup *eg]
  1835. : <<ExceptionHandler *h; LabelEntry *label=NULL;   /* MR6 */
  1836.   FoundException = 1; FoundExceptionGroup = 1;>>  /* MR6 */
  1838. "exception"  <<$eg = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));>>
  1839. { <<char *p;>>
  1840. PassAction /* did they attach a label? */
  1841. <<
  1842. p = LATEXT(1)+1;
  1843. p[strlen(p)-1] = ''; /* kill trailing space */
  1844. label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
  1845. if ( label==NULL )
  1846. {
  1847. err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
  1848. }
  1849. >>
  1850. }
  1851. ( exception_handler > [h]
  1852. <<list_add(&($eg->handlers), (void *)h);>>
  1853. )*
  1854. { "default" ":" Action
  1855. <<{
  1856. ExceptionHandler *eh = (ExceptionHandler *)
  1857. calloc(1, sizeof(ExceptionHandler));
  1858. char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1859. require(eh!=NULL, "exception: cannot allocate handler");
  1860. require(a!=NULL, "exception: cannot allocate action");
  1861. strcpy(a, LATEXT(1));
  1862. eh->action = a;
  1863. eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
  1864. require(eh->signalname!=NULL, "exception: cannot allocate sig name");
  1865. strcpy(eh->signalname, "default");
  1866. list_add(&($eg->handlers), (void *)eh);
  1867. }>>
  1868. }
  1870. <<
  1871. if ( label!=NULL ) {
  1872.              /* Record ex group in sym tab for this label */
  1873.    if ( label->ex_group!=NULL ) {
  1874.       err(eMsg1("duplicate exception handler for label '%s'",label->str));
  1875.    } else {
  1876.   label->ex_group = $eg;
  1877. /* Label the exception group itself */
  1878.   $eg->label = label->str;
  1879. /* Make the labelled element pt to the exception also */
  1880. /* MR6 */   if (label->elem == NULL) {
  1881. /* MR6 */      err(eMsg1("reference in exception handler to undefined label '%s'",label->str));
  1882. /* MR6 */   } else {
  1883.      switch ( label->elem->ntype ) {
  1884.     case nRuleRef :
  1885.                         {
  1886.          RuleRefNode *r = (RuleRefNode *)label->elem;
  1887.          r->ex_group = $eg;
  1888.           break;
  1889.                         }
  1890.                   case nToken :
  1891.         {
  1892.         TokNode *t = (TokNode *)label->elem;
  1893.         t->ex_group = $eg;
  1894.         break;
  1895.         }
  1896.  } /* end switch */
  1897. /* MR6 */   }; /* end test on label->elem */
  1898.     } /* end test on label->ex_group */
  1900. } /* end test on exception label */
  1902. /* MR7 */
  1903. /* MR7 */   if (BlkLevel == 1 && label == NULL) {
  1904. /* MR7 */     $eg->forRule=1;
  1905. /* MR7 */   } else if (label == NULL) {
  1906. /* MR7 */     $eg->altID = makeAltID(CurBlockID,CurAltNum);
  1907. /* MR7 */     egAdd($eg);
  1908. /* MR7 */   } else {
  1909. /* MR7 */     $eg->labelEntry=label;
  1910. /* MR7 */   };
  1911. /* MR7 */
  1912. /* MR7 */     /* You may want to remove this exc from the rule list  */
  1913. /* MR7 */ /* and handle at the labeled element site.             */
  1914. /* MR7 */
  1915. /* MR7 */   if (label != NULL) {
  1916. /* MR7 */     $eg = NULL;
  1917. /* MR7 */   };
  1919. >>
  1920. ;
  1921. <<CannotContinue=TRUE;>>
  1923. exception_handler > [ExceptionHandler *eh]
  1924. : <<;>>                               /* MR9 Removed unreferenced variable "a" */
  1925. "catch"
  1926. <<
  1927. $eh = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
  1928. require($eh!=NULL, "exception: cannot allocate handler");
  1929. >>
  1930. ( NonTerminal
  1931. <<
  1932. $eh->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1933. require($eh->signalname!=NULL, "exception: cannot allocate sig name");
  1934. strcpy($eh->signalname, LATEXT(1));
  1935. >>
  1936. | TokenTerm
  1937. <<
  1938. $eh->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1939. require($eh->signalname!=NULL, "exception: cannot allocate sig name");
  1940. strcpy($eh->signalname, LATEXT(1));
  1941. >>
  1942. )
  1943. ":"
  1944. { <<$eh->action = NULL;>>
  1945. Action
  1946. <<
  1947. $eh->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1948. require($eh->action!=NULL, "exception: cannot allocate action");
  1949. strcpy($eh->action, LATEXT(1));
  1950. >>
  1951. }
  1952. ;
  1953. <<CannotContinue=TRUE;>>
  1955. #token NonTerminal "[a-z] [A-Za-z0-9_]*"
  1956. <<
  1957. while ( zzchar==' ' || zzchar=='t' ) {
  1958. zzadvance();
  1959. }
  1960. if ( zzchar == ':' && inAlt ) NLA = LABEL;
  1961. >>
  1962. #token TokenTerm "[A-Z] [A-Za-z0-9_]*"
  1963. <<
  1964. while ( zzchar==' ' || zzchar=='t' ) {
  1965. zzadvance();
  1966. }
  1967. if ( zzchar == ':' && inAlt ) NLA = LABEL;
  1968. >>
  1969. #token "{\}#[A-Za-z0-9_]*" <<warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip(); >>
  1971. #lexclass PARSE_ENUM_FILE
  1973. #token "[t ]+" << zzskip(); >> /* Ignore White */
  1974. #token "n|r|rn" << zzline++; zzskip(); >> /* Track Line # */
  1975. #token "//" << zzmode(TOK_DEF_CPP_COMMENTS); zzmore(); >>
  1976. #token "/*" << zzmode(TOK_DEF_COMMENTS); zzskip(); >>
  1977. #token "#ifdef" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1978. #token "#if" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1979. #token "#ifndef" << ; >>
  1980. #token "#else" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1981. #token "#endif" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1982. #token "#undef" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1983. #token "#import" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
  1984. #token "@" << ; >>
  1986. enum_file[char *fname]
  1987. : { "#ifndef" ID
  1988. { "#define" ID /* ignore if it smells like a gate */
  1989. /* First #define after the first #ifndef (if any) is ignored */
  1990. }
  1991. }
  1992. ( ( enum_def[$fname] )+
  1993. | defines[$fname]
  1994. )
  1995. |
  1996. ;
  1998. defines[char *fname]
  1999. : <<int v; int maxt=(-1); char *t;>> /* MR3 */
  2000. (
  2001. "#define" ID
  2002. <<t = mystrdup(LATEXT(1));>>
  2003. INT
  2004. <<
  2005. v = atoi(LATEXT(1));
  2006. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2008. /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
  2009. /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
  2010. /* MR2 Don't let #tokdefs be confused by  */
  2011. /* MR2   DLGminToken and DLGmaxToken      */
  2013. if ( ! isDLGmaxToken(t)) { /* MR2 */
  2014.   TokenNum = v;
  2015.   if ( v>maxt ) maxt=v;
  2016.   if ( Tnum( t ) == 0 ) {
  2017.     addForcedTname( t, v );
  2018.   } else {
  2019.     warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
  2020.   };
  2021.                 };
  2022. >>
  2023. )+
  2024. <<TokenNum = maxt + 1;>>
  2025. ;
  2027. enum_def[char *fname]
  2028. : <<int v= 0; int maxt=(-1); char *t;>> /* MR3 */
  2029. "enum" ID
  2030. "{"
  2031. ID
  2032. <<t = mystrdup(LATEXT(1));>>
  2033. ( "=" INT <<v=atoi(LATEXT(1));>>
  2034. | <<v++;>>
  2035. )
  2036. <<
  2037. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2038. TokenNum = v;
  2039. if ( v>maxt ) maxt=v; /* MR3 */
  2040. if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2041. else {
  2042. warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
  2043. }
  2044. >>
  2045. ( ","
  2047. /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
  2048. /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
  2049. /* MR2 Don't let #tokdefs be confused by  */
  2050. /* MR2   DLGminToken and DLGmaxToken      */
  2052. {
  2053.   <<isDLGmaxToken(LATEXT(1))>>? ID { "=" INT } /* MR2 */
  2054. | ID                 /* MR2 */
  2055. <<t = mystrdup(LATEXT(1));>>
  2056. ( "=" INT <<v=atoi(LATEXT(1));>>
  2057. | <<v++;>>
  2058. )
  2059. <<
  2060. /* fprintf(stderr, "#token %s=%dn", t, v);*/
  2061. TokenNum = v;
  2062. if ( v>maxt ) maxt=v; /* MR3 */
  2063. if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2064. else {
  2065. warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
  2066. }
  2067. >>
  2068. }
  2069. )*
  2070. "}"
  2071. ";"
  2072. <<TokenNum = maxt + 1;>> /* MR3 */
  2073. ;
  2075. #token INT "[0-9]+"
  2076. #token ID "[a-zA-Z_][_a-zA-Z0-9]*"
  2078. #lexclass START
  2080. /* MR14 Arpad Beszedes  26-May-98
  2081.         Add support for #line directives when antlr source is pre-processed
  2082. */
  2084. #lexaction
  2085. <<
  2087. static char *
  2088. #ifdef __USE_PROTOS
  2089. getFileNameFromTheLineInfo(char *toStr, char *fromStr)
  2090. #else
  2091. getFileNameFromTheLineInfo(toStr, fromStr)
  2092. char *toStr, *fromStr;
  2093. #endif
  2094. {
  2095.   int i, j, k;
  2097.   if (!fromStr || !toStr) return toStr;
  2099.   /* find the first " */
  2101.   for (i=0;
  2102.         (i<MaxFileName) &&
  2103.         (fromStr[i] != 'n') &&
  2104.         (fromStr[i] != 'r') &&
  2105.         (fromStr[i] != '"');
  2106.       i++) /* nothing */ ;
  2108.   if ( (i == MaxFileName) ||
  2109.        (fromStr[i] == 'n') ||
  2110.        (fromStr[i] == 'r') ) {
  2111.     return toStr;
  2112.   }
  2114.   /* find the second " */
  2116.   for (j=i+1;
  2117.         (j<MaxFileName) &&
  2118.         (fromStr[j] != 'n') &&
  2119.         (fromStr[j] != 'r') &&
  2120.         (fromStr[j] != '"');
  2121.        j++) /* nothing */ ;
  2123.   if ((j == MaxFileName) ||
  2124.       (fromStr[j] == 'n') ||
  2125.       (fromStr[j] == 'r') ) {
  2126.     return toStr;
  2127.   }
  2129.   /* go back until the last / or  */
  2131.   for (k=j-1;
  2132.         (fromStr[k] != '"') &&
  2133.         (fromStr[k] != '/') &&
  2134.         (fromStr[k] != '\');
  2135.        k--) /* nothing */ ;
  2137.   /* copy the string after " / or  into toStr */
  2139.   for (i=k+1; fromStr[i] != '"'; i++) {
  2140.     toStr[i-k-1] = fromStr[i];
  2141.   }
  2143.   toStr[i-k-1] = '';
  2145.   return toStr;
  2146. }
  2148. /* MR14 end of a block to support #line in antlr source code */
  2150. >>
  2152. <<
  2154. /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
  2155. /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs            */
  2156. /* MR2 Don't let #tokdefs be confused by  */
  2157. /* MR2   DLGminToken and DLGmaxToken      */
  2159. /* semantic check on DLGminToken and DLGmaxmaxToken in #tokdefs */
  2161. #ifdef __USE_PROTOS
  2162. static int isDLGmaxToken(char *Token)
  2163. #else
  2164. static int isDLGmaxToken(Token)
  2165.   char * Token;
  2166. #endif
  2167. {
  2168.    static char checkStr1[] = "DLGmaxToken";
  2169.    static char checkStr2[] = "DLGminToken";
  2171.    if (strcmp(Token, checkStr1) == 0)
  2172.       return 1;
  2173.    else if (strcmp(Token, checkStr2) == 0)
  2174.       return 1;
  2175.    else
  2176.       return 0;
  2177. }
  2179. /* semantics of #token */
  2180. static void
  2181. #ifdef __USE_PROTOS
  2182. chkToken(char *t, char *e, char *a, int tnum)
  2183. #else
  2184. chkToken(t,e,a,tnum)
  2185. char *t, *e, *a;
  2186. int tnum;
  2187. #endif
  2188. {
  2189. TermEntry *p;
  2191. /* check to see that they don't try to redefine a token as a token class */
  2192. if ( t!=NULL ) {
  2193. p = (TermEntry *) hash_get(Tname, t);
  2194. if ( p!=NULL && p->classname ) {
  2195. err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
  2196. if ( a!=NULL ) free((char *)a);
  2197. return;
  2198. }
  2199. }
  2201. if ( t==NULL && e==NULL ) { /* none found */
  2202. err("#token requires at least token name or rexpr");
  2203. }
  2204. else if ( t!=NULL && e!=NULL ) { /* both found */
  2205. if ( UserDefdTokens ) { /* if #tokdefs, must not define new */
  2206. p = (TermEntry *) hash_get(Tname, t);
  2207. if ( p == NULL) {
  2208. err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
  2209.      return;
  2210.             };
  2211. }
  2212. Tklink(t, e);
  2213. if ( a!=NULL ) {
  2214. if ( hasAction(e) ) {
  2215. err(eMsg1("redefinition of action for %s; ignored",e));
  2216. }
  2217. else setHasAction(e, a);
  2218. }
  2219. }
  2220. else if ( t!=NULL ) { /* only one found */
  2221. if ( UserDefdTokens ) {
  2222. p = (TermEntry *) hash_get(Tname, t);
  2223.             if (p == NULL) {
  2224. err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
  2225.             };
  2226.         return;
  2227. }
  2228. if ( Tnum( t ) == 0 ) addTname( t );
  2229. else {
  2230. err(eMsg1("redefinition of token %s; ignored",t));
  2231. }
  2232. if ( a!=NULL ) {
  2233. err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  2234. free((char *)a);
  2235. }
  2236. }
  2237. else if ( e!=NULL ) {
  2238. if ( Tnum( e ) == 0 ) addTexpr( e );
  2239. else {
  2240. if ( hasAction(e) ) {
  2241. err(eMsg1("redefinition of action for expr %s; ignored",e));
  2242. }
  2243. else if ( a==NULL ) {
  2244. err(eMsg1("redefinition of expr %s; ignored",e));
  2245. }
  2246. }
  2247. if ( a!=NULL ) setHasAction(e, a);
  2248. }
  2250. /* if a token type number was specified, then add the token ID and 'tnum'
  2251.  * pair to the ForcedTokens list.  (only applies if an id was given)
  2252.  */
  2253. if ( t!=NULL && tnum>0 )
  2254. {
  2255. if ( set_el(tnum, reserved_positions) )
  2256. {
  2257. err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
  2258. }
  2259. else
  2260. {
  2261. list_add(&ForcedTokens, newForcedToken(t,tnum));
  2262. set_orel(tnum, &reserved_positions);
  2263. }
  2264. }
  2265. }
  2266. >>
  2268. <<
  2269. static int
  2270. #ifdef __USE_PROTOS
  2271. match_token(char *s, char **nxt)
  2272. #else
  2273. match_token(s,nxt)
  2274. char *s;
  2275. char **nxt;
  2276. #endif
  2277. {
  2278.     if ( !(*s>='A' && *s<='Z') ) return 0;
  2279. s++;
  2280.     while ( (*s>='a' && *s<='z') ||
  2281.     (*s>='A' && *s<='Z') ||
  2282.     (*s>='0' && *s<='9') ||
  2283.     *s=='_' )
  2284.     {
  2285.    s++;
  2286. }
  2287. if ( *s!=' ' && *s!='}' ) return 0;
  2288. *nxt = s;
  2289. return 1;
  2290. }
  2292. static int
  2293. #ifdef __USE_PROTOS
  2294. match_rexpr(char *s, char **nxt)
  2295. #else
  2296. match_rexpr(s,nxt)
  2297. char *s;
  2298. char **nxt;
  2299. #endif
  2300. {
  2301.     if ( *s!='"' ) return 0;
  2302. s++;
  2303.     while ( *s!='"' )
  2304.     {
  2305.    if ( *s=='n' || *s=='r' )                   /* MR13 */
  2306.   warn("eoln found in regular expression");
  2307.    if ( *s=='\' ) s++;
  2308.    s++;
  2309. }
  2310. *nxt = s+1;
  2311. return 1;
  2312. }
  2314. /*
  2315.  * Walk a string "{ A .. Z }" where A..Z is a space separated list
  2316.  * of token references (either labels or reg exprs).  Return a
  2317.  * string "inlineX_set" for some unique integer X.  Basically,
  2318.  * we pretend as if we had seen "#tokclass inlineX { A .. Z }"
  2319.  * on the input stream outside of an action.
  2320.  */
  2321. char *
  2322. #ifdef __USE_PROTOS
  2323. inline_set(char *s)
  2324. #else
  2325. inline_set(s)
  2326. char *s;
  2327. #endif
  2328. {
  2329. char *nxt;
  2330.     fprintf(stderr, "found consumeUntil( {...} )n");
  2331. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  2332. if ( *s!='{' )
  2333. {
  2334.    err("malformed consumeUntil( {...} ); missing '{'");
  2335.    return "bad_set";
  2336. }
  2337. s++;
  2338. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  2339. while ( *s!='}' )
  2340. {
  2341.     if ( match_token(s,&nxt) ) fprintf(stderr, "found token %sn", s);
  2342. else if ( match_rexpr(s,&nxt) ) fprintf(stderr, "found rexpr %sn", s);
  2343. else {
  2344.     err("invalid element in consumeUntil( {...} )");
  2345. return "bad_set";
  2346. }
  2347. s = nxt;
  2348. while ( *s==' ' || *s=='t' || *s=='n' || *s=='r' ) {s++;}
  2349. }
  2350. return "inlineX_set";
  2351. }
  2352. >>
  2354. <<
  2355. /* ANTLR-specific syntax error message generator
  2356.  * (define USER_ZZSYN when compiling so don't get 2 definitions)
  2357.  */
  2358. void
  2359. #ifdef __USE_PROTOS
  2360. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok,
  2361. int k, char *bad_text)
  2362. #else
  2363. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  2364. char *text, *egroup, *bad_text;
  2365. int tok;
  2366. int etok;
  2367. int k;
  2368. SetWordType *eset;
  2369. #endif
  2370. {
  2371. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  2372. fprintf(stderr, " syntax error at "%s"", (tok==zzEOF_TOKEN)?"EOF":text);
  2373. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  2374. if ( k==1 ) fprintf(stderr, " missing");
  2375. else
  2376. {
  2377. fprintf(stderr, "; "%s" not", bad_text);
  2378. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  2379. }
  2380. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  2381. else fprintf(stderr, " %s", zztokens[etok]);
  2382. if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
  2383. fprintf(stderr, "n");
  2384. }
  2385. >>
  2387. #lexaction <<
  2388. #ifdef __USE_PROTOS
  2389. void mark_label_used_in_sem_pred(LabelEntry *le)              /* MR10 */
  2390. #else
  2391. void mark_label_used_in_sem_pred(le)                          /* MR10 */
  2392.   LabelEntry    *le;
  2393. #endif
  2394. {
  2395.   TokNode   *tn;
  2396.   require (le->elem->ntype == nToken,"mark_label_used... ntype != nToken");
  2397.   tn=(TokNode *)le->elem;
  2398.   require (tn->label != 0,"mark_label_used... TokNode has no label");
  2399.   tn->label_used_in_semantic_pred=1;
  2400. }
  2401. >>