/usr.bin/lex/parse.y

https://bitbucket.org/freebsd/freebsd-head/ · Happy · 914 lines · 737 code · 177 blank · 0 comment · 0 complexity · 841cb6e964918a1d0493427b94ccda50 MD5 · raw file

  1. /* parse.y - parser for flex input */
  2. %token CHAR NUMBER SECTEND SCDECL XSCDECL NAME PREVCCL EOF_OP
  3. %token OPTION_OP OPT_OUTFILE OPT_PREFIX OPT_YYCLASS
  4. %token CCE_ALNUM CCE_ALPHA CCE_BLANK CCE_CNTRL CCE_DIGIT CCE_GRAPH
  5. %token CCE_LOWER CCE_PRINT CCE_PUNCT CCE_SPACE CCE_UPPER CCE_XDIGIT
  6. %{
  7. /*-
  8. * Copyright (c) 1990 The Regents of the University of California.
  9. * All rights reserved.
  10. *
  11. * This code is derived from software contributed to Berkeley by
  12. * Vern Paxson.
  13. *
  14. * The United States Government has rights in this work pursuant
  15. * to contract no. DE-AC03-76SF00098 between the United States
  16. * Department of Energy and the University of California.
  17. *
  18. * Redistribution and use in source and binary forms are permitted provided
  19. * that: (1) source distributions retain this entire copyright notice and
  20. * comment, and (2) distributions including binaries display the following
  21. * acknowledgement: ``This product includes software developed by the
  22. * University of California, Berkeley and its contributors'' in the
  23. * documentation or other materials provided with the distribution and in
  24. * all advertising materials mentioning features or use of this software.
  25. * Neither the name of the University nor the names of its contributors may
  26. * be used to endorse or promote products derived from this software without
  27. * specific prior written permission.
  28. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  29. * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  30. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  31. */
  32. /* $Header: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.28 95/04/21 11:51:51 vern Exp $ */
  33. /* $FreeBSD$ */
  34. /* Some versions of bison are broken in that they use alloca() but don't
  35. * declare it properly. The following is the patented (just kidding!)
  36. * #ifdef chud to fix the problem, courtesy of Francois Pinard.
  37. */
  38. #ifdef YYBISON
  39. /* AIX requires this to be the first thing in the file. What a piece. */
  40. # ifdef _AIX
  41. #pragma alloca
  42. # endif
  43. #endif
  44. #include "flexdef.h"
  45. /* The remainder of the alloca() cruft has to come after including flexdef.h,
  46. * so HAVE_ALLOCA_H is (possibly) defined.
  47. */
  48. #ifdef YYBISON
  49. # ifdef __GNUC__
  50. # ifndef alloca
  51. # define alloca __builtin_alloca
  52. # endif
  53. # else
  54. # if HAVE_ALLOCA_H
  55. # include <alloca.h>
  56. # else
  57. # ifdef __hpux
  58. void *alloca ();
  59. # else
  60. # ifdef __TURBOC__
  61. # include <malloc.h>
  62. # else
  63. char *alloca ();
  64. # endif
  65. # endif
  66. # endif
  67. # endif
  68. #endif
  69. /* Bletch, ^^^^ that was ugly! */
  70. int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
  71. int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
  72. int *scon_stk;
  73. int scon_stk_ptr;
  74. static int madeany = false; /* whether we've made the '.' character class */
  75. int previous_continued_action; /* whether the previous rule's action was '|' */
  76. /* Expand a POSIX character class expression. */
  77. #define CCL_EXPR(func) \
  78. { \
  79. int c; \
  80. for ( c = 0; c < csize; ++c ) \
  81. if ( isascii(c) && func(c) ) \
  82. ccladd( currccl, c ); \
  83. }
  84. /* While POSIX defines isblank(), it's not ANSI C. */
  85. #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
  86. /* On some over-ambitious machines, such as DEC Alpha's, the default
  87. * token type is "long" instead of "int"; this leads to problems with
  88. * declaring yylval in flexdef.h. But so far, all the yacc's I've seen
  89. * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
  90. * following should ensure that the default token type is "int".
  91. */
  92. #define YYSTYPE int
  93. %}
  94. %%
  95. goal : initlex sect1 sect1end sect2 initforrule
  96. { /* add default rule */
  97. int def_rule;
  98. pat = cclinit();
  99. cclnegate( pat );
  100. def_rule = mkstate( -pat );
  101. /* Remember the number of the default rule so we
  102. * don't generate "can't match" warnings for it.
  103. */
  104. default_rule = num_rules;
  105. finish_rule( def_rule, false, 0, 0 );
  106. for ( i = 1; i <= lastsc; ++i )
  107. scset[i] = mkbranch( scset[i], def_rule );
  108. if ( spprdflt )
  109. add_action(
  110. "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
  111. else
  112. add_action( "ECHO" );
  113. add_action( ";\n\tYY_BREAK\n" );
  114. }
  115. ;
  116. initlex :
  117. { /* initialize for processing rules */
  118. /* Create default DFA start condition. */
  119. scinstal( "INITIAL", false );
  120. }
  121. ;
  122. sect1 : sect1 startconddecl namelist1
  123. | sect1 options
  124. |
  125. | error
  126. { synerr( "unknown error processing section 1" ); }
  127. ;
  128. sect1end : SECTEND
  129. {
  130. check_options();
  131. scon_stk = allocate_integer_array( lastsc + 1 );
  132. scon_stk_ptr = 0;
  133. }
  134. ;
  135. startconddecl : SCDECL
  136. { xcluflg = false; }
  137. | XSCDECL
  138. { xcluflg = true; }
  139. ;
  140. namelist1 : namelist1 NAME
  141. { scinstal( nmstr, xcluflg ); }
  142. | NAME
  143. { scinstal( nmstr, xcluflg ); }
  144. | error
  145. { synerr( "bad start condition list" ); }
  146. ;
  147. options : OPTION_OP optionlist
  148. ;
  149. optionlist : optionlist option
  150. |
  151. ;
  152. option : OPT_OUTFILE '=' NAME
  153. {
  154. outfilename = copy_string( nmstr );
  155. did_outfilename = 1;
  156. }
  157. | OPT_PREFIX '=' NAME
  158. { prefix = copy_string( nmstr ); }
  159. | OPT_YYCLASS '=' NAME
  160. { yyclass = copy_string( nmstr ); }
  161. ;
  162. sect2 : sect2 scon initforrule flexrule '\n'
  163. { scon_stk_ptr = $2; }
  164. | sect2 scon '{' sect2 '}'
  165. { scon_stk_ptr = $2; }
  166. |
  167. ;
  168. initforrule :
  169. {
  170. /* Initialize for a parse of one rule. */
  171. trlcontxt = variable_trail_rule = varlength = false;
  172. trailcnt = headcnt = rulelen = 0;
  173. current_state_type = STATE_NORMAL;
  174. previous_continued_action = continued_action;
  175. in_rule = true;
  176. new_rule();
  177. }
  178. ;
  179. flexrule : '^' rule
  180. {
  181. pat = $2;
  182. finish_rule( pat, variable_trail_rule,
  183. headcnt, trailcnt );
  184. if ( scon_stk_ptr > 0 )
  185. {
  186. for ( i = 1; i <= scon_stk_ptr; ++i )
  187. scbol[scon_stk[i]] =
  188. mkbranch( scbol[scon_stk[i]],
  189. pat );
  190. }
  191. else
  192. {
  193. /* Add to all non-exclusive start conditions,
  194. * including the default (0) start condition.
  195. */
  196. for ( i = 1; i <= lastsc; ++i )
  197. if ( ! scxclu[i] )
  198. scbol[i] = mkbranch( scbol[i],
  199. pat );
  200. }
  201. if ( ! bol_needed )
  202. {
  203. bol_needed = true;
  204. if ( performance_report > 1 )
  205. pinpoint_message(
  206. "'^' operator results in sub-optimal performance" );
  207. }
  208. }
  209. | rule
  210. {
  211. pat = $1;
  212. finish_rule( pat, variable_trail_rule,
  213. headcnt, trailcnt );
  214. if ( scon_stk_ptr > 0 )
  215. {
  216. for ( i = 1; i <= scon_stk_ptr; ++i )
  217. scset[scon_stk[i]] =
  218. mkbranch( scset[scon_stk[i]],
  219. pat );
  220. }
  221. else
  222. {
  223. for ( i = 1; i <= lastsc; ++i )
  224. if ( ! scxclu[i] )
  225. scset[i] =
  226. mkbranch( scset[i],
  227. pat );
  228. }
  229. }
  230. | EOF_OP
  231. {
  232. if ( scon_stk_ptr > 0 )
  233. build_eof_action();
  234. else
  235. {
  236. /* This EOF applies to all start conditions
  237. * which don't already have EOF actions.
  238. */
  239. for ( i = 1; i <= lastsc; ++i )
  240. if ( ! sceof[i] )
  241. scon_stk[++scon_stk_ptr] = i;
  242. if ( scon_stk_ptr == 0 )
  243. warn(
  244. "all start conditions already have <<EOF>> rules" );
  245. else
  246. build_eof_action();
  247. }
  248. }
  249. | error
  250. { synerr( "unrecognized rule" ); }
  251. ;
  252. scon_stk_ptr :
  253. { $$ = scon_stk_ptr; }
  254. ;
  255. scon : '<' scon_stk_ptr namelist2 '>'
  256. { $$ = $2; }
  257. | '<' '*' '>'
  258. {
  259. $$ = scon_stk_ptr;
  260. for ( i = 1; i <= lastsc; ++i )
  261. {
  262. int j;
  263. for ( j = 1; j <= scon_stk_ptr; ++j )
  264. if ( scon_stk[j] == i )
  265. break;
  266. if ( j > scon_stk_ptr )
  267. scon_stk[++scon_stk_ptr] = i;
  268. }
  269. }
  270. |
  271. { $$ = scon_stk_ptr; }
  272. ;
  273. namelist2 : namelist2 ',' sconname
  274. | sconname
  275. | error
  276. { synerr( "bad start condition list" ); }
  277. ;
  278. sconname : NAME
  279. {
  280. if ( (scnum = sclookup( nmstr )) == 0 )
  281. format_pinpoint_message(
  282. "undeclared start condition %s",
  283. nmstr );
  284. else
  285. {
  286. for ( i = 1; i <= scon_stk_ptr; ++i )
  287. if ( scon_stk[i] == scnum )
  288. {
  289. format_warn(
  290. "<%s> specified twice",
  291. scname[scnum] );
  292. break;
  293. }
  294. if ( i > scon_stk_ptr )
  295. scon_stk[++scon_stk_ptr] = scnum;
  296. }
  297. }
  298. ;
  299. rule : re2 re
  300. {
  301. if ( transchar[lastst[$2]] != SYM_EPSILON )
  302. /* Provide final transition \now/ so it
  303. * will be marked as a trailing context
  304. * state.
  305. */
  306. $2 = link_machines( $2,
  307. mkstate( SYM_EPSILON ) );
  308. mark_beginning_as_normal( $2 );
  309. current_state_type = STATE_NORMAL;
  310. if ( previous_continued_action )
  311. {
  312. /* We need to treat this as variable trailing
  313. * context so that the backup does not happen
  314. * in the action but before the action switch
  315. * statement. If the backup happens in the
  316. * action, then the rules "falling into" this
  317. * one's action will *also* do the backup,
  318. * erroneously.
  319. */
  320. if ( ! varlength || headcnt != 0 )
  321. warn(
  322. "trailing context made variable due to preceding '|' action" );
  323. /* Mark as variable. */
  324. varlength = true;
  325. headcnt = 0;
  326. }
  327. if ( lex_compat || (varlength && headcnt == 0) )
  328. { /* variable trailing context rule */
  329. /* Mark the first part of the rule as the
  330. * accepting "head" part of a trailing
  331. * context rule.
  332. *
  333. * By the way, we didn't do this at the
  334. * beginning of this production because back
  335. * then current_state_type was set up for a
  336. * trail rule, and add_accept() can create
  337. * a new state ...
  338. */
  339. add_accept( $1,
  340. num_rules | YY_TRAILING_HEAD_MASK );
  341. variable_trail_rule = true;
  342. }
  343. else
  344. trailcnt = rulelen;
  345. $$ = link_machines( $1, $2 );
  346. }
  347. | re2 re '$'
  348. { synerr( "trailing context used twice" ); }
  349. | re '$'
  350. {
  351. headcnt = 0;
  352. trailcnt = 1;
  353. rulelen = 1;
  354. varlength = false;
  355. current_state_type = STATE_TRAILING_CONTEXT;
  356. if ( trlcontxt )
  357. {
  358. synerr( "trailing context used twice" );
  359. $$ = mkstate( SYM_EPSILON );
  360. }
  361. else if ( previous_continued_action )
  362. {
  363. /* See the comment in the rule for "re2 re"
  364. * above.
  365. */
  366. warn(
  367. "trailing context made variable due to preceding '|' action" );
  368. varlength = true;
  369. }
  370. if ( lex_compat || varlength )
  371. {
  372. /* Again, see the comment in the rule for
  373. * "re2 re" above.
  374. */
  375. add_accept( $1,
  376. num_rules | YY_TRAILING_HEAD_MASK );
  377. variable_trail_rule = true;
  378. }
  379. trlcontxt = true;
  380. eps = mkstate( SYM_EPSILON );
  381. $$ = link_machines( $1,
  382. link_machines( eps, mkstate( '\n' ) ) );
  383. }
  384. | re
  385. {
  386. $$ = $1;
  387. if ( trlcontxt )
  388. {
  389. if ( lex_compat || (varlength && headcnt == 0) )
  390. /* Both head and trail are
  391. * variable-length.
  392. */
  393. variable_trail_rule = true;
  394. else
  395. trailcnt = rulelen;
  396. }
  397. }
  398. ;
  399. re : re '|' series
  400. {
  401. varlength = true;
  402. $$ = mkor( $1, $3 );
  403. }
  404. | series
  405. { $$ = $1; }
  406. ;
  407. re2 : re '/'
  408. {
  409. /* This rule is written separately so the
  410. * reduction will occur before the trailing
  411. * series is parsed.
  412. */
  413. if ( trlcontxt )
  414. synerr( "trailing context used twice" );
  415. else
  416. trlcontxt = true;
  417. if ( varlength )
  418. /* We hope the trailing context is
  419. * fixed-length.
  420. */
  421. varlength = false;
  422. else
  423. headcnt = rulelen;
  424. rulelen = 0;
  425. current_state_type = STATE_TRAILING_CONTEXT;
  426. $$ = $1;
  427. }
  428. ;
  429. series : series singleton
  430. {
  431. /* This is where concatenation of adjacent patterns
  432. * gets done.
  433. */
  434. $$ = link_machines( $1, $2 );
  435. }
  436. | singleton
  437. { $$ = $1; }
  438. ;
  439. singleton : singleton '*'
  440. {
  441. varlength = true;
  442. $$ = mkclos( $1 );
  443. }
  444. | singleton '+'
  445. {
  446. varlength = true;
  447. $$ = mkposcl( $1 );
  448. }
  449. | singleton '?'
  450. {
  451. varlength = true;
  452. $$ = mkopt( $1 );
  453. }
  454. | singleton '{' NUMBER ',' NUMBER '}'
  455. {
  456. varlength = true;
  457. if ( $3 > $5 || $3 < 0 )
  458. {
  459. synerr( "bad iteration values" );
  460. $$ = $1;
  461. }
  462. else
  463. {
  464. if ( $3 == 0 )
  465. {
  466. if ( $5 <= 0 )
  467. {
  468. synerr(
  469. "bad iteration values" );
  470. $$ = $1;
  471. }
  472. else
  473. $$ = mkopt(
  474. mkrep( $1, 1, $5 ) );
  475. }
  476. else
  477. $$ = mkrep( $1, $3, $5 );
  478. }
  479. }
  480. | singleton '{' NUMBER ',' '}'
  481. {
  482. varlength = true;
  483. if ( $3 <= 0 )
  484. {
  485. synerr( "iteration value must be positive" );
  486. $$ = $1;
  487. }
  488. else
  489. $$ = mkrep( $1, $3, INFINITY );
  490. }
  491. | singleton '{' NUMBER '}'
  492. {
  493. /* The singleton could be something like "(foo)",
  494. * in which case we have no idea what its length
  495. * is, so we punt here.
  496. */
  497. varlength = true;
  498. if ( $3 <= 0 )
  499. {
  500. synerr( "iteration value must be positive" );
  501. $$ = $1;
  502. }
  503. else
  504. $$ = link_machines( $1,
  505. copysingl( $1, $3 - 1 ) );
  506. }
  507. | '.'
  508. {
  509. if ( ! madeany )
  510. {
  511. /* Create the '.' character class. */
  512. anyccl = cclinit();
  513. ccladd( anyccl, '\n' );
  514. cclnegate( anyccl );
  515. if ( useecs )
  516. mkeccl( ccltbl + cclmap[anyccl],
  517. ccllen[anyccl], nextecm,
  518. ecgroup, csize, csize );
  519. madeany = true;
  520. }
  521. ++rulelen;
  522. $$ = mkstate( -anyccl );
  523. }
  524. | fullccl
  525. {
  526. if ( ! cclsorted )
  527. /* Sort characters for fast searching. We
  528. * use a shell sort since this list could
  529. * be large.
  530. */
  531. cshell( ccltbl + cclmap[$1], ccllen[$1], true );
  532. if ( useecs )
  533. mkeccl( ccltbl + cclmap[$1], ccllen[$1],
  534. nextecm, ecgroup, csize, csize );
  535. ++rulelen;
  536. $$ = mkstate( -$1 );
  537. }
  538. | PREVCCL
  539. {
  540. ++rulelen;
  541. $$ = mkstate( -$1 );
  542. }
  543. | '"' string '"'
  544. { $$ = $2; }
  545. | '(' re ')'
  546. { $$ = $2; }
  547. | CHAR
  548. {
  549. ++rulelen;
  550. if ( caseins && $1 >= 'A' && $1 <= 'Z' )
  551. $1 = clower( $1 );
  552. $$ = mkstate( $1 );
  553. }
  554. ;
  555. fullccl : '[' ccl ']'
  556. { $$ = $2; }
  557. | '[' '^' ccl ']'
  558. {
  559. cclnegate( $3 );
  560. $$ = $3;
  561. }
  562. ;
  563. ccl : ccl CHAR '-' CHAR
  564. {
  565. if ( caseins )
  566. {
  567. if ( $2 >= 'A' && $2 <= 'Z' )
  568. $2 = clower( $2 );
  569. if ( $4 >= 'A' && $4 <= 'Z' )
  570. $4 = clower( $4 );
  571. }
  572. if ( $2 > $4 )
  573. synerr( "negative range in character class" );
  574. else
  575. {
  576. for ( i = $2; i <= $4; ++i )
  577. ccladd( $1, i );
  578. /* Keep track if this ccl is staying in
  579. * alphabetical order.
  580. */
  581. cclsorted = cclsorted && ($2 > lastchar);
  582. lastchar = $4;
  583. }
  584. $$ = $1;
  585. }
  586. | ccl CHAR
  587. {
  588. if ( caseins && $2 >= 'A' && $2 <= 'Z' )
  589. $2 = clower( $2 );
  590. ccladd( $1, $2 );
  591. cclsorted = cclsorted && ($2 > lastchar);
  592. lastchar = $2;
  593. $$ = $1;
  594. }
  595. | ccl ccl_expr
  596. {
  597. /* Too hard to properly maintain cclsorted. */
  598. cclsorted = false;
  599. $$ = $1;
  600. }
  601. |
  602. {
  603. cclsorted = true;
  604. lastchar = 0;
  605. currccl = $$ = cclinit();
  606. }
  607. ;
  608. ccl_expr: CCE_ALNUM { CCL_EXPR(isalnum) }
  609. | CCE_ALPHA { CCL_EXPR(isalpha) }
  610. | CCE_BLANK { CCL_EXPR(IS_BLANK) }
  611. | CCE_CNTRL { CCL_EXPR(iscntrl) }
  612. | CCE_DIGIT { CCL_EXPR(isdigit) }
  613. | CCE_GRAPH { CCL_EXPR(isgraph) }
  614. | CCE_LOWER { CCL_EXPR(islower) }
  615. | CCE_PRINT { CCL_EXPR(isprint) }
  616. | CCE_PUNCT { CCL_EXPR(ispunct) }
  617. | CCE_SPACE { CCL_EXPR(isspace) }
  618. | CCE_UPPER {
  619. if ( caseins )
  620. CCL_EXPR(islower)
  621. else
  622. CCL_EXPR(isupper)
  623. }
  624. | CCE_XDIGIT { CCL_EXPR(isxdigit) }
  625. ;
  626. string : string CHAR
  627. {
  628. if ( caseins && $2 >= 'A' && $2 <= 'Z' )
  629. $2 = clower( $2 );
  630. ++rulelen;
  631. $$ = link_machines( $1, mkstate( $2 ) );
  632. }
  633. |
  634. { $$ = mkstate( SYM_EPSILON ); }
  635. ;
  636. %%
  637. /* build_eof_action - build the "<<EOF>>" action for the active start
  638. * conditions
  639. */
  640. void build_eof_action()
  641. {
  642. int i;
  643. char action_text[MAXLINE];
  644. for ( i = 1; i <= scon_stk_ptr; ++i )
  645. {
  646. if ( sceof[scon_stk[i]] )
  647. format_pinpoint_message(
  648. "multiple <<EOF>> rules for start condition %s",
  649. scname[scon_stk[i]] );
  650. else
  651. {
  652. sceof[scon_stk[i]] = true;
  653. sprintf( action_text, "case YY_STATE_EOF(%s):\n",
  654. scname[scon_stk[i]] );
  655. add_action( action_text );
  656. }
  657. }
  658. line_directive_out( (FILE *) 0, 1 );
  659. /* This isn't a normal rule after all - don't count it as
  660. * such, so we don't have any holes in the rule numbering
  661. * (which make generating "rule can never match" warnings
  662. * more difficult.
  663. */
  664. --num_rules;
  665. ++num_eof_rules;
  666. }
  667. /* format_synerr - write out formatted syntax error */
  668. void format_synerr( msg, arg )
  669. char msg[], arg[];
  670. {
  671. char errmsg[MAXLINE];
  672. (void) sprintf( errmsg, msg, arg );
  673. synerr( errmsg );
  674. }
  675. /* synerr - report a syntax error */
  676. void synerr( str )
  677. char str[];
  678. {
  679. syntaxerror = true;
  680. pinpoint_message( str );
  681. }
  682. /* format_warn - write out formatted warning */
  683. void format_warn( msg, arg )
  684. char msg[], arg[];
  685. {
  686. char warn_msg[MAXLINE];
  687. (void) sprintf( warn_msg, msg, arg );
  688. warn( warn_msg );
  689. }
  690. /* warn - report a warning, unless -w was given */
  691. void warn( str )
  692. char str[];
  693. {
  694. line_warning( str, linenum );
  695. }
  696. /* format_pinpoint_message - write out a message formatted with one string,
  697. * pinpointing its location
  698. */
  699. void format_pinpoint_message( msg, arg )
  700. char msg[], arg[];
  701. {
  702. char errmsg[MAXLINE];
  703. (void) sprintf( errmsg, msg, arg );
  704. pinpoint_message( errmsg );
  705. }
  706. /* pinpoint_message - write out a message, pinpointing its location */
  707. void pinpoint_message( str )
  708. char str[];
  709. {
  710. line_pinpoint( str, linenum );
  711. }
  712. /* line_warning - report a warning at a given line, unless -w was given */
  713. void line_warning( str, line )
  714. char str[];
  715. int line;
  716. {
  717. char warning[MAXLINE];
  718. if ( ! nowarn )
  719. {
  720. sprintf( warning, "warning, %s", str );
  721. line_pinpoint( warning, line );
  722. }
  723. }
  724. /* line_pinpoint - write out a message, pinpointing it at the given line */
  725. void line_pinpoint( str, line )
  726. char str[];
  727. int line;
  728. {
  729. fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
  730. }
  731. /* yyerror - eat up an error message from the parser;
  732. * currently, messages are ignore
  733. */
  734. void yyerror( msg )
  735. char msg[];
  736. {
  737. }