Logo Search packages:      
Sourcecode: maxdb-buildtools version File versions

main.c

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

/*-
 * 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.
 *
 * Redistribution and use in source and binary forms with or without
 * modification are permitted provided that: (1) source distributions retain
 * this entire copyright notice and comment, and (2) distributions including
 * binaries display the following acknowledgement:  ``This product includes
 * software developed by the University of California, Berkeley and its
 * contributors'' in the documentation or other materials provided with the
 * distribution and in all advertising materials mentioning features or use
 * of this software.  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.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1990 The Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

/* $Header: /home/daffy/u0/vern/flex/RCS/main.c,v 2.64 96/05/25 20:42:42 vern Exp $ */


#include "flexdef.h"
#include "version.h"

static char flex_version[] = FLEX_VERSION;


/* declare functions that have forward references */

void flexinit PROTO((int, char**));
void readin PROTO((void));
void set_up_initial_allocations PROTO((void));

#ifdef NEED_ARGV_FIXUP
extern void argv_fixup PROTO((int *, char ***));
#endif


/* these globals are all defined and commented in flexdef.h */
int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
int interactive, caseins, lex_compat, do_yylineno, useecs, fulltbl, usemecs;
int fullspd, gen_line_dirs, performance_report, backing_up_report;
int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, csize;
int yymore_used, reject, real_reject, continued_action, in_rule;
int yymore_really_used, reject_really_used;
int datapos, dataline, linenum, out_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, *outfilename = NULL;
int did_outfilename;
char *prefix, *yyclass;
int do_stdinit, use_stdout;
int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
int 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, *rule_useful;
int current_state_type;
int 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, *sceof;
int current_max_scs;
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;
Char *ccltbl;
char nmstr[MAXLINE];
int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
int num_backing_up, bol_needed;
FILE *backing_up_file;
int end_of_buffer_state;
char **input_files;
int num_input_files;

/* 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";

#ifndef SHORT_FILE_NAMES
static char *outfile_template = "lex.%s.%s";
static char *backing_name = "lex.backup";
#else
static char *outfile_template = "lex%s.%s";
static char *backing_name = "lex.bck";
#endif

#ifdef THINK_C
#include <console.h>
#endif

#ifdef MS_DOS
extern unsigned _stklen = 16384;
#endif

static char outfile_path[MAXLINE];
static int outfile_created = 0;
static char *skelname = NULL;


int main( argc, argv )
int argc;
char **argv;
      {
      int i;

#ifdef THINK_C
      argc = ccommand( &argv );
#endif
#ifdef NEED_ARGV_FIXUP
      argv_fixup( &argc, &argv );
#endif

      flexinit( argc, argv );

      readin();

      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 ( spprdflt && ! reject && rule_useful[default_rule] )
            line_warning(
                  _( "-s option given but default rule can be matched" ),
                  rule_linenum[default_rule] );

      /* Generate the C state transition tables from the DFA. */
      make_tables();

      /* Note, flexend does not return.  It exits with its argument
       * as status.
       */
      flexend( 0 );

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


/* check_options - check user-specified options */

