/* flex - tool to generate fast lexical analyzers */

/* SPDX-License-Identifier: BSD-3-Clause-flex */

/*  Copyright (c) 1990 The Regents of the University of California. */

/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */

/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */

/*  to contract no. DE-AC03-76SF00098 between the United States */

/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */

/*  modification, are permitted provided that the following conditions */

/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */

/*     notice, this list of conditions and the following disclaimer. */

/*  2. Redistributions in binary form must reproduce the above copyright */

/*     notice, this list of conditions and the following disclaimer in the */

/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */

/*  may be used to endorse or promote products derived from this software */

/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */

/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */

/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */

/*  PURPOSE. */

#include "flexdef.h"

#include "version.h"

#include "options.h"

#include "tables.h"

#include "parse.h"

static char flex_version[] ="ran";// FLEX_VERSION;

/* declare functions that have forward references */

void flexinit(int, char **);

void readin(void);

void set_up_initial_allocations(void);

/* these globals are all defined and commented in flexdef.h */

bool    syntaxerror, eofseen;

int     yymore_used, reject, real_reject, continued_action, in_rule;

int     datapos, dataline, linenum;

FILE   *skelfile = NULL;

int     skel_ind = 0;

char   *action_array;

int     action_size, defs1_offset, prolog_offset, action_offset,

  action_index;

char   *infilename = NULL;

char   *extra_type = NULL;

int     onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];

int     onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;

int     maximum_mns, current_mns, current_max_rules;

int     num_rules, num_eof_rules, default_rule, lastnfa;

int    *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;

int    *accptnum, *assoc_rule, *state_type;

int    *rule_type, *rule_linenum;

int     current_state_type;

bool    variable_trailing_context_rules;

int     numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];

int     protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];

int     numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs,

  tecfwd[CSIZE + 1];

int     tecbck[CSIZE + 1];

int     lastsc, *scset, *scbol;

/* scxclu[] and sceof[] are boolean arrays, but allocated as char

 * arrays for size. */

char   *scxclu, *sceof;

int     current_max_scs;

const char **scname;

int     current_max_dfa_size, current_max_xpairs;

int     current_max_template_xpairs, current_max_dfas;

int     lastdfa, *nxt, *chk, *tnxt;

int    *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;

union dfaacc_union *dfaacc;

int    *accsiz, *dhash, numas;

int     numsnpairs, jambase, jamstate;

int     lastccl, *cclmap, *ccllen, *cclng, cclreuse;

int     current_maxccls, current_max_ccl_tbl_size;

unsigned char   *ccltbl;

char    nmstr[MAXLINE];

int     sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval;

int     tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;

int     num_backing_up, bol_needed;

int     end_of_buffer_state;

char  **input_files;

int     num_input_files;

jmp_buf flex_main_jmp_buf;

/* rule_useful[], rule_has_nl[] and ccl_has_nl[] are boolean arrays,

 * but allocated as char arrays for size. */

char   *rule_useful, *rule_has_nl, *ccl_has_nl;

int     nlch = '\n';

bool    tablesext, tablesverify, gentables;

char   *tablesfilename=0,*tablesname=0;

struct yytbl_writer tableswr;

size_t footprint;

struct ctrl_bundle_t ctrl;

struct env_bundle_t env;

/* Make sure program_name is initialized so we don't crash if writing

 * out an error message before getting the program name from argv[0].

 */

char   *program_name = "flex";

static const char outfile_template[] = "lex.%s.%s";

static const char *backing_name = "lex.backup";

static const char tablesfile_template[] = "lex.%s.tables";

/* From scan.l */

extern FILE* yyout;

static char outfile_path[MAXLINE];

static int outfile_created = 0;

static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */

