?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sort(1): Fix some obvious issues
[dragonfly.git] / contrib / flex / main.c
blob1e730bf1430b54d837e5f77f721a777f5700d202
1 /* flex - tool to generate fast lexical analyzers */
2
3 /* Copyright (c) 1990 The Regents of the University of California. */
4 /* All rights reserved. */
5
6 /* This code is derived from software contributed to Berkeley by */
7 /* Vern Paxson. */
8
9 /* The United States Government has rights in this work pursuant */
10 /* to contract no. DE-AC03-76SF00098 between the United States */
11 /* Department of Energy and the University of California. */
12
13 /* This file is part of flex. */
14
15 /* Redistribution and use in source and binary forms, with or without */
16 /* modification, are permitted provided that the following conditions */
17 /* are met: */
18
19 /* 1. Redistributions of source code must retain the above copyright */
20 /* notice, this list of conditions and the following disclaimer. */
21 /* 2. Redistributions in binary form must reproduce the above copyright */
22 /* notice, this list of conditions and the following disclaimer in the */
23 /* documentation and/or other materials provided with the distribution. */
24
25 /* Neither the name of the University nor the names of its contributors */
26 /* may be used to endorse or promote products derived from this software */
27 /* without specific prior written permission. */
28
29 /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
30 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
31 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
32 /* PURPOSE. */
33 \f
34
35 #include "flexdef.h"
36 #include "version.h"
37 #include "options.h"
38 #include "tables.h"
39
40 static char flex_version[] = FLEX_VERSION;
41
42 /* declare functions that have forward references */
43
44 void flexinit PROTO ((int, char **));
45 void readin PROTO ((void));
46 void set_up_initial_allocations PROTO ((void));
47 static char *basename2 PROTO ((char *path, int should_strip_ext));
48
49
50 /* these globals are all defined and commented in flexdef.h */
51 int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
52 int interactive, lex_compat, posix_compat, do_yylineno,
53 useecs, fulltbl, usemecs;
54 int fullspd, gen_line_dirs, performance_report, backing_up_report;
55 int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap,
56 csize;
57 int reentrant, bison_bridge_lval, bison_bridge_lloc;
58 int yymore_used, reject, real_reject, continued_action, in_rule;
59 int yymore_really_used, reject_really_used;
60 int datapos, dataline, linenum;
61 FILE *skelfile = NULL;
62 int skel_ind = 0;
63 char *action_array;
64 int action_size, defs1_offset, prolog_offset, action_offset,
65 action_index;
66 char *infilename = NULL, *outfilename = NULL, *headerfilename = NULL;
67 int did_outfilename;
68 char *prefix, *yyclass, *extra_type = NULL;
69 int do_stdinit, use_stdout;
70 int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
71 int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
72 int maximum_mns, current_mns, current_max_rules;
73 int num_rules, num_eof_rules, default_rule, lastnfa;
74 int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
75 int *accptnum, *assoc_rule, *state_type;
76 int *rule_type, *rule_linenum, *rule_useful;
77 int current_state_type;
78 int variable_trailing_context_rules;
79 int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
80 int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
81 int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs,
82 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 jmp_buf flex_main_jmp_buf;
106 bool *rule_has_nl, *ccl_has_nl;
107 int nlch = '\n';
108 bool ansi_func_defs, ansi_func_protos;
109
110 bool tablesext, tablesverify, gentables;
111 char *tablesfilename=0,*tablesname=0;
112 struct yytbl_writer tableswr;
113
114 /* Make sure program_name is initialized so we don't crash if writing
115 * out an error message before getting the program name from argv[0].
116 */
117 char *program_name = "flex";
118
119 #ifndef SHORT_FILE_NAMES
120 static char *outfile_template = "lex.%s.%s";
121 static char *backing_name = "lex.backup";
122 static char *tablesfile_template = "lex.%s.tables";
123 #else
124 static char *outfile_template = "lex%s.%s";
125 static char *backing_name = "lex.bck";
126 static char *tablesfile_template = "lex%s.tbl";
127 #endif
128
129 #ifdef MS_DOS
130 extern unsigned _stklen = 16384;
131 #endif
132
133 /* From scan.l */
134 extern FILE* yyout;
135
136 static char outfile_path[MAXLINE];
137 static int outfile_created = 0;
138 static char *skelname = NULL;
139 static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */
140 const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]";
141 const char *escaped_qend = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
142
143 /* For debugging. The max number of filters to apply to skeleton. */
144 static int preproc_level = 1000;
145
146 int flex_main PROTO ((int argc, char *argv[]));
147 int main PROTO ((int argc, char *argv[]));
148
149 int flex_main (argc, argv)
150 int argc;
151 char *argv[];
152 {
153 int i, exit_status, child_status;
154
155 /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The
156 * return value of setjmp, if non-zero, is the desired exit code PLUS ONE.
157 * For example, if you want 'main' to return with code '2', then call
158 * longjmp() with an argument of 3. This is because it is invalid to
159 * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of
160 * exit(n);
161 */
162 exit_status = setjmp (flex_main_jmp_buf);
163 if (exit_status){
164 if (stdout && !_stdout_closed && !ferror(stdout)){
165 fflush(stdout);
166 fclose(stdout);
167 }
168 while (wait(&child_status) > 0){
169 if (!WIFEXITED (child_status)
170 || WEXITSTATUS (child_status) != 0){
171 /* report an error of a child
172 */
173 if( exit_status <= 1 )
174 exit_status = 2;
175
176 }
177 }
178 return exit_status - 1;
179 }
180
181 flexinit (argc, argv);
182
183 readin ();
184
185 ntod ();
186
187 for (i = 1; i <= num_rules; ++i)
188 if (!rule_useful[i] && i != default_rule)
189 line_warning (_("rule cannot be matched"),
190 rule_linenum[i]);
191
192 if (spprdflt && !reject && rule_useful[default_rule])
193 line_warning (_
194 ("-s option given but default rule can be matched"),
195 rule_linenum[default_rule]);
196
197 /* Generate the C state transition tables from the DFA. */
198 make_tables ();
199
200 /* Note, flexend does not return. It exits with its argument
201 * as status.
202 */
203 flexend (0);
204
205 return 0; /* keep compilers/lint happy */
206 }
207
208 /* Wrapper around flex_main, so flex_main can be built as a library. */
209 int main (argc, argv)
210 int argc;
211 char *argv[];
212 {
213 #if ENABLE_NLS
214 #if HAVE_LOCALE_H
215 setlocale (LC_MESSAGES, "");
216 setlocale (LC_CTYPE, "");
217 textdomain (PACKAGE);
218 bindtextdomain (PACKAGE, LOCALEDIR);
219 #endif
220 #endif
221
222 return flex_main (argc, argv);
223 }
224
225 /* check_options - check user-specified options */
226
227 void check_options ()
228 {
229 int i;
230 const char * m4 = NULL;
231
232 if (lex_compat) {
233 if (C_plus_plus)
234 flexerror (_("Can't use -+ with -l option"));
235
236 if (fulltbl || fullspd)
237 flexerror (_("Can't use -f or -F with -l option"));
238
239 if (reentrant || bison_bridge_lval)
240 flexerror (_
241 ("Can't use --reentrant or --bison-bridge with -l option"));
242
243 /* Don't rely on detecting use of yymore() and REJECT,
244 * just assume they'll be used.
245 */
246 yymore_really_used = reject_really_used = true;
247
248 yytext_is_array = true;
249 do_yylineno = true;
250 use_read = false;
251 }
252
253
254 #if 0
255 /* This makes no sense whatsoever. I'm removing it. */
256 if (do_yylineno)
257 /* This should really be "maintain_backup_tables = true" */
258 reject_really_used = true;
259 #endif
260
261 if (csize == unspecified) {
262 if ((fulltbl || fullspd) && !useecs)
263 csize = DEFAULT_CSIZE;
264 else
265 csize = CSIZE;
266 }
267
268 if (interactive == unspecified) {
269 if (fulltbl || fullspd)
270 interactive = false;
271 else
272 interactive = true;
273 }
274
275 if (fulltbl || fullspd) {
276 if (usemecs)
277 flexerror (_
278 ("-Cf/-CF and -Cm don't make sense together"));
279
280 if (interactive)
281 flexerror (_("-Cf/-CF and -I are incompatible"));
282
283 if (lex_compat)
284 flexerror (_
285 ("-Cf/-CF are incompatible with lex-compatibility mode"));
286
287
288 if (fulltbl && fullspd)
289 flexerror (_
290 ("-Cf and -CF are mutually exclusive"));
291 }
292
293 if (C_plus_plus && fullspd)
294 flexerror (_("Can't use -+ with -CF option"));
295
296 if (C_plus_plus && yytext_is_array) {
297 warn (_("%array incompatible with -+ option"));
298 yytext_is_array = false;
299 }
300
301 if (C_plus_plus && (reentrant))
302 flexerror (_("Options -+ and --reentrant are mutually exclusive."));
303
304 if (C_plus_plus && bison_bridge_lval)
305 flexerror (_("bison bridge not supported for the C++ scanner."));
306
307
308 if (useecs) { /* Set up doubly-linked equivalence classes. */
309
310 /* We loop all the way up to csize, since ecgroup[csize] is
311 * the position used for NUL characters.
312 */
313 ecgroup[1] = NIL;
314
315 for (i = 2; i <= csize; ++i) {
316 ecgroup[i] = i - 1;
317 nextecm[i - 1] = i;
318 }
319
320 nextecm[csize] = NIL;
321 }
322
323 else {
324 /* Put everything in its own equivalence class. */
325 for (i = 1; i <= csize; ++i) {
326 ecgroup[i] = i;
327 nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
328 }
329 }
330
331 if (!ansi_func_defs)
332 buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL);
333
334 if (!ansi_func_protos)
335 buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL);
336
337 if (extra_type)
338 buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
339
340 if (!use_stdout) {
341 FILE *prev_stdout;
342
343 if (!did_outfilename) {
344 char *suffix;
345
346 if (C_plus_plus)
347 suffix = "cc";
348 else
349 suffix = "c";
350
351 snprintf (outfile_path, sizeof(outfile_path), outfile_template,
352 prefix, suffix);
353
354 outfilename = outfile_path;
355 }
356
357 prev_stdout = freopen (outfilename, "w+", stdout);
358
359 if (prev_stdout == NULL)
360 lerrsf (_("could not create %s"), outfilename);
361
362 outfile_created = 1;
363 }
364
365
366 /* Setup the filter chain. */
367 output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
368 if ( !(m4 = getenv("M4")))
369 m4 = M4;
370 filter_create_ext(output_chain, m4, "-P", 0);
371 filter_create_int(output_chain, filter_fix_linedirs, NULL);
372
373 /* For debugging, only run the requested number of filters. */
374 if (preproc_level > 0) {
375 filter_truncate(output_chain, preproc_level);
376 filter_apply_chain(output_chain);
377 }
378 yyout = stdout;
379
380
381 /* always generate the tablesverify flag. */
382 buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0");
383 if (tablesext)
384 gentables = false;
385
386 if (tablesverify)
387 /* force generation of C tables. */
388 gentables = true;
389
390
391 if (tablesext) {
392 FILE *tablesout;
393 struct yytbl_hdr hdr;
394 char *pname = 0;
395 int nbytes = 0;
396
397 buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
398
399 if (!tablesfilename) {
400 nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
401 tablesfilename = pname = (char *) calloc (nbytes, 1);
402 snprintf (pname, nbytes, tablesfile_template, prefix);
403 }
404
405 if ((tablesout = fopen (tablesfilename, "w")) == NULL)
406 lerrsf (_("could not create %s"), tablesfilename);
407 if (pname)
408 free (pname);
409 tablesfilename = 0;
410
411 yytbl_writer_init (&tableswr, tablesout);
412
413 nbytes = strlen (prefix) + strlen ("tables") + 2;
414 tablesname = (char *) calloc (nbytes, 1);
415 snprintf (tablesname, nbytes, "%stables", prefix);
416 yytbl_hdr_init (&hdr, flex_version, tablesname);
417
418 if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0)
419 flexerror (_("could not write tables header"));
420 }
421
422 if (skelname && (skelfile = fopen (skelname, "r")) == NULL)
423 lerrsf (_("can't open skeleton file %s"), skelname);
424
425 if (reentrant) {
426 buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL);
427 if (yytext_is_array)
428 buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL);
429 }
430
431 if ( bison_bridge_lval)
432 buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL);
433
434 if ( bison_bridge_lloc)
435 buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
436
437 buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix);
438
439 if (did_outfilename)
440 line_directive_out (stdout, 0);
441
442 if (do_yylineno)
443 buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
444
445 /* Create the alignment type. */
446 buf_strdefine (&userdef_buf, "YY_INT_ALIGNED",
447 long_align ? "long int" : "short int");
448
449 /* Define the start condition macros. */
450 {
451 struct Buf tmpbuf;
452 buf_init(&tmpbuf, sizeof(char));
453 for (i = 1; i <= lastsc; i++) {
454 char *str, *fmt = "#define %s %d\n";
455 size_t strsz;
456
457 str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2);
458 if (!str)
459 flexfatal(_("allocation of macro definition failed"));
460 snprintf(str, strsz, fmt, scname[i], i - 1);
461 buf_strappend(&tmpbuf, str);
462 free(str);
463 }
464 buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts);
465 buf_destroy(&tmpbuf);
466 }
467
468 /* This is where we begin writing to the file. */
469
470 /* Dump the %top code. */
471 if( top_buf.elts)
472 outn((char*) top_buf.elts);
473
474 /* Dump the m4 definitions. */
475 buf_print_strings(&m4defs_buf, stdout);
476 m4defs_buf.nelts = 0; /* memory leak here. */
477
478 /* Place a bogus line directive, it will be fixed in the filter. */
479 outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
480
481 /* Dump the user defined preproc directives. */
482 if (userdef_buf.elts)
483 outn ((char *) (userdef_buf.elts));
484
485 skelout ();
486 /* %% [1.0] */
487 }
488
489 /* flexend - terminate flex
490 *
491 * note
492 * This routine does not return.
493 */
494
495 void flexend (exit_status)
496 int exit_status;
497
498 {
499 static int called_before = -1; /* prevent infinite recursion. */
500 int tblsiz;
501
502 if (++called_before)
503 FLEX_EXIT (exit_status);
504
505 if (skelfile != NULL) {
506 if (ferror (skelfile))
507 lerrsf (_("input error reading skeleton file %s"),
508 skelname);
509
510 else if (fclose (skelfile))
511 lerrsf (_("error closing skeleton file %s"),
512 skelname);
513 }
514
515 #if 0
516 fprintf (header_out,
517 "#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n");
518 fprintf (header_out,
519 "/* Beware! Start conditions are not prefixed. */\n");
520
521 /* Special case for "INITIAL" */
522 fprintf (header_out,
523 "#undef INITIAL\n#define INITIAL 0\n");
524 for (i = 2; i <= lastsc; i++)
525 fprintf (header_out, "#define %s %d\n", scname[i], i - 1);
526 fprintf (header_out,
527 "#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n");
528
529 /* Kill ALL flex-related macros. This is so the user
530 * can #include more than one generated header file. */
531 fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n");
532 fprintf (header_out,
533 "/* Undefine all internal macros, etc., that do no belong in the header. */\n\n");
534
535 {
536 const char * undef_list[] = {
537
538 "BEGIN",
539 "ECHO",
540 "EOB_ACT_CONTINUE_SCAN",
541 "EOB_ACT_END_OF_FILE",
542 "EOB_ACT_LAST_MATCH",
543 "FLEX_SCANNER",
544 "FLEX_STD",
545 "REJECT",
546 "YYFARGS0",
547 "YYFARGS1",
548 "YYFARGS2",
549 "YYFARGS3",
550 "YYLMAX",
551 "YYSTATE",
552 "YY_AT_BOL",
553 "YY_BREAK",
554 "YY_BUFFER_EOF_PENDING",
555 "YY_BUFFER_NEW",
556 "YY_BUFFER_NORMAL",
557 "YY_BUF_SIZE",
558 "M4_YY_CALL_LAST_ARG",
559 "M4_YY_CALL_ONLY_ARG",
560 "YY_CURRENT_BUFFER",
561 "YY_DECL",
562 "M4_YY_DECL_LAST_ARG",
563 "M4_YY_DEF_LAST_ARG",
564 "M4_YY_DEF_ONLY_ARG",
565 "YY_DO_BEFORE_ACTION",
566 "YY_END_OF_BUFFER",
567 "YY_END_OF_BUFFER_CHAR",
568 "YY_EXIT_FAILURE",
569 "YY_EXTRA_TYPE",
570 "YY_FATAL_ERROR",
571 "YY_FLEX_DEFINED_ECHO",
572 "YY_FLEX_LEX_COMPAT",
573 "YY_FLEX_MAJOR_VERSION",
574 "YY_FLEX_MINOR_VERSION",
575 "YY_FLEX_SUBMINOR_VERSION",
576 "YY_FLUSH_BUFFER",
577 "YY_G",
578 "YY_INPUT",
579 "YY_INTERACTIVE",
580 "YY_INT_ALIGNED",
581 "YY_LAST_ARG",
582 "YY_LESS_LINENO",
583 "YY_LEX_ARGS",
584 "YY_LEX_DECLARATION",
585 "YY_LEX_PROTO",
586 "YY_MAIN",
587 "YY_MORE_ADJ",
588 "YY_NEED_STRLEN",
589 "YY_NEW_FILE",
590 "YY_NULL",
591 "YY_NUM_RULES",
592 "YY_ONLY_ARG",
593 "YY_PARAMS",
594 "YY_PROTO",
595 "M4_YY_PROTO_LAST_ARG",
596 "M4_YY_PROTO_ONLY_ARG void",
597 "YY_READ_BUF_SIZE",
598 "YY_REENTRANT",
599 "YY_RESTORE_YY_MORE_OFFSET",
600 "YY_RULE_SETUP",
601 "YY_SC_TO_UI",
602 "YY_SKIP_YYWRAP",
603 "YY_START",
604 "YY_START_STACK_INCR",
605 "YY_STATE_EOF",
606 "YY_STDINIT",
607 "YY_TRAILING_HEAD_MASK",
608 "YY_TRAILING_MASK",
609 "YY_USER_ACTION",
610 "YY_USE_CONST",
611 "YY_USE_PROTOS",
612 "unput",
613 "yyTABLES_NAME",
614 "yy_create_buffer",
615 "yy_delete_buffer",
616 "yy_flex_debug",
617 "yy_flush_buffer",
618 "yy_init_buffer",
619 "yy_load_buffer_state",
620 "yy_new_buffer",
621 "yy_scan_buffer",
622 "yy_scan_bytes",
623 "yy_scan_string",
624 "yy_set_bol",
625 "yy_set_interactive",
626 "yy_switch_to_buffer",
627 "yypush_buffer_state",
628 "yypop_buffer_state",
629 "yyensure_buffer_stack",
630 "yyalloc",
631 "yyconst",
632 "yyextra",
633 "yyfree",
634 "yyget_debug",
635 "yyget_extra",
636 "yyget_in",
637 "yyget_leng",
638 "yyget_lineno",
639 "yyget_lloc",
640 "yyget_lval",
641 "yyget_out",
642 "yyget_text",
643 "yyin",
644 "yyleng",
645 "yyless",
646 "yylex",
647 "yylex_destroy",
648 "yylex_init",
649 "yylex_init_extra",
650 "yylineno",
651 "yylloc",
652 "yylval",
653 "yymore",
654 "yyout",
655 "yyrealloc",
656 "yyrestart",
657 "yyset_debug",
658 "yyset_extra",
659 "yyset_in",
660 "yyset_lineno",
661 "yyset_lloc",
662 "yyset_lval",
663 "yyset_out",
664 "yytables_destroy",
665 "yytables_fload",
666 "yyterminate",
667 "yytext",
668 "yytext_ptr",
669 "yywrap",
670
671 /* must be null-terminated */
672 NULL};
673
674
675 for (i=0; undef_list[i] != NULL; i++)
676 fprintf (header_out, "#undef %s\n", undef_list[i]);
677 }
678
679 /* undef any of the auto-generated symbols. */
680 for (i = 0; i < defs_buf.nelts; i++) {
681
682 /* don't undef start conditions */
683 if (sclookup (((char **) defs_buf.elts)[i]) > 0)
684 continue;
685 fprintf (header_out, "#undef %s\n",
686 ((char **) defs_buf.elts)[i]);
687 }
688
689 fprintf (header_out,
690 "#endif /* !YY_HEADER_NO_UNDEFS */\n");
691 fprintf (header_out, "\n");
692 fprintf (header_out, "#undef %sIN_HEADER\n", prefix);
693 fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
694
695 if (ferror (header_out))
696 lerrsf (_("error creating header file %s"),
697 headerfilename);
698 fflush (header_out);
699 fclose (header_out);
700 #endif
701
702 if (exit_status != 0 && outfile_created) {
703 if (ferror (stdout))
704 lerrsf (_("error writing output file %s"),
705 outfilename);
706
707 else if ((_stdout_closed = 1) && fclose (stdout))
708 lerrsf (_("error closing output file %s"),
709 outfilename);
710
711 else if (unlink (outfilename))
712 lerrsf (_("error deleting output file %s"),
713 outfilename);
714 }
715
716
717 if (backing_up_report && backing_up_file) {
718 if (num_backing_up == 0)
719 fprintf (backing_up_file, _("No backing up.\n"));
720 else if (fullspd || fulltbl)
721 fprintf (backing_up_file,
722 _
723 ("%d backing up (non-accepting) states.\n"),
724 num_backing_up);
725 else
726 fprintf (backing_up_file,
727 _("Compressed tables always back up.\n"));
728
729 if (ferror (backing_up_file))
730 lerrsf (_("error writing backup file %s"),
731 backing_name);
732
733 else if (fclose (backing_up_file))
734 lerrsf (_("error closing backup file %s"),
735 backing_name);
736 }
737
738 if (printstats) {
739 fprintf (stderr, _("%s version %s usage statistics:\n"),
740 program_name, flex_version);
741
742 fprintf (stderr, _(" scanner options: -"));
743
744 if (C_plus_plus)
745 putc ('+', stderr);
746 if (backing_up_report)
747 putc ('b', stderr);
748 if (ddebug)
749 putc ('d', stderr);
750 if (sf_case_ins())
751 putc ('i', stderr);
752 if (lex_compat)
753 putc ('l', stderr);
754 if (posix_compat)
755 putc ('X', stderr);
756 if (performance_report > 0)
757 putc ('p', stderr);
758 if (performance_report > 1)
759 putc ('p', stderr);
760 if (spprdflt)
761 putc ('s', stderr);
762 if (reentrant)
763 fputs ("--reentrant", stderr);
764 if (bison_bridge_lval)
765 fputs ("--bison-bridge", stderr);
766 if (bison_bridge_lloc)
767 fputs ("--bison-locations", stderr);
768 if (use_stdout)
769 putc ('t', stderr);
770 if (printstats)
771 putc ('v', stderr); /* always true! */
772 if (nowarn)
773 putc ('w', stderr);
774 if (interactive == false)
775 putc ('B', stderr);
776 if (interactive == true)
777 putc ('I', stderr);
778 if (!gen_line_dirs)
779 putc ('L', stderr);
780 if (trace)
781 putc ('T', stderr);
782
783 if (csize == unspecified)
784 /* We encountered an error fairly early on, so csize
785 * never got specified. Define it now, to prevent
786 * bogus table sizes being written out below.
787 */
788 csize = 256;
789
790 if (csize == 128)
791 putc ('7', stderr);
792 else
793 putc ('8', stderr);
794
795 fprintf (stderr, " -C");
796
797 if (long_align)
798 putc ('a', stderr);
799 if (fulltbl)
800 putc ('f', stderr);
801 if (fullspd)
802 putc ('F', stderr);
803 if (useecs)
804 putc ('e', stderr);
805 if (usemecs)
806 putc ('m', stderr);
807 if (use_read)
808 putc ('r', stderr);
809
810 if (did_outfilename)
811 fprintf (stderr, " -o%s", outfilename);
812
813 if (skelname)
814 fprintf (stderr, " -S%s", skelname);
815
816 if (strcmp (prefix, "yy"))
817 fprintf (stderr, " -P%s", prefix);
818
819 putc ('\n', stderr);
820
821 fprintf (stderr, _(" %d/%d NFA states\n"),
822 lastnfa, current_mns);
823 fprintf (stderr, _(" %d/%d DFA states (%d words)\n"),
824 lastdfa, current_max_dfas, totnst);
825 fprintf (stderr, _(" %d rules\n"),
826 num_rules + num_eof_rules -
827 1 /* - 1 for def. rule */ );
828
829 if (num_backing_up == 0)
830 fprintf (stderr, _(" No backing up\n"));
831 else if (fullspd || fulltbl)
832 fprintf (stderr,
833 _
834 (" %d backing-up (non-accepting) states\n"),
835 num_backing_up);
836 else
837 fprintf (stderr,
838 _
839 (" Compressed tables always back-up\n"));
840
841 if (bol_needed)
842 fprintf (stderr,
843 _(" Beginning-of-line patterns used\n"));
844
845 fprintf (stderr, _(" %d/%d start conditions\n"), lastsc,
846 current_max_scs);
847 fprintf (stderr,
848 _
849 (" %d epsilon states, %d double epsilon states\n"),
850 numeps, eps2);
851
852 if (lastccl == 0)
853 fprintf (stderr, _(" no character classes\n"));
854 else
855 fprintf (stderr,
856 _
857 (" %d/%d character classes needed %d/%d words of storage, %d reused\n"),
858 lastccl, current_maxccls,
859 cclmap[lastccl] + ccllen[lastccl],
860 current_max_ccl_tbl_size, cclreuse);
861
862 fprintf (stderr, _(" %d state/nextstate pairs created\n"),
863 numsnpairs);
864 fprintf (stderr,
865 _(" %d/%d unique/duplicate transitions\n"),
866 numuniq, numdup);
867
868 if (fulltbl) {
869 tblsiz = lastdfa * numecs;
870 fprintf (stderr, _(" %d table entries\n"),
871 tblsiz);
872 }
873
874 else {
875 tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
876
877 fprintf (stderr,
878 _(" %d/%d base-def entries created\n"),
879 lastdfa + numtemps, current_max_dfas);
880 fprintf (stderr,
881 _
882 (" %d/%d (peak %d) nxt-chk entries created\n"),
883 tblend, current_max_xpairs, peakpairs);
884 fprintf (stderr,
885 _
886 (" %d/%d (peak %d) template nxt-chk entries created\n"),
887 numtemps * nummecs,
888 current_max_template_xpairs,
889 numtemps * numecs);
890 fprintf (stderr, _(" %d empty table entries\n"),
891 nummt);
892 fprintf (stderr, _(" %d protos created\n"),
893 numprots);
894 fprintf (stderr,
895 _(" %d templates created, %d uses\n"),
896 numtemps, tmpuses);
897 }
898
899 if (useecs) {
900 tblsiz = tblsiz + csize;
901 fprintf (stderr,
902 _
903 (" %d/%d equivalence classes created\n"),
904 numecs, csize);
905 }
906
907 if (usemecs) {
908 tblsiz = tblsiz + numecs;
909 fprintf (stderr,
910 _
911 (" %d/%d meta-equivalence classes created\n"),
912 nummecs, csize);
913 }
914
915 fprintf (stderr,
916 _
917 (" %d (%d saved) hash collisions, %d DFAs equal\n"),
918 hshcol, hshsave, dfaeql);
919 fprintf (stderr, _(" %d sets of reallocations needed\n"),
920 num_reallocs);
921 fprintf (stderr, _(" %d total table entries needed\n"),
922 tblsiz);
923 }
924
925 FLEX_EXIT (exit_status);
926 }
927
928
929 /* flexinit - initialize flex */
930
931 void flexinit (argc, argv)
932 int argc;
933 char **argv;
934 {
935 int i, sawcmpflag, rv, optind;
936 char *arg;
937 scanopt_t sopt;
938
939 printstats = syntaxerror = trace = spprdflt = false;
940 lex_compat = posix_compat = C_plus_plus = backing_up_report =
941 ddebug = fulltbl = false;
942 fullspd = long_align = nowarn = yymore_used = continued_action =
943 false;
944 do_yylineno = yytext_is_array = in_rule = reject = do_stdinit =
945 false;
946 yymore_really_used = reject_really_used = unspecified;
947 interactive = csize = unspecified;
948 do_yywrap = gen_line_dirs = usemecs = useecs = true;
949 reentrant = bison_bridge_lval = bison_bridge_lloc = false;
950 performance_report = 0;
951 did_outfilename = 0;
952 prefix = "yy";
953 yyclass = 0;
954 use_read = use_stdout = false;
955 tablesext = tablesverify = false;
956 gentables = true;
957 tablesfilename = tablesname = NULL;
958 ansi_func_defs = ansi_func_protos = true;
959
960 sawcmpflag = false;
961
962 /* Initialize dynamic array for holding the rule actions. */
963 action_size = 2048; /* default size of action array in bytes */
964 action_array = allocate_character_array (action_size);
965 defs1_offset = prolog_offset = action_offset = action_index = 0;
966 action_array[0] = '\0';
967
968 /* Initialize any buffers. */
969 buf_init (&userdef_buf, sizeof (char)); /* one long string */
970 buf_init (&defs_buf, sizeof (char *)); /* list of strings */
971 buf_init (&yydmap_buf, sizeof (char)); /* one long string */
972 buf_init (&top_buf, sizeof (char)); /* one long string */
973
974 {
975 const char * m4defs_init_str[] = {"m4_changequote\n",
976 "m4_changequote([[, ]])\n"};
977 buf_init (&m4defs_buf, sizeof (char *));
978 buf_append (&m4defs_buf, &m4defs_init_str, 2);
979 }
980
981 sf_init ();
982
983 /* initialize regex lib */
984 flex_init_regex();
985
986 /* Enable C++ if program name ends with '+'. */
987 program_name = basename2 (argv[0], 0);
988
989 if (program_name[0] != '\0' &&
990 program_name[strlen (program_name) - 1] == '+')
991 C_plus_plus = true;
992
993 /* read flags */
994 sopt = scanopt_init (flexopts, argc, argv, 0);
995 if (!sopt) {
996 /* This will only happen when flexopts array is altered. */
997 fprintf (stderr,
998 _("Internal error. flexopts are malformed.\n"));
999 FLEX_EXIT (1);
1000 }
1001
1002 while ((rv = scanopt (sopt, &arg, &optind)) != 0) {
1003
1004 if (rv < 0) {
1005 /* Scanopt has already printed an option-specific error message. */
1006 fprintf (stderr,
1007 _
1008 ("Try `%s --help' for more information.\n"),
1009 program_name);
1010 FLEX_EXIT (1);
1011 }
1012
1013 switch ((enum flexopt_flag_t) rv) {
1014 case OPT_CPLUSPLUS:
1015 C_plus_plus = true;
1016 break;
1017
1018 case OPT_BATCH:
1019 interactive = false;
1020 break;
1021
1022 case OPT_BACKUP:
1023 backing_up_report = true;
1024 break;
1025
1026 case OPT_DONOTHING:
1027 break;
1028
1029 case OPT_COMPRESSION:
1030 if (!sawcmpflag) {
1031 useecs = false;
1032 usemecs = false;
1033 fulltbl = false;
1034 sawcmpflag = true;
1035 }
1036
1037 for (i = 0; arg && arg[i] != '\0'; i++)
1038 switch (arg[i]) {
1039 case 'a':
1040 long_align = true;
1041 break;
1042
1043 case 'e':
1044 useecs = true;
1045 break;
1046
1047 case 'F':
1048 fullspd = true;
1049 break;
1050
1051 case 'f':
1052 fulltbl = true;
1053 break;
1054
1055 case 'm':
1056 usemecs = true;
1057 break;
1058
1059 case 'r':
1060 use_read = true;
1061 break;
1062
1063 default:
1064 lerrif (_
1065 ("unknown -C option '%c'"),
1066 (int) arg[i]);
1067 break;
1068 }
1069 break;
1070
1071 case OPT_DEBUG:
1072 ddebug = true;
1073 break;
1074
1075 case OPT_NO_DEBUG:
1076 ddebug = false;
1077 break;
1078
1079 case OPT_FULL:
1080 useecs = usemecs = false;
1081 use_read = fulltbl = true;
1082 break;
1083
1084 case OPT_FAST:
1085 useecs = usemecs = false;
1086 use_read = fullspd = true;
1087 break;
1088
1089 case OPT_HELP:
1090 usage ();
1091 FLEX_EXIT (0);
1092
1093 case OPT_INTERACTIVE:
1094 interactive = true;
1095 break;
1096
1097 case OPT_CASE_INSENSITIVE:
1098 sf_set_case_ins(true);
1099 break;
1100
1101 case OPT_LEX_COMPAT:
1102 lex_compat = true;
1103 break;
1104
1105 case OPT_POSIX_COMPAT:
1106 posix_compat = true;
1107 break;
1108
1109 case OPT_PREPROC_LEVEL:
1110 preproc_level = strtol(arg,NULL,0);
1111 break;
1112
1113 case OPT_MAIN:
1114 buf_strdefine (&userdef_buf, "YY_MAIN", "1");
1115 do_yywrap = false;
1116 break;
1117
1118 case OPT_NO_MAIN:
1119 buf_strdefine (&userdef_buf, "YY_MAIN", "0");
1120 break;
1121
1122 case OPT_NO_LINE:
1123 gen_line_dirs = false;
1124 break;
1125
1126 case OPT_OUTFILE:
1127 outfilename = arg;
1128 did_outfilename = 1;
1129 break;
1130
1131 case OPT_PREFIX:
1132 prefix = arg;
1133 break;
1134
1135 case OPT_PERF_REPORT:
1136 ++performance_report;
1137 break;
1138
1139 case OPT_BISON_BRIDGE:
1140 bison_bridge_lval = true;
1141 break;
1142
1143 case OPT_BISON_BRIDGE_LOCATIONS:
1144 bison_bridge_lval = bison_bridge_lloc = true;
1145 break;
1146
1147 case OPT_REENTRANT:
1148 reentrant = true;
1149 break;
1150
1151 case OPT_NO_REENTRANT:
1152 reentrant = false;
1153 break;
1154
1155 case OPT_SKEL:
1156 skelname = arg;
1157 break;
1158
1159 case OPT_DEFAULT:
1160 spprdflt = false;
1161 break;
1162
1163 case OPT_NO_DEFAULT:
1164 spprdflt = true;
1165 break;
1166
1167 case OPT_STDOUT:
1168 use_stdout = true;
1169 break;
1170
1171 case OPT_NO_UNISTD_H:
1172 //buf_strdefine (&userdef_buf, "YY_NO_UNISTD_H", "1");
1173 buf_m4_define( &m4defs_buf, "M4_YY_NO_UNISTD_H",0);
1174 break;
1175
1176 case OPT_TABLES_FILE:
1177 tablesext = true;
1178 tablesfilename = arg;
1179 break;
1180
1181 case OPT_TABLES_VERIFY:
1182 tablesverify = true;
1183 break;
1184
1185 case OPT_TRACE:
1186 trace = true;
1187 break;
1188
1189 case OPT_VERBOSE:
1190 printstats = true;
1191 break;
1192
1193 case OPT_VERSION:
1194 printf (_("%s %s\n"), program_name, flex_version);
1195 FLEX_EXIT (0);
1196
1197 case OPT_WARN:
1198 nowarn = false;
1199 break;
1200
1201 case OPT_NO_WARN:
1202 nowarn = true;
1203 break;
1204
1205 case OPT_7BIT:
1206 csize = 128;
1207 break;
1208
1209 case OPT_8BIT:
1210 csize = CSIZE;
1211 break;
1212
1213 case OPT_ALIGN:
1214 long_align = true;
1215 break;
1216
1217 case OPT_NO_ALIGN:
1218 long_align = false;
1219 break;
1220
1221 case OPT_ALWAYS_INTERACTIVE:
1222 buf_m4_define (&m4defs_buf, "M4_YY_ALWAYS_INTERACTIVE", 0);
1223 break;
1224
1225 case OPT_NEVER_INTERACTIVE:
1226 buf_m4_define( &m4defs_buf, "M4_YY_NEVER_INTERACTIVE", 0);
1227 break;
1228
1229 case OPT_ARRAY:
1230 yytext_is_array = true;
1231 break;
1232
1233 case OPT_POINTER:
1234 yytext_is_array = false;
1235 break;
1236
1237 case OPT_ECS:
1238 useecs = true;
1239 break;
1240
1241 case OPT_NO_ECS:
1242 useecs = false;
1243 break;
1244
1245 case OPT_HEADER_FILE:
1246 headerfilename = arg;
1247 break;
1248
1249 case OPT_META_ECS:
1250 usemecs = true;
1251 break;
1252
1253 case OPT_NO_META_ECS:
1254 usemecs = false;
1255 break;
1256
1257 case OPT_PREPROCDEFINE:
1258 {
1259 /* arg is "symbol" or "symbol=definition". */
1260 char *def;
1261
1262 for (def = arg;
1263 *def != '\0' && *def != '='; ++def) ;
1264
1265 buf_strappend (&userdef_buf, "#define ");
1266 if (*def == '\0') {
1267 buf_strappend (&userdef_buf, arg);
1268 buf_strappend (&userdef_buf,
1269 " 1\n");
1270 }
1271 else {
1272 buf_strnappend (&userdef_buf, arg,
1273 def - arg);
1274 buf_strappend (&userdef_buf, " ");
1275 buf_strappend (&userdef_buf,
1276 def + 1);
1277 buf_strappend (&userdef_buf, "\n");
1278 }
1279 }
1280 break;
1281
1282 case OPT_READ:
1283 use_read = true;
1284 break;
1285
1286 case OPT_STACK:
1287 //buf_strdefine (&userdef_buf, "YY_STACK_USED", "1");
1288 buf_m4_define( &m4defs_buf, "M4_YY_STACK_USED",0);
1289 break;
1290
1291 case OPT_STDINIT:
1292 do_stdinit = true;
1293 break;
1294
1295 case OPT_NO_STDINIT:
1296 do_stdinit = false;
1297 break;
1298
1299 case OPT_YYCLASS:
1300 yyclass = arg;
1301 break;
1302
1303 case OPT_YYLINENO:
1304 do_yylineno = true;
1305 break;
1306
1307 case OPT_NO_YYLINENO:
1308 do_yylineno = false;
1309 break;
1310
1311 case OPT_YYWRAP:
1312 do_yywrap = true;
1313 break;
1314
1315 case OPT_NO_YYWRAP:
1316 do_yywrap = false;
1317 break;
1318
1319 case OPT_YYMORE:
1320 yymore_really_used = true;
1321 break;
1322
1323 case OPT_NO_YYMORE:
1324 yymore_really_used = false;
1325 break;
1326
1327 case OPT_REJECT:
1328 reject_really_used = true;
1329 break;
1330
1331 case OPT_NO_REJECT:
1332 reject_really_used = false;
1333 break;
1334
1335 case OPT_NO_ANSI_FUNC_DEFS:
1336 ansi_func_defs = false;
1337 break;
1338
1339 case OPT_NO_ANSI_FUNC_PROTOS:
1340 ansi_func_protos = false;
1341 break;
1342
1343 case OPT_NO_YY_PUSH_STATE:
1344 //buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1");
1345 buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0);
1346 break;
1347 case OPT_NO_YY_POP_STATE:
1348 //buf_strdefine (&userdef_buf, "YY_NO_POP_STATE", "1");
1349 buf_m4_define( &m4defs_buf, "M4_YY_NO_POP_STATE",0);
1350 break;
1351 case OPT_NO_YY_TOP_STATE:
1352 //buf_strdefine (&userdef_buf, "YY_NO_TOP_STATE", "1");
1353 buf_m4_define( &m4defs_buf, "M4_YY_NO_TOP_STATE",0);
1354 break;
1355 case OPT_NO_UNPUT:
1356 //buf_strdefine (&userdef_buf, "YY_NO_UNPUT", "1");
1357 buf_m4_define( &m4defs_buf, "M4_YY_NO_UNPUT",0);
1358 break;
1359 case OPT_NO_YY_SCAN_BUFFER:
1360 //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BUFFER", "1");
1361 buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BUFFER",0);
1362 break;
1363 case OPT_NO_YY_SCAN_BYTES:
1364 //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BYTES", "1");
1365 buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BYTES",0);
1366 break;
1367 case OPT_NO_YY_SCAN_STRING:
1368 //buf_strdefine (&userdef_buf, "YY_NO_SCAN_STRING", "1");
1369 buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_STRING",0);
1370 break;
1371 case OPT_NO_YYGET_EXTRA:
1372 //buf_strdefine (&userdef_buf, "YY_NO_GET_EXTRA", "1");
1373 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_EXTRA",0);
1374 break;
1375 case OPT_NO_YYSET_EXTRA:
1376 //buf_strdefine (&userdef_buf, "YY_NO_SET_EXTRA", "1");
1377 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_EXTRA",0);
1378 break;
1379 case OPT_NO_YYGET_LENG:
1380 //buf_strdefine (&userdef_buf, "YY_NO_GET_LENG", "1");
1381 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LENG",0);
1382 break;
1383 case OPT_NO_YYGET_TEXT:
1384 //buf_strdefine (&userdef_buf, "YY_NO_GET_TEXT", "1");
1385 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_TEXT",0);
1386 break;
1387 case OPT_NO_YYGET_LINENO:
1388 //buf_strdefine (&userdef_buf, "YY_NO_GET_LINENO", "1");
1389 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LINENO",0);
1390 break;
1391 case OPT_NO_YYSET_LINENO:
1392 //buf_strdefine (&userdef_buf, "YY_NO_SET_LINENO", "1");
1393 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LINENO",0);
1394 break;
1395 case OPT_NO_YYGET_IN:
1396 //buf_strdefine (&userdef_buf, "YY_NO_GET_IN", "1");
1397 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_IN",0);
1398 break;
1399 case OPT_NO_YYSET_IN:
1400 //buf_strdefine (&userdef_buf, "YY_NO_SET_IN", "1");
1401 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_IN",0);
1402 break;
1403 case OPT_NO_YYGET_OUT:
1404 //buf_strdefine (&userdef_buf, "YY_NO_GET_OUT", "1");
1405 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_OUT",0);
1406 break;
1407 case OPT_NO_YYSET_OUT:
1408 //buf_strdefine (&userdef_buf, "YY_NO_SET_OUT", "1");
1409 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_OUT",0);
1410 break;
1411 case OPT_NO_YYGET_LVAL:
1412 //buf_strdefine (&userdef_buf, "YY_NO_GET_LVAL", "1");
1413 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LVAL",0);
1414 break;
1415 case OPT_NO_YYSET_LVAL:
1416 //buf_strdefine (&userdef_buf, "YY_NO_SET_LVAL", "1");
1417 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LVAL",0);
1418 break;
1419 case OPT_NO_YYGET_LLOC:
1420 //buf_strdefine (&userdef_buf, "YY_NO_GET_LLOC", "1");
1421 buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LLOC",0);
1422 break;
1423 case OPT_NO_YYSET_LLOC:
1424 //buf_strdefine (&userdef_buf, "YY_NO_SET_LLOC", "1");
1425 buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LLOC",0);
1426 break;
1427
1428 } /* switch */
1429 } /* while scanopt() */
1430
1431 scanopt_destroy (sopt);
1432
1433 num_input_files = argc - optind;
1434 input_files = argv + optind;
1435 set_input_file (num_input_files > 0 ? input_files[0] : NULL);
1436
1437 lastccl = lastsc = lastdfa = lastnfa = 0;
1438 num_rules = num_eof_rules = default_rule = 0;
1439 numas = numsnpairs = tmpuses = 0;
1440 numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst =
1441 0;
1442 numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
1443 num_backing_up = onesp = numprots = 0;
1444 variable_trailing_context_rules = bol_needed = false;
1445
1446 linenum = sectnum = 1;
1447 firstprot = NIL;
1448
1449 /* Used in mkprot() so that the first proto goes in slot 1
1450 * of the proto queue.
1451 */
1452 lastprot = 1;
1453
1454 set_up_initial_allocations ();
1455 }
1456
1457
1458 /* readin - read in the rules section of the input file(s) */
1459
1460 void readin ()
1461 {
1462 static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
1463 static char yy_nostdinit[] =
1464 "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
1465
1466 line_directive_out ((FILE *) 0, 1);
1467
1468 if (yyparse ()) {
1469 pinpoint_message (_("fatal parse error"));
1470 flexend (1);
1471 }
1472
1473 if (syntaxerror)
1474 flexend (1);
1475
1476 /* If the user explicitly requested posix compatibility by specifing the
1477 * posix-compat option, then we check for conflicting options. However, if
1478 * the POSIXLY_CORRECT variable is set, then we quietly make flex as
1479 * posix-compatible as possible. This is the recommended behavior
1480 * according to the GNU Coding Standards.
1481 *
1482 * Note: The posix option was added to flex to provide the posix behavior
1483 * of the repeat operator in regular expressions, e.g., `ab{3}'
1484 */
1485 if (posix_compat) {
1486 /* TODO: This is where we try to make flex behave according to
1487 * posiz, AND check for conflicting options. How far should we go
1488 * with this? Should we disable all the neat-o flex features?
1489 */
1490 /* Update: Estes says no, since other flex features don't violate posix. */
1491 }
1492
1493 if (getenv ("POSIXLY_CORRECT")) {
1494 posix_compat = true;
1495 }
1496
1497 if (backing_up_report) {
1498 backing_up_file = fopen (backing_name, "w");
1499 if (backing_up_file == NULL)
1500 lerrsf (_
1501 ("could not create backing-up info file %s"),
1502 backing_name);
1503 }
1504
1505 else
1506 backing_up_file = NULL;
1507
1508 if (yymore_really_used == true)
1509 yymore_used = true;
1510 else if (yymore_really_used == false)
1511 yymore_used = false;
1512
1513 if (reject_really_used == true)
1514 reject = true;
1515 else if (reject_really_used == false)
1516 reject = false;
1517
1518 if (performance_report > 0) {
1519 if (lex_compat) {
1520 fprintf (stderr,
1521 _
1522 ("-l AT&T lex compatibility option entails a large performance penalty\n"));
1523 fprintf (stderr,
1524 _
1525 (" and may be the actual source of other reported performance penalties\n"));
1526 }
1527
1528 else if (do_yylineno) {
1529 fprintf (stderr,
1530 _
1531 ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"));
1532 }
1533
1534 if (performance_report > 1) {
1535 if (interactive)
1536 fprintf (stderr,
1537 _
1538 ("-I (interactive) entails a minor performance penalty\n"));
1539
1540 if (yymore_used)
1541 fprintf (stderr,
1542 _
1543 ("yymore() entails a minor performance penalty\n"));
1544 }
1545
1546 if (reject)
1547 fprintf (stderr,
1548 _
1549 ("REJECT entails a large performance penalty\n"));
1550
1551 if (variable_trailing_context_rules)
1552 fprintf (stderr,
1553 _
1554 ("Variable trailing context rules entail a large performance penalty\n"));
1555 }
1556
1557 if (reject)
1558 real_reject = true;
1559
1560 if (variable_trailing_context_rules)
1561 reject = true;
1562
1563 if ((fulltbl || fullspd) && reject) {
1564 if (real_reject)
1565 flexerror (_
1566 ("REJECT cannot be used with -f or -F"));
1567 else if (do_yylineno)
1568 flexerror (_
1569 ("%option yylineno cannot be used with REJECT"));
1570 else
1571 flexerror (_
1572 ("variable trailing context rules cannot be used with -f or -F"));
1573 }
1574
1575 if (reject){
1576 out_m4_define( "M4_YY_USES_REJECT", NULL);
1577 //outn ("\n#define YY_USES_REJECT");
1578 }
1579
1580 if (!do_yywrap) {
1581 if (!C_plus_plus) {
1582 if (reentrant)
1583 outn ("\n#define yywrap(yyscanner) 1");
1584 else
1585 outn ("\n#define yywrap() 1");
1586 }
1587 outn ("#define YY_SKIP_YYWRAP");
1588 }
1589
1590 if (ddebug)
1591 outn ("\n#define FLEX_DEBUG");
1592
1593 OUT_BEGIN_CODE ();
1594 if (csize == 256)
1595 outn ("typedef unsigned char YY_CHAR;");
1596 else
1597 outn ("typedef char YY_CHAR;");
1598 OUT_END_CODE ();
1599
1600 if (C_plus_plus) {
1601 outn ("#define yytext_ptr yytext");
1602
1603 if (interactive)
1604 outn ("#define YY_INTERACTIVE");
1605 }
1606
1607 else {
1608 OUT_BEGIN_CODE ();
1609 /* In reentrant scanner, stdinit is handled in flex.skl. */
1610 if (do_stdinit) {
1611 if (reentrant){
1612 outn ("#ifdef VMS");
1613 outn ("#ifdef __VMS_POSIX");
1614 outn ("#define YY_STDINIT");
1615 outn ("#endif");
1616 outn ("#else");
1617 outn ("#define YY_STDINIT");
1618 outn ("#endif");
1619 }
1620
1621 outn ("#ifdef VMS");
1622 outn ("#ifndef __VMS_POSIX");
1623 outn (yy_nostdinit);
1624 outn ("#else");
1625 outn (yy_stdinit);
1626 outn ("#endif");
1627 outn ("#else");
1628 outn (yy_stdinit);
1629 outn ("#endif");
1630 }
1631
1632 else {
1633 if(!reentrant)
1634 outn (yy_nostdinit);
1635 }
1636 OUT_END_CODE ();
1637 }
1638
1639 OUT_BEGIN_CODE ();
1640 if (fullspd)
1641 outn ("typedef yyconst struct yy_trans_info *yy_state_type;");
1642 else if (!C_plus_plus)
1643 outn ("typedef int yy_state_type;");
1644 OUT_END_CODE ();
1645
1646 if (lex_compat)
1647 outn ("#define YY_FLEX_LEX_COMPAT");
1648
1649 if (!C_plus_plus && !reentrant) {
1650 outn ("extern int yylineno;");
1651 OUT_BEGIN_CODE ();
1652 outn ("int yylineno = 1;");
1653 OUT_END_CODE ();
1654 }
1655
1656 if (C_plus_plus) {
1657 outn ("\n#include <FlexLexer.h>");
1658
1659 if (!do_yywrap) {
1660 outn("\nint yyFlexLexer::yywrap() { return 1; }");
1661 }
1662
1663 if (yyclass) {
1664 outn ("int yyFlexLexer::yylex()");
1665 outn ("\t{");
1666 outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
1667 outn ("\treturn 0;");
1668 outn ("\t}");
1669
1670 out_str ("\n#define YY_DECL int %s::yylex()\n",
1671 yyclass);
1672 }
1673 }
1674
1675 else {
1676
1677 /* Watch out: yytext_ptr is a variable when yytext is an array,
1678 * but it's a macro when yytext is a pointer.
1679 */
1680 if (yytext_is_array) {
1681 if (!reentrant)
1682 outn ("extern char yytext[];\n");
1683 }
1684 else {
1685 if (reentrant) {
1686 outn ("#define yytext_ptr yytext_r");
1687 }
1688 else {
1689 outn ("extern char *yytext;");
1690 outn ("#define yytext_ptr yytext");
1691 }
1692 }
1693
1694 if (yyclass)
1695 flexerror (_
1696 ("%option yyclass only meaningful for C++ scanners"));
1697 }
1698
1699 if (useecs)
1700 numecs = cre8ecs (nextecm, ecgroup, csize);
1701 else
1702 numecs = csize;
1703
1704 /* Now map the equivalence class for NUL to its expected place. */
1705 ecgroup[0] = ecgroup[csize];
1706 NUL_ec = ABS (ecgroup[0]);
1707
1708 if (useecs)
1709 ccl2ecl ();
1710 }
1711
1712
1713 /* set_up_initial_allocations - allocate memory for internal tables */
1714
1715 void set_up_initial_allocations ()
1716 {
1717 maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
1718 current_mns = INITIAL_MNS;
1719 firstst = allocate_integer_array (current_mns);
1720 lastst = allocate_integer_array (current_mns);
1721 finalst = allocate_integer_array (current_mns);
1722 transchar = allocate_integer_array (current_mns);
1723 trans1 = allocate_integer_array (current_mns);
1724 trans2 = allocate_integer_array (current_mns);
1725 accptnum = allocate_integer_array (current_mns);
1726 assoc_rule = allocate_integer_array (current_mns);
1727 state_type = allocate_integer_array (current_mns);
1728
1729 current_max_rules = INITIAL_MAX_RULES;
1730 rule_type = allocate_integer_array (current_max_rules);
1731 rule_linenum = allocate_integer_array (current_max_rules);
1732 rule_useful = allocate_integer_array (current_max_rules);
1733 rule_has_nl = allocate_bool_array (current_max_rules);
1734
1735 current_max_scs = INITIAL_MAX_SCS;
1736 scset = allocate_integer_array (current_max_scs);
1737 scbol = allocate_integer_array (current_max_scs);
1738 scxclu = allocate_integer_array (current_max_scs);
1739 sceof = allocate_integer_array (current_max_scs);
1740 scname = allocate_char_ptr_array (current_max_scs);
1741
1742 current_maxccls = INITIAL_MAX_CCLS;
1743 cclmap = allocate_integer_array (current_maxccls);
1744 ccllen = allocate_integer_array (current_maxccls);
1745 cclng = allocate_integer_array (current_maxccls);
1746 ccl_has_nl = allocate_bool_array (current_maxccls);
1747
1748 current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
1749 ccltbl = allocate_Character_array (current_max_ccl_tbl_size);
1750
1751 current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
1752
1753 current_max_xpairs = INITIAL_MAX_XPAIRS;
1754 nxt = allocate_integer_array (current_max_xpairs);
1755 chk = allocate_integer_array (current_max_xpairs);
1756
1757 current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
1758 tnxt = allocate_integer_array (current_max_template_xpairs);
1759
1760 current_max_dfas = INITIAL_MAX_DFAS;
1761 base = allocate_integer_array (current_max_dfas);
1762 def = allocate_integer_array (current_max_dfas);
1763 dfasiz = allocate_integer_array (current_max_dfas);
1764 accsiz = allocate_integer_array (current_max_dfas);
1765 dhash = allocate_integer_array (current_max_dfas);
1766 dss = allocate_int_ptr_array (current_max_dfas);
1767 dfaacc = allocate_dfaacc_union (current_max_dfas);
1768
1769 nultrans = (int *) 0;
1770 }
1771
1772
1773 /* extracts basename from path, optionally stripping the extension "\.*"
1774 * (same concept as /bin/sh `basename`, but different handling of extension). */
1775 static char *basename2 (path, strip_ext)
1776 char *path;
1777 int strip_ext; /* boolean */
1778 {
1779 char *b, *e = 0;
1780
1781 b = path;
1782 for (b = path; *path; path++)
1783 if (*path == '/')
1784 b = path + 1;
1785 else if (*path == '.')
1786 e = path;
1787
1788 if (strip_ext && e && e > b)
1789 *e = '\0';
1790 return b;
1791 }
1792
1793 void usage ()
1794 {
1795 FILE *f = stdout;
1796
1797 if (!did_outfilename) {
1798 snprintf (outfile_path, sizeof(outfile_path), outfile_template,
1799 prefix, C_plus_plus ? "cc" : "c");
1800 outfilename = outfile_path;
1801 }
1802
1803 fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), program_name);
1804 fprintf (f,
1805 _
1806 ("Generates programs that perform pattern-matching on text.\n"
1807 "\n" "Table Compression:\n"
1808 " -Ca, --align trade off larger tables for better memory alignment\n"
1809 " -Ce, --ecs construct equivalence classes\n"
1810 " -Cf do not compress tables; use -f representation\n"
1811 " -CF do not compress tables; use -F representation\n"
1812 " -Cm, --meta-ecs construct meta-equivalence classes\n"
1813 " -Cr, --read use read() instead of stdio for scanner input\n"
1814 " -f, --full generate fast, large scanner. Same as -Cfr\n"
1815 " -F, --fast use alternate table representation. Same as -CFr\n"
1816 " -Cem default compression (same as --ecs --meta-ecs)\n"
1817 "\n" "Debugging:\n"
1818 " -d, --debug enable debug mode in scanner\n"
1819 " -b, --backup write backing-up information to %s\n"
1820 " -p, --perf-report write performance report to stderr\n"
1821 " -s, --nodefault suppress default rule to ECHO unmatched text\n"
1822 " -T, --trace %s should run in trace mode\n"
1823 " -w, --nowarn do not generate warnings\n"
1824 " -v, --verbose write summary of scanner statistics to stdout\n"
1825 "\n" "Files:\n"
1826 " -o, --outfile=FILE specify output filename\n"
1827 " -S, --skel=FILE specify skeleton file\n"
1828 " -t, --stdout write scanner on stdout instead of %s\n"
1829 " --yyclass=NAME name of C++ class\n"
1830 " --header-file=FILE create a C header file in addition to the scanner\n"
1831 " --tables-file[=FILE] write tables to FILE\n" "\n"
1832 "Scanner behavior:\n"
1833 " -7, --7bit generate 7-bit scanner\n"
1834 " -8, --8bit generate 8-bit scanner\n"
1835 " -B, --batch generate batch scanner (opposite of -I)\n"
1836 " -i, --case-insensitive ignore case in patterns\n"
1837 " -l, --lex-compat maximal compatibility with original lex\n"
1838 " -X, --posix-compat maximal compatibility with POSIX lex\n"
1839 " -I, --interactive generate interactive scanner (opposite of -B)\n"
1840 " --yylineno track line count in yylineno\n"
1841 "\n" "Generated code:\n"
1842 " -+, --c++ generate C++ scanner class\n"
1843 " -Dmacro[=defn] #define macro defn (default defn is '1')\n"
1844 " -L, --noline suppress #line directives in scanner\n"
1845 " -P, --prefix=STRING use STRING as prefix instead of \"yy\"\n"
1846 " -R, --reentrant generate a reentrant C scanner\n"
1847 " --bison-bridge scanner for bison pure parser.\n"
1848 " --bison-locations include yylloc support.\n"
1849 " --stdinit initialize yyin/yyout to stdin/stdout\n"
1850 " --noansi-definitions old-style function definitions\n"
1851 " --noansi-prototypes empty parameter list in prototypes\n"
1852 " --nounistd do not include <unistd.h>\n"
1853 " --noFUNCTION do not generate a particular FUNCTION\n"
1854 "\n" "Miscellaneous:\n"
1855 " -c do-nothing POSIX option\n"
1856 " -n do-nothing POSIX option\n"
1857 " -?\n"
1858 " -h, --help produce this help message\n"
1859 " -V, --version report %s version\n"),
1860 backing_name, program_name, outfile_path, program_name);
1861
1862 }
DragonFly BSD