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