void check_options()
      {
      int i;

      if ( lex_compat )
            {
            if ( C_plus_plus )
                  flexerror( _( "Can't use -+ with -l option" ) );

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

            /* Don't rely on detecting use of yymore() and REJECT,
             * just assume they'll be used.
             */
            yymore_really_used = reject_really_used = true;

            yytext_is_array = true;
            do_yylineno = true;
            use_read = false;
            }

      if ( do_yylineno )
            /* This should really be "maintain_backup_tables = true" */
            reject_really_used = true;

      if ( csize == unspecified )
            {
            if ( (fulltbl || fullspd) && ! useecs )
                  csize = DEFAULT_CSIZE;
            else
                  csize = CSIZE;
            }

      if ( interactive == unspecified )
            {
            if ( fulltbl || fullspd )
                  interactive = false;
            else
                  interactive = true;
            }

      if ( fulltbl || fullspd )
            {
            if ( usemecs )
                  flexerror(
                  _( "-Cf/-CF and -Cm don't make sense together" ) );

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

            if ( lex_compat )
                  flexerror(
            _( "-Cf/-CF are incompatible with lex-compatibility mode" ) );

            if ( do_yylineno )
                  flexerror(
                  _( "-Cf/-CF and %option yylineno are incompatible" ) );

            if ( fulltbl && fullspd )
                  flexerror( _( "-Cf and -CF are mutually exclusive" ) );
            }

      if ( C_plus_plus && fullspd )
            flexerror( _( "Can't use -+ with -CF option" ) );

      if ( C_plus_plus && yytext_is_array )
            {
            warn( _( "%array incompatible with -+ option" ) );
            yytext_is_array = false;
            }

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

            /* We loop all the way up to csize, since ecgroup[csize] is
             * the position used for NUL characters.
             */
            ecgroup[1] = NIL;

            for ( i = 2; i <= csize; ++i )
                  {
                  ecgroup[i] = i - 1;
                  nextecm[i - 1] = i;
                  }

            nextecm[csize] = NIL;
            }

      else
            {
            /* Put everything in its own equivalence class. */
            for ( i = 1; i <= csize; ++i )
                  {
                  ecgroup[i] = i;
                  nextecm[i] = BAD_SUBSCRIPT;   /* to catch errors */
                  }
            }

      if ( ! use_stdout )
            {
            FILE *prev_stdout;

            if ( ! did_outfilename )
                  {
                  char *suffix;

                  if ( C_plus_plus )
                        suffix = "cc";
                  else
                        suffix = "c";

                  sprintf( outfile_path, outfile_template,
                        prefix, suffix );

                  outfilename = outfile_path;
                  }

            prev_stdout = freopen( outfilename, "w", stdout );

            if ( prev_stdout == NULL )
                  lerrsf( _( "could not create %s" ), outfilename );

            outfile_created = 1;
            }

      if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
            lerrsf( _( "can't open skeleton file %s" ), skelname );

      if ( strcmp( prefix, "yy" ) )
            {
#define GEN_PREFIX(name) out_str3( "#define yy%s %s%s\n", name, prefix, name )
            if ( C_plus_plus )
                  GEN_PREFIX( "FlexLexer" );
            else
                  {
                  GEN_PREFIX( "_create_buffer" );
                  GEN_PREFIX( "_delete_buffer" );
                  GEN_PREFIX( "_scan_buffer" );
                  GEN_PREFIX( "_scan_string" );
                  GEN_PREFIX( "_scan_bytes" );
                  GEN_PREFIX( "_flex_debug" );
                  GEN_PREFIX( "_init_buffer" );
                  GEN_PREFIX( "_flush_buffer" );
                  GEN_PREFIX( "_load_buffer_state" );
                  GEN_PREFIX( "_switch_to_buffer" );
                  GEN_PREFIX( "in" );
                  GEN_PREFIX( "leng" );
                  GEN_PREFIX( "lex" );
                  GEN_PREFIX( "out" );
                  GEN_PREFIX( "restart" );
                  GEN_PREFIX( "text" );

                  if ( do_yylineno )
                        GEN_PREFIX( "lineno" );
                  }

            if ( do_yywrap )
                  GEN_PREFIX( "wrap" );

            outn( "" );
            }

      if ( did_outfilename )
            line_directive_out( stdout, 0 );

      skelout();
      }


/* flexend - terminate flex
 *
 * note
 *    This routine does not return.
 */

void flexend( exit_status )
int exit_status;

      {
      int tblsiz;
      int unlink();

      if ( skelfile != NULL )
            {
            if ( ferror( skelfile ) )
                  lerrsf( _( "input error reading skeleton file %s" ),
                        skelname );

            else if ( fclose( skelfile ) )
                  lerrsf( _( "error closing skeleton file %s" ),
                        skelname );
            }

      if ( exit_status != 0 && outfile_created )
            {
            if ( ferror( stdout ) )
                  lerrsf( _( "error writing output file %s" ),
                        outfilename );

            else if ( fclose( stdout ) )
                  lerrsf( _( "error closing output file %s" ),
                        outfilename );

            else if ( unlink( outfilename ) )
                  lerrsf( _( "error deleting output file %s" ),
                        outfilename );
            }

      if ( backing_up_report && backing_up_file )
            {
            if ( num_backing_up == 0 )
                  fprintf( backing_up_file, _( "No backing up.\n" ) );
            else if ( fullspd || fulltbl )
                  fprintf( backing_up_file,
                        _( "%d backing up (non-accepting) states.\n" ),
                        num_backing_up );
            else
                  fprintf( backing_up_file,
                        _( "Compressed tables always back up.\n" ) );

            if ( ferror( backing_up_file ) )
                  lerrsf( _( "error writing backup file %s" ),
                        backing_name );

            else if ( fclose( backing_up_file ) )
                  lerrsf( _( "error closing backup file %s" ),
                        backing_name );
            }

      if ( printstats )
            {
            fprintf( stderr, _( "%s version %s usage statistics:\n" ),
                  program_name, flex_version );

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

            if ( C_plus_plus )
                  putc( '+', stderr );
            if ( backing_up_report )
                  putc( 'b', stderr );
            if ( ddebug )
                  putc( 'd', stderr );
            if ( caseins )
                  putc( 'i', stderr );
            if ( lex_compat )
                  putc( 'l', stderr );
            if ( performance_report > 0 )
                  putc( 'p', stderr );
            if ( performance_report > 1 )
                  putc( 'p', stderr );
            if ( spprdflt )
                  putc( 's', stderr );
            if ( use_stdout )
                  putc( 't', stderr );
            if ( printstats )
                  putc( 'v', stderr );    /* always true! */
            if ( nowarn )
                  putc( 'w', stderr );
            if ( interactive == false )
                  putc( 'B', stderr );
            if ( interactive == true )
                  putc( 'I', stderr );
            if ( ! gen_line_dirs )
                  putc( 'L', stderr );
            if ( trace )
                  putc( 'T', stderr );

            if ( csize == unspecified )
                  /* We encountered an error fairly early on, so csize
                   * never got specified.  Define it now, to prevent
                   * bogus table sizes being written out below.
                   */
                  csize = 256;

            if ( csize == 128 )
                  putc( '7', stderr );
            else
                  putc( '8', stderr );

            fprintf( stderr, " -C" );

            if ( long_align )
                  putc( 'a', stderr );
            if ( fulltbl )
                  putc( 'f', stderr );
            if ( fullspd )
                  putc( 'F', stderr );
            if ( useecs )
                  putc( 'e', stderr );
            if ( usemecs )
                  putc( 'm', stderr );
            if ( use_read )
                  putc( 'r', stderr );

            if ( did_outfilename )
                  fprintf( stderr, " -o%s", outfilename );

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

            if ( strcmp( prefix, "yy" ) )
                  fprintf( stderr, " -P%s", 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 ( fullspd || 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 ( 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 ( useecs )
                  {
                  tblsiz = tblsiz + csize;
                  fprintf( stderr,
                        _( "  %d/%d equivalence classes created\n" ),
                        numecs, csize );
                  }

            if ( usemecs )
                  {
                  tblsiz = tblsiz + numecs;
                  fprintf( stderr,
                  _( "  %d/%d meta-equivalence classes created\n" ),
                        nummecs, 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 );
            }

      exit( exit_status );
      }


/* flexinit - initialize flex */

void flexinit( argc, argv )
int argc;
char **argv;
      {
      int i, sawcmpflag;
      char *arg;

      printstats = syntaxerror = trace = spprdflt = caseins = false;
      lex_compat = C_plus_plus = backing_up_report = ddebug = fulltbl = false;
      fullspd = long_align = nowarn = yymore_used = continued_action = false;
      do_yylineno = yytext_is_array = in_rule = reject = do_stdinit = false;
      yymore_really_used = reject_really_used = unspecified;
      interactive = csize = unspecified;
      do_yywrap = gen_line_dirs = usemecs = useecs = true;
      performance_report = 0;
      did_outfilename = 0;
      prefix = "yy";
      yyclass = 0;
      use_read = use_stdout = false;

      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';

      program_name = argv[0];

      if ( program_name[0] != '\0' &&
           program_name[strlen( program_name ) - 1] == '+' )
            C_plus_plus = true;

      /* read flags */
      for ( --argc, ++argv; argc ; --argc, ++argv )
            {
            arg = argv[0];

            if ( arg[0] != '-' || arg[1] == '\0' )
                  break;

            if ( arg[1] == '-' )
                  { /* --option */
                  if ( ! strcmp( arg, "--help" ) )
                        arg = "-h";

                  else if ( ! strcmp( arg, "--version" ) )
                        arg = "-V";

                  else if ( ! strcmp( arg, "--" ) )
                        { /* end of options */
                        --argc;
                        ++argv;
                        break;
                        }
                  }

            for ( i = 1; arg[i] != '\0'; ++i )
                  switch ( arg[i] )
                        {
                        case '+':
                              C_plus_plus = true;
                              break;

                        case 'B':
                              interactive = false;
                              break;

                        case 'b':
                              backing_up_report = true;
                              break;

                        case 'c':
                              break;

                        case 'C':
                              if ( i != 1 )
                                    flexerror(
                        _( "-C flag must be given separately" ) );

                              if ( ! sawcmpflag )
                                    {
                                    useecs = false;
                                    usemecs = false;
                                    fulltbl = false;
                                    sawcmpflag = true;
                                    }

                              for ( ++i; arg[i] != '\0'; ++i )
                                    switch ( arg[i] )
                                          {
                                          case 'a':
                                                long_align =
                                                      true;
                                                break;

                                          case 'e':
                                                useecs = true;
                                                break;

                                          case 'F':
                                                fullspd = true;
                                                break;

                                          case 'f':
                                                fulltbl = true;
                                                break;

                                          case 'm':
                                                usemecs = true;
                                                break;

                                          case 'r':
                                                use_read = true;
                                                break;

                                          default:
                                                lerrif(
                                    _( "unknown -C option '%c'" ),
                                                (int) arg[i] );
                                                break;
                                          }

                              goto get_next_arg;

                        case 'd':
                              ddebug = true;
                              break;

                        case 'f':
                              useecs = usemecs = false;
                              use_read = fulltbl = true;
                              break;

                        case 'F':
                              useecs = usemecs = false;
                              use_read = fullspd = true;
                              break;

                        case '?':
                        case 'h':
                              usage();
                              exit( 0 );

                        case 'I':
                              interactive = true;
                              break;

                        case 'i':
                              caseins = true;
                              break;

                        case 'l':
                              lex_compat = true;
                              break;

                        case 'L':
                              gen_line_dirs = false;
                              break;

                        case 'n':
                              /* Stupid do-nothing deprecated
                               * option.
                               */
                              break;

                        case 'o':
                              if ( i != 1 )
                                    flexerror(
                        _( "-o flag must be given separately" ) );

                              outfilename = arg + i + 1;
                              did_outfilename = 1;
                              goto get_next_arg;

                        case 'P':
                              if ( i != 1 )
                                    flexerror(
                        _( "-P flag must be given separately" ) );

                              prefix = arg + i + 1;
                              goto get_next_arg;

                        case 'p':
                              ++performance_report;
                              break;

                        case 'S':
                              if ( i != 1 )
                                    flexerror(
                        _( "-S flag must be given separately" ) );

                              skelname = arg + i + 1;
                              goto get_next_arg;

                        case 's':
                              spprdflt = true;
                              break;

                        case 't':
                              use_stdout = true;
                              break;

                        case 'T':
                              trace = true;
                              break;

                        case 'v':
                              printstats = true;
                              break;

                        case 'V':
                              printf( _( "%s version %s\n" ),
                                    program_name, flex_version );
                              exit( 0 );

                        case 'w':
                              nowarn = true;
                              break;

                        case '7':
                              csize = 128;
                              break;

                        case '8':
                              csize = CSIZE;
                              break;

                        default:
                              fprintf( stderr,
            _( "%s: unknown flag '%c'.  For usage, try\n\t%s --help\n" ),
                                    program_name, (int) arg[i],
                                    program_name );
                              exit( 1 );
                        }

            /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2"
             * control.
             */
            get_next_arg: ;
            }

      num_input_files = argc;
      input_files = argv;
      set_input_file( num_input_files > 0 ? input_files[0] : NULL );

      lastccl = lastsc = lastdfa = lastnfa = 0;
      num_rules = num_eof_rules = default_rule = 0;
      numas = numsnpairs = tmpuses = 0;
      numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
      numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
      num_backing_up = onesp = numprots = 0;
      variable_trailing_context_rules = bol_needed = false;

      out_linenum = linenum = sectnum = 1;
      firstprot = NIL;

      /* Used in mkprot() so that the first proto goes in slot 1
       * of the proto queue.
       */
      lastprot = 1;

      set_up_initial_allocations();
      }


/* readin - read in the rules section of the input file(s) */

void readin()
      {
      static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
      static char yy_nostdinit[] =
            "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";

      line_directive_out( (FILE *) 0, 1 );

      if ( yyparse() )
            {
            pinpoint_message( _( "fatal parse error" ) );
            flexend( 1 );
            }

      if ( syntaxerror )
            flexend( 1 );

      if ( backing_up_report )
            {
            backing_up_file = fopen( backing_name, "w" );
            if ( backing_up_file == NULL )
                  lerrsf(
                  _( "could not create backing-up info file %s" ),
                        backing_name );
            }

      else
            backing_up_file = NULL;

      if ( yymore_really_used == true )
            yymore_used = true;
      else if ( yymore_really_used == false )
            yymore_used = false;

      if ( reject_really_used == true )
            reject = true;
      else if ( reject_really_used == false )
            reject = false;

      if ( performance_report > 0 )
            {
            if ( lex_compat )
                  {
                  fprintf( stderr,
_( "-l AT&T lex compatibility option entails a large performance penalty\n" ) );
                  fprintf( stderr,
_( " and may be the actual source of other reported performance penalties\n" ) );
                  }

            else if ( do_yylineno )
                  {
                  fprintf( stderr,
      _( "%%option yylineno entails a large performance penalty\n" ) );
                  }

            if ( performance_report > 1 )
                  {
                  if ( interactive )
                        fprintf( stderr,
      _( "-I (interactive) entails a minor performance penalty\n" ) );

                  if ( yymore_used )
                        fprintf( stderr,
            _( "yymore() entails a minor performance penalty\n" ) );
                  }

            if ( reject )
                  fprintf( stderr,
                  _( "REJECT entails a large performance penalty\n" ) );

            if ( variable_trailing_context_rules )
                  fprintf( stderr,
_( "Variable trailing context rules entail a large performance penalty\n" ) );
            }

      if ( reject )
            real_reject = true;

      if ( variable_trailing_context_rules )
            reject = true;

      if ( (fulltbl || fullspd) && reject )
            {
            if ( real_reject )
                  flexerror(
                        _( "REJECT cannot be used with -f or -F" ) );
            else if ( do_yylineno )
                  flexerror(
                  _( "%option yylineno cannot be used with -f or -F" ) );
            else
                  flexerror(
      _( "variable trailing context rules cannot be used with -f or -F" ) );
            }

      if ( reject )
            outn( "\n#define YY_USES_REJECT" );

      if ( ! do_yywrap )
            {
            outn( "\n#define yywrap() 1" );
            outn( "#define YY_SKIP_YYWRAP" );
            }

      if ( ddebug )
            outn( "\n#define FLEX_DEBUG" );

      if ( csize == 256 )
            outn( "typedef unsigned char YY_CHAR;" );
      else
            outn( "typedef char YY_CHAR;" );

      if ( C_plus_plus )
            {
            outn( "#define yytext_ptr yytext" );

            if ( interactive )
                  outn( "#define YY_INTERACTIVE" );
            }

      else
            {
            if ( do_stdinit )
                  {
                  outn( "#ifdef VMS" );
                  outn( "#ifndef __VMS_POSIX" );
                  outn( yy_nostdinit );
                  outn( "#else" );
                  outn( yy_stdinit );
                  outn( "#endif" );
                  outn( "#else" );
                  outn( yy_stdinit );
                  outn( "#endif" );
                  }

            else
                  outn( yy_nostdinit );
            }

      if ( fullspd )
            outn( "typedef yyconst struct yy_trans_info *yy_state_type;" );
      else if ( ! C_plus_plus )
            outn( "typedef int yy_state_type;" );

      if ( ddebug )
            outn( "\n#define FLEX_DEBUG" );

      if ( lex_compat )
            outn( "#define YY_FLEX_LEX_COMPAT" );

      if ( do_yylineno && ! C_plus_plus )
            {
            outn( "extern int yylineno;" );
            outn( "int yylineno = 1;" );
            }

      if ( C_plus_plus )
            {
            outn( "\n#include <FlexLexer.h>" );

            if ( yyclass )
                  {
                  outn( "int yyFlexLexer::yylex()" );
                  outn( "\t{" );
                  outn(
"\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );" );
                  outn( "\treturn 0;" );
                  outn( "\t}" );
      
                  out_str( "\n#define YY_DECL int %s::yylex()\n",
                        yyclass );
                  }
            }

      else
            {
            if ( yytext_is_array )
                  outn( "extern char yytext[];\n" );

            else
                  {
                  outn( "extern char *yytext;" );
                  outn( "#define yytext_ptr yytext" );
                  }

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

      if ( useecs )
            numecs = cre8ecs( nextecm, ecgroup, csize );
      else
            numecs = csize;

      /* Now map the equivalence class for NUL to its expected place. */
      ecgroup[0] = ecgroup[csize];
      NUL_ec = ABS( ecgroup[0] );

      if ( useecs )
            ccl2ecl();
      }


/* set_up_initial_allocations - allocate memory for internal tables */

void set_up_initial_allocations()
      {
      current_mns = INITIAL_MNS;
      firstst = allocate_integer_array( current_mns );
      lastst = allocate_integer_array( current_mns );
      finalst = allocate_integer_array( current_mns );
      transchar = allocate_integer_array( current_mns );
      trans1 = allocate_integer_array( current_mns );
      trans2 = allocate_integer_array( current_mns );
      accptnum = allocate_integer_array( current_mns );
      assoc_rule = allocate_integer_array( current_mns );
      state_type = allocate_integer_array( current_mns );

      current_max_rules = INITIAL_MAX_RULES;
      rule_type = allocate_integer_array( current_max_rules );
      rule_linenum = allocate_integer_array( current_max_rules );
      rule_useful = allocate_integer_array( current_max_rules );

      current_max_scs = INITIAL_MAX_SCS;
      scset = allocate_integer_array( current_max_scs );
      scbol = allocate_integer_array( current_max_scs );
      scxclu = allocate_integer_array( current_max_scs );
      sceof = allocate_integer_array( current_max_scs );
      scname = allocate_char_ptr_array( current_max_scs );

      current_maxccls = INITIAL_MAX_CCLS;
      cclmap = allocate_integer_array( current_maxccls );
      ccllen = allocate_integer_array( current_maxccls );
      cclng = allocate_integer_array( current_maxccls );

      current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
      ccltbl = allocate_Character_array( current_max_ccl_tbl_size );

      current_max_dfa_size = INITIAL_MAX_DFA_SIZE;

      current_max_xpairs = INITIAL_MAX_XPAIRS;
      nxt = allocate_integer_array( current_max_xpairs );
      chk = allocate_integer_array( current_max_xpairs );

      current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
      tnxt = allocate_integer_array( current_max_template_xpairs );

      current_max_dfas = INITIAL_MAX_DFAS;
      base = allocate_integer_array( current_max_dfas );
      def = allocate_integer_array( current_max_dfas );
      dfasiz = allocate_integer_array( current_max_dfas );
      accsiz = allocate_integer_array( current_max_dfas );
      dhash = allocate_integer_array( current_max_dfas );
      dss = allocate_int_ptr_array( current_max_dfas );
      dfaacc = allocate_dfaacc_union( current_max_dfas );

      nultrans = (int *) 0;
      }


void usage()
      {
      FILE *f = stdout;

      fprintf( f,
_( "%s [-bcdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ),
            program_name );
      fprintf( f, _( "\t[--help --version] [file ...]\n" ) );

      fprintf( f, _( "\t-b  generate backing-up information to %s\n" ),
            backing_name );
      fprintf( f, _( "\t-c  do-nothing POSIX option\n" ) );
      fprintf( f, _( "\t-d  turn on debug mode in generated scanner\n" ) );
      fprintf( f, _( "\t-f  generate fast, large scanner\n" ) );
      fprintf( f, _( "\t-h  produce this help message\n" ) );
      fprintf( f, _( "\t-i  generate case-insensitive scanner\n" ) );
      fprintf( f, _( "\t-l  maximal compatibility with original lex\n" ) );
      fprintf( f, _( "\t-n  do-nothing POSIX option\n" ) );
      fprintf( f, _( "\t-p  generate performance report to stderr\n" ) );
      fprintf( f,
            _( "\t-s  suppress default rule to ECHO unmatched text\n" ) );

      if ( ! did_outfilename )
            {
            sprintf( outfile_path, outfile_template,
                  prefix, C_plus_plus ? "cc" : "c" );
            outfilename = outfile_path;
            }

      fprintf( f,
            _( "\t-t  write generated scanner on stdout instead of %s\n" ),
            outfilename );

      fprintf( f,
            _( "\t-v  write summary of scanner statistics to f\n" ) );
      fprintf( f, _( "\t-w  do not generate warnings\n" ) );
      fprintf( f, _( "\t-B  generate batch scanner (opposite of -I)\n" ) );
      fprintf( f,
            _( "\t-F  use alternative fast scanner representation\n" ) );
      fprintf( f,
            _( "\t-I  generate interactive scanner (opposite of -B)\n" ) );
      fprintf( f, _( "\t-L  suppress #line directives in scanner\n" ) );
      fprintf( f, _( "\t-T  %s should run in trace mode\n" ), program_name );
      fprintf( f, _( "\t-V  report %s version\n" ), program_name );
      fprintf( f, _( "\t-7  generate 7-bit scanner\n" ) );
      fprintf( f, _( "\t-8  generate 8-bit scanner\n" ) );
      fprintf( f, _( "\t-+  generate C++ scanner class\n" ) );
      fprintf( f, _( "\t-?  produce this help message\n" ) );
      fprintf( f,
_( "\t-C  specify degree of table compression (default is -Cem):\n" ) );
      fprintf( f,
_( "\t\t-Ca  trade off larger tables for better memory alignment\n" ) );
      fprintf( f, _( "\t\t-Ce  construct equivalence classes\n" ) );
      fprintf( f,
_( "\t\t-Cf  do not compress scanner tables; use -f representation\n" ) );
      fprintf( f,
_( "\t\t-CF  do not compress scanner tables; use -F representation\n" ) );
      fprintf( f, _( "\t\t-Cm  construct meta-equivalence classes\n" ) );
      fprintf( f,
      _( "\t\t-Cr  use read() instead of stdio for scanner input\n" ) );
      fprintf( f, _( "\t-o  specify output filename\n" ) );
      fprintf( f, _( "\t-P  specify scanner prefix other than \"yy\"\n" ) );
      fprintf( f, _( "\t-S  specify skeleton file\n" ) );
      fprintf( f, _( "\t--help     produce this help message\n" ) );
      fprintf( f, _( "\t--version  report %s version\n" ), program_name );
      }

Generated by  Doxygen 1.6.0   Back to index