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 with or without
15 * modification are permitted provided that: (1) source distributions retain
16 * this entire copyright notice and comment, and (2) distributions including
17 * binaries display the following acknowledgement: ``This product includes
18 * software developed by the University of California, Berkeley and its
19 * contributors'' in the documentation or other materials provided with the
20 * distribution and in all advertising materials mentioning features or use
21 * of this software. Neither the name of the University nor the names of
22 * its contributors may be used to endorse or promote products derived from
23 * this software without 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: /home/daffy/u0/vern/flex/RCS/main.c,v 2.64 96/05/25 20:42:42 vern 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
main(argc,argv)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
check_options()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
flexend(exit_status)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
flexinit(argc,argv)583 void flexinit( argc, argv )
584 int argc;
585 char **argv;
586 {
587 int i, sawcmpflag;
588 char *arg;
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
readin()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
set_up_initial_allocations()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
usage()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 }
1178