const char *escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[";

const char *escaped_qend   = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[";

/* For debugging. The max number of filters to apply to skeleton. */

static int preproc_level = 1000;

int flex_main (int argc, char *argv[]);

int flex_main (int argc, char *argv[])

{

  int     i, exit_status, child_status;

  int did_eof_rule = false;

  /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The

   * return value of setjmp, if non-zero, is the desired exit code PLUS ONE.

   * For example, if you want 'main' to return with code '2', then call

   * longjmp() with an argument of 3. This is because it is invalid to

   * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of

   * exit(n);

   */

  exit_status = setjmp (flex_main_jmp_buf);

  if (exit_status){

    if (stdout && !_stdout_closed && !ferror(stdout)){

      fflush(stdout);

      fclose(stdout);

    }

    return 0;

    /*

    while (wait(&child_status) > 0){

      if (!WIFEXITED (child_status)

          || WEXITSTATUS (child_status) != 0){

        if( exit_status <= 1 )

          exit_status = 2;

      }

    }

    return exit_status - 1;

    */

  }

  flexinit (argc, argv);

  readin ();

  skelout (true);    /* %% [1.0] DFA */

  footprint += ntod ();

  for (i = 1; i <= num_rules; ++i)

    if (!rule_useful[i] && i != default_rule)

      line_warning (_("rule cannot be matched"),

              rule_linenum[i]);

  if (ctrl.spprdflt && !reject && rule_useful[default_rule])

    line_warning (_

            ("-s option given but default rule can be matched"),

            rule_linenum[default_rule]);

  comment("START of m4 controls\n");

  // mode switches for yy_trans_info specification

  // nultrans

  if (nultrans)

    visible_define ( "M4_MODE_NULTRANS");

  else {

    visible_define ( "M4_MODE_NO_NULTRANS");

    if (ctrl.fulltbl)

        visible_define ( "M4_MODE_NULTRANS_FULLTBL");

    else

        visible_define ( "M4_MODE_NO_NULTRANS_FULLTBL");

    if (ctrl.fullspd)

        visible_define ( "M4_MODE_NULTRANS_FULLSPD");

    else

        visible_define ( "M4_MODE_NO_NULTRANS_FULLSPD");

  }

  comment("END of m4 controls\n");

  out ("\n");

  comment("START of Flex-generated definitions\n");

  out_str_dec ("M4_HOOK_CONST_DEFINE_UINT(%s, %d)", "YY_NUM_RULES", num_rules);

  out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_END_OF_BUFFER", num_rules + 1);

  out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMBASE", jambase);

  out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMSTATE", jamstate);

  out_str_dec ("M4_HOOK_CONST_DEFINE_BYTE(%s, %d)", "YY_NUL_EC", NUL_ec);

  /* Need to define the transet type as a size large

   * enough to hold the biggest offset.

   */

  out_str ("M4_HOOK_SET_OFFSET_TYPE(%s)", optimize_pack(tblend + numecs + 1)->name);

  comment("END of Flex-generated definitions\n");

  skelout (true);    /* %% [2.0] - tables get dumped here */

  /* Generate the C state transition tables from the DFA. */

  make_tables ();

  skelout (true);    /* %% [3.0] - mode-dependent static declarations get dumped here */

  out (&action_array[defs1_offset]);

  line_directive_out (stdout, NULL, linenum);

  skelout (true);    /* %% [4.0] - various random yylex internals get dumped here */

  /* Copy prolog to output file. */

  out (&action_array[prolog_offset]);

  line_directive_out (stdout, NULL, linenum);

  skelout (true);    /* %% [5.0] - main loop of matching-engine code gets dumped here */

  /* Copy actions to output file. */

  out (&action_array[action_offset]);

  line_directive_out (stdout, NULL, linenum);

  /* generate cases for any missing EOF rules */

  for (i = 1; i <= lastsc; ++i)

    if (!sceof[i]) {

      out_str ("M4_HOOK_EOF_STATE_CASE_ARM(%s)", scname[i]);

      outc('\n');

      out ("M4_HOOK_EOF_STATE_CASE_FALLTHROUGH");

      outc('\n');

      did_eof_rule = true;

    }

  if (did_eof_rule) {

    out ("M4_HOOK_EOF_STATE_CASE_TERMINATE");

  }

  skelout (true);

  /* Copy remainder of input to output. */

  line_directive_out (stdout, infilename, linenum);

  if (sectnum == 3) {

    OUT_BEGIN_CODE ();

                if (!ctrl.no_section3_escape)

                   fputs("[[", stdout);

    (void) flexscan (); /* copy remainder of input to output */

                if (!ctrl.no_section3_escape)

                   fputs("]]", stdout);

    OUT_END_CODE ();

  }

  /* Note, flexend does not return.  It exits with its argument

   * as status.

   */

  flexend (0);

  return 0;   /* keep compilers/lint happy */

}

/* Wrapper around flex_main, so flex_main can be built as a library. */

int main2 (int argc, char *argv[])

{

#if defined(ENABLE_NLS) && ENABLE_NLS

#if HAVE_LOCALE_H

  setlocale (LC_MESSAGES, "");

        setlocale (LC_CTYPE, "");

  textdomain (PACKAGE);

  bindtextdomain (PACKAGE, LOCALEDIR);

#endif

#endif

  return flex_main (argc, argv);

}

/* Set up the output filter chain. */

void initialize_output_filters(void)

{

  const char * m4 = NULL;

  output_chain = filter_create_int(NULL, filter_tee_header, env.headerfilename);

  if ( !(m4 = getenv("M4"))) {

    m4 = NULL;

  }

  filter_create_ext(output_chain, m4, "-P", (char *) 0);

  filter_create_int(output_chain, filter_fix_linedirs, NULL);

  /* For debugging, only run the requested number of filters. */

  if (preproc_level > 0) {

    filter_truncate(output_chain, preproc_level);

    filter_apply_chain(output_chain);

  }

}

/* check_options - check user-specified options */

void check_options (void)

{

  int     i;

  if (ctrl.lex_compat) {

    if (ctrl.C_plus_plus)

      flexerror (_("Can't use -+ with -l option"));

    if (ctrl.fulltbl || ctrl.fullspd)

      flexerror (_("Can't use -f or -F with -l option"));

    if (ctrl.reentrant || ctrl.bison_bridge_lval)

      flexerror (_

           ("Can't use --ctrl.reentrant or --bison-bridge with -l option"));

    ctrl.yytext_is_array = true;

    ctrl.do_yylineno = true;

    ctrl.use_read = false;

  }

#if 0

  /* This makes no sense whatsoever. I'm removing it. */

  if (ctrl.do_yylineno)

    /* This should really be "maintain_backup_tables = true" */

    ctrl.reject_really_used = true;

#endif

  if (ctrl.csize == trit_unspecified) {

    if ((ctrl.fulltbl || ctrl.fullspd) && !ctrl.useecs)

      ctrl.csize = DEFAULT_CSIZE;

    else

      ctrl.csize = CSIZE;

  }

  if (ctrl.interactive == trit_unspecified) {

    if (ctrl.fulltbl || ctrl.fullspd)

      ctrl.interactive = trit_false;

    else

      ctrl.interactive = trit_true;

  }

  if (ctrl.fulltbl || ctrl.fullspd) {

    if (ctrl.usemecs)

      flexerror (_

           ("-Cf/-CF and -Cm don't make sense together"));

    if (ctrl.interactive != trit_false)

      flexerror (_("-Cf/-CF and -I are incompatible"));

    if (ctrl.lex_compat)

      flexerror (_

           ("-Cf/-CF are incompatible with lex-compatibility mode"));

    if (ctrl.fulltbl && ctrl.fullspd)

      flexerror (_

           ("-Cf and -CF are mutually exclusive"));

  }

  if (ctrl.C_plus_plus && ctrl.fullspd)

    flexerror (_("Can't use -+ with -CF option"));

  if (ctrl.C_plus_plus && ctrl.yytext_is_array) {

    lwarn (_("%array incompatible with -+ option"));

    ctrl.yytext_is_array = false;

  }

  if (ctrl.C_plus_plus && (ctrl.reentrant))

    flexerror (_("Options -+ and --reentrant are mutually exclusive."));

  if (ctrl.C_plus_plus && ctrl.bison_bridge_lval)

    flexerror (_("bison bridge not supported for the C++ scanner."));

  if (ctrl.useecs) {   /* Set up doubly-linked equivalence classes. */

    /* We loop all the way up to ctrl.csize, since ecgroup[ctrl.csize] is

     * the position used for NUL characters.

     */

    ecgroup[1] = NIL;

    for (i = 2; i <= ctrl.csize; ++i) {

      ecgroup[i] = i - 1;

      nextecm[i - 1] = i;

    }

    nextecm[ctrl.csize] = NIL;

  }

  else {

    /* Put everything in its own equivalence class. */

    for (i = 1; i <= ctrl.csize; ++i) {

      ecgroup[i] = i;

      nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */

    }

  }

  if (!env.use_stdout) {

    FILE   *prev_stdout;

    if (!env.did_outfilename) {

      snprintf (outfile_path, sizeof(outfile_path), outfile_template,

          ctrl.prefix, suffix());

      env.outfilename = outfile_path;

    }

    prev_stdout = freopen (env.outfilename, "w+", stdout);

    if (prev_stdout == NULL)

      lerr (_("could not create %s"), env.outfilename);

    outfile_created = 1;

  }

}

/* flexend - terminate flex

 *

 * note

 *    This routine does not return.

 */

void flexend (int exit_status)

{

  static int called_before = -1;  /* prevent infinite recursion. */

  int     tblsiz;

  if (++called_before)

    FLEX_EXIT (exit_status);

  if (ctrl.yyclass != NULL && !ctrl.C_plus_plus)

    flexerror (_("%option yyclass only meaningful for C++ scanners"));

  if (skelfile != NULL) {

    if (ferror (skelfile))

      lerr (_("input error reading skeleton file %s"),

        env.skelname);

    else if (fclose (skelfile))

      lerr (_("error closing skeleton file %s"),

        env.skelname);

  }

  if (exit_status != 0 && outfile_created) {

    if (ferror (stdout))

      lerr (_("error writing output file %s"),

        env.outfilename);

    else if ((_stdout_closed = 1) && fclose (stdout))

      lerr (_("error closing output file %s"),

        env.outfilename);

    else if (unlink (env.outfilename))

      lerr (_("error deleting output file %s"),

        env.outfilename);

  }

  if (env.backing_up_report && ctrl.backing_up_file) {

    if (num_backing_up == 0)

      fprintf (ctrl.backing_up_file, _("No backing up.\n"));

    else if (ctrl.fullspd || ctrl.fulltbl)

      fprintf (ctrl.backing_up_file,

         _

         ("%d backing up (non-accepting) states.\n"),

         num_backing_up);

    else

      fprintf (ctrl.backing_up_file,

         _("Compressed tables always back up.\n"));

    if (ferror (ctrl.backing_up_file))

      lerr (_("error writing backup file %s"),

        backing_name);

    else if (fclose (ctrl.backing_up_file))

      lerr (_("error closing backup file %s"),

        backing_name);

  }

  if (env.printstats) {

    fprintf (stderr, _("%s version %s usage statistics:\n"),

       program_name, flex_version);

    fprintf (stderr, _("  scanner options: -"));

    if (ctrl.C_plus_plus)

      putc ('+', stderr);

    if (env.backing_up_report)

      putc ('b', stderr);

    if (ctrl.ddebug)

      putc ('d', stderr);

    if (sf_case_ins())

      putc ('i', stderr);

    if (ctrl.lex_compat)

      putc ('l', stderr);

    if (ctrl.posix_compat)

      putc ('X', stderr);

    if (env.performance_hint > 0)

      putc ('p', stderr);

    if (env.performance_hint > 1)

      putc ('p', stderr);

    if (ctrl.spprdflt)

      putc ('s', stderr);

    if (ctrl.reentrant)

      fputs ("--reentrant", stderr);

        if (ctrl.bison_bridge_lval)

            fputs ("--bison-bridge", stderr);

        if (ctrl.bison_bridge_lloc)

            fputs ("--bison-locations", stderr);

    if (env.use_stdout)

      putc ('t', stderr);

    if (env.printstats)

      putc ('v', stderr); /* always true! */

    if (env.nowarn)

      putc ('w', stderr);

    if (ctrl.interactive == trit_false)

      putc ('B', stderr);

    if (ctrl.interactive == trit_true)

      putc ('I', stderr);

    if (!ctrl.gen_line_dirs)

      putc ('L', stderr);

    if (env.trace)

      putc ('T', stderr);

    if (ctrl.csize == trit_unspecified)

      /* We encountered an error fairly early on, so ctrl.csize

       * never got specified.  Define it now, to prevent

       * bogus table sizes being written out below.

       */

      ctrl.csize = 256;

    if (ctrl.csize == 128)

      putc ('7', stderr);

    else

      putc ('8', stderr);

    fprintf (stderr, " -C");

    if (ctrl.long_align)

      putc ('a', stderr);

    if (ctrl.fulltbl)

      putc ('f', stderr);

    if (ctrl.fullspd)

      putc ('F', stderr);

    if (ctrl.useecs)

      putc ('e', stderr);

    if (ctrl.usemecs)

      putc ('m', stderr);

    if (ctrl.use_read)

      putc ('r', stderr);

    if (env.did_outfilename)

      fprintf (stderr, " -o%s", env.outfilename);

    if (env.skelname != NULL)

      fprintf (stderr, " -S%s", env.skelname);

    if (strcmp (ctrl.prefix, "yy"))

      fprintf (stderr, " -P%s", ctrl.prefix);

    putc ('\n', stderr);

    fprintf (stderr, _("  %d/%d NFA states\n"),

       lastnfa, current_mns);

    fprintf (stderr, _("  %d/%d DFA states (%d words)\n"),

       lastdfa, current_max_dfas, totnst);

    fprintf (stderr, _("  %d rules\n"),

       num_rules + num_eof_rules -

       1 /* - 1 for def. rule */ );

    if (num_backing_up == 0)

      fprintf (stderr, _("  No backing up\n"));

    else if (ctrl.fullspd || ctrl.fulltbl)

      fprintf (stderr,

         _

         ("  %d backing-up (non-accepting) states\n"),

         num_backing_up);

    else

      fprintf (stderr,

         _

         ("  Compressed tables always back-up\n"));

    if (bol_needed)

      fprintf (stderr,

         _("  Beginning-of-line patterns used\n"));

    fprintf (stderr, _("  %d/%d start conditions\n"), lastsc,

       current_max_scs);

    fprintf (stderr,

       _

       ("  %d epsilon states, %d double epsilon states\n"),

       numeps, eps2);

    if (lastccl == 0)

      fprintf (stderr, _("  no character classes\n"));

    else

      fprintf (stderr,

         _

         ("  %d/%d character classes needed %d/%d words of storage, %d reused\n"),

         lastccl, current_maxccls,

         cclmap[lastccl] + ccllen[lastccl],

         current_max_ccl_tbl_size, cclreuse);

    fprintf (stderr, _("  %d state/nextstate pairs created\n"),

       numsnpairs);

    fprintf (stderr,

       _("  %d/%d unique/duplicate transitions\n"),

       numuniq, numdup);

    if (ctrl.fulltbl) {

      tblsiz = lastdfa * numecs;

      fprintf (stderr, _("  %d table entries\n"),

         tblsiz);

    }

    else {

      tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;

      fprintf (stderr,

         _("  %d/%d base-def entries created\n"),

         lastdfa + numtemps, current_max_dfas);

      fprintf (stderr,

         _

         ("  %d/%d (peak %d) nxt-chk entries created\n"),

         tblend, current_max_xpairs, peakpairs);

      fprintf (stderr,

         _

         ("  %d/%d (peak %d) template nxt-chk entries created\n"),

         numtemps * nummecs,

         current_max_template_xpairs,

         numtemps * numecs);

      fprintf (stderr, _("  %d empty table entries\n"),

         nummt);

      fprintf (stderr, _("  %d protos created\n"),

         numprots);

      fprintf (stderr,

         _("  %d templates created, %d uses\n"),

         numtemps, tmpuses);

    }

    if (ctrl.useecs) {

      tblsiz = tblsiz + ctrl.csize;

      fprintf (stderr,

         _

         ("  %d/%d equivalence classes created\n"),

         numecs, ctrl.csize);

    }

    if (ctrl.usemecs) {

      tblsiz = tblsiz + numecs;

      fprintf (stderr,

         _

         ("  %d/%d meta-equivalence classes created\n"),

         nummecs, ctrl.csize);

    }

    fprintf (stderr,

       _

       ("  %d (%d saved) hash collisions, %d DFAs equal\n"),

       hshcol, hshsave, dfaeql);

    fprintf (stderr, _("  %d sets of reallocations needed\n"),

       num_reallocs);

    fprintf (stderr, _("  %d total table entries needed\n"),

       tblsiz);

  }

  FLEX_EXIT (exit_status);

}

/* flexinit - initialize flex */

void flexinit (int argc, char **argv)

{

  int     i, sawcmpflag, rv, optind;

  char   *arg;

  scanopt_t sopt;

  memset(&ctrl, '\0', sizeof(ctrl));

  syntaxerror = false;

  yymore_used = continued_action = false;

  in_rule = reject = false;

  ctrl.yymore_really_used = ctrl.reject_really_used = trit_unspecified;

  ctrl.do_main = trit_unspecified;

  ctrl.interactive = ctrl.csize = trit_unspecified;

  ctrl.do_yywrap = ctrl.gen_line_dirs = ctrl.usemecs = ctrl.useecs = true;

  ctrl.reentrant = ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = false;

  env.performance_hint = 0;

  ctrl.prefix = "yy";

  ctrl.rewrite = false;

  ctrl.yylmax = BUFSIZ;

  tablesext = tablesverify = false;

  gentables = true;

  tablesfilename = tablesname = NULL;

  sawcmpflag = false;

  /* Initialize dynamic array for holding the rule actions. */

  action_size = 2048; /* default size of action array in bytes */

  action_array = allocate_character_array (action_size);

  defs1_offset = prolog_offset = action_offset = action_index = 0;

  action_array[0] = '\0';

  /* Initialize any buffers. */

  buf_init (&userdef_buf, sizeof (char)); /* one long string */

  buf_init (&top_buf, sizeof (char));     /* one long string */

  sf_init ();

  /* Enable C++ if program name ends with '+'. */

  program_name = argv[0];

  if (program_name != NULL &&

      program_name[strlen (program_name) - 1] == '+')

    ctrl.C_plus_plus = true;

  /* read flags */

  sopt = scanopt_init (flexopts, argc, argv, 0);

  if (!sopt) {

    /* This will only happen when flexopts array is altered. */

    fprintf (stderr,

       _("Internal error. flexopts are malformed.\n"));

    FLEX_EXIT (1);

  }

  while ((rv = scanopt (sopt, &arg, &optind)) != 0) {

    if (rv < 0) {

      /* Scanopt has already printed an option-specific error message. */

      fprintf (stderr,

         _

         ("Try `%s --help' for more information.\n"),

         program_name);

      FLEX_EXIT (1);

    }

    switch ((enum flexopt_flag_t) rv) {

        case OPT_CPLUSPLUS:

      ctrl.C_plus_plus = true;

      break;

        case OPT_BATCH:

      ctrl.interactive = trit_false;

      break;

        case OPT_BACKUP:

      env.backing_up_report = trit_true;

      break;

        case OPT_BACKUP_FILE:

      env.backing_up_report = true;

                        backing_name = arg;

      break;

        case OPT_DONOTHING:

      break;

        case OPT_COMPRESSION:

      if (!sawcmpflag) {

        ctrl.useecs = false;

        ctrl.usemecs = false;

        ctrl.fulltbl = false;

        sawcmpflag = true;

      }

      for (i = 0; arg && arg[i] != '\0'; i++)

        switch (arg[i]) {

            case 'a':

          ctrl.long_align = true;

          break;

            case 'e':

          ctrl.useecs = true;

          break;

            case 'F':

          ctrl.fullspd = true;

          break;

            case 'f':

          ctrl.fulltbl = true;

          break;

            case 'm':

          ctrl.usemecs = true;

          break;

            case 'r':

          ctrl.use_read = true;

          break;

            default:

          lerr (_

                ("unknown -C option '%c'"),

                arg[i]);

          break;

        }

      break;

        case OPT_DEBUG:

      ctrl.ddebug = true;

      break;

        case OPT_NO_DEBUG:

      ctrl.ddebug = false;

      break;

        case OPT_FULL:

      ctrl.useecs = ctrl.usemecs = false;

      ctrl.use_read = ctrl.fulltbl = true;

      break;

        case OPT_FAST:

      ctrl.useecs = ctrl.usemecs = false;

      ctrl.use_read = ctrl.fullspd = true;

      break;

        case OPT_HELP:

      usage ();

      FLEX_EXIT (0);

        case OPT_INTERACTIVE:

      ctrl.interactive = true;

      break;

        case OPT_CASE_INSENSITIVE:

      sf_set_case_ins(true);

      break;

        case OPT_LEX_COMPAT:

      ctrl.lex_compat = true;

      break;

        case OPT_POSIX_COMPAT:

      ctrl.posix_compat = true;

      break;

        case OPT_PREPROC_LEVEL:

      preproc_level = (int) strtol(arg,NULL,0);

      break;

        case OPT_MAIN:

      ctrl.do_yywrap = false;

      ctrl.do_main = trit_true;

      break;

        case OPT_NO_MAIN:

      ctrl.do_main = trit_false;

      break;

        case OPT_NO_LINE:

      ctrl.gen_line_dirs = false;

      break;

        case OPT_OUTFILE:

      env.outfilename = arg;

      env.did_outfilename = 1;

      break;

        case OPT_PREFIX:

      ctrl.prefix = arg;

      break;

        case OPT_PERF_REPORT:

      ++env.performance_hint;

      break;

        case OPT_BISON_BRIDGE:

      ctrl.bison_bridge_lval = true;

      break;

        case OPT_BISON_BRIDGE_LOCATIONS:

      ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = true;

      break;

        case OPT_REENTRANT:

      ctrl.reentrant = true;

      break;

        case OPT_NO_REENTRANT:

      ctrl.reentrant = false;

      break;

        case OPT_SKEL:

      env.skelname = arg;