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