Subversion Repositories Vertical

#line 2 "rep2_lex.c"

#define YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER

#define YY_FLEX_MAJOR_VERSION 2

#define YY_FLEX_MINOR_VERSION 6

#define YY_FLEX_SUBMINOR_VERSION 4

#if YY_FLEX_SUBMINOR_VERSION > 0

#define FLEX_BETA

#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H

#define FLEXINT_H

/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,

 * if you want the limit (max/min) macros for int types.

 */

#ifndef __STDC_LIMIT_MACROS

#define __STDC_LIMIT_MACROS 1

#endif

#include <inttypes.h>

typedef int8_t flex_int8_t;

typedef uint8_t flex_uint8_t;

typedef int16_t flex_int16_t;

typedef uint16_t flex_uint16_t;

typedef int32_t flex_int32_t;

typedef uint32_t flex_uint32_t;

#else

typedef signed char flex_int8_t;

typedef short int flex_int16_t;

typedef int flex_int32_t;

typedef unsigned char flex_uint8_t;

typedef unsigned short int flex_uint16_t;

typedef unsigned int flex_uint32_t;

/* Limits of integral types. */

#ifndef INT8_MIN

#define INT8_MIN (-128)

#endif

#ifndef INT16_MIN

#define INT16_MIN (-32767 - 1)

#endif

#ifndef INT32_MIN

#define INT32_MIN (-2147483647 - 1)

#endif

#ifndef INT8_MAX

#define INT8_MAX (127)

#endif

#ifndef INT16_MAX

#define INT16_MAX (32767)

#endif

#ifndef INT32_MAX

#define INT32_MAX (2147483647)

#endif

#ifndef UINT8_MAX

#define UINT8_MAX (255U)

#endif

#ifndef UINT16_MAX

#define UINT16_MAX (65535U)

#endif

#ifndef UINT32_MAX

#define UINT32_MAX (4294967295U)

#endif

#ifndef SIZE_MAX

#define SIZE_MAX (~(size_t) 0)

#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */

#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3

#define yynoreturn __attribute__ ((__noreturn__))

#else

#define yynoreturn

#endif

/* Returned upon end-of-file. */

#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an

 *   integer in range [0..255] for use as an array index.

 */

#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* Enter a start condition.  This macro really ought to take a parameter,

 * but we do it the disgusting crufty way forced on us by the ()-less

 * definition of BEGIN.

 */

#define BEGIN (yy_start) = 1 + 2 *

/* Translate the current start state into a value that can be later handed

 * to BEGIN to return to the state.  The YYSTATE alias is for lex

 * compatibility.

 */

#define YY_START (((yy_start) -1) / 2)

#define YYSTATE YY_START

/* Action number for EOF rule of a given start state. */

#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* Special action meaning "start processing a new file". */

#define YY_NEW_FILE yyrestart (yyin)

#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */

#ifndef YY_BUF_SIZE

#ifdef __ia64__

/* On IA-64, the buffer size is 16k, not 8k.

 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.

 * Ditto for the __ia64__ case accordingly.

 */

#define YY_BUF_SIZE 32768

#else

#define YY_BUF_SIZE 16384

#endif /* __ia64__ */

#endif

/* The state buf must be large enough to hold one state per character in the main buffer.

 */

#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof (yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

typedef struct yy_buffer_state *YY_BUFFER_STATE;

#endif

#ifndef YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

typedef size_t yy_size_t;

#endif

extern int yyleng;

extern FILE *yyin, *yyout;

#define EOB_ACT_CONTINUE_SCAN 0

#define EOB_ACT_END_OF_FILE 1

#define EOB_ACT_LAST_MATCH 2

#define YY_LESS_LINENO(n)

#define YY_LINENO_REWIND_TO(ptr)

/* Return all but the first "n" matched characters back to the input stream. */

