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