| 1 | /* Parse command line arguments for Bison. |
| 2 | |
| 3 | Copyright (C) 1984, 1986, 1989, 1992, 2000-2012 Free Software |
| 4 | Foundation, Inc. |
| 5 | |
| 6 | This file is part of Bison, the GNU Compiler Compiler. |
| 7 | |
| 8 | This program is free software: you can redistribute it and/or modify |
| 9 | it under the terms of the GNU General Public License as published by |
| 10 | the Free Software Foundation, either version 3 of the License, or |
| 11 | (at your option) any later version. |
| 12 | |
| 13 | This program is distributed in the hope that it will be useful, |
| 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | GNU General Public License for more details. |
| 17 | |
| 18 | You should have received a copy of the GNU General Public License |
| 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| 20 | |
| 21 | #include <config.h> |
| 22 | #include "system.h" |
| 23 | #include "output.h" |
| 24 | |
| 25 | #include <argmatch.h> |
| 26 | #include <c-strcase.h> |
| 27 | #include <configmake.h> |
| 28 | #include <error.h> |
| 29 | |
| 30 | /* Hack to get <getopt.h> to declare getopt with a prototype. */ |
| 31 | #if lint && ! defined __GNU_LIBRARY__ |
| 32 | # define __GNU_LIBRARY__ |
| 33 | # define HACK_FOR___GNU_LIBRARY___PROTOTYPE 1 |
| 34 | #endif |
| 35 | |
| 36 | #include <getopt.h> |
| 37 | |
| 38 | #ifdef HACK_FOR___GNU_LIBRARY___PROTOTYPE |
| 39 | # undef __GNU_LIBRARY__ |
| 40 | # undef HACK_FOR___GNU_LIBRARY___PROTOTYPE |
| 41 | #endif |
| 42 | |
| 43 | #include <progname.h> |
| 44 | |
| 45 | #include "complain.h" |
| 46 | #include "files.h" |
| 47 | #include "getargs.h" |
| 48 | #include "muscle-tab.h" |
| 49 | #include "quote.h" |
| 50 | #include "uniqstr.h" |
| 51 | |
| 52 | bool debug_flag; |
| 53 | bool defines_flag; |
| 54 | bool graph_flag; |
| 55 | bool xml_flag; |
| 56 | bool locations_flag; |
| 57 | bool no_lines_flag; |
| 58 | bool token_table_flag; |
| 59 | bool yacc_flag; /* for -y */ |
| 60 | |
| 61 | bool error_verbose = false; |
| 62 | |
| 63 | bool nondeterministic_parser = false; |
| 64 | bool glr_parser = false; |
| 65 | |
| 66 | int report_flag = report_none; |
| 67 | int trace_flag = trace_none; |
| 68 | int warnings_flag = warnings_conflicts_sr | warnings_conflicts_rr |
| 69 | | warnings_other; |
| 70 | |
| 71 | static struct bison_language const valid_languages[] = { |
| 72 | { "c", "c-skel.m4", ".c", ".h", true }, |
| 73 | { "c++", "c++-skel.m4", ".cc", ".hh", true }, |
| 74 | { "java", "java-skel.m4", ".java", ".java", false }, |
| 75 | { "", "", "", "", false } |
| 76 | }; |
| 77 | |
| 78 | int skeleton_prio = default_prio; |
| 79 | const char *skeleton = NULL; |
| 80 | int language_prio = default_prio; |
| 81 | struct bison_language const *language = &valid_languages[0]; |
| 82 | const char *include = NULL; |
| 83 | |
| 84 | |
| 85 | /** Decode an option's set of keys. |
| 86 | * |
| 87 | * \param option option being decoded. |
| 88 | * \param keys array of valid subarguments. |
| 89 | * \param values array of corresponding (int) values. |
| 90 | * \param all the all value. |
| 91 | * \param flags the flags to update |
| 92 | * \param args comma separated list of effective subarguments to decode. |
| 93 | * If 0, then activate all the flags. |
| 94 | * |
| 95 | * If VALUE != 0 then KEY sets flags and no-KEY clears them. |
| 96 | * If VALUE == 0 then KEY clears all flags from \c all and no-KEY sets all |
| 97 | * flags from \c all. Thus no-none = all and no-all = none. |
| 98 | */ |
| 99 | static void |
| 100 | flags_argmatch (const char *option, |
| 101 | const char * const keys[], const int values[], |
| 102 | int all, int *flags, char *args) |
| 103 | { |
| 104 | if (args) |
| 105 | { |
| 106 | args = strtok (args, ","); |
| 107 | while (args) |
| 108 | { |
| 109 | int no = strncmp (args, "no-", 3) == 0 ? 3 : 0; |
| 110 | int value = XARGMATCH (option, args + no, keys, values); |
| 111 | if (value == 0) |
| 112 | { |
| 113 | if (no) |
| 114 | *flags |= all; |
| 115 | else |
| 116 | *flags &= ~all; |
| 117 | } |
| 118 | else |
| 119 | { |
| 120 | if (no) |
| 121 | *flags &= ~value; |
| 122 | else |
| 123 | *flags |= value; |
| 124 | } |
| 125 | args = strtok (NULL, ","); |
| 126 | } |
| 127 | } |
| 128 | else |
| 129 | *flags |= all; |
| 130 | } |
| 131 | |
| 132 | /** Decode a set of sub arguments. |
| 133 | * |
| 134 | * \param FlagName the flag familly to update. |
| 135 | * \param Args the effective sub arguments to decode. |
| 136 | * |
| 137 | * \arg FlagName_args the list of keys. |
| 138 | * \arg FlagName_types the list of values. |
| 139 | * \arg FlagName_all the all value. |
| 140 | * \arg FlagName_flag the flag to update. |
| 141 | */ |
| 142 | #define FLAGS_ARGMATCH(FlagName, Args) \ |
| 143 | flags_argmatch ("--" #FlagName, FlagName ## _args, FlagName ## _types, \ |
| 144 | FlagName ## _all, &FlagName ## _flag, Args) |
| 145 | |
| 146 | |
| 147 | /*----------------------. |
| 148 | | --report's handling. | |
| 149 | `----------------------*/ |
| 150 | |
| 151 | static const char * const report_args[] = |
| 152 | { |
| 153 | /* In a series of synonyms, present the most meaningful first, so |
| 154 | that argmatch_valid be more readable. */ |
| 155 | "none", |
| 156 | "state", "states", |
| 157 | "itemset", "itemsets", |
| 158 | "lookahead", "lookaheads", "look-ahead", |
| 159 | "solved", |
| 160 | "all", |
| 161 | 0 |
| 162 | }; |
| 163 | |
| 164 | static const int report_types[] = |
| 165 | { |
| 166 | report_none, |
| 167 | report_states, report_states, |
| 168 | report_states | report_itemsets, report_states | report_itemsets, |
| 169 | report_states | report_lookahead_tokens, |
| 170 | report_states | report_lookahead_tokens, |
| 171 | report_states | report_lookahead_tokens, |
| 172 | report_states | report_solved_conflicts, |
| 173 | report_all |
| 174 | }; |
| 175 | |
| 176 | ARGMATCH_VERIFY (report_args, report_types); |
| 177 | |
| 178 | |
| 179 | /*---------------------. |
| 180 | | --trace's handling. | |
| 181 | `---------------------*/ |
| 182 | |
| 183 | static const char * const trace_args[] = |
| 184 | { |
| 185 | /* In a series of synonyms, present the most meaningful first, so |
| 186 | that argmatch_valid be more readable. */ |
| 187 | "none - no traces", |
| 188 | "scan - grammar scanner traces", |
| 189 | "parse - grammar parser traces", |
| 190 | "automaton - construction of the automaton", |
| 191 | "bitsets - use of bitsets", |
| 192 | "grammar - reading, reducing the grammar", |
| 193 | "resource - memory consumption (where available)", |
| 194 | "sets - grammar sets: firsts, nullable etc.", |
| 195 | "muscles - m4 definitions passed to the skeleton", |
| 196 | "tools - m4 invocation", |
| 197 | "m4 - m4 traces", |
| 198 | "skeleton - skeleton postprocessing", |
| 199 | "time - time consumption", |
| 200 | "ielr - IELR conversion", |
| 201 | "all - all of the above", |
| 202 | 0 |
| 203 | }; |
| 204 | |
| 205 | static const int trace_types[] = |
| 206 | { |
| 207 | trace_none, |
| 208 | trace_scan, |
| 209 | trace_parse, |
| 210 | trace_automaton, |
| 211 | trace_bitsets, |
| 212 | trace_grammar, |
| 213 | trace_resource, |
| 214 | trace_sets, |
| 215 | trace_muscles, |
| 216 | trace_tools, |
| 217 | trace_m4, |
| 218 | trace_skeleton, |
| 219 | trace_time, |
| 220 | trace_ielr, |
| 221 | trace_all |
| 222 | }; |
| 223 | |
| 224 | ARGMATCH_VERIFY (trace_args, trace_types); |
| 225 | |
| 226 | |
| 227 | /*------------------------. |
| 228 | | --warnings's handling. | |
| 229 | `------------------------*/ |
| 230 | |
| 231 | static const char * const warnings_args[] = |
| 232 | { |
| 233 | /* In a series of synonyms, present the most meaningful first, so |
| 234 | that argmatch_valid be more readable. */ |
| 235 | "none - no warnings", |
| 236 | "midrule-values - unset or unused midrule values", |
| 237 | "yacc - incompatibilities with POSIX Yacc", |
| 238 | "conflicts-sr - S/R conflicts", |
| 239 | "conflicts-rr - R/R conflicts", |
| 240 | "other - all other warnings", |
| 241 | "all - all of the above", |
| 242 | "error - warnings are errors", |
| 243 | 0 |
| 244 | }; |
| 245 | |
| 246 | static const int warnings_types[] = |
| 247 | { |
| 248 | warnings_none, |
| 249 | warnings_midrule_values, |
| 250 | warnings_yacc, |
| 251 | warnings_conflicts_sr, |
| 252 | warnings_conflicts_rr, |
| 253 | warnings_other, |
| 254 | warnings_all, |
| 255 | warnings_error |
| 256 | }; |
| 257 | |
| 258 | ARGMATCH_VERIFY (warnings_args, warnings_types); |
| 259 | |
| 260 | |
| 261 | /*-------------------------------------------. |
| 262 | | Display the help message and exit STATUS. | |
| 263 | `-------------------------------------------*/ |
| 264 | |
| 265 | static void usage (int) ATTRIBUTE_NORETURN; |
| 266 | |
| 267 | static void |
| 268 | usage (int status) |
| 269 | { |
| 270 | if (status != 0) |
| 271 | fprintf (stderr, _("Try `%s --help' for more information.\n"), |
| 272 | program_name); |
| 273 | else |
| 274 | { |
| 275 | /* For ../build-aux/cross-options.pl to work, use the format: |
| 276 | ^ -S, --long[=ARGS] (whitespace) |
| 277 | A --long option is required. |
| 278 | Otherwise, add exceptions to ../build-aux/cross-options.pl. */ |
| 279 | |
| 280 | printf (_("Usage: %s [OPTION]... FILE\n"), program_name); |
| 281 | fputs (_("\ |
| 282 | Generate a deterministic LR or generalized LR (GLR) parser employing\n\ |
| 283 | LALR(1), IELR(1), or canonical LR(1) parser tables. IELR(1) and\n\ |
| 284 | canonical LR(1) support is experimental.\n\ |
| 285 | \n\ |
| 286 | "), stdout); |
| 287 | |
| 288 | fputs (_("\ |
| 289 | Mandatory arguments to long options are mandatory for short options too.\n\ |
| 290 | "), stdout); |
| 291 | fputs (_("\ |
| 292 | The same is true for optional arguments.\n\ |
| 293 | "), stdout); |
| 294 | |
| 295 | fputs (_("\ |
| 296 | \n\ |
| 297 | Operation modes:\n\ |
| 298 | -h, --help display this help and exit\n\ |
| 299 | -V, --version output version information and exit\n\ |
| 300 | --print-localedir output directory containing locale-dependent data\n\ |
| 301 | --print-datadir output directory containing skeletons and XSLT\n\ |
| 302 | -y, --yacc emulate POSIX Yacc\n\ |
| 303 | -W, --warnings[=CATEGORY] report the warnings falling in CATEGORY\n\ |
| 304 | \n\ |
| 305 | "), stdout); |
| 306 | |
| 307 | fputs (_("\ |
| 308 | Parser:\n\ |
| 309 | -L, --language=LANGUAGE specify the output programming language\n\ |
| 310 | (this is an experimental feature)\n\ |
| 311 | -S, --skeleton=FILE specify the skeleton to use\n\ |
| 312 | -t, --debug instrument the parser for debugging\n\ |
| 313 | --locations enable location support\n\ |
| 314 | -D, --define=NAME[=VALUE] similar to `%define NAME \"VALUE\"'\n\ |
| 315 | -F, --force-define=NAME[=VALUE] override `%define NAME \"VALUE\"'\n\ |
| 316 | -p, --name-prefix=PREFIX prepend PREFIX to the external symbols\n\ |
| 317 | -l, --no-lines don't generate `#line' directives\n\ |
| 318 | -k, --token-table include a table of token names\n\ |
| 319 | \n\ |
| 320 | "), stdout); |
| 321 | |
| 322 | /* Keep -d and --defines separate so that ../build-aux/cross-options.pl |
| 323 | * won't assume that -d also takes an argument. */ |
| 324 | fputs (_("\ |
| 325 | Output:\n\ |
| 326 | --defines[=FILE] also produce a header file\n\ |
| 327 | -d likewise but cannot specify FILE (for POSIX Yacc)\n\ |
| 328 | -r, --report=THINGS also produce details on the automaton\n\ |
| 329 | --report-file=FILE write report to FILE\n\ |
| 330 | -v, --verbose same as `--report=state'\n\ |
| 331 | -b, --file-prefix=PREFIX specify a PREFIX for output files\n\ |
| 332 | -o, --output=FILE leave output to FILE\n\ |
| 333 | -g, --graph[=FILE] also output a graph of the automaton\n\ |
| 334 | -x, --xml[=FILE] also output an XML report of the automaton\n\ |
| 335 | (the XML schema is experimental)\n\ |
| 336 | \n\ |
| 337 | "), stdout); |
| 338 | |
| 339 | fputs (_("\ |
| 340 | Warning categories include:\n\ |
| 341 | `midrule-values' unset or unused midrule values\n\ |
| 342 | `yacc' incompatibilities with POSIX Yacc\n\ |
| 343 | `conflicts-sr' S/R conflicts (enabled by default)\n\ |
| 344 | `conflicts-rr' R/R conflicts (enabled by default)\n\ |
| 345 | `other' all other warnings (enabled by default)\n\ |
| 346 | `all' all the warnings\n\ |
| 347 | `no-CATEGORY' turn off warnings in CATEGORY\n\ |
| 348 | `none' turn off all the warnings\n\ |
| 349 | `error' treat warnings as errors\n\ |
| 350 | \n\ |
| 351 | "), stdout); |
| 352 | |
| 353 | fputs (_("\ |
| 354 | THINGS is a list of comma separated words that can include:\n\ |
| 355 | `state' describe the states\n\ |
| 356 | `itemset' complete the core item sets with their closure\n\ |
| 357 | `lookahead' explicitly associate lookahead tokens to items\n\ |
| 358 | `solved' describe shift/reduce conflicts solving\n\ |
| 359 | `all' include all the above information\n\ |
| 360 | `none' disable the report\n\ |
| 361 | "), stdout); |
| 362 | |
| 363 | printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT); |
| 364 | } |
| 365 | |
| 366 | exit (status); |
| 367 | } |
| 368 | |
| 369 | |
| 370 | /*------------------------------. |
| 371 | | Display the version message. | |
| 372 | `------------------------------*/ |
| 373 | |
| 374 | static void |
| 375 | version (void) |
| 376 | { |
| 377 | /* Some efforts were made to ease the translators' task, please |
| 378 | continue. */ |
| 379 | printf (_("bison (GNU Bison) %s"), VERSION); |
| 380 | putc ('\n', stdout); |
| 381 | fputs (_("Written by Robert Corbett and Richard Stallman.\n"), stdout); |
| 382 | putc ('\n', stdout); |
| 383 | |
| 384 | fprintf (stdout, |
| 385 | _("Copyright (C) %d Free Software Foundation, Inc.\n"), |
| 386 | PACKAGE_COPYRIGHT_YEAR); |
| 387 | |
| 388 | fputs (_("\ |
| 389 | This is free software; see the source for copying conditions. There is NO\n\ |
| 390 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ |
| 391 | "), |
| 392 | stdout); |
| 393 | } |
| 394 | |
| 395 | |
| 396 | /*-------------------------------------. |
| 397 | | --skeleton and --language handling. | |
| 398 | `--------------------------------------*/ |
| 399 | |
| 400 | void |
| 401 | skeleton_arg (char const *arg, int prio, location loc) |
| 402 | { |
| 403 | if (prio < skeleton_prio) |
| 404 | { |
| 405 | skeleton_prio = prio; |
| 406 | skeleton = arg; |
| 407 | } |
| 408 | else if (prio == skeleton_prio) |
| 409 | complain_at (loc, _("multiple skeleton declarations are invalid")); |
| 410 | } |
| 411 | |
| 412 | void |
| 413 | language_argmatch (char const *arg, int prio, location loc) |
| 414 | { |
| 415 | char const *msg; |
| 416 | |
| 417 | if (prio < language_prio) |
| 418 | { |
| 419 | int i; |
| 420 | for (i = 0; valid_languages[i].language[0]; i++) |
| 421 | if (c_strcasecmp (arg, valid_languages[i].language) == 0) |
| 422 | { |
| 423 | language_prio = prio; |
| 424 | language = &valid_languages[i]; |
| 425 | return; |
| 426 | } |
| 427 | msg = _("%s: invalid language"); |
| 428 | } |
| 429 | else if (language_prio == prio) |
| 430 | msg = _("multiple language declarations are invalid"); |
| 431 | else |
| 432 | return; |
| 433 | |
| 434 | complain_at (loc, msg, quotearg_colon (arg)); |
| 435 | } |
| 436 | |
| 437 | /*----------------------. |
| 438 | | Process the options. | |
| 439 | `----------------------*/ |
| 440 | |
| 441 | /* Shorts options. |
| 442 | Should be computed from long_options. */ |
| 443 | static char const short_options[] = |
| 444 | "D:" |
| 445 | "F:" |
| 446 | "L:" |
| 447 | "S:" |
| 448 | "T::" |
| 449 | "V" |
| 450 | "W::" |
| 451 | "b:" |
| 452 | "d" |
| 453 | "e" |
| 454 | "g::" |
| 455 | "h" |
| 456 | "k" |
| 457 | "l" |
| 458 | "n" |
| 459 | "o:" |
| 460 | "p:" |
| 461 | "r:" |
| 462 | "t" |
| 463 | "v" |
| 464 | "x::" |
| 465 | "y" |
| 466 | ; |
| 467 | |
| 468 | /* Values for long options that do not have single-letter equivalents. */ |
| 469 | enum |
| 470 | { |
| 471 | LOCATIONS_OPTION = CHAR_MAX + 1, |
| 472 | PRINT_LOCALEDIR_OPTION, |
| 473 | PRINT_DATADIR_OPTION, |
| 474 | REPORT_FILE_OPTION |
| 475 | }; |
| 476 | |
| 477 | static struct option const long_options[] = |
| 478 | { |
| 479 | /* Operation modes. */ |
| 480 | { "help", no_argument, 0, 'h' }, |
| 481 | { "version", no_argument, 0, 'V' }, |
| 482 | { "print-localedir", no_argument, 0, PRINT_LOCALEDIR_OPTION }, |
| 483 | { "print-datadir", no_argument, 0, PRINT_DATADIR_OPTION }, |
| 484 | { "warnings", optional_argument, 0, 'W' }, |
| 485 | |
| 486 | /* Parser. */ |
| 487 | { "name-prefix", required_argument, 0, 'p' }, |
| 488 | { "include", required_argument, 0, 'I' }, |
| 489 | |
| 490 | /* Output. */ |
| 491 | { "file-prefix", required_argument, 0, 'b' }, |
| 492 | { "output", required_argument, 0, 'o' }, |
| 493 | { "output-file", required_argument, 0, 'o' }, |
| 494 | { "graph", optional_argument, 0, 'g' }, |
| 495 | { "xml", optional_argument, 0, 'x' }, |
| 496 | { "report", required_argument, 0, 'r' }, |
| 497 | { "report-file", required_argument, 0, REPORT_FILE_OPTION }, |
| 498 | { "verbose", no_argument, 0, 'v' }, |
| 499 | |
| 500 | /* Hidden. */ |
| 501 | { "trace", optional_argument, 0, 'T' }, |
| 502 | |
| 503 | /* Output. */ |
| 504 | { "defines", optional_argument, 0, 'd' }, |
| 505 | |
| 506 | /* Operation modes. */ |
| 507 | { "fixed-output-files", no_argument, 0, 'y' }, |
| 508 | { "yacc", no_argument, 0, 'y' }, |
| 509 | |
| 510 | /* Parser. */ |
| 511 | { "debug", no_argument, 0, 't' }, |
| 512 | { "define", required_argument, 0, 'D' }, |
| 513 | { "force-define", required_argument, 0, 'F' }, |
| 514 | { "locations", no_argument, 0, LOCATIONS_OPTION }, |
| 515 | { "no-lines", no_argument, 0, 'l' }, |
| 516 | { "raw", no_argument, 0, 0 }, |
| 517 | { "skeleton", required_argument, 0, 'S' }, |
| 518 | { "language", required_argument, 0, 'L' }, |
| 519 | { "token-table", no_argument, 0, 'k' }, |
| 520 | |
| 521 | {0, 0, 0, 0} |
| 522 | }; |
| 523 | |
| 524 | /* Under DOS, there is no difference on the case. This can be |
| 525 | troublesome when looking for `.tab' etc. */ |
| 526 | #ifdef MSDOS |
| 527 | # define AS_FILE_NAME(File) (strlwr (File), (File)) |
| 528 | #else |
| 529 | # define AS_FILE_NAME(File) (File) |
| 530 | #endif |
| 531 | |
| 532 | /* Build a location for the current command line argument. */ |
| 533 | static |
| 534 | location |
| 535 | command_line_location (void) |
| 536 | { |
| 537 | location res; |
| 538 | /* "<command line>" is used in GCC's messages about -D. */ |
| 539 | boundary_set (&res.start, uniqstr_new ("<command line>"), optind, -1); |
| 540 | res.end = res.start; |
| 541 | return res; |
| 542 | } |
| 543 | |
| 544 | |
| 545 | void |
| 546 | getargs (int argc, char *argv[]) |
| 547 | { |
| 548 | int c; |
| 549 | |
| 550 | while ((c = getopt_long (argc, argv, short_options, long_options, NULL)) |
| 551 | != -1) |
| 552 | switch (c) |
| 553 | { |
| 554 | /* ASCII Sorting for short options (i.e., upper case then |
| 555 | lower case), and then long-only options. */ |
| 556 | |
| 557 | case 0: |
| 558 | /* Certain long options cause getopt_long to return 0. */ |
| 559 | break; |
| 560 | |
| 561 | case 'D': /* -DNAME[=VALUE]. */ |
| 562 | case 'F': /* -FNAME[=VALUE]. */ |
| 563 | { |
| 564 | char* name = optarg; |
| 565 | char* value = mbschr (optarg, '='); |
| 566 | if (value) |
| 567 | *value++ = 0; |
| 568 | muscle_percent_define_insert (name, command_line_location (), |
| 569 | value ? value : "", |
| 570 | c == 'D' ? MUSCLE_PERCENT_DEFINE_D |
| 571 | : MUSCLE_PERCENT_DEFINE_F); |
| 572 | } |
| 573 | break; |
| 574 | |
| 575 | case 'I': |
| 576 | include = AS_FILE_NAME (optarg); |
| 577 | break; |
| 578 | |
| 579 | case 'L': |
| 580 | language_argmatch (optarg, command_line_prio, |
| 581 | command_line_location ()); |
| 582 | break; |
| 583 | |
| 584 | case 'S': |
| 585 | skeleton_arg (AS_FILE_NAME (optarg), command_line_prio, |
| 586 | command_line_location ()); |
| 587 | break; |
| 588 | |
| 589 | case 'T': |
| 590 | FLAGS_ARGMATCH (trace, optarg); |
| 591 | break; |
| 592 | |
| 593 | case 'V': |
| 594 | version (); |
| 595 | exit (EXIT_SUCCESS); |
| 596 | |
| 597 | case 'W': |
| 598 | FLAGS_ARGMATCH (warnings, optarg); |
| 599 | break; |
| 600 | |
| 601 | case 'b': |
| 602 | spec_file_prefix = AS_FILE_NAME (optarg); |
| 603 | break; |
| 604 | |
| 605 | case 'd': |
| 606 | /* Here, the -d and --defines options are differentiated. */ |
| 607 | defines_flag = true; |
| 608 | if (optarg) |
| 609 | { |
| 610 | free (spec_defines_file); |
| 611 | spec_defines_file = xstrdup (AS_FILE_NAME (optarg)); |
| 612 | } |
| 613 | break; |
| 614 | |
| 615 | case 'g': |
| 616 | graph_flag = true; |
| 617 | if (optarg) |
| 618 | { |
| 619 | free (spec_graph_file); |
| 620 | spec_graph_file = xstrdup (AS_FILE_NAME (optarg)); |
| 621 | } |
| 622 | break; |
| 623 | |
| 624 | case 'h': |
| 625 | usage (EXIT_SUCCESS); |
| 626 | |
| 627 | case 'k': |
| 628 | token_table_flag = true; |
| 629 | break; |
| 630 | |
| 631 | case 'l': |
| 632 | no_lines_flag = true; |
| 633 | break; |
| 634 | |
| 635 | case 'o': |
| 636 | spec_outfile = AS_FILE_NAME (optarg); |
| 637 | break; |
| 638 | |
| 639 | case 'p': |
| 640 | spec_name_prefix = optarg; |
| 641 | break; |
| 642 | |
| 643 | case 'r': |
| 644 | FLAGS_ARGMATCH (report, optarg); |
| 645 | break; |
| 646 | |
| 647 | case 't': |
| 648 | debug_flag = true; |
| 649 | break; |
| 650 | |
| 651 | case 'v': |
| 652 | report_flag |= report_states; |
| 653 | break; |
| 654 | |
| 655 | case 'x': |
| 656 | xml_flag = true; |
| 657 | if (optarg) |
| 658 | { |
| 659 | free (spec_xml_file); |
| 660 | spec_xml_file = xstrdup (AS_FILE_NAME (optarg)); |
| 661 | } |
| 662 | break; |
| 663 | |
| 664 | case 'y': |
| 665 | yacc_flag = true; |
| 666 | break; |
| 667 | |
| 668 | case LOCATIONS_OPTION: |
| 669 | locations_flag = true; |
| 670 | break; |
| 671 | |
| 672 | case PRINT_LOCALEDIR_OPTION: |
| 673 | printf ("%s\n", LOCALEDIR); |
| 674 | exit (EXIT_SUCCESS); |
| 675 | |
| 676 | case PRINT_DATADIR_OPTION: |
| 677 | printf ("%s\n", compute_pkgdatadir ()); |
| 678 | exit (EXIT_SUCCESS); |
| 679 | |
| 680 | case REPORT_FILE_OPTION: |
| 681 | free (spec_verbose_file); |
| 682 | spec_verbose_file = xstrdup (AS_FILE_NAME (optarg)); |
| 683 | break; |
| 684 | |
| 685 | default: |
| 686 | usage (EXIT_FAILURE); |
| 687 | } |
| 688 | |
| 689 | if (argc - optind != 1) |
| 690 | { |
| 691 | if (argc - optind < 1) |
| 692 | error (0, 0, _("%s: missing operand"), quotearg_colon (argv[argc - 1])); |
| 693 | else |
| 694 | error (0, 0, _("extra operand %s"), quote (argv[optind + 1])); |
| 695 | usage (EXIT_FAILURE); |
| 696 | } |
| 697 | |
| 698 | current_file = grammar_file = uniqstr_new (argv[optind]); |
| 699 | MUSCLE_INSERT_C_STRING ("file_name", grammar_file); |
| 700 | } |
| 701 | |
| 702 | void |
| 703 | tr (char *s, char from, char to) |
| 704 | { |
| 705 | for (; *s; s++) |
| 706 | if (*s == from) |
| 707 | *s = to; |
| 708 | } |