![[BACK]](/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex|
Return to main.c CVS log | Up to [local] / src / usr.bin / lex |
1.1 deraadt 1: /* flex - tool to generate fast lexical analyzers */
2:
3: /*-
4: * Copyright (c) 1990 The Regents of the University of California.
5: * All rights reserved.
6: *
7: * This code is derived from software contributed to Berkeley by
8: * Vern Paxson.
9: *
10: * The United States Government has rights in this work pursuant
11: * to contract no. DE-AC03-76SF00098 between the United States
12: * Department of Energy and the University of California.
13: *
14: * Redistribution and use in source and binary forms are permitted provided
15: * that: (1) source distributions retain this entire copyright notice and
16: * comment, and (2) distributions including binaries display the following
17: * acknowledgement: ``This product includes software developed by the
18: * University of California, Berkeley and its contributors'' in the
19: * documentation or other materials provided with the distribution and in
20: * all advertising materials mentioning features or use of this software.
21: * Neither the name of the University nor the names of its contributors may
22: * be used to endorse or promote products derived from this software without
23: * specific prior written permission.
24: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
25: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
26: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27: */
28:
29: #ifndef lint
30: char copyright[] =
31: "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
32: All rights reserved.\n";
33: #endif /* not lint */
34:
35: /* $Header: /a/cvsroot/src/usr.bin/lex/main.c,v 1.9 1995/05/05 05:35:34 jtc Exp $ */
36:
37:
38: #include "flexdef.h"
39: #include "version.h"
40:
41: static char flex_version[] = FLEX_VERSION;
42:
43:
44: /* declare functions that have forward references */
45:
46: void flexinit PROTO((int, char**));
47: void readin PROTO((void));
48: void set_up_initial_allocations PROTO((void));
49:
50: #ifdef NEED_ARGV_FIXUP
51: extern void argv_fixup PROTO((int *, char ***));
52: #endif
53:
54:
55: /* these globals are all defined and commented in flexdef.h */
56: int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
57: int interactive, caseins, lex_compat, do_yylineno, useecs, fulltbl, usemecs;
58: int fullspd, gen_line_dirs, performance_report, backing_up_report;
59: int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, csize;
60: int yymore_used, reject, real_reject, continued_action, in_rule;
61: int yymore_really_used, reject_really_used;
62: int datapos, dataline, linenum, out_linenum;
63: FILE *skelfile = NULL;
64: int skel_ind = 0;
65: char *action_array;
66: int action_size, defs1_offset, prolog_offset, action_offset, action_index;
67: char *infilename = NULL, *outfilename = NULL;
68: int did_outfilename;
69: char *prefix, *yyclass;
70: int do_stdinit, use_stdout;
71: int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
72: int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
73: int current_mns, current_max_rules;
74: int num_rules, num_eof_rules, default_rule, lastnfa;
75: int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
76: int *accptnum, *assoc_rule, *state_type;
77: int *rule_type, *rule_linenum, *rule_useful;
78: int current_state_type;
79: int variable_trailing_context_rules;
80: int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
81: int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
82: int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
83: int tecbck[CSIZE + 1];
84: int lastsc, *scset, *scbol, *scxclu, *sceof;
85: int current_max_scs;
86: char **scname;
87: int current_max_dfa_size, current_max_xpairs;
88: int current_max_template_xpairs, current_max_dfas;
89: int lastdfa, *nxt, *chk, *tnxt;
90: int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
91: union dfaacc_union *dfaacc;
92: int *accsiz, *dhash, numas;
93: int numsnpairs, jambase, jamstate;
94: int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
95: int current_maxccls, current_max_ccl_tbl_size;
96: Char *ccltbl;
97: char nmstr[MAXLINE];
98: int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
99: int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
100: int num_backing_up, bol_needed;
101: FILE *backing_up_file;
102: int end_of_buffer_state;
103: char **input_files;
104: int num_input_files;
105:
106: /* Make sure program_name is initialized so we don't crash if writing
107: * out an error message before getting the program name from argv[0].
108: */
109: char *program_name = "flex";
110:
111: #ifndef SHORT_FILE_NAMES
112: static char *outfile_template = "lex.%s.%s";
113: static char *backing_name = "lex.backup";
114: #else
115: static char *outfile_template = "lex%s.%s";
116: static char *backing_name = "lex.bck";
117: #endif
118:
119: #ifdef THINK_C
120: #include <console.h>
121: #endif
122:
123: #ifdef MS_DOS
124: extern unsigned _stklen = 16384;
125: #endif
126:
127: static char outfile_path[MAXLINE];
128: static int outfile_created = 0;
129: static char *skelname = NULL;
130:
131:
132: int main( argc, argv )
133: int argc;
134: char **argv;
135: {
136: int i;
137:
138: #ifdef THINK_C
139: argc = ccommand( &argv );
140: #endif
141: #ifdef NEED_ARGV_FIXUP
142: argv_fixup( &argc, &argv );
143: #endif
144:
145: flexinit( argc, argv );
146:
147: readin();
148:
149: ntod();
150:
151: for ( i = 1; i <= num_rules; ++i )
152: if ( ! rule_useful[i] && i != default_rule )
153: line_warning( _( "rule cannot be matched" ),
154: rule_linenum[i] );
155:
156: if ( spprdflt && ! reject && rule_useful[default_rule] )
157: line_warning(
158: _( "-s option given but default rule can be matched" ),
159: rule_linenum[default_rule] );
160:
161: /* Generate the C state transition tables from the DFA. */
162: make_tables();
163:
164: /* Note, flexend does not return. It exits with its argument
165: * as status.
166: */
167: flexend( 0 );
168:
169: return 0; /* keep compilers/lint happy */
170: }
171:
172:
173: /* check_options - check user-specified options */
174:
175: void check_options()
176: {
177: int i;
178:
179: if ( lex_compat )
180: {
181: if ( C_plus_plus )
182: flexerror( _( "Can't use -+ with -l option" ) );
183:
184: if ( fulltbl || fullspd )
185: flexerror( _( "Can't use -f or -F with -l option" ) );
186:
187: /* Don't rely on detecting use of yymore() and REJECT,
188: * just assume they'll be used.
189: */
190: yymore_really_used = reject_really_used = true;
191:
192: yytext_is_array = true;
193: do_yylineno = true;
194: use_read = false;
195: }
196:
197: if ( do_yylineno )
198: /* This should really be "maintain_backup_tables = true" */
199: reject_really_used = true;
200:
201: if ( csize == unspecified )
202: {
203: if ( (fulltbl || fullspd) && ! useecs )
204: csize = DEFAULT_CSIZE;
205: else
206: csize = CSIZE;
207: }
208:
209: if ( interactive == unspecified )
210: {
211: if ( fulltbl || fullspd )
212: interactive = false;
213: else
214: interactive = true;
215: }
216:
217: if ( fulltbl || fullspd )
218: {
219: if ( usemecs )
220: flexerror(
221: _( "-Cf/-CF and -Cm don't make sense together" ) );
222:
223: if ( interactive )
224: flexerror( _( "-Cf/-CF and -I are incompatible" ) );
225:
226: if ( lex_compat )
227: flexerror(
228: _( "-Cf/-CF are incompatible with lex-compatibility mode" ) );
229:
230: if ( do_yylineno )
231: flexerror(
232: _( "-Cf/-CF and %option yylineno are incompatible" ) );
233:
234: if ( fulltbl && fullspd )
235: flexerror( _( "-Cf and -CF are mutually exclusive" ) );
236: }
237:
238: if ( C_plus_plus && fullspd )
239: flexerror( _( "Can't use -+ with -CF option" ) );
240:
241: if ( C_plus_plus && yytext_is_array )
242: {
243: warn( _( "%array incompatible with -+ option" ) );
244: yytext_is_array = false;
245: }
246:
247: if ( useecs )
248: { /* Set up doubly-linked equivalence classes. */
249:
250: /* We loop all the way up to csize, since ecgroup[csize] is
251: * the position used for NUL characters.
252: */
253: ecgroup[1] = NIL;
254:
255: for ( i = 2; i <= csize; ++i )
256: {
257: ecgroup[i] = i - 1;
258: nextecm[i - 1] = i;
259: }
260:
261: nextecm[csize] = NIL;
262: }
263:
264: else
265: {
266: /* Put everything in its own equivalence class. */
267: for ( i = 1; i <= csize; ++i )
268: {
269: ecgroup[i] = i;
270: nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
271: }
272: }
273:
274: if ( ! use_stdout )
275: {
276: FILE *prev_stdout;
277:
278: if ( ! did_outfilename )
279: {
280: char *suffix;
281:
282: if ( C_plus_plus )
283: suffix = "cc";
284: else
285: suffix = "c";
286:
287: sprintf( outfile_path, outfile_template,
288: prefix, suffix );
289:
290: outfilename = outfile_path;
291: }
292:
293: prev_stdout = freopen( outfilename, "w", stdout );
294:
295: if ( prev_stdout == NULL )
296: lerrsf( _( "could not create %s" ), outfilename );
297:
298: outfile_created = 1;
299: }
300:
301: if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
302: lerrsf( _( "can't open skeleton file %s" ), skelname );
303:
304: if ( strcmp( prefix, "yy" ) )
305: {
306: #define GEN_PREFIX(name) out_str3( "#define yy%s %s%s\n", name, prefix, name )
307: if ( C_plus_plus )
308: GEN_PREFIX( "FlexLexer" );
309: else
310: {
311: GEN_PREFIX( "_create_buffer" );
312: GEN_PREFIX( "_delete_buffer" );
313: GEN_PREFIX( "_scan_buffer" );
314: GEN_PREFIX( "_scan_string" );
315: GEN_PREFIX( "_scan_bytes" );
316: GEN_PREFIX( "_flex_debug" );
317: GEN_PREFIX( "_init_buffer" );
318: GEN_PREFIX( "_flush_buffer" );
319: GEN_PREFIX( "_load_buffer_state" );
320: GEN_PREFIX( "_switch_to_buffer" );
321: GEN_PREFIX( "in" );
322: GEN_PREFIX( "leng" );
323: GEN_PREFIX( "lex" );
324: GEN_PREFIX( "out" );
325: GEN_PREFIX( "restart" );
326: GEN_PREFIX( "text" );
327:
328: if ( do_yylineno )
329: GEN_PREFIX( "lineno" );
330: }
331:
332: if ( do_yywrap )
333: GEN_PREFIX( "wrap" );
334:
335: outn( "" );
336: }
337:
338: if ( did_outfilename )
339: line_directive_out( stdout, 0 );
340:
341: skelout();
342: }
343:
344:
345: /* flexend - terminate flex
346: *
347: * note
348: * This routine does not return.
349: */
350:
351: void flexend( exit_status )
352: int exit_status;
353:
354: {
355: int tblsiz;
356: int unlink();
357:
358: if ( skelfile != NULL )
359: {
360: if ( ferror( skelfile ) )
361: lerrsf( _( "input error reading skeleton file %s" ),
362: skelname );
363:
364: else if ( fclose( skelfile ) )
365: lerrsf( _( "error closing skeleton file %s" ),
366: skelname );
367: }
368:
369: if ( exit_status != 0 && outfile_created )
370: {
371: if ( ferror( stdout ) )
372: lerrsf( _( "error writing output file %s" ),
373: outfilename );
374:
375: else if ( fclose( stdout ) )
376: lerrsf( _( "error closing output file %s" ),
377: outfilename );
378:
379: else if ( unlink( outfilename ) )
380: lerrsf( _( "error deleting output file %s" ),
381: outfilename );
382: }
383:
384: if ( backing_up_report && backing_up_file )
385: {
386: if ( num_backing_up == 0 )
387: fprintf( backing_up_file, _( "No backing up.\n" ) );
388: else if ( fullspd || fulltbl )
389: fprintf( backing_up_file,
390: _( "%d backing up (non-accepting) states.\n" ),
391: num_backing_up );
392: else
393: fprintf( backing_up_file,
394: _( "Compressed tables always back up.\n" ) );
395:
396: if ( ferror( backing_up_file ) )
397: lerrsf( _( "error writing backup file %s" ),
398: backing_name );
399:
400: else if ( fclose( backing_up_file ) )
401: lerrsf( _( "error closing backup file %s" ),
402: backing_name );
403: }
404:
405: if ( printstats )
406: {
407: fprintf( stderr, _( "%s version %s usage statistics:\n" ),
408: program_name, flex_version );
409:
410: fprintf( stderr, _( " scanner options: -" ) );
411:
412: if ( C_plus_plus )
413: putc( '+', stderr );
414: if ( backing_up_report )
415: putc( 'b', stderr );
416: if ( ddebug )
417: putc( 'd', stderr );
418: if ( caseins )
419: putc( 'i', stderr );
420: if ( lex_compat )
421: putc( 'l', stderr );
422: if ( performance_report > 0 )
423: putc( 'p', stderr );
424: if ( performance_report > 1 )
425: putc( 'p', stderr );
426: if ( spprdflt )
427: putc( 's', stderr );
428: if ( use_stdout )
429: putc( 't', stderr );
430: if ( printstats )
431: putc( 'v', stderr ); /* always true! */
432: if ( nowarn )
433: putc( 'w', stderr );
434: if ( interactive == false )
435: putc( 'B', stderr );
436: if ( interactive == true )
437: putc( 'I', stderr );
438: if ( ! gen_line_dirs )
439: putc( 'L', stderr );
440: if ( trace )
441: putc( 'T', stderr );
442:
443: if ( csize == unspecified )
444: /* We encountered an error fairly early on, so csize
445: * never got specified. Define it now, to prevent
446: * bogus table sizes being written out below.
447: */
448: csize = 256;
449:
450: if ( csize == 128 )
451: putc( '7', stderr );
452: else
453: putc( '8', stderr );
454:
455: fprintf( stderr, " -C" );
456:
457: if ( long_align )
458: putc( 'a', stderr );
459: if ( fulltbl )
460: putc( 'f', stderr );
461: if ( fullspd )
462: putc( 'F', stderr );
463: if ( useecs )
464: putc( 'e', stderr );
465: if ( usemecs )
466: putc( 'm', stderr );
467: if ( use_read )
468: putc( 'r', stderr );
469:
470: if ( did_outfilename )
471: fprintf( stderr, " -o%s", outfilename );
472:
473: if ( skelname )
474: fprintf( stderr, " -S%s", skelname );
475:
476: if ( strcmp( prefix, "yy" ) )
477: fprintf( stderr, " -P%s", prefix );
478:
479: putc( '\n', stderr );
480:
481: fprintf( stderr, _( " %d/%d NFA states\n" ),
482: lastnfa, current_mns );
483: fprintf( stderr, _( " %d/%d DFA states (%d words)\n" ),
484: lastdfa, current_max_dfas, totnst );
485: fprintf( stderr, _( " %d rules\n" ),
486: num_rules + num_eof_rules - 1 /* - 1 for def. rule */ );
487:
488: if ( num_backing_up == 0 )
489: fprintf( stderr, _( " No backing up\n" ) );
490: else if ( fullspd || fulltbl )
491: fprintf( stderr,
492: _( " %d backing-up (non-accepting) states\n" ),
493: num_backing_up );
494: else
495: fprintf( stderr,
496: _( " Compressed tables always back-up\n" ) );
497:
498: if ( bol_needed )
499: fprintf( stderr,
500: _( " Beginning-of-line patterns used\n" ) );
501:
502: fprintf( stderr, _( " %d/%d start conditions\n" ), lastsc,
503: current_max_scs );
504: fprintf( stderr,
505: _( " %d epsilon states, %d double epsilon states\n" ),
506: numeps, eps2 );
507:
508: if ( lastccl == 0 )
509: fprintf( stderr, _( " no character classes\n" ) );
510: else
511: fprintf( stderr,
512: _( " %d/%d character classes needed %d/%d words of storage, %d reused\n" ),
513: lastccl, current_maxccls,
514: cclmap[lastccl] + ccllen[lastccl],
515: current_max_ccl_tbl_size, cclreuse );
516:
517: fprintf( stderr, _( " %d state/nextstate pairs created\n" ),
518: numsnpairs );
519: fprintf( stderr, _( " %d/%d unique/duplicate transitions\n" ),
520: numuniq, numdup );
521:
522: if ( fulltbl )
523: {
524: tblsiz = lastdfa * numecs;
525: fprintf( stderr, _( " %d table entries\n" ), tblsiz );
526: }
527:
528: else
529: {
530: tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
531:
532: fprintf( stderr,
533: _( " %d/%d base-def entries created\n" ),
534: lastdfa + numtemps, current_max_dfas );
535: fprintf( stderr,
536: _( " %d/%d (peak %d) nxt-chk entries created\n" ),
537: tblend, current_max_xpairs, peakpairs );
538: fprintf( stderr,
539: _( " %d/%d (peak %d) template nxt-chk entries created\n" ),
540: numtemps * nummecs,
541: current_max_template_xpairs,
542: numtemps * numecs );
543: fprintf( stderr, _( " %d empty table entries\n" ),
544: nummt );
545: fprintf( stderr, _( " %d protos created\n" ),
546: numprots );
547: fprintf( stderr,
548: _( " %d templates created, %d uses\n" ),
549: numtemps, tmpuses );
550: }
551:
552: if ( useecs )
553: {
554: tblsiz = tblsiz + csize;
555: fprintf( stderr,
556: _( " %d/%d equivalence classes created\n" ),
557: numecs, csize );
558: }
559:
560: if ( usemecs )
561: {
562: tblsiz = tblsiz + numecs;
563: fprintf( stderr,
564: _( " %d/%d meta-equivalence classes created\n" ),
565: nummecs, csize );
566: }
567:
568: fprintf( stderr,
569: _( " %d (%d saved) hash collisions, %d DFAs equal\n" ),
570: hshcol, hshsave, dfaeql );
571: fprintf( stderr, _( " %d sets of reallocations needed\n" ),
572: num_reallocs );
573: fprintf( stderr, _( " %d total table entries needed\n" ),
574: tblsiz );
575: }
576:
577: exit( exit_status );
578: }
579:
580:
581: /* flexinit - initialize flex */
582:
583: void flexinit( argc, argv )
584: int argc;
585: char **argv;
586: {
587: int i, sawcmpflag;
588: char *arg, *mktemp();
589:
590: printstats = syntaxerror = trace = spprdflt = caseins = false;
591: lex_compat = C_plus_plus = backing_up_report = ddebug = fulltbl = false;
592: fullspd = long_align = nowarn = yymore_used = continued_action = false;
593: do_yylineno = yytext_is_array = in_rule = reject = do_stdinit = false;
594: yymore_really_used = reject_really_used = unspecified;
595: interactive = csize = unspecified;
596: do_yywrap = gen_line_dirs = usemecs = useecs = true;
597: performance_report = 0;
598: did_outfilename = 0;
599: prefix = "yy";
600: yyclass = 0;
601: use_read = use_stdout = false;
602:
603: sawcmpflag = false;
604:
605: /* Initialize dynamic array for holding the rule actions. */
606: action_size = 2048; /* default size of action array in bytes */
607: action_array = allocate_character_array( action_size );
608: defs1_offset = prolog_offset = action_offset = action_index = 0;
609: action_array[0] = '\0';
610:
611: program_name = argv[0];
612:
613: if ( program_name[0] != '\0' &&
614: program_name[strlen( program_name ) - 1] == '+' )
615: C_plus_plus = true;
616:
617: /* read flags */
618: for ( --argc, ++argv; argc ; --argc, ++argv )
619: {
620: arg = argv[0];
621:
622: if ( arg[0] != '-' || arg[1] == '\0' )
623: break;
624:
625: if ( arg[1] == '-' )
626: { /* --option */
627: if ( ! strcmp( arg, "--help" ) )
628: arg = "-h";
629:
630: else if ( ! strcmp( arg, "--version" ) )
631: arg = "-V";
632:
633: else if ( ! strcmp( arg, "--" ) )
634: { /* end of options */
635: --argc;
636: ++argv;
637: break;
638: }
639: }
640:
641: for ( i = 1; arg[i] != '\0'; ++i )
642: switch ( arg[i] )
643: {
644: case '+':
645: C_plus_plus = true;
646: break;
647:
648: case 'B':
649: interactive = false;
650: break;
651:
652: case 'b':
653: backing_up_report = true;
654: break;
655:
656: case 'c':
657: break;
658:
659: case 'C':
660: if ( i != 1 )
661: flexerror(
662: _( "-C flag must be given separately" ) );
663:
664: if ( ! sawcmpflag )
665: {
666: useecs = false;
667: usemecs = false;
668: fulltbl = false;
669: sawcmpflag = true;
670: }
671:
672: for ( ++i; arg[i] != '\0'; ++i )
673: switch ( arg[i] )
674: {
675: case 'a':
676: long_align =
677: true;
678: break;
679:
680: case 'e':
681: useecs = true;
682: break;
683:
684: case 'F':
685: fullspd = true;
686: break;
687:
688: case 'f':
689: fulltbl = true;
690: break;
691:
692: case 'm':
693: usemecs = true;
694: break;
695:
696: case 'r':
697: use_read = true;
698: break;
699:
700: default:
701: lerrif(
702: _( "unknown -C option '%c'" ),
703: (int) arg[i] );
704: break;
705: }
706:
707: goto get_next_arg;
708:
709: case 'd':
710: ddebug = true;
711: break;
712:
713: case 'f':
714: useecs = usemecs = false;
715: use_read = fulltbl = true;
716: break;
717:
718: case 'F':
719: useecs = usemecs = false;
720: use_read = fullspd = true;
721: break;
722:
723: case '?':
724: case 'h':
725: usage();
726: exit( 0 );
727:
728: case 'I':
729: interactive = true;
730: break;
731:
732: case 'i':
733: caseins = true;
734: break;
735:
736: case 'l':
737: lex_compat = true;
738: break;
739:
740: case 'L':
741: gen_line_dirs = false;
742: break;
743:
744: case 'n':
745: /* Stupid do-nothing deprecated
746: * option.
747: */
748: break;
749:
750: case 'o':
751: if ( i != 1 )
752: flexerror(
753: _( "-o flag must be given separately" ) );
754:
755: outfilename = arg + i + 1;
756: did_outfilename = 1;
757: goto get_next_arg;
758:
759: case 'P':
760: if ( i != 1 )
761: flexerror(
762: _( "-P flag must be given separately" ) );
763:
764: prefix = arg + i + 1;
765: goto get_next_arg;
766:
767: case 'p':
768: ++performance_report;
769: break;
770:
771: case 'S':
772: if ( i != 1 )
773: flexerror(
774: _( "-S flag must be given separately" ) );
775:
776: skelname = arg + i + 1;
777: goto get_next_arg;
778:
779: case 's':
780: spprdflt = true;
781: break;
782:
783: case 't':
784: use_stdout = true;
785: break;
786:
787: case 'T':
788: trace = true;
789: break;
790:
791: case 'v':
792: printstats = true;
793: break;
794:
795: case 'V':
796: printf( _( "%s version %s\n" ),
797: program_name, flex_version );
798: exit( 0 );
799:
800: case 'w':
801: nowarn = true;
802: break;
803:
804: case '7':
805: csize = 128;
806: break;
807:
808: case '8':
809: csize = CSIZE;
810: break;
811:
812: default:
813: fprintf( stderr,
814: _( "%s: unknown flag '%c'. For usage, try\n\t%s --help\n" ),
815: program_name, (int) arg[i],
816: program_name );
817: exit( 1 );
818: }
819:
820: /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2"
821: * control.
822: */
823: get_next_arg: ;
824: }
825:
826: num_input_files = argc;
827: input_files = argv;
828: set_input_file( num_input_files > 0 ? input_files[0] : NULL );
829:
830: lastccl = lastsc = lastdfa = lastnfa = 0;
831: num_rules = num_eof_rules = default_rule = 0;
832: numas = numsnpairs = tmpuses = 0;
833: numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
834: numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
835: num_backing_up = onesp = numprots = 0;
836: variable_trailing_context_rules = bol_needed = false;
837:
838: out_linenum = linenum = sectnum = 1;
839: firstprot = NIL;
840:
841: /* Used in mkprot() so that the first proto goes in slot 1
842: * of the proto queue.
843: */
844: lastprot = 1;
845:
846: set_up_initial_allocations();
847: }
848:
849:
850: /* readin - read in the rules section of the input file(s) */
851:
852: void readin()
853: {
854: static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
855: static char yy_nostdinit[] =
856: "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
857:
858: line_directive_out( (FILE *) 0, 1 );
859:
860: if ( yyparse() )
861: {
862: pinpoint_message( _( "fatal parse error" ) );
863: flexend( 1 );
864: }
865:
866: if ( syntaxerror )
867: flexend( 1 );
868:
869: if ( backing_up_report )
870: {
871: backing_up_file = fopen( backing_name, "w" );
872: if ( backing_up_file == NULL )
873: lerrsf(
874: _( "could not create backing-up info file %s" ),
875: backing_name );
876: }
877:
878: else
879: backing_up_file = NULL;
880:
881: if ( yymore_really_used == true )
882: yymore_used = true;
883: else if ( yymore_really_used == false )
884: yymore_used = false;
885:
886: if ( reject_really_used == true )
887: reject = true;
888: else if ( reject_really_used == false )
889: reject = false;
890:
891: if ( performance_report > 0 )
892: {
893: if ( lex_compat )
894: {
895: fprintf( stderr,
896: _( "-l AT&T lex compatibility option entails a large performance penalty\n" ) );
897: fprintf( stderr,
898: _( " and may be the actual source of other reported performance penalties\n" ) );
899: }
900:
901: else if ( do_yylineno )
902: {
903: fprintf( stderr,
904: _( "%%option yylineno entails a large performance penalty\n" ) );
905: }
906:
907: if ( performance_report > 1 )
908: {
909: if ( interactive )
910: fprintf( stderr,
911: _( "-I (interactive) entails a minor performance penalty\n" ) );
912:
913: if ( yymore_used )
914: fprintf( stderr,
915: _( "yymore() entails a minor performance penalty\n" ) );
916: }
917:
918: if ( reject )
919: fprintf( stderr,
920: _( "REJECT entails a large performance penalty\n" ) );
921:
922: if ( variable_trailing_context_rules )
923: fprintf( stderr,
924: _( "Variable trailing context rules entail a large performance penalty\n" ) );
925: }
926:
927: if ( reject )
928: real_reject = true;
929:
930: if ( variable_trailing_context_rules )
931: reject = true;
932:
933: if ( (fulltbl || fullspd) && reject )
934: {
935: if ( real_reject )
936: flexerror(
937: _( "REJECT cannot be used with -f or -F" ) );
938: else if ( do_yylineno )
939: flexerror(
940: _( "%option yylineno cannot be used with -f or -F" ) );
941: else
942: flexerror(
943: _( "variable trailing context rules cannot be used with -f or -F" ) );
944: }
945:
946: if ( reject )
947: outn( "\n#define YY_USES_REJECT" );
948:
949: if ( ! do_yywrap )
950: {
951: outn( "\n#define yywrap() 1" );
952: outn( "#define YY_SKIP_YYWRAP" );
953: }
954:
955: if ( ddebug )
956: outn( "\n#define FLEX_DEBUG" );
957:
958: if ( csize == 256 )
959: outn( "typedef unsigned char YY_CHAR;" );
960: else
961: outn( "typedef char YY_CHAR;" );
962:
963: if ( C_plus_plus )
964: {
965: outn( "#define yytext_ptr yytext" );
966:
967: if ( interactive )
968: outn( "#define YY_INTERACTIVE" );
969: }
970:
971: else
972: {
973: if ( do_stdinit )
974: {
975: outn( "#ifdef VMS" );
976: outn( "#ifndef __VMS_POSIX" );
977: outn( yy_nostdinit );
978: outn( "#else" );
979: outn( yy_stdinit );
980: outn( "#endif" );
981: outn( "#else" );
982: outn( yy_stdinit );
983: outn( "#endif" );
984: }
985:
986: else
987: outn( yy_nostdinit );
988: }
989:
990: if ( fullspd )
991: outn( "typedef yyconst struct yy_trans_info *yy_state_type;" );
992: else if ( ! C_plus_plus )
993: outn( "typedef int yy_state_type;" );
994:
995: if ( ddebug )
996: outn( "\n#define FLEX_DEBUG" );
997:
998: if ( lex_compat )
999: outn( "#define YY_FLEX_LEX_COMPAT" );
1000:
1001: if ( do_yylineno && ! C_plus_plus )
1002: {
1003: outn( "extern int yylineno;" );
1004: outn( "int yylineno = 1;" );
1005: }
1006:
1007: if ( C_plus_plus )
1008: {
1009: outn( "\n#include <FlexLexer.h>" );
1010:
1011: if ( yyclass )
1012: {
1013: outn( "int yyFlexLexer::yylex()" );
1014: outn( "\t{" );
1015: outn(
1016: "\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );" );
1017: outn( "\treturn 0;" );
1018: outn( "\t}" );
1019:
1020: out_str( "\n#define YY_DECL int %s::yylex()\n",
1021: yyclass );
1022: }
1023: }
1024:
1025: else
1026: {
1027: if ( yytext_is_array )
1028: outn( "extern char yytext[];\n" );
1029:
1030: else
1031: {
1032: outn( "extern char *yytext;" );
1033: outn( "#define yytext_ptr yytext" );
1034: }
1035:
1036: if ( yyclass )
1037: flexerror(
1038: _( "%option yyclass only meaningful for C++ scanners" ) );
1039: }
1040:
1041: if ( useecs )
1042: numecs = cre8ecs( nextecm, ecgroup, csize );
1043: else
1044: numecs = csize;
1045:
1046: /* Now map the equivalence class for NUL to its expected place. */
1047: ecgroup[0] = ecgroup[csize];
1048: NUL_ec = ABS( ecgroup[0] );
1049:
1050: if ( useecs )
1051: ccl2ecl();
1052: }
1053:
1054:
1055: /* set_up_initial_allocations - allocate memory for internal tables */
1056:
1057: void set_up_initial_allocations()
1058: {
1059: current_mns = INITIAL_MNS;
1060: firstst = allocate_integer_array( current_mns );
1061: lastst = allocate_integer_array( current_mns );
1062: finalst = allocate_integer_array( current_mns );
1063: transchar = allocate_integer_array( current_mns );
1064: trans1 = allocate_integer_array( current_mns );
1065: trans2 = allocate_integer_array( current_mns );
1066: accptnum = allocate_integer_array( current_mns );
1067: assoc_rule = allocate_integer_array( current_mns );
1068: state_type = allocate_integer_array( current_mns );
1069:
1070: current_max_rules = INITIAL_MAX_RULES;
1071: rule_type = allocate_integer_array( current_max_rules );
1072: rule_linenum = allocate_integer_array( current_max_rules );
1073: rule_useful = allocate_integer_array( current_max_rules );
1074:
1075: current_max_scs = INITIAL_MAX_SCS;
1076: scset = allocate_integer_array( current_max_scs );
1077: scbol = allocate_integer_array( current_max_scs );
1078: scxclu = allocate_integer_array( current_max_scs );
1079: sceof = allocate_integer_array( current_max_scs );
1080: scname = allocate_char_ptr_array( current_max_scs );
1081:
1082: current_maxccls = INITIAL_MAX_CCLS;
1083: cclmap = allocate_integer_array( current_maxccls );
1084: ccllen = allocate_integer_array( current_maxccls );
1085: cclng = allocate_integer_array( current_maxccls );
1086:
1087: current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
1088: ccltbl = allocate_Character_array( current_max_ccl_tbl_size );
1089:
1090: current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
1091:
1092: current_max_xpairs = INITIAL_MAX_XPAIRS;
1093: nxt = allocate_integer_array( current_max_xpairs );
1094: chk = allocate_integer_array( current_max_xpairs );
1095:
1096: current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
1097: tnxt = allocate_integer_array( current_max_template_xpairs );
1098:
1099: current_max_dfas = INITIAL_MAX_DFAS;
1100: base = allocate_integer_array( current_max_dfas );
1101: def = allocate_integer_array( current_max_dfas );
1102: dfasiz = allocate_integer_array( current_max_dfas );
1103: accsiz = allocate_integer_array( current_max_dfas );
1104: dhash = allocate_integer_array( current_max_dfas );
1105: dss = allocate_int_ptr_array( current_max_dfas );
1106: dfaacc = allocate_dfaacc_union( current_max_dfas );
1107:
1108: nultrans = (int *) 0;
1109: }
1110:
1111:
1112: void usage()
1113: {
1114: FILE *f = stdout;
1115:
1116: fprintf( f,
1117: _( "%s [-bcdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ),
1118: program_name );
1119: fprintf( f, _( "\t[--help --version] [file ...]\n" ) );
1120:
1121: fprintf( f, _( "\t-b generate backing-up information to %s\n" ),
1122: backing_name );
1123: fprintf( f, _( "\t-c do-nothing POSIX option\n" ) );
1124: fprintf( f, _( "\t-d turn on debug mode in generated scanner\n" ) );
1125: fprintf( f, _( "\t-f generate fast, large scanner\n" ) );
1126: fprintf( f, _( "\t-h produce this help message\n" ) );
1127: fprintf( f, _( "\t-i generate case-insensitive scanner\n" ) );
1128: fprintf( f, _( "\t-l maximal compatibility with original lex\n" ) );
1129: fprintf( f, _( "\t-n do-nothing POSIX option\n" ) );
1130: fprintf( f, _( "\t-p generate performance report to stderr\n" ) );
1131: fprintf( f,
1132: _( "\t-s suppress default rule to ECHO unmatched text\n" ) );
1133:
1134: if ( ! did_outfilename )
1135: {
1136: sprintf( outfile_path, outfile_template,
1137: prefix, C_plus_plus ? "cc" : "c" );
1138: outfilename = outfile_path;
1139: }
1140:
1141: fprintf( f,
1142: _( "\t-t write generated scanner on stdout instead of %s\n" ),
1143: outfilename );
1144:
1145: fprintf( f,
1146: _( "\t-v write summary of scanner statistics to f\n" ) );
1147: fprintf( f, _( "\t-w do not generate warnings\n" ) );
1148: fprintf( f, _( "\t-B generate batch scanner (opposite of -I)\n" ) );
1149: fprintf( f,
1150: _( "\t-F use alternative fast scanner representation\n" ) );
1151: fprintf( f,
1152: _( "\t-I generate interactive scanner (opposite of -B)\n" ) );
1153: fprintf( f, _( "\t-L suppress #line directives in scanner\n" ) );
1154: fprintf( f, _( "\t-T %s should run in trace mode\n" ), program_name );
1155: fprintf( f, _( "\t-V report %s version\n" ), program_name );
1156: fprintf( f, _( "\t-7 generate 7-bit scanner\n" ) );
1157: fprintf( f, _( "\t-8 generate 8-bit scanner\n" ) );
1158: fprintf( f, _( "\t-+ generate C++ scanner class\n" ) );
1159: fprintf( f, _( "\t-? produce this help message\n" ) );
1160: fprintf( f,
1161: _( "\t-C specify degree of table compression (default is -Cem):\n" ) );
1162: fprintf( f,
1163: _( "\t\t-Ca trade off larger tables for better memory alignment\n" ) );
1164: fprintf( f, _( "\t\t-Ce construct equivalence classes\n" ) );
1165: fprintf( f,
1166: _( "\t\t-Cf do not compress scanner tables; use -f representation\n" ) );
1167: fprintf( f,
1168: _( "\t\t-CF do not compress scanner tables; use -F representation\n" ) );
1169: fprintf( f, _( "\t\t-Cm construct meta-equivalence classes\n" ) );
1170: fprintf( f,
1171: _( "\t\t-Cr use read() instead of stdio for scanner input\n" ) );
1172: fprintf( f, _( "\t-o specify output filename\n" ) );
1173: fprintf( f, _( "\t-P specify scanner prefix other than \"yy\"\n" ) );
1174: fprintf( f, _( "\t-S specify skeleton file\n" ) );
1175: fprintf( f, _( "\t--help produce this help message\n" ) );
1176: fprintf( f, _( "\t--version report %s version\n" ), program_name );
1177: }