#define yyless(n)                                                                             \

        do                                                                                    \

        {                                                                                     \

                /* Undo effects of setting up yytext. */                                      \

                int yyless_macro_arg = (n);                                                   \

                YY_LESS_LINENO (yyless_macro_arg);                                            \

                *yy_cp = (yy_hold_char);                                                      \

                YY_RESTORE_YY_MORE_OFFSET (yy_c_buf_p) = yy_cp =                              \

                    yy_bp + yyless_macro_arg - YY_MORE_ADJ;                                   \

                YY_DO_BEFORE_ACTION; /* set up yytext again */                                \

        } while (0)

#define unput(c) yyunput (c, (yytext_ptr))

#ifndef YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

struct yy_buffer_state

{

        FILE *yy_input_file;

        char *yy_ch_buf;  /* input buffer */

        char *yy_buf_pos; /* current position in input buffer */

        /* Size of input buffer in bytes, not including room for EOB

         * characters.

         */

        int yy_buf_size;

        /* Number of characters read into yy_ch_buf, not including EOB

         * characters.

         */

        int yy_n_chars;

        /* Whether we "own" the buffer - i.e., we know we created it,

         * and can realloc() it to grow it, and should free() it to

         * delete it.

         */

        int yy_is_our_buffer;

        /* Whether this is an "interactive" input source; if so, and

         * if we're using stdio for input, then we want to use getc()

         * instead of fread(), to make sure we stop fetching input after

         * each newline.

         */

        int yy_is_interactive;

        /* Whether we're considered to be at the beginning of a line.

         * If so, '^' rules will be active on the next match, otherwise

         * not.

         */

        int yy_at_bol;

        int yy_bs_lineno; /**< The line count. */

        int yy_bs_column; /**< The column count. */

        /* Whether to try to fill the input buffer when we reach the

         * end of it.

         */

        int yy_fill_buffer;

        int yy_buffer_status;

#define YY_BUFFER_NEW 0

#define YY_BUFFER_NORMAL 1

        /* When an EOF's been seen but there's still some text to process

         * then we mark the buffer as YY_EOF_PENDING, to indicate that we

         * shouldn't try reading from the input source any more.  We might

         * still have a bunch of tokens to match, though, because of

         * possible backing-up.

         *

         * When we actually see the EOF, we change the status to "new"

         * (via yyrestart()), so that the user can continue scanning by

         * just pointing yyin at a new input file.

         */

#define YY_BUFFER_EOF_PENDING 2

};

#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* Stack of input buffers. */

static size_t yy_buffer_stack_top = 0;          /**< index of top of stack. */

static size_t yy_buffer_stack_max = 0;          /**< capacity of stack. */

static YY_BUFFER_STATE *yy_buffer_stack = NULL; /**< Stack as an array. */

/* We provide macros for accessing buffer states in case in the

 * future we want to put the buffer states in a more general

 * "scanner state".

 *

 * Returns the top of the stack, or NULL.

 */

#define YY_CURRENT_BUFFER ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL)

/* Same as previous macro, but useful when we know that the buffer stack is not

 * NULL or when we need an lvalue. For internal use only.

 */

#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

/* yy_hold_char holds the character lost when yytext is formed. */

static char yy_hold_char;

static int yy_n_chars; /* number of characters read into yy_ch_buf */

int yyleng;

/* Points to current character in buffer. */

static char *yy_c_buf_p = NULL;

static int yy_init = 0;  /* whether we need to initialize */

static int yy_start = 0; /* start state number */

/* Flag which is used to allow yywrap()'s to do buffer switches

 * instead of setting up a fresh yyin.  A bit of a hack ...

 */

static int yy_did_buffer_switch_on_eof;

void yyrestart (FILE *input_file);

void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer);

YY_BUFFER_STATE yy_create_buffer (FILE *file, int size);

void yy_delete_buffer (YY_BUFFER_STATE b);

void yy_flush_buffer (YY_BUFFER_STATE b);

void yypush_buffer_state (YY_BUFFER_STATE new_buffer);

void yypop_buffer_state (void);

static void yyensure_buffer_stack (void);

static void yy_load_buffer_state (void);

static void yy_init_buffer (YY_BUFFER_STATE b, FILE *file);

#define YY_FLUSH_BUFFER yy_flush_buffer (YY_CURRENT_BUFFER)

YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size);

YY_BUFFER_STATE yy_scan_string (const char *yy_str);

YY_BUFFER_STATE yy_scan_bytes (const char *bytes, int len);

void *yyalloc (yy_size_t);

void *yyrealloc (void *, yy_size_t);

void yyfree (void *);

#define yy_new_buffer yy_create_buffer

#define yy_set_interactive(is_interactive)                                                    \

        {                                                                                     \

                if (!YY_CURRENT_BUFFER)                                                       \

                {                                                                             \

                        yyensure_buffer_stack ();                                             \

                        YY_CURRENT_BUFFER_LVALUE = yy_create_buffer (yyin, YY_BUF_SIZE);      \

                }                                                                             \

                YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive;                 \

        }

#define yy_set_bol(at_bol)                                                                    \

        {                                                                                     \

                if (!YY_CURRENT_BUFFER)                                                       \

                {                                                                             \

                        yyensure_buffer_stack ();                                             \

                        YY_CURRENT_BUFFER_LVALUE = yy_create_buffer (yyin, YY_BUF_SIZE);      \

                }                                                                             \

                YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol;                                 \

        }

#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

typedef flex_uint8_t YY_CHAR;

FILE *yyin = NULL, *yyout = NULL;

typedef int yy_state_type;

extern int yylineno;

int yylineno = 1;

extern char *yytext;

#ifdef yytext_ptr

#undef yytext_ptr

#endif

#define yytext_ptr yytext

static yy_state_type yy_get_previous_state (void);

static yy_state_type yy_try_NUL_trans (yy_state_type current_state);

static int yy_get_next_buffer (void);

static void yynoreturn yy_fatal_error (const char *msg);

/* Done after the current pattern has been matched and before the

 * corresponding action - sets up yytext.

 */

#define YY_DO_BEFORE_ACTION                                                                   \

        (yytext_ptr) = yy_bp;                                                                 \

        yyleng = (int) (yy_cp - yy_bp);                                                       \

        (yy_hold_char) = *yy_cp;                                                              \

        *yy_cp = '\0';                                                                        \

        (yy_c_buf_p) = yy_cp;

#define YY_NUM_RULES 8

#define YY_END_OF_BUFFER 9

/* This struct is not used in this scanner,

   but its presence is necessary. */

struct yy_trans_info

{

        flex_int32_t yy_verify;

        flex_int32_t yy_nxt;

};

static const flex_int16_t yy_accept[27] = {0, 0, 0, 9, 8, 5, 7, 6, 8, 2, 2, 2, 0, 1,

                                           2, 2, 2, 0, 3, 2, 0, 2, 2, 0, 2, 4, 0};

static const YY_CHAR yy_ec[256] = {

    0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1,

    1, 1, 1, 1, 5, 6, 7, 8, 8, 6, 6, 6, 6, 6, 9, 8, 6, 10, 8, 11, 8, 8, 8, 8, 8, 8, 8, 8,

    8, 8, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8,  8, 8,  8, 8, 8, 8, 8, 8, 8, 8,

    8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 8, 6, 8, 8, 8, 8,

    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,  8, 8,  8, 8, 6, 6, 6, 8, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1};

static const YY_CHAR yy_meta[12] = {0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3};

static const flex_int16_t yy_base[30] = {0,  0,  0,  49, 50, 50, 50, 50, 41, 0,

                                         37, 37, 38, 50, 0,  11, 18, 22, 50, 0,

                                         35, 0,  32, 25, 0,  33, 50, 36, 32, 38};

static const flex_int16_t yy_def[30] = {0,  26, 1,  26, 26, 26, 26, 26, 27, 28,

                                        28, 28, 27, 26, 28, 26, 26, 15, 26, 15,

                                        29, 16, 16, 29, 16, 29, 0,  26, 26, 26};

