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