![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parse.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex|
Return to parse.y CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex |
1.1 root 1: /* parse.y - parser for flex input */
2:
3: %token CHAR NUMBER SECTEND SCDECL XSCDECL WHITESPACE NAME PREVCCL EOF_OP
4:
5: %{
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:
33: #ifndef lint
34: static char sccsid[] = "@(#)parse.y 5.2 (Berkeley) 6/18/90";
35: #endif /* not lint */
36:
37: #include "flexdef.h"
38:
39: int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, actvp, rulelen;
40: int trlcontxt, xcluflg, cclsorted, varlength, variable_trail_rule;
41: Char clower();
42:
43: static int madeany = false; /* whether we've made the '.' character class */
44: int previous_continued_action; /* whether the previous rule's action was '|' */
45:
46: %}
47:
48: %%
49: goal : initlex sect1 sect1end sect2 initforrule
50: { /* add default rule */
51: int def_rule;
52:
53: pat = cclinit();
54: cclnegate( pat );
55:
56: def_rule = mkstate( -pat );
57:
58: finish_rule( def_rule, false, 0, 0 );
59:
60: for ( i = 1; i <= lastsc; ++i )
61: scset[i] = mkbranch( scset[i], def_rule );
62:
63: if ( spprdflt )
64: fputs( "YY_FATAL_ERROR( \"flex scanner jammed\" )",
65: temp_action_file );
66: else
67: fputs( "ECHO", temp_action_file );
68:
69: fputs( ";\n\tYY_BREAK\n", temp_action_file );
70: }
71: ;
72:
73: initlex :
74: {
75: /* initialize for processing rules */
76:
77: /* create default DFA start condition */
78: scinstal( "INITIAL", false );
79: }
80: ;
81:
82: sect1 : sect1 startconddecl WHITESPACE namelist1 '\n'
83: |
84: | error '\n'
85: { synerr( "unknown error processing section 1" ); }
86: ;
87:
88: sect1end : SECTEND
89: ;
90:
91: startconddecl : SCDECL
92: {
93: /* these productions are separate from the s1object
94: * rule because the semantics must be done before
95: * we parse the remainder of an s1object
96: */
97:
98: xcluflg = false;
99: }
100:
101: | XSCDECL
102: { xcluflg = true; }
103: ;
104:
105: namelist1 : namelist1 WHITESPACE NAME
106: { scinstal( nmstr, xcluflg ); }
107:
108: | NAME
109: { scinstal( nmstr, xcluflg ); }
110:
111: | error
112: { synerr( "bad start condition list" ); }
113: ;
114:
115: sect2 : sect2 initforrule flexrule '\n'
116: |
117: ;
118:
119: initforrule :
120: {
121: /* initialize for a parse of one rule */
122: trlcontxt = variable_trail_rule = varlength = false;
123: trailcnt = headcnt = rulelen = 0;
124: current_state_type = STATE_NORMAL;
125: previous_continued_action = continued_action;
126: new_rule();
127: }
128: ;
129:
130: flexrule : scon '^' rule
131: {
132: pat = $3;
133: finish_rule( pat, variable_trail_rule,
134: headcnt, trailcnt );
135:
136: for ( i = 1; i <= actvp; ++i )
137: scbol[actvsc[i]] =
138: mkbranch( scbol[actvsc[i]], pat );
139:
140: if ( ! bol_needed )
141: {
142: bol_needed = true;
143:
144: if ( performance_report )
145: pinpoint_message(
146: "'^' operator results in sub-optimal performance" );
147: }
148: }
149:
150: | scon rule
151: {
152: pat = $2;
153: finish_rule( pat, variable_trail_rule,
154: headcnt, trailcnt );
155:
156: for ( i = 1; i <= actvp; ++i )
157: scset[actvsc[i]] =
158: mkbranch( scset[actvsc[i]], pat );
159: }
160:
161: | '^' rule
162: {
163: pat = $2;
164: finish_rule( pat, variable_trail_rule,
165: headcnt, trailcnt );
166:
167: /* add to all non-exclusive start conditions,
168: * including the default (0) start condition
169: */
170:
171: for ( i = 1; i <= lastsc; ++i )
172: if ( ! scxclu[i] )
173: scbol[i] = mkbranch( scbol[i], pat );
174:
175: if ( ! bol_needed )
176: {
177: bol_needed = true;
178:
179: if ( performance_report )
180: pinpoint_message(
181: "'^' operator results in sub-optimal performance" );
182: }
183: }
184:
185: | rule
186: {
187: pat = $1;
188: finish_rule( pat, variable_trail_rule,
189: headcnt, trailcnt );
190:
191: for ( i = 1; i <= lastsc; ++i )
192: if ( ! scxclu[i] )
193: scset[i] = mkbranch( scset[i], pat );
194: }
195:
196: | scon EOF_OP
197: { build_eof_action(); }
198:
199: | EOF_OP
200: {
201: /* this EOF applies to all start conditions
202: * which don't already have EOF actions
203: */
204: actvp = 0;
205:
206: for ( i = 1; i <= lastsc; ++i )
207: if ( ! sceof[i] )
208: actvsc[++actvp] = i;
209:
210: if ( actvp == 0 )
211: pinpoint_message(
212: "warning - all start conditions already have <<EOF>> rules" );
213:
214: else
215: build_eof_action();
216: }
217:
218: | error
219: { synerr( "unrecognized rule" ); }
220: ;
221:
222: scon : '<' namelist2 '>'
223: ;
224:
225: namelist2 : namelist2 ',' NAME
226: {
227: if ( (scnum = sclookup( nmstr )) == 0 )
228: format_pinpoint_message(
229: "undeclared start condition %s", nmstr );
230:
231: else
232: actvsc[++actvp] = scnum;
233: }
234:
235: | NAME
236: {
237: if ( (scnum = sclookup( nmstr )) == 0 )
238: format_pinpoint_message(
239: "undeclared start condition %s", nmstr );
240: else
241: actvsc[actvp = 1] = scnum;
242: }
243:
244: | error
245: { synerr( "bad start condition list" ); }
246: ;
247:
248: rule : re2 re
249: {
250: if ( transchar[lastst[$2]] != SYM_EPSILON )
251: /* provide final transition \now/ so it
252: * will be marked as a trailing context
253: * state
254: */
255: $2 = link_machines( $2, mkstate( SYM_EPSILON ) );
256:
257: mark_beginning_as_normal( $2 );
258: current_state_type = STATE_NORMAL;
259:
260: if ( previous_continued_action )
261: {
262: /* we need to treat this as variable trailing
263: * context so that the backup does not happen
264: * in the action but before the action switch
265: * statement. If the backup happens in the
266: * action, then the rules "falling into" this
267: * one's action will *also* do the backup,
268: * erroneously.
269: */
270: if ( ! varlength || headcnt != 0 )
271: {
272: fprintf( stderr,
273: "%s: warning - trailing context rule at line %d made variable because\n",
274: program_name, linenum );
275: fprintf( stderr,
276: " of preceding '|' action\n" );
277: }
278:
279: /* mark as variable */
280: varlength = true;
281: headcnt = 0;
282: }
283:
284: if ( varlength && headcnt == 0 )
285: { /* variable trailing context rule */
286: /* mark the first part of the rule as the accepting
287: * "head" part of a trailing context rule
288: */
289: /* by the way, we didn't do this at the beginning
290: * of this production because back then
291: * current_state_type was set up for a trail
292: * rule, and add_accept() can create a new
293: * state ...
294: */
295: add_accept( $1, num_rules | YY_TRAILING_HEAD_MASK );
296: variable_trail_rule = true;
297: }
298:
299: else
300: trailcnt = rulelen;
301:
302: $$ = link_machines( $1, $2 );
303: }
304:
305: | re2 re '$'
306: { synerr( "trailing context used twice" ); }
307:
308: | re '$'
309: {
310: if ( trlcontxt )
311: {
312: synerr( "trailing context used twice" );
313: $$ = mkstate( SYM_EPSILON );
314: }
315:
316: else if ( previous_continued_action )
317: {
318: /* see the comment in the rule for "re2 re"
319: * above
320: */
321: if ( ! varlength || headcnt != 0 )
322: {
323: fprintf( stderr,
324: "%s: warning - trailing context rule at line %d made variable because\n",
325: program_name, linenum );
326: fprintf( stderr,
327: " of preceding '|' action\n" );
328: }
329:
330: /* mark as variable */
331: varlength = true;
332: headcnt = 0;
333: }
334:
335: trlcontxt = true;
336:
337: if ( ! varlength )
338: headcnt = rulelen;
339:
340: ++rulelen;
341: trailcnt = 1;
342:
343: eps = mkstate( SYM_EPSILON );
344: $$ = link_machines( $1,
345: link_machines( eps, mkstate( '\n' ) ) );
346: }
347:
348: | re
349: {
350: $$ = $1;
351:
352: if ( trlcontxt )
353: {
354: if ( varlength && headcnt == 0 )
355: /* both head and trail are variable-length */
356: variable_trail_rule = true;
357: else
358: trailcnt = rulelen;
359: }
360: }
361: ;
362:
363:
364: re : re '|' series
365: {
366: varlength = true;
367: $$ = mkor( $1, $3 );
368: }
369:
370: | series
371: { $$ = $1; }
372: ;
373:
374:
375: re2 : re '/'
376: {
377: /* this rule is written separately so
378: * the reduction will occur before the trailing
379: * series is parsed
380: */
381:
382: if ( trlcontxt )
383: synerr( "trailing context used twice" );
384: else
385: trlcontxt = true;
386:
387: if ( varlength )
388: /* we hope the trailing context is fixed-length */
389: varlength = false;
390: else
391: headcnt = rulelen;
392:
393: rulelen = 0;
394:
395: current_state_type = STATE_TRAILING_CONTEXT;
396: $$ = $1;
397: }
398: ;
399:
400: series : series singleton
401: {
402: /* this is where concatenation of adjacent patterns
403: * gets done
404: */
405: $$ = link_machines( $1, $2 );
406: }
407:
408: | singleton
409: { $$ = $1; }
410: ;
411:
412: singleton : singleton '*'
413: {
414: varlength = true;
415:
416: $$ = mkclos( $1 );
417: }
418:
419: | singleton '+'
420: {
421: varlength = true;
422:
423: $$ = mkposcl( $1 );
424: }
425:
426: | singleton '?'
427: {
428: varlength = true;
429:
430: $$ = mkopt( $1 );
431: }
432:
433: | singleton '{' NUMBER ',' NUMBER '}'
434: {
435: varlength = true;
436:
437: if ( $3 > $5 || $3 < 0 )
438: {
439: synerr( "bad iteration values" );
440: $$ = $1;
441: }
442: else
443: {
444: if ( $3 == 0 )
445: $$ = mkopt( mkrep( $1, $3, $5 ) );
446: else
447: $$ = mkrep( $1, $3, $5 );
448: }
449: }
450:
451: | singleton '{' NUMBER ',' '}'
452: {
453: varlength = true;
454:
455: if ( $3 <= 0 )
456: {
457: synerr( "iteration value must be positive" );
458: $$ = $1;
459: }
460:
461: else
462: $$ = mkrep( $1, $3, INFINITY );
463: }
464:
465: | singleton '{' NUMBER '}'
466: {
467: /* the singleton could be something like "(foo)",
468: * in which case we have no idea what its length
469: * is, so we punt here.
470: */
471: varlength = true;
472:
473: if ( $3 <= 0 )
474: {
475: synerr( "iteration value must be positive" );
476: $$ = $1;
477: }
478:
479: else
480: $$ = link_machines( $1, copysingl( $1, $3 - 1 ) );
481: }
482:
483: | '.'
484: {
485: if ( ! madeany )
486: {
487: /* create the '.' character class */
488: anyccl = cclinit();
489: ccladd( anyccl, '\n' );
490: cclnegate( anyccl );
491:
492: if ( useecs )
493: mkeccl( ccltbl + cclmap[anyccl],
494: ccllen[anyccl], nextecm,
495: ecgroup, csize, csize );
496:
497: madeany = true;
498: }
499:
500: ++rulelen;
501:
502: $$ = mkstate( -anyccl );
503: }
504:
505: | fullccl
506: {
507: if ( ! cclsorted )
508: /* sort characters for fast searching. We use a
509: * shell sort since this list could be large.
510: */
511: cshell( ccltbl + cclmap[$1], ccllen[$1], true );
512:
513: if ( useecs )
514: mkeccl( ccltbl + cclmap[$1], ccllen[$1],
515: nextecm, ecgroup, csize, csize );
516:
517: ++rulelen;
518:
519: $$ = mkstate( -$1 );
520: }
521:
522: | PREVCCL
523: {
524: ++rulelen;
525:
526: $$ = mkstate( -$1 );
527: }
528:
529: | '"' string '"'
530: { $$ = $2; }
531:
532: | '(' re ')'
533: { $$ = $2; }
534:
535: | CHAR
536: {
537: ++rulelen;
538:
539: if ( caseins && $1 >= 'A' && $1 <= 'Z' )
540: $1 = clower( $1 );
541:
542: $$ = mkstate( $1 );
543: }
544: ;
545:
546: fullccl : '[' ccl ']'
547: { $$ = $2; }
548:
549: | '[' '^' ccl ']'
550: {
551: /* *Sigh* - to be compatible Unix lex, negated ccls
552: * match newlines
553: */
554: #ifdef NOTDEF
555: ccladd( $3, '\n' ); /* negated ccls don't match '\n' */
556: cclsorted = false; /* because we added the newline */
557: #endif
558: cclnegate( $3 );
559: $$ = $3;
560: }
561: ;
562:
563: ccl : ccl CHAR '-' CHAR
564: {
565: if ( $2 > $4 )
566: synerr( "negative range in character class" );
567:
568: else
569: {
570: if ( caseins )
571: {
572: if ( $2 >= 'A' && $2 <= 'Z' )
573: $2 = clower( $2 );
574: if ( $4 >= 'A' && $4 <= 'Z' )
575: $4 = clower( $4 );
576: }
577:
578: for ( i = $2; i <= $4; ++i )
579: ccladd( $1, i );
580:
581: /* keep track if this ccl is staying in alphabetical
582: * order
583: */
584: cclsorted = cclsorted && ($2 > lastchar);
585: lastchar = $4;
586: }
587:
588: $$ = $1;
589: }
590:
591: | ccl CHAR
592: {
593: if ( caseins )
594: if ( $2 >= 'A' && $2 <= 'Z' )
595: $2 = clower( $2 );
596:
597: ccladd( $1, $2 );
598: cclsorted = cclsorted && ($2 > lastchar);
599: lastchar = $2;
600: $$ = $1;
601: }
602:
603: |
604: {
605: cclsorted = true;
606: lastchar = 0;
607: $$ = cclinit();
608: }
609: ;
610:
611: string : string CHAR
612: {
613: if ( caseins )
614: if ( $2 >= 'A' && $2 <= 'Z' )
615: $2 = clower( $2 );
616:
617: ++rulelen;
618:
619: $$ = link_machines( $1, mkstate( $2 ) );
620: }
621:
622: |
623: { $$ = mkstate( SYM_EPSILON ); }
624: ;
625:
626: %%
627:
628:
629: /* build_eof_action - build the "<<EOF>>" action for the active start
630: * conditions
631: */
632:
633: void build_eof_action()
634:
635: {
636: register int i;
637:
638: for ( i = 1; i <= actvp; ++i )
639: {
640: if ( sceof[actvsc[i]] )
641: format_pinpoint_message(
642: "multiple <<EOF>> rules for start condition %s",
643: scname[actvsc[i]] );
644:
645: else
646: {
647: sceof[actvsc[i]] = true;
648: fprintf( temp_action_file, "case YY_STATE_EOF(%s):\n",
649: scname[actvsc[i]] );
650: }
651: }
652:
653: line_directive_out( temp_action_file );
654: }
655:
656:
657: /* synerr - report a syntax error */
658:
659: void synerr( str )
660: char str[];
661:
662: {
663: syntaxerror = true;
664: pinpoint_message( str );
665: }
666:
667:
668: /* format_pinpoint_message - write out a message formatted with one string,
669: * pinpointing its location
670: */
671:
672: void format_pinpoint_message( msg, arg )
673: char msg[], arg[];
674:
675: {
676: char errmsg[MAXLINE];
677:
678: (void) sprintf( errmsg, msg, arg );
679: pinpoint_message( errmsg );
680: }
681:
682:
683: /* pinpoint_message - write out a message, pinpointing its location */
684:
685: void pinpoint_message( str )
686: char str[];
687:
688: {
689: fprintf( stderr, "\"%s\", line %d: %s\n", infilename, linenum, str );
690: }
691:
692:
693: /* yyerror - eat up an error message from the parser;
694: * currently, messages are ignore
695: */
696:
697: void yyerror( msg )
698: char msg[];
699:
700: {
701: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.