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
30char 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
41static char flex_version[] = FLEX_VERSION;
42
43
44/* declare functions that have forward references */
45
46void flexinit PROTO((int, char**));
47void readin PROTO((void));
48void set_up_initial_allocations PROTO((void));
49
50#ifdef NEED_ARGV_FIXUP
51extern void argv_fixup PROTO((int *, char ***));
52#endif
53
54
55/* these globals are all defined and commented in flexdef.h */
56int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
57int interactive, caseins, lex_compat, do_yylineno, useecs, fulltbl, usemecs;
58int fullspd, gen_line_dirs, performance_report, backing_up_report;
59int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, csize;
60int yymore_used, reject, real_reject, continued_action, in_rule;
61int yymore_really_used, reject_really_used;
62int datapos, dataline, linenum, out_linenum;
63FILE *skelfile = NULL;
64int skel_ind = 0;
65char *action_array;
66int action_size, defs1_offset, prolog_offset, action_offset, action_index;
67char *infilename = NULL, *outfilename = NULL;
68int did_outfilename;
69char *prefix, *yyclass;
70int do_stdinit, use_stdout;
71int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
72int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
73int current_mns, current_max_rules;
74int num_rules, num_eof_rules, default_rule, lastnfa;
75int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
76int *accptnum, *assoc_rule, *state_type;
77int *rule_type, *rule_linenum, *rule_useful;
78int current_state_type;
79int variable_trailing_context_rules;
80int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
81int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
82int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
83int tecbck[CSIZE + 1];
84int lastsc, *scset, *scbol, *scxclu, *sceof;
85int current_max_scs;
86char **scname;
87int current_max_dfa_size, current_max_xpairs;
88int current_max_template_xpairs, current_max_dfas;
89int lastdfa, *nxt, *chk, *tnxt;
90int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
91union dfaacc_union *dfaacc;
92int *accsiz, *dhash, numas;
93int numsnpairs, jambase, jamstate;
94int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
95int current_maxccls, current_max_ccl_tbl_size;
96Char *ccltbl;
97char nmstr[MAXLINE];
98int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
99int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
100int num_backing_up, bol_needed;
101FILE *backing_up_file;
102int end_of_buffer_state;
103char **input_files;
104int 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 */
109char *program_name = "flex";
110
111#ifndef SHORT_FILE_NAMES
112static char *outfile_template = "lex.%s.%s";
113static char *backing_name = "lex.backup";
114#else
115static char *outfile_template = "lex%s.%s";
116static char *backing_name = "lex.bck";
117#endif
118
119#ifdef THINK_C
120#include <console.h>
121#endif
122
123#ifdef MS_DOS
124extern unsigned _stklen = 16384;
125#endif
126
127static char outfile_path[MAXLINE];
128static int outfile_created = 0;
129static char *skelname = NULL;
130
131
132int main( argc, argv )
133int argc;
134char **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
175void 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
351void flexend( exit_status )
352int 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
583void flexinit( argc, argv )
584int argc;
585char **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
852void 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
1057void 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
1112void 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