static const flex_int16_t yy_nxt[62] = {

    0,  4,  5,  6,  7,  5,  4,  8,  9,  9,  10, 11, 17, 17, 18, 17, 17, 17, 17, 19, 19,

    19, 19, 20, 20, 20, 21, 22, 21, 21, 17, 17, 17, 17, 23, 14, 25, 12, 12, 12, 20, 20,

    23, 24, 23, 13, 16, 15, 13, 26, 3,  26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26};

static const flex_int16_t yy_chk[62] = {

    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  15, 15, 15, 15, 15, 15, 15, 15, 15,

    15, 15, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 23, 28, 23, 27, 27, 27, 29, 29,

    25, 22, 20, 12, 11, 10, 8,  3,  26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26};

static yy_state_type yy_last_accepting_state;

static char *yy_last_accepting_cpos;

extern int yy_flex_debug;

int yy_flex_debug = 0;

/* The intent behind this definition is that it'll catch

 * any uses of REJECT which flex missed.

 */

#define REJECT reject_used_but_not_detected

#define yymore() yymore_used_but_not_detected

#define YY_MORE_ADJ 0

#define YY_RESTORE_YY_MORE_OFFSET

char *yytext;

#line 1 "rep2_lex.l"

#line 2 "rep2_lex.l"

/*

 * $Id: rep2_lex.l,v 1.1.1.1 2003/11/04 23:34:58 mjames Exp $

 *

 * $Log: rep2_lex.l,v $

 * Revision 1.1.1.1  2003/11/04 23:34:58  mjames

 * Imported into local repositrory

 *

 * Revision 1.7  2002/10/02 19:37:27  MJAMES

 * Moved dummy functions to a separate support file.

 *

 * Used correct number of arguments to define_pin

 *

 * Revision 1.6  2002/09/18 09:18:37  mjames

 * Added dummy function to make code link to create final application

 *

 * Revision 1.5  2002/09/09 10:16:42  mjames

 * Modified expression parser to match CC as previous one was

 * broken

 *

 * Revision 1.4  2002/01/16 11:22:48  mjames

 * database.h header file is read in first as it undefined DLL stuff irrelevant

 * to HPUX

 *

 * Revision 1.3  2001/12/13 22:11:10  mjames

 * Added dummy tidy_lex function : used in Vertical reader only

 *

 * Revision 1.2  2001/10/31 22:20:15  mjames

 * Tidying up problematical comments caused by CVS

 * 'intelligent' comment guessing

 *

 * Revision 1.1  2001/10/02 20:53:06  mjames

 * Another .REP file format reader

 *

 *

 *  */

#include <stdio.h>

#if defined HAS_TCL

#include "tcl_l.h"

#endif

#include "database.h"

#include "expression.h"

#include "generic.h"

/* see makefile for why */

#include "lx_support.h"

#include "rep2_yacc.h"

#define YYLMAX MAXIDLEN

#ident                                                                                        \

    "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/rep2_src/rep2_lex.l,v 1.1.1.1 2003/11/04 23:34:58 mjames Exp $"

extern int yyval;

extern int lineno;

#line 514 "rep2_lex.c"

#line 515 "rep2_lex.c"

#define INITIAL 0

#ifndef YY_NO_UNISTD_H

/* Special case for "unistd.h", since it is non-ANSI. We include it way

 * down here because we want the user's section 1 to have been scanned first.

 * The user has a chance to override it with an option.

 */

#include <unistd.h>

#endif

#ifndef YY_EXTRA_TYPE

#define YY_EXTRA_TYPE void *

#endif

static int yy_init_globals (void);

/* Accessor methods to globals.

   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy (void);

int yyget_debug (void);

void yyset_debug (int debug_flag);

YY_EXTRA_TYPE yyget_extra (void);

void yyset_extra (YY_EXTRA_TYPE user_defined);

FILE *yyget_in (void);

void yyset_in (FILE *_in_str);

FILE *yyget_out (void);

void yyset_out (FILE *_out_str);

int yyget_leng (void);

char *yyget_text (void);

int yyget_lineno (void);

void yyset_lineno (int _line_number);

/* Macros after this point can all be overridden by user definitions in

 * section 1.

 */

#ifndef YY_SKIP_YYWRAP

#ifdef __cplusplus

extern "C" int yywrap (void);

#else

extern int yywrap (void);

#endif

#endif

#ifndef YY_NO_UNPUT

static void yyunput (int c, char *buf_ptr);

#endif

#ifndef yytext_ptr

static void yy_flex_strncpy (char *, const char *, int);

#endif

#ifdef YY_NEED_STRLEN

static int yy_flex_strlen (const char *);

#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus

static int yyinput (void);

#else

static int input (void);

#endif

#endif

/* Amount of stuff to slurp up with each read. */

#ifndef YY_READ_BUF_SIZE

#ifdef __ia64__

/* On IA-64, the buffer size is 16k, not 8k */

#define YY_READ_BUF_SIZE 16384

#else

#define YY_READ_BUF_SIZE 8192

#endif /* __ia64__ */

#endif

/* Copy whatever the last rule matched to the standard output. */

#ifndef ECHO

/* This used to be an fputs(), but since the string might contain NUL's,

 * we now use fwrite().

 */

#define ECHO                                                                                  \

        do                                                                                    \

        {                                                                                     \

                if (fwrite (yytext, (size_t) yyleng, 1, yyout))                               \

                {                                                                             \

                }                                                                             \

        } while (0)

#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,

 * is returned in "result".

 */

#ifndef YY_INPUT

#define YY_INPUT(buf, result, max_size)                                                       \

        if (YY_CURRENT_BUFFER_LVALUE->yy_is_interactive)                                      \

        {                                                                                     \

                int c = '*';                                                                  \

                int n;                                                                        \

                for (n = 0; n < max_size && (c = getc (yyin)) != EOF && c != '\n'; ++n)       \

                        buf[n] = (char) c;                                                    \

                if (c == '\n')                                                                \

                        buf[n++] = (char) c;                                                  \

                if (c == EOF && ferror (yyin))                                                \

                        YY_FATAL_ERROR ("input in flex scanner failed");                      \

                result = n;                                                                   \

        }                                                                                     \

        else                                                                                  \

        {                                                                                     \

                errno = 0;                                                                    \

                while ((result = (int) fread (buf, 1, (yy_size_t) max_size, yyin)) == 0 &&    \

                       ferror (yyin))                                                         \

                {                                                                             \

                        if (errno != EINTR)                                                   \

                        {                                                                     \

                                YY_FATAL_ERROR ("input in flex scanner failed");              \

                                break;                                                        \

                        }                                                                     \

                        errno = 0;                                                            \

                        clearerr (yyin);                                                      \

                }                                                                             \

        }

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -

 * we don't want an extra ';' after the "return" because that will cause

 * some compilers to complain about unreachable statements.

 */

#ifndef yyterminate

#define yyterminate() return YY_NULL

#endif

/* Number of entries by which start-condition stack grows. */

#ifndef YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

#endif

/* Report a fatal error. */

#ifndef YY_FATAL_ERROR

#define YY_FATAL_ERROR(msg) yy_fatal_error (msg)

#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can

 * easily add parameters.

 */

#ifndef YY_DECL

#define YY_DECL_IS_OURS 1

extern int yylex (void);

#define YY_DECL int yylex (void)

#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng

 * have been set up.

 */

#ifndef YY_USER_ACTION

#define YY_USER_ACTION

#endif

/* Code executed at the end of each rule. */

#ifndef YY_BREAK

#define YY_BREAK /*LINTED*/ break;

#endif

#define YY_RULE_SETUP YY_USER_ACTION

/** The main scanner function which does all the work.

 */

YY_DECL

{

        yy_state_type yy_current_state;

        char *yy_cp, *yy_bp;

        int yy_act;

        if (!(yy_init))

        {

                (yy_init) = 1;

#ifdef YY_USER_INIT

                YY_USER_INIT;

#endif

                if (!(yy_start))

                        (yy_start) = 1; /* first start state */

                if (!yyin)

                        yyin = stdin;

                if (!yyout)

                        yyout = stdout;

                if (!YY_CURRENT_BUFFER)

                {

                        yyensure_buffer_stack ();

                        YY_CURRENT_BUFFER_LVALUE = yy_create_buffer (yyin, YY_BUF_SIZE);

                }

                yy_load_buffer_state ();

        }

        {

#line 73 "rep2_lex.l"

#line 736 "rep2_lex.c"

                while (/*CONSTCOND*/ 1) /* loops until end-of-file is reached */

                {

                        yy_cp = (yy_c_buf_p);

                        /* Support of yytext. */

                        *yy_cp = (yy_hold_char);

                        /* yy_bp points to the position in yy_ch_buf of the start of

                         * the current run.

                         */

                        yy_bp = yy_cp;

                        yy_current_state = (yy_start);

                yy_match:

                        do

                        {

                                YY_CHAR yy_c = yy_ec[YY_SC_TO_UI (*yy_cp)];

                                if (yy_accept[yy_current_state])

                                {

                                        (yy_last_accepting_state) = yy_current_state;

                                        (yy_last_accepting_cpos) = yy_cp;

                                }

                                while (yy_chk[yy_base[yy_current_state] + yy_c] !=

                                       yy_current_state)

                                {

                                        yy_current_state = (int) yy_def[yy_current_state];

                                        if (yy_current_state >= 27)

                                                yy_c = yy_meta[yy_c];

                                }

                                yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];

                                ++yy_cp;

                        } while (yy_base[yy_current_state] != 50);

                yy_find_action:

                        yy_act = yy_accept[yy_current_state];

                        if (yy_act == 0)

                        { /* have to back up */

                                yy_cp = (yy_last_accepting_cpos);

                                yy_current_state = (yy_last_accepting_state);

                                yy_act = yy_accept[yy_current_state];

                        }

                        YY_DO_BEFORE_ACTION;

                do_action: /* This label is used only to access EOF actions. */

                        switch (yy_act)

                        {       /* beginning of action switch */

                        case 0: /* must back up */

                                /* undo the effects of YY_DO_BEFORE_ACTION */

                                *yy_cp = (yy_hold_char);

                                yy_cp = (yy_last_accepting_cpos);

                                yy_current_state = (yy_last_accepting_state);

                                goto yy_find_action;

                        case 1:

                                /* rule 1 can match eol */

                                YY_RULE_SETUP

#line 76 "rep2_lex.l"

                                {

                                        yylval.string = make_string (

                                            yytext, &lx_first, &lx_last); /* do it anyway */

                                        return (ASTRING);

                                };

                                YY_BREAK

                        case 2:

                                YY_RULE_SETUP

#line 78 "rep2_lex.l"

                                {

                                        yylval.string = make_string (

                                            yytext, &lx_first, &lx_last); /* do it anyway */

                                        return (ASTRING);

                                };

                                YY_BREAK

                        case 3:

                                /* rule 3 can match eol */

                                YY_RULE_SETUP

#line 81 "rep2_lex.l"

                                {

                                        lineno++;

                                        return (LF); /* VHDL comment */

                                };

                                YY_BREAK

                        case 4:

                                YY_RULE_SETUP

#line 82 "rep2_lex.l"

                                {

                                        break; /* c comment */

                                };

                                YY_BREAK

                        case 5:

                                YY_RULE_SETUP

#line 84 "rep2_lex.l"

                                {

                                        return (SPACE); /* single char white space */

                                };

                                YY_BREAK

                        case 6:

                                YY_RULE_SETUP

#line 85 "rep2_lex.l"

                                {

                                        return (CR);

                                };

                                YY_BREAK

                        case 7:

                                /* rule 7 can match eol */

                                YY_RULE_SETUP

#line 86 "rep2_lex.l"

                                {

                                        lineno++;

                                        return (LF);

                                };

                                YY_BREAK

                        case YY_STATE_EOF (INITIAL):

#line 88 "rep2_lex.l"

                        {

                                yyterminate ();

                        };

                                YY_BREAK

                        case 8:

                                YY_RULE_SETUP

#line 91 "rep2_lex.l"