verilog_lexer.cc File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "kernel/log.h"
#include "verilog_frontend.h"
#include "frontends/ast/ast.h"
#include "verilog_parser.tab.h"
#include <unistd.h>

Include dependency graph for verilog_lexer.cc:

Go to the source code of this file.

Data Structures
struct	yy_buffer_state
struct	yy_trans_info

Namespaces
	VERILOG_FRONTEND

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   frontend_verilog_yy_create_buffer
#define	yy_delete_buffer   frontend_verilog_yy_delete_buffer
#define	yy_flex_debug   frontend_verilog_yy_flex_debug
#define	yy_init_buffer   frontend_verilog_yy_init_buffer
#define	yy_flush_buffer   frontend_verilog_yy_flush_buffer
#define	yy_load_buffer_state   frontend_verilog_yy_load_buffer_state
#define	yy_switch_to_buffer   frontend_verilog_yy_switch_to_buffer
#define	yyin   frontend_verilog_yyin
#define	yyleng   frontend_verilog_yyleng
#define	yylex   frontend_verilog_yylex
#define	yylineno   frontend_verilog_yylineno
#define	yyout   frontend_verilog_yyout
#define	yyrestart   frontend_verilog_yyrestart
#define	yytext   frontend_verilog_yytext
#define	yywrap   frontend_verilog_yywrap
#define	yyalloc   frontend_verilog_yyalloc
#define	yyrealloc   frontend_verilog_yyrealloc
#define	yyfree   frontend_verilog_yyfree
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   35
#define	FLEX_BETA
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE   frontend_verilog_yyrestart(frontend_verilog_yyin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#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	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_TYPEDEF_YY_SIZE_T
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	YY_FLUSH_BUFFER   frontend_verilog_yy_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   frontend_verilog_yy_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	frontend_verilog_yywrap(n)   1
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   frontend_verilog_yytext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   115
#define	YY_END_OF_BUFFER   116
#define	REJECT   reject_used_but_not_detected
#define	yymore()   ((yy_more_flag) = 1)
#define	YY_MORE_ADJ   (yy_more_len)
#define	YY_RESTORE_YY_MORE_OFFSET
#define	SV_KEYWORD(_tok)
#define	YY_INPUT(buf, result, max_size)   result = readsome(*VERILOG_FRONTEND::lexin, buf, max_size)
#define	INITIAL   0
#define	COMMENT   1
#define	STRING   2
#define	SYNOPSYS_TRANSLATE_OFF   3
#define	SYNOPSYS_FLAGS   4
#define	IMPORT_DPI   5
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( frontend_verilog_yytext, frontend_verilog_yyleng, 1, frontend_verilog_yyout )) {} } while (0)
#define	yyterminate()   return YY_NULL
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int frontend_verilog_yylex (void)
#define	YY_USER_ACTION
#define	YY_BREAK   break;
#define	YY_RULE_SETUP   YY_USER_ACTION
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
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
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type

Functions
void	frontend_verilog_yyrestart (FILE *input_file)
void	frontend_verilog_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	frontend_verilog_yy_create_buffer (FILE *file, int size)
void	frontend_verilog_yy_delete_buffer (YY_BUFFER_STATE b)
void	frontend_verilog_yy_flush_buffer (YY_BUFFER_STATE b)
void	frontend_verilog_yypush_buffer_state (YY_BUFFER_STATE new_buffer)
void	frontend_verilog_yypop_buffer_state (void)
static void	frontend_verilog_yyensure_buffer_stack (void)
static void	frontend_verilog_yy_load_buffer_state (void)
static void	frontend_verilog_yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	frontend_verilog_yy_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	frontend_verilog_yy_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	frontend_verilog_yy_scan_bytes (yyconst char *bytes, int len)
void *	frontend_verilog_yyalloc (yy_size_t)
void *	frontend_verilog_yyrealloc (void *, yy_size_t)
void	frontend_verilog_yyfree (void *)
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	yy_fatal_error (yyconst char msg[])
static int	yy_init_globals (void)
int	frontend_verilog_yylex_destroy (void)
int	frontend_verilog_yyget_debug (void)
void	frontend_verilog_yyset_debug (int debug_flag)
YY_EXTRA_TYPE	frontend_verilog_yyget_extra (void)
void	frontend_verilog_yyset_extra (YY_EXTRA_TYPE user_defined)
FILE *	frontend_verilog_yyget_in (void)
void	frontend_verilog_yyset_in (FILE *in_str)
FILE *	frontend_verilog_yyget_out (void)
void	frontend_verilog_yyset_out (FILE *out_str)
int	frontend_verilog_yyget_leng (void)
char *	frontend_verilog_yyget_text (void)
int	frontend_verilog_yyget_lineno (void)
void	frontend_verilog_yyset_lineno (int line_number)
static int	input (void)
int	frontend_verilog_yylex (void)
	if (!(yy_init))
	while (1)
int	isatty (int)
static void	yy_fatal_error (yyconst char *msg)
void *	frontend_verilog_avoid_input_warnings ()

Variables
int	frontend_verilog_yyleng
FILE *	frontend_verilog_yyin = (FILE *) 0
FILE *	frontend_verilog_yyout = (FILE *) 0
static size_t	yy_buffer_stack_top = 0
static size_t	yy_buffer_stack_max = 0
static YY_BUFFER_STATE *	yy_buffer_stack = 0
static char	yy_hold_char
static int	yy_n_chars
static char *	yy_c_buf_p = (char *) 0
static int	yy_init = 0
static int	yy_start = 0
static int	yy_did_buffer_switch_on_eof
int	frontend_verilog_yylineno = 1
char *	frontend_verilog_yytext
static yyconst flex_int16_t	yy_accept [569]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [67]
static yyconst flex_int16_t	yy_base [592]
static yyconst flex_int16_t	yy_def [592]
static yyconst flex_int16_t	yy_nxt [1121]
static yyconst flex_int16_t	yy_chk [1121]
static yyconst flex_int32_t	yy_rule_can_match_eol [116]
static yy_state_type	yy_last_accepting_state
static char *	yy_last_accepting_cpos
int	frontend_verilog_yy_flex_debug = 0
static int	yy_more_flag = 0
static int	yy_more_len = 0
std::vector< std::string >	VERILOG_FRONTEND::fn_stack
std::vector< int >	VERILOG_FRONTEND::ln_stack
	YY_DECL
register char *	yy_cp
register char *	yy_bp
register int	yy_act

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 145 of file verilog_lexer.cc.

#define COMMENT   1

Definition at line 1022 of file verilog_lexer.cc.

#define ECHO   do { if (fwrite( frontend_verilog_yytext, frontend_verilog_yyleng, 1, frontend_verilog_yyout )) {} } while (0)

Definition at line 1116 of file verilog_lexer.cc.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 188 of file verilog_lexer.cc.

#define EOB_ACT_END_OF_FILE   1

Definition at line 189 of file verilog_lexer.cc.

#define EOB_ACT_LAST_MATCH   2

Definition at line 190 of file verilog_lexer.cc.

#define FLEX_BETA

Definition at line 33 of file verilog_lexer.cc.

#define FLEX_SCANNER

Definition at line 28 of file verilog_lexer.cc.

#define FLEXINT_H

Definition at line 49 of file verilog_lexer.cc.

#define frontend_verilog_yywrap

(

n

)

1

Definition at line 376 of file verilog_lexer.cc.

#define IMPORT_DPI   5

Definition at line 1026 of file verilog_lexer.cc.

#define INITIAL   0

Definition at line 1021 of file verilog_lexer.cc.

#define INT16_MAX   (32767)

Definition at line 91 of file verilog_lexer.cc.

#define INT16_MIN   (-32767-1)

Definition at line 82 of file verilog_lexer.cc.

#define INT32_MAX   (2147483647)

Definition at line 94 of file verilog_lexer.cc.

#define INT32_MIN   (-2147483647-1)

Definition at line 85 of file verilog_lexer.cc.

#define INT8_MAX   (127)

Definition at line 88 of file verilog_lexer.cc.

#define INT8_MIN   (-128)

Definition at line 79 of file verilog_lexer.cc.

#define REJECT   reject_used_but_not_detected

Definition at line 939 of file verilog_lexer.cc.

#define STRING   2

Definition at line 1023 of file verilog_lexer.cc.

#define SV_KEYWORD

(

_tok

)

Value:

if (sv_mode) return _tok; \
	log("Lexer warning: The SystemVerilog keyword `%s' (at %s:%d) is not "\
            "recognized unless read_verilog is called with -sv!\n", frontend_verilog_yytext, \
            AST::current_filename.c_str(), frontend_verilog_yyget_lineno()); \
	frontend_verilog_yylval.string = new std::string(std::string("\\") + frontend_verilog_yytext); \
    return TOK_ID;

Definition at line 1003 of file verilog_lexer.cc.

#define SYNOPSYS_FLAGS   4

Definition at line 1025 of file verilog_lexer.cc.

#define SYNOPSYS_TRANSLATE_OFF   3

Definition at line 1024 of file verilog_lexer.cc.

#define UINT16_MAX   (65535U)

Definition at line 100 of file verilog_lexer.cc.

#define UINT32_MAX   (4294967295U)

Definition at line 103 of file verilog_lexer.cc.

#define UINT8_MAX   (255U)

Definition at line 97 of file verilog_lexer.cc.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 221 of file verilog_lexer.cc.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 372 of file verilog_lexer.cc.

#define YY_BREAK   break;

Definition at line 1195 of file verilog_lexer.cc.

#define YY_BUF_SIZE   16384

Definition at line 171 of file verilog_lexer.cc.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 288 of file verilog_lexer.cc.

#define YY_BUFFER_NEW   0

Definition at line 276 of file verilog_lexer.cc.

#define YY_BUFFER_NORMAL   1

Definition at line 277 of file verilog_lexer.cc.

#define yy_create_buffer   frontend_verilog_yy_create_buffer

Definition at line 9 of file verilog_lexer.cc.

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 304 of file verilog_lexer.cc.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 311 of file verilog_lexer.cc.

#define YY_DECL   int frontend_verilog_yylex (void)

Definition at line 1183 of file verilog_lexer.cc.

#define YY_DECL_IS_OURS   1

Definition at line 1179 of file verilog_lexer.cc.

#define yy_delete_buffer   frontend_verilog_yy_delete_buffer

Definition at line 10 of file verilog_lexer.cc.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
    (yytext_ptr) -= (yy_more_len); \
	frontend_verilog_yyleng = (size_t) (yy_cp - (yytext_ptr)); \
    (yy_hold_char) = *yy_cp; \
    *yy_cp = '\0'; \
    (yy_c_buf_p) = yy_cp;

Definition at line 400 of file verilog_lexer.cc.

#define YY_END_OF_BUFFER   116

Definition at line 409 of file verilog_lexer.cc.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 160 of file verilog_lexer.cc.

#define YY_EXIT_FAILURE   2

Definition at line 2774 of file verilog_lexer.cc.

#define YY_EXTRA_TYPE   void *

Definition at line 1037 of file verilog_lexer.cc.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 1170 of file verilog_lexer.cc.

#define yy_flex_debug   frontend_verilog_yy_flex_debug

Definition at line 11 of file verilog_lexer.cc.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file verilog_lexer.cc.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file verilog_lexer.cc.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file verilog_lexer.cc.

#define yy_flush_buffer   frontend_verilog_yy_flush_buffer

Definition at line 13 of file verilog_lexer.cc.

#define YY_FLUSH_BUFFER   frontend_verilog_yy_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 340 of file verilog_lexer.cc.

#define yy_init_buffer   frontend_verilog_yy_init_buffer

Definition at line 12 of file verilog_lexer.cc.

#define YY_INPUT	(		buf,
			result,
			max_size
	)		result = readsome(*VERILOG_FRONTEND::lexin, buf, max_size)

Definition at line 1011 of file verilog_lexer.cc.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file verilog_lexer.cc.

#define YY_LESS_LINENO

(

n

)

Value:

do { \
                int yyl;\
                for ( yyl = n; yyl < frontend_verilog_yyleng; ++yyl )\
                    if ( frontend_verilog_yytext[yyl] == '\n' )\
                        --frontend_verilog_yylineno;\
            }while(0)

Definition at line 199 of file verilog_lexer.cc.

#define yy_load_buffer_state   frontend_verilog_yy_load_buffer_state

Definition at line 14 of file verilog_lexer.cc.

#define YY_MORE_ADJ   (yy_more_len)

Definition at line 943 of file verilog_lexer.cc.

#define yy_new_buffer   frontend_verilog_yy_create_buffer

Definition at line 350 of file verilog_lexer.cc.

#define YY_NEW_FILE   frontend_verilog_yyrestart(frontend_verilog_yyin )

Definition at line 158 of file verilog_lexer.cc.

#define YY_NULL   0

Definition at line 132 of file verilog_lexer.cc.

#define YY_NUM_RULES   115

Definition at line 408 of file verilog_lexer.cc.

#define YY_READ_BUF_SIZE   8192

Definition at line 1107 of file verilog_lexer.cc.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 944 of file verilog_lexer.cc.

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 1198 of file verilog_lexer.cc.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 139 of file verilog_lexer.cc.

#define yy_set_bol

(

at_bol

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        frontend_verilog_yyensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            frontend_verilog_yy_create_buffer(frontend_verilog_yyin,YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    }

Definition at line 362 of file verilog_lexer.cc.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        frontend_verilog_yyensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            frontend_verilog_yy_create_buffer(frontend_verilog_yyin,YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

Definition at line 352 of file verilog_lexer.cc.

#define YY_SKIP_YYWRAP

Definition at line 377 of file verilog_lexer.cc.

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

Definition at line 151 of file verilog_lexer.cc.

#define YY_START_STACK_INCR   25

Definition at line 1165 of file verilog_lexer.cc.

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

Definition at line 177 of file verilog_lexer.cc.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 155 of file verilog_lexer.cc.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 229 of file verilog_lexer.cc.

#define yy_switch_to_buffer   frontend_verilog_yy_switch_to_buffer

Definition at line 15 of file verilog_lexer.cc.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 180 of file verilog_lexer.cc.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 224 of file verilog_lexer.cc.

#define YY_USER_ACTION

Definition at line 1190 of file verilog_lexer.cc.

#define yyalloc   frontend_verilog_yyalloc

Definition at line 24 of file verilog_lexer.cc.

#define yyconst

Definition at line 128 of file verilog_lexer.cc.

#define yyfree   frontend_verilog_yyfree

Definition at line 26 of file verilog_lexer.cc.

#define yyin   frontend_verilog_yyin

Definition at line 16 of file verilog_lexer.cc.

#define yyleng   frontend_verilog_yyleng

Definition at line 17 of file verilog_lexer.cc.

#define yyless

(

n

)

Value:

do \
        { \
        /* Undo effects of setting up frontend_verilog_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 frontend_verilog_yytext again */ \
        } \
	while ( 0 )

Definition at line 2786 of file verilog_lexer.cc.

#define yyless

(

n

)

Value:

do \
        { \
        /* Undo effects of setting up frontend_verilog_yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		frontend_verilog_yytext[frontend_verilog_yyleng] = (yy_hold_char); \
        (yy_c_buf_p) = frontend_verilog_yytext + yyless_macro_arg; \
        (yy_hold_char) = *(yy_c_buf_p); \
        *(yy_c_buf_p) = '\0'; \
		frontend_verilog_yyleng = yyless_macro_arg; \
        } \
	while ( 0 )

Definition at line 2786 of file verilog_lexer.cc.

#define yylex   frontend_verilog_yylex

Definition at line 18 of file verilog_lexer.cc.

#define yylineno   frontend_verilog_yylineno

Definition at line 19 of file verilog_lexer.cc.

#define yymore

(

)

((yy_more_flag) = 1)

Definition at line 942 of file verilog_lexer.cc.

#define yyout   frontend_verilog_yyout

Definition at line 20 of file verilog_lexer.cc.

#define yyrealloc   frontend_verilog_yyrealloc

Definition at line 25 of file verilog_lexer.cc.

#define yyrestart   frontend_verilog_yyrestart

Definition at line 21 of file verilog_lexer.cc.

#define YYSTATE   YY_START

Definition at line 152 of file verilog_lexer.cc.

#define YYTABLES_NAME   "yytables"

Definition at line 2979 of file verilog_lexer.cc.

#define yyterminate

(

)

return YY_NULL

Definition at line 1160 of file verilog_lexer.cc.

#define yytext   frontend_verilog_yytext

Definition at line 22 of file verilog_lexer.cc.

#define yytext_ptr   frontend_verilog_yytext

Definition at line 390 of file verilog_lexer.cc.

#define yywrap   frontend_verilog_yywrap

Definition at line 23 of file verilog_lexer.cc.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 71 of file verilog_lexer.cc.

typedef int flex_int32_t

Definition at line 72 of file verilog_lexer.cc.

typedef signed char flex_int8_t

Definition at line 70 of file verilog_lexer.cc.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file verilog_lexer.cc.

typedef unsigned int flex_uint32_t

Definition at line 75 of file verilog_lexer.cc.

typedef unsigned char flex_uint8_t

Definition at line 73 of file verilog_lexer.cc.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 181 of file verilog_lexer.cc.

typedef unsigned char YY_CHAR

Definition at line 379 of file verilog_lexer.cc.

typedef size_t yy_size_t

Definition at line 225 of file verilog_lexer.cc.

typedef int yy_state_type

Definition at line 383 of file verilog_lexer.cc.

Function Documentation

void* frontend_verilog_avoid_input_warnings

(

)

Definition at line 2986 of file verilog_lexer.cc.

                                              {
    return (void*)&yyinput;
}

YY_BUFFER_STATE frontend_verilog_yy_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Definition at line 2487 of file verilog_lexer.cc.

{
    YY_BUFFER_STATE b;
    
    b = (YY_BUFFER_STATE) frontend_verilog_yyalloc(sizeof( struct yy_buffer_state )  );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yy_create_buffer()" );

    b->yy_buf_size = size;

    /* yy_ch_buf has to be 2 characters longer than the size given because
     * we need to put in 2 end-of-buffer characters.
     */
    b->yy_ch_buf = (char *) frontend_verilog_yyalloc(b->yy_buf_size + 2  );
    if ( ! b->yy_ch_buf )
        YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yy_create_buffer()" );

    b->yy_is_our_buffer = 1;

    frontend_verilog_yy_init_buffer(b,file );

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yy_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with frontend_verilog_yy_create_buffer()

Definition at line 2515 of file verilog_lexer.cc.

{
    
    if ( ! b )
        return;

    if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
        YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

    if ( b->yy_is_our_buffer )
        frontend_verilog_yyfree((void *) b->yy_ch_buf  );

    frontend_verilog_yyfree((void *) b  );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yy_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 2566 of file verilog_lexer.cc.

{
        if ( ! b )
        return;

    b->yy_n_chars = 0;

    /* We always need two end-of-buffer characters.  The first causes
     * a transition to the end-of-buffer state.  The second causes
     * a jam in that state.
     */
    b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

    b->yy_buf_pos = &b->yy_ch_buf[0];

    b->yy_at_bol = 1;
    b->yy_buffer_status = YY_BUFFER_NEW;

    if ( b == YY_CURRENT_BUFFER )
        frontend_verilog_yy_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void frontend_verilog_yy_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 2538 of file verilog_lexer.cc.

{
    int oerrno = errno;
    
    frontend_verilog_yy_flush_buffer(b );

    b->yy_input_file = file;
    b->yy_fill_buffer = 1;

    /* If b is the current buffer, then frontend_verilog_yy_init_buffer was _probably_
     * called from frontend_verilog_yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
    errno = oerrno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void frontend_verilog_yy_load_buffer_state ( void  )

static

Definition at line 2473 of file verilog_lexer.cc.

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    frontend_verilog_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    (yy_hold_char) = *(yy_c_buf_p);
}

Here is the caller graph for this function:

YY_BUFFER_STATE frontend_verilog_yy_scan_buffer	(	char *	base,
		yy_size_t	size
	)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters

base	the character buffer
size	the size in bytes of the character buffer

Returns

the newly allocated buffer state object.

Definition at line 2693 of file verilog_lexer.cc.

{
    YY_BUFFER_STATE b;
    
    if ( size < 2 ||
         base[size-2] != YY_END_OF_BUFFER_CHAR ||
         base[size-1] != YY_END_OF_BUFFER_CHAR )
        /* They forgot to leave room for the EOB's. */
        return 0;

    b = (YY_BUFFER_STATE) frontend_verilog_yyalloc(sizeof( struct yy_buffer_state )  );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yy_scan_buffer()" );

    b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
    b->yy_buf_pos = b->yy_ch_buf = base;
    b->yy_is_our_buffer = 0;
    b->yy_input_file = 0;
    b->yy_n_chars = b->yy_buf_size;
    b->yy_is_interactive = 0;
    b->yy_at_bol = 1;
    b->yy_fill_buffer = 0;
    b->yy_buffer_status = YY_BUFFER_NEW;

    frontend_verilog_yy_switch_to_buffer(b  );

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

YY_BUFFER_STATE frontend_verilog_yy_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

Setup the input buffer state to scan the given bytes. The next call to frontend_verilog_yylex() will scan from a copy of bytes.

Parameters

yybytes	the byte buffer to scan
_yybytes_len	the number of bytes in the buffer pointed to by bytes.

Returns

the newly allocated buffer state object.

Definition at line 2743 of file verilog_lexer.cc.

{
    YY_BUFFER_STATE b;
    char *buf;
    yy_size_t n;
    int i;
    
    /* Get memory for full buffer, including space for trailing EOB's. */
    n = _yybytes_len + 2;
    buf = (char *) frontend_verilog_yyalloc(n  );
    if ( ! buf )
        YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yy_scan_bytes()" );

    for ( i = 0; i < _yybytes_len; ++i )
        buf[i] = yybytes[i];

    buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

    b = frontend_verilog_yy_scan_buffer(buf,n );
    if ( ! b )
        YY_FATAL_ERROR( "bad buffer in frontend_verilog_yy_scan_bytes()" );

    /* It's okay to grow etc. this buffer, and we should throw it
     * away when we're done.
     */
    b->yy_is_our_buffer = 1;

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

YY_BUFFER_STATE frontend_verilog_yy_scan_string

(

yyconst char *

yystr

)

Setup the input buffer state to scan a string. The next call to frontend_verilog_yylex() will scan from a copy of str.

Parameters

yystr

a NUL-terminated string to scan

Returns

the newly allocated buffer state object.

Note

If you want to scan bytes that may contain NUL values, then use frontend_verilog_yy_scan_bytes() instead.

Definition at line 2730 of file verilog_lexer.cc.

{
    
    return frontend_verilog_yy_scan_bytes(yystr,strlen(yystr) );
}

Here is the call graph for this function:

void frontend_verilog_yy_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 2442 of file verilog_lexer.cc.

{
    
    /* TODO. We should be able to replace this entire function body
     * with
     *      frontend_verilog_yypop_buffer_state();
     *      frontend_verilog_yypush_buffer_state(new_buffer);
     */
    frontend_verilog_yyensure_buffer_stack ();
    if ( YY_CURRENT_BUFFER == new_buffer )
        return;

    if ( YY_CURRENT_BUFFER )
        {
        /* Flush out information for old buffer. */
        *(yy_c_buf_p) = (yy_hold_char);
        YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    YY_CURRENT_BUFFER_LVALUE = new_buffer;
    frontend_verilog_yy_load_buffer_state( );

    /* We don't actually know whether we did this switch during
     * EOF (frontend_verilog_yywrap()) processing, but the only time this flag
     * is looked at is after frontend_verilog_yywrap() is called, so it's safe
     * to go ahead and always set it.
     */
    (yy_did_buffer_switch_on_eof) = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * frontend_verilog_yyalloc

(

yy_size_t

size

)

Definition at line 2957 of file verilog_lexer.cc.

{
    return (void *) malloc( size );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void frontend_verilog_yyensure_buffer_stack ( void  )

static

Definition at line 2644 of file verilog_lexer.cc.

{
    int num_to_alloc;
    
    if (!(yy_buffer_stack)) {

        /* First allocation is just for 2 elements, since we don't know if this
         * scanner will even need a stack. We use 2 instead of 1 to avoid an
         * immediate realloc on the next call.
         */
        num_to_alloc = 1;
        (yy_buffer_stack) = (struct yy_buffer_state**)frontend_verilog_yyalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yyensure_buffer_stack()" );
                                  
        memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                
        (yy_buffer_stack_max) = num_to_alloc;
        (yy_buffer_stack_top) = 0;
        return;
    }

    if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

        /* Increase the buffer to prepare for a possible push. */
        int grow_size = 8 /* arbitrary grow size */;

        num_to_alloc = (yy_buffer_stack_max) + grow_size;
        (yy_buffer_stack) = (struct yy_buffer_state**)frontend_verilog_yyrealloc
                                ((yy_buffer_stack),
                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in frontend_verilog_yyensure_buffer_stack()" );

        /* zero only the new slots.*/
        memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
        (yy_buffer_stack_max) = num_to_alloc;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yyfree

(

void *

ptr

)

Definition at line 2974 of file verilog_lexer.cc.

{
    free( (char *) ptr );   /* see frontend_verilog_yyrealloc() for (char *) cast */
}

Here is the call graph for this function:

Here is the caller graph for this function:

int frontend_verilog_yyget_debug

(

void

)

Definition at line 2870 of file verilog_lexer.cc.

{
        return frontend_verilog_yy_flex_debug;
}

YY_EXTRA_TYPE frontend_verilog_yyget_extra

(

void

)

FILE * frontend_verilog_yyget_in

(

void

)

Get the input stream.

Definition at line 2814 of file verilog_lexer.cc.

{
        return frontend_verilog_yyin;
}

int frontend_verilog_yyget_leng

(

void

)

Get the length of the current token.

Definition at line 2830 of file verilog_lexer.cc.

{
        return frontend_verilog_yyleng;
}

int frontend_verilog_yyget_lineno

(

void

)

Get the current line number.

Definition at line 2805 of file verilog_lexer.cc.

{
        
    return frontend_verilog_yylineno;
}

Here is the caller graph for this function:

FILE * frontend_verilog_yyget_out

(

void

)

Get the output stream.

Definition at line 2822 of file verilog_lexer.cc.

{
        return frontend_verilog_yyout;
}

char * frontend_verilog_yyget_text

(

void

)

Get the current token.

Definition at line 2839 of file verilog_lexer.cc.

{
        return frontend_verilog_yytext;
}

int frontend_verilog_yylex

(

void

)

int frontend_verilog_yylex_destroy

(

void

)

Definition at line 2912 of file verilog_lexer.cc.

{
    
    /* Pop the buffer stack, destroying each element. */
    while(YY_CURRENT_BUFFER){
        frontend_verilog_yy_delete_buffer(YY_CURRENT_BUFFER  );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        frontend_verilog_yypop_buffer_state();
    }

    /* Destroy the stack itself. */
    frontend_verilog_yyfree((yy_buffer_stack) );
    (yy_buffer_stack) = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * frontend_verilog_yylex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yypop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 2625 of file verilog_lexer.cc.

{
        if (!YY_CURRENT_BUFFER)
        return;

    frontend_verilog_yy_delete_buffer(YY_CURRENT_BUFFER );
    YY_CURRENT_BUFFER_LVALUE = NULL;
    if ((yy_buffer_stack_top) > 0)
        --(yy_buffer_stack_top);

    if (YY_CURRENT_BUFFER) {
        frontend_verilog_yy_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yypush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

Definition at line 2595 of file verilog_lexer.cc.

{
        if (new_buffer == NULL)
        return;

    frontend_verilog_yyensure_buffer_stack();

    /* This block is copied from frontend_verilog_yy_switch_to_buffer. */
    if ( YY_CURRENT_BUFFER )
        {
        /* Flush out information for old buffer. */
        *(yy_c_buf_p) = (yy_hold_char);
        YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    /* Only push if top exists. Otherwise, replace top. */
    if (YY_CURRENT_BUFFER)
        (yy_buffer_stack_top)++;
    YY_CURRENT_BUFFER_LVALUE = new_buffer;

    /* copied from frontend_verilog_yy_switch_to_buffer. */
    frontend_verilog_yy_load_buffer_state( );
    (yy_did_buffer_switch_on_eof) = 1;
}

Here is the call graph for this function:

void * frontend_verilog_yyrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 2962 of file verilog_lexer.cc.

{
    /* The cast to (char *) in the following accommodates both
     * implementations that use char* generic pointers, and those
     * that use void* generic pointers.  It works with the latter
     * because both ANSI C and C++ allow castless assignment from
     * any pointer type to void*, and deal with argument conversions
     * as though doing an assignment.
     */
    return (void *) realloc( (char *) ptr, size );
}

Here is the caller graph for this function:

void frontend_verilog_yyrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 2425 of file verilog_lexer.cc.

{
    
    if ( ! YY_CURRENT_BUFFER ){
        frontend_verilog_yyensure_buffer_stack ();
        YY_CURRENT_BUFFER_LVALUE =
            frontend_verilog_yy_create_buffer(frontend_verilog_yyin,YY_BUF_SIZE );
    }

    frontend_verilog_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
    frontend_verilog_yy_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frontend_verilog_yyset_debug

(

int

debug_flag

)

Definition at line 2875 of file verilog_lexer.cc.

{
        frontend_verilog_yy_flex_debug = bdebug ;
}

void frontend_verilog_yyset_extra

(

YY_EXTRA_TYPE

user_defined

)

void frontend_verilog_yyset_in

(

FILE *

in_str

)

Set the input stream. This does not discard the current input buffer.

Parameters

in_str

A readable stream.

See Also

frontend_verilog_yy_switch_to_buffer

Definition at line 2860 of file verilog_lexer.cc.

{
        frontend_verilog_yyin = in_str ;
}

void frontend_verilog_yyset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

Definition at line 2848 of file verilog_lexer.cc.

{
    
    frontend_verilog_yylineno = line_number;
}

Here is the caller graph for this function:

void frontend_verilog_yyset_out

(

FILE *

out_str

)

Definition at line 2865 of file verilog_lexer.cc.

{
        frontend_verilog_yyout = out_str ;
}

if

(

!

yy_init

)

Definition at line 1214 of file verilog_lexer.cc.

        {
        (yy_init) = 1;

#ifdef YY_USER_INIT
        YY_USER_INIT;
#endif

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

        if ( ! frontend_verilog_yyin )
            frontend_verilog_yyin = stdin;

        if ( ! frontend_verilog_yyout )
            frontend_verilog_yyout = stdout;

        if ( ! YY_CURRENT_BUFFER ) {
            frontend_verilog_yyensure_buffer_stack ();
            YY_CURRENT_BUFFER_LVALUE =
                frontend_verilog_yy_create_buffer(frontend_verilog_yyin,YY_BUF_SIZE );
        }

        frontend_verilog_yy_load_buffer_state( );
        }

Here is the call graph for this function:

static int input ( void  )

static

Definition at line 2345 of file verilog_lexer.cc.

{
    int c;
    
    *(yy_c_buf_p) = (yy_hold_char);

    if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
        {
        /* yy_c_buf_p now points to the character we want to return.
         * If this occurs *before* the EOB characters, then it's a
         * valid NUL; if not, then we've hit the end of the buffer.
         */
        if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
            /* This was really a NUL. */
            *(yy_c_buf_p) = '\0';

        else
            { /* need more input */
            int offset = (yy_c_buf_p) - (yytext_ptr);
            ++(yy_c_buf_p);

            switch ( yy_get_next_buffer(  ) )
                {
                case EOB_ACT_LAST_MATCH:
                    /* This happens because yy_g_n_b()
                     * sees that we've accumulated a
                     * token and flags that we need to
                     * try matching the token before
                     * proceeding.  But for input(),
                     * there's no matching to consider.
                     * So convert the EOB_ACT_LAST_MATCH
                     * to EOB_ACT_END_OF_FILE.
                     */

                    /* Reset buffer status. */
                    frontend_verilog_yyrestart(frontend_verilog_yyin );

                    /*FALLTHROUGH*/

                case EOB_ACT_END_OF_FILE:
                    {
                    if ( frontend_verilog_yywrap( ) )
                        return EOF;

                    if ( ! (yy_did_buffer_switch_on_eof) )
                        YY_NEW_FILE;
#ifdef __cplusplus
                    return yyinput();
#else
                    return input();
#endif
                    }

                case EOB_ACT_CONTINUE_SCAN:
                    (yy_c_buf_p) = (yytext_ptr) + offset;
                    break;
                }
            }
        }

    c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
    *(yy_c_buf_p) = '\0';   /* preserve frontend_verilog_yytext */
    (yy_hold_char) = *++(yy_c_buf_p);

    if ( c == '\n' )
           
    frontend_verilog_yylineno++;
;

    return c;
}

Here is the call graph for this function:

int isatty

(

int

)

Here is the caller graph for this function:

while

(

1

)

Definition at line 1240 of file verilog_lexer.cc.

        {
        (yy_more_len) = 0;
        if ( (yy_more_flag) )
            {
            (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);
            (yy_more_flag) = 0;
            }
        yy_cp = (yy_c_buf_p);

        /* Support of frontend_verilog_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
            {
            register 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 >= 569 )
                    yy_c = yy_meta[(unsigned int) yy_c];
                }
            yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
            ++yy_cp;
            }
        while ( yy_base[yy_current_state] != 1054 );

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;

        if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
            {
            int yyl;
            for ( yyl = (yy_more_len); yyl < frontend_verilog_yyleng; ++yyl )
                if ( frontend_verilog_yytext[yyl] == '\n' )
                       
    frontend_verilog_yylineno++;
;
            }

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:
YY_RULE_SETUP
#line 84 "frontends/verilog/verilog_lexer.l"
{
    fn_stack.push_back(current_filename);
    ln_stack.push_back(frontend_verilog_yyget_lineno());
    current_filename = frontend_verilog_yytext+11;
    frontend_verilog_yyset_lineno(0);
}
    YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
#line 91 "frontends/verilog/verilog_lexer.l"
{
    current_filename = fn_stack.back();
    fn_stack.pop_back();
    frontend_verilog_yyset_lineno(ln_stack.back());
    ln_stack.pop_back();
}
    YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
#line 98 "frontends/verilog/verilog_lexer.l"
{
    char *p = frontend_verilog_yytext + 5;
    while (*p == ' ' || *p == '\t') p++;
    frontend_verilog_yyset_lineno(atoi(p));
    while (*p && *p != ' ' && *p != '\t') p++;
    while (*p == ' ' || *p == '\t') p++;
    char *q = *p ? p + 1 : p;
    while (*q && *q != '"') q++;
    current_filename = std::string(p).substr(1, q-p-1);
}
    YY_BREAK
case 4:
YY_RULE_SETUP
#line 109 "frontends/verilog/verilog_lexer.l"
{
    log_error("Can't open include file `%s'!\n", frontend_verilog_yytext + 15);
}
    YY_BREAK
case 5:
YY_RULE_SETUP
#line 113 "frontends/verilog/verilog_lexer.l"
/* ignore timescale directive */
    YY_BREAK
case 6:
YY_RULE_SETUP
#line 115 "frontends/verilog/verilog_lexer.l"
{
    char *p = frontend_verilog_yytext;
    while (*p != 0 && *p != ' ' && *p != '\t') p++;
    while (*p == ' ' || *p == '\t') p++;
    if (!strcmp(p, "none"))
        VERILOG_FRONTEND::default_nettype_wire = false;
    else if (!strcmp(p, "wire"))
        VERILOG_FRONTEND::default_nettype_wire = true;
    else
        frontend_verilog_yyerror("Unsupported default nettype: %s", p);
}
    YY_BREAK
case 7:
YY_RULE_SETUP
#line 127 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yyerror("Unimplemented compiler directive or undefined macro %s.", frontend_verilog_yytext);
}
    YY_BREAK
case 8:
YY_RULE_SETUP
#line 131 "frontends/verilog/verilog_lexer.l"
{ return TOK_MODULE; }
    YY_BREAK
case 9:
YY_RULE_SETUP
#line 132 "frontends/verilog/verilog_lexer.l"
{ return TOK_ENDMODULE; }
    YY_BREAK
case 10:
YY_RULE_SETUP
#line 133 "frontends/verilog/verilog_lexer.l"
{ return TOK_FUNCTION; }
    YY_BREAK
case 11:
YY_RULE_SETUP
#line 134 "frontends/verilog/verilog_lexer.l"
{ return TOK_ENDFUNCTION; }
    YY_BREAK
case 12:
YY_RULE_SETUP
#line 135 "frontends/verilog/verilog_lexer.l"
{ return TOK_TASK; }
    YY_BREAK
case 13:
YY_RULE_SETUP
#line 136 "frontends/verilog/verilog_lexer.l"
{ return TOK_ENDTASK; }
    YY_BREAK
case 14:
YY_RULE_SETUP
#line 137 "frontends/verilog/verilog_lexer.l"
{ return TOK_PARAMETER; }
    YY_BREAK
case 15:
YY_RULE_SETUP
#line 138 "frontends/verilog/verilog_lexer.l"
{ return TOK_LOCALPARAM; }
    YY_BREAK
case 16:
YY_RULE_SETUP
#line 139 "frontends/verilog/verilog_lexer.l"
{ return TOK_DEFPARAM; }
    YY_BREAK
case 17:
YY_RULE_SETUP
#line 140 "frontends/verilog/verilog_lexer.l"
{ return TOK_ASSIGN; }
    YY_BREAK
case 18:
YY_RULE_SETUP
#line 141 "frontends/verilog/verilog_lexer.l"
{ return TOK_ALWAYS; }
    YY_BREAK
case 19:
YY_RULE_SETUP
#line 142 "frontends/verilog/verilog_lexer.l"
{ return TOK_INITIAL; }
    YY_BREAK
case 20:
YY_RULE_SETUP
#line 143 "frontends/verilog/verilog_lexer.l"
{ return TOK_BEGIN; }
    YY_BREAK
case 21:
YY_RULE_SETUP
#line 144 "frontends/verilog/verilog_lexer.l"
{ return TOK_END; }
    YY_BREAK
case 22:
YY_RULE_SETUP
#line 145 "frontends/verilog/verilog_lexer.l"
{ return TOK_IF; }
    YY_BREAK
case 23:
YY_RULE_SETUP
#line 146 "frontends/verilog/verilog_lexer.l"
{ return TOK_ELSE; }
    YY_BREAK
case 24:
YY_RULE_SETUP
#line 147 "frontends/verilog/verilog_lexer.l"
{ return TOK_FOR; }
    YY_BREAK
case 25:
YY_RULE_SETUP
#line 148 "frontends/verilog/verilog_lexer.l"
{ return TOK_POSEDGE; }
    YY_BREAK
case 26:
YY_RULE_SETUP
#line 149 "frontends/verilog/verilog_lexer.l"
{ return TOK_NEGEDGE; }
    YY_BREAK
case 27:
YY_RULE_SETUP
#line 150 "frontends/verilog/verilog_lexer.l"
{ return TOK_OR; }
    YY_BREAK
case 28:
YY_RULE_SETUP
#line 151 "frontends/verilog/verilog_lexer.l"
{ return TOK_CASE; }
    YY_BREAK
case 29:
YY_RULE_SETUP
#line 152 "frontends/verilog/verilog_lexer.l"
{ return TOK_CASEX; }
    YY_BREAK
case 30:
YY_RULE_SETUP
#line 153 "frontends/verilog/verilog_lexer.l"
{ return TOK_CASEZ; }
    YY_BREAK
case 31:
YY_RULE_SETUP
#line 154 "frontends/verilog/verilog_lexer.l"
{ return TOK_ENDCASE; }
    YY_BREAK
case 32:
YY_RULE_SETUP
#line 155 "frontends/verilog/verilog_lexer.l"
{ return TOK_DEFAULT; }
    YY_BREAK
case 33:
YY_RULE_SETUP
#line 156 "frontends/verilog/verilog_lexer.l"
{ return TOK_GENERATE; }
    YY_BREAK
case 34:
YY_RULE_SETUP
#line 157 "frontends/verilog/verilog_lexer.l"
{ return TOK_ENDGENERATE; }
    YY_BREAK
case 35:
YY_RULE_SETUP
#line 158 "frontends/verilog/verilog_lexer.l"
{ return TOK_WHILE; }
    YY_BREAK
case 36:
YY_RULE_SETUP
#line 159 "frontends/verilog/verilog_lexer.l"
{ return TOK_REPEAT; }
    YY_BREAK
case 37:
YY_RULE_SETUP
#line 161 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_ALWAYS); }
    YY_BREAK
case 38:
YY_RULE_SETUP
#line 162 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_ALWAYS); }
    YY_BREAK
case 39:
YY_RULE_SETUP
#line 163 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_ALWAYS); }
    YY_BREAK
case 40:
YY_RULE_SETUP
#line 165 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_ASSERT); }
    YY_BREAK
case 41:
YY_RULE_SETUP
#line 166 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_PROPERTY); }
    YY_BREAK
case 42:
YY_RULE_SETUP
#line 167 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_REG); }
    YY_BREAK
case 43:
YY_RULE_SETUP
#line 168 "frontends/verilog/verilog_lexer.l"
{ SV_KEYWORD(TOK_REG); }
    YY_BREAK
case 44:
YY_RULE_SETUP
#line 170 "frontends/verilog/verilog_lexer.l"
{ return TOK_INPUT; }
    YY_BREAK
case 45:
YY_RULE_SETUP
#line 171 "frontends/verilog/verilog_lexer.l"
{ return TOK_OUTPUT; }
    YY_BREAK
case 46:
YY_RULE_SETUP
#line 172 "frontends/verilog/verilog_lexer.l"
{ return TOK_INOUT; }
    YY_BREAK
case 47:
YY_RULE_SETUP
#line 173 "frontends/verilog/verilog_lexer.l"
{ return TOK_WIRE; }
    YY_BREAK
case 48:
YY_RULE_SETUP
#line 174 "frontends/verilog/verilog_lexer.l"
{ return TOK_REG; }
    YY_BREAK
case 49:
YY_RULE_SETUP
#line 175 "frontends/verilog/verilog_lexer.l"
{ return TOK_INTEGER; }
    YY_BREAK
case 50:
YY_RULE_SETUP
#line 176 "frontends/verilog/verilog_lexer.l"
{ return TOK_SIGNED; }
    YY_BREAK
case 51:
YY_RULE_SETUP
#line 177 "frontends/verilog/verilog_lexer.l"
{ return TOK_GENVAR; }
    YY_BREAK
case 52:
YY_RULE_SETUP
#line 178 "frontends/verilog/verilog_lexer.l"
{ return TOK_REAL; }
    YY_BREAK
case 53:
YY_RULE_SETUP
#line 180 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_CONST;
}
    YY_BREAK
case 54:
/* rule 54 can match eol */
YY_RULE_SETUP
#line 185 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_CONST;
}
    YY_BREAK
case 55:
YY_RULE_SETUP
#line 190 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_REALVAL;
}
    YY_BREAK
case 56:
YY_RULE_SETUP
#line 195 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_REALVAL;
}
    YY_BREAK
case 57:
YY_RULE_SETUP
#line 200 "frontends/verilog/verilog_lexer.l"
{ BEGIN(STRING); }
    YY_BREAK
case 58:
YY_RULE_SETUP
#line 201 "frontends/verilog/verilog_lexer.l"
{ yymore(); }
    YY_BREAK
case 59:
YY_RULE_SETUP
#line 202 "frontends/verilog/verilog_lexer.l"
{
    BEGIN(0);
    char *yystr = strdup(frontend_verilog_yytext);
    yystr[strlen(frontend_verilog_yytext) - 1] = 0;
    int i = 0, j = 0;
    while (yystr[i]) {
        if (yystr[i] == '\\' && yystr[i + 1]) {
            i++;
            if (yystr[i] == 'n')
                yystr[i] = '\n';
            else if (yystr[i] == 't')
                yystr[i] = '\t';
            else if ('0' <= yystr[i] && yystr[i] <= '7') {
                yystr[i] = yystr[i] - '0';
                if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
                    yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
                    i++;
                }
                if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
                    yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
                    i++;
                }
            }
        }
        yystr[j++] = yystr[i++];
    }
    yystr[j] = 0;
    frontend_verilog_yylval.string = new std::string(yystr);
    free(yystr);
    return TOK_STRING;
}
    YY_BREAK
case 60:
YY_RULE_SETUP
#line 233 "frontends/verilog/verilog_lexer.l"
{ yymore(); }
    YY_BREAK
case 61:
YY_RULE_SETUP
#line 235 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_PRIMITIVE;
}
    YY_BREAK
case 62:
YY_RULE_SETUP
#line 240 "frontends/verilog/verilog_lexer.l"
{ return TOK_SUPPLY0; }
    YY_BREAK
case 63:
YY_RULE_SETUP
#line 241 "frontends/verilog/verilog_lexer.l"
{ return TOK_SUPPLY1; }
    YY_BREAK
case 64:
YY_RULE_SETUP
#line 243 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_ID;
}
    YY_BREAK
case 65:
YY_RULE_SETUP
#line 248 "frontends/verilog/verilog_lexer.l"
{ return TOK_TO_SIGNED; }
    YY_BREAK
case 66:
YY_RULE_SETUP
#line 249 "frontends/verilog/verilog_lexer.l"
{ return TOK_TO_UNSIGNED; }
    YY_BREAK
case 67:
YY_RULE_SETUP
#line 251 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(std::string("\\") + frontend_verilog_yytext);
    return TOK_ID;
}
    YY_BREAK
case 68:
YY_RULE_SETUP
#line 256 "frontends/verilog/verilog_lexer.l"
{
    log("Warning: Found one of those horrible `(synopsys|synthesis) translate_off' comments.\n");
    log("It is strongly suggested to use `ifdef constructs instead!\n");
    BEGIN(SYNOPSYS_TRANSLATE_OFF);
}
    YY_BREAK
case 69:
YY_RULE_SETUP
#line 261 "frontends/verilog/verilog_lexer.l"
/* ignore synopsys translate_off body */
    YY_BREAK
case 70:
/* rule 70 can match eol */
YY_RULE_SETUP
#line 262 "frontends/verilog/verilog_lexer.l"
/* ignore synopsys translate_off body */
    YY_BREAK
case 71:
YY_RULE_SETUP
#line 263 "frontends/verilog/verilog_lexer.l"
{ BEGIN(0); }
    YY_BREAK
case 72:
YY_RULE_SETUP
#line 265 "frontends/verilog/verilog_lexer.l"
{
    BEGIN(SYNOPSYS_FLAGS);
}
    YY_BREAK
case 73:
YY_RULE_SETUP
#line 268 "frontends/verilog/verilog_lexer.l"
{
    log("Warning: Found one of those horrible `(synopsys|synthesis) full_case' comments.\n");
    log("It is strongly suggested to use verilog x-values and default branches instead!\n");
    return TOK_SYNOPSYS_FULL_CASE;
}
    YY_BREAK
case 74:
YY_RULE_SETUP
#line 273 "frontends/verilog/verilog_lexer.l"
{
    log("Warning: Found one of those horrible `(synopsys|synthesis) parallel_case' comments.\n");
    log("It is strongly suggested to use verilog `parallel_case' attributes instead!\n");
    return TOK_SYNOPSYS_PARALLEL_CASE;
}
    YY_BREAK
case 75:
YY_RULE_SETUP
#line 278 "frontends/verilog/verilog_lexer.l"
/* ignore everything else */
    YY_BREAK
case 76:
YY_RULE_SETUP
#line 279 "frontends/verilog/verilog_lexer.l"
{ BEGIN(0); }
    YY_BREAK
case 77:
/* rule 77 can match eol */
YY_RULE_SETUP
#line 281 "frontends/verilog/verilog_lexer.l"
{
    BEGIN(IMPORT_DPI);
    return TOK_DPI_FUNCTION;
}
    YY_BREAK
case 78:
YY_RULE_SETUP
#line 286 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(std::string("\\") + frontend_verilog_yytext);
    return TOK_ID;
}
    YY_BREAK
case 79:
/* rule 79 can match eol */
YY_RULE_SETUP
#line 291 "frontends/verilog/verilog_lexer.l"
/* ignore whitespaces */
    YY_BREAK
case 80:
YY_RULE_SETUP
#line 293 "frontends/verilog/verilog_lexer.l"
{
    BEGIN(0);
    return *frontend_verilog_yytext;
}
    YY_BREAK
case 81:
YY_RULE_SETUP
#line 298 "frontends/verilog/verilog_lexer.l"
{
    return *frontend_verilog_yytext;
}
    YY_BREAK
case 82:
YY_RULE_SETUP
#line 302 "frontends/verilog/verilog_lexer.l"
{
    frontend_verilog_yylval.string = new std::string(frontend_verilog_yytext);
    return TOK_ID;
}
    YY_BREAK
case 83:
YY_RULE_SETUP
#line 307 "frontends/verilog/verilog_lexer.l"
{ return ATTR_BEGIN; }
    YY_BREAK
case 84:
YY_RULE_SETUP
#line 308 "frontends/verilog/verilog_lexer.l"
{ return ATTR_END; }
    YY_BREAK
case 85:
YY_RULE_SETUP
#line 310 "frontends/verilog/verilog_lexer.l"
{ return DEFATTR_BEGIN; }
    YY_BREAK
case 86:
YY_RULE_SETUP
#line 311 "frontends/verilog/verilog_lexer.l"
{ return DEFATTR_END; }
    YY_BREAK
case 87:
YY_RULE_SETUP
#line 313 "frontends/verilog/verilog_lexer.l"
{ return OP_POW; }
    YY_BREAK
case 88:
YY_RULE_SETUP
#line 314 "frontends/verilog/verilog_lexer.l"
{ return OP_LOR; }
    YY_BREAK
case 89:
YY_RULE_SETUP
#line 315 "frontends/verilog/verilog_lexer.l"
{ return OP_LAND; }
    YY_BREAK
case 90:
YY_RULE_SETUP
#line 316 "frontends/verilog/verilog_lexer.l"
{ return OP_EQ; }
    YY_BREAK
case 91:
YY_RULE_SETUP
#line 317 "frontends/verilog/verilog_lexer.l"
{ return OP_NE; }
    YY_BREAK
case 92:
YY_RULE_SETUP
#line 318 "frontends/verilog/verilog_lexer.l"
{ return OP_LE; }
    YY_BREAK
case 93:
YY_RULE_SETUP
#line 319 "frontends/verilog/verilog_lexer.l"
{ return OP_GE; }
    YY_BREAK
case 94:
YY_RULE_SETUP
#line 321 "frontends/verilog/verilog_lexer.l"
{ return OP_EQX; }
    YY_BREAK
case 95:
YY_RULE_SETUP
#line 322 "frontends/verilog/verilog_lexer.l"
{ return OP_NEX; }
    YY_BREAK
case 96:
YY_RULE_SETUP
#line 324 "frontends/verilog/verilog_lexer.l"
{ return OP_NAND; }
    YY_BREAK
case 97:
YY_RULE_SETUP
#line 325 "frontends/verilog/verilog_lexer.l"
{ return OP_NOR;  }
    YY_BREAK
case 98:
YY_RULE_SETUP
#line 326 "frontends/verilog/verilog_lexer.l"
{ return OP_XNOR; }
    YY_BREAK
case 99:
YY_RULE_SETUP
#line 327 "frontends/verilog/verilog_lexer.l"
{ return OP_XNOR; }
    YY_BREAK
case 100:
YY_RULE_SETUP
#line 329 "frontends/verilog/verilog_lexer.l"
{ return OP_SHL; }
    YY_BREAK
case 101:
YY_RULE_SETUP
#line 330 "frontends/verilog/verilog_lexer.l"
{ return OP_SHR; }
    YY_BREAK
case 102:
YY_RULE_SETUP
#line 331 "frontends/verilog/verilog_lexer.l"
{ return OP_SSHL; }
    YY_BREAK
case 103:
YY_RULE_SETUP
#line 332 "frontends/verilog/verilog_lexer.l"
{ return OP_SSHR; }
    YY_BREAK
case 104:
YY_RULE_SETUP
#line 334 "frontends/verilog/verilog_lexer.l"
{ return TOK_POS_INDEXED; }
    YY_BREAK
case 105:
YY_RULE_SETUP
#line 335 "frontends/verilog/verilog_lexer.l"
{ return TOK_NEG_INDEXED; }
    YY_BREAK
case 106:
YY_RULE_SETUP
#line 337 "frontends/verilog/verilog_lexer.l"
{ BEGIN(COMMENT); }
    YY_BREAK
case 107:
YY_RULE_SETUP
#line 338 "frontends/verilog/verilog_lexer.l"
/* ignore comment body */
    YY_BREAK
case 108:
/* rule 108 can match eol */
YY_RULE_SETUP
#line 339 "frontends/verilog/verilog_lexer.l"
/* ignore comment body */
    YY_BREAK
case 109:
YY_RULE_SETUP
#line 340 "frontends/verilog/verilog_lexer.l"
{ BEGIN(0); }
    YY_BREAK
case 110:
/* rule 110 can match eol */
YY_RULE_SETUP
#line 342 "frontends/verilog/verilog_lexer.l"
/* ignore whitespaces */
    YY_BREAK
case 111:
/* rule 111 can match eol */
YY_RULE_SETUP
#line 343 "frontends/verilog/verilog_lexer.l"
/* ignore continuation sequence */
    YY_BREAK
case 112:
YY_RULE_SETUP
#line 344 "frontends/verilog/verilog_lexer.l"
/* ignore one-line comments */
    YY_BREAK
case 113:
YY_RULE_SETUP
#line 345 "frontends/verilog/verilog_lexer.l"
/* ignore simulation timings */
    YY_BREAK
case 114:
YY_RULE_SETUP
#line 347 "frontends/verilog/verilog_lexer.l"
{ return *frontend_verilog_yytext; }
    YY_BREAK
case 115:
YY_RULE_SETUP
#line 349 "frontends/verilog/verilog_lexer.l"
ECHO;
    YY_BREAK
#line 2008 "frontends/verilog/verilog_lexer.cc"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(COMMENT):
case YY_STATE_EOF(STRING):
case YY_STATE_EOF(SYNOPSYS_TRANSLATE_OFF):
case YY_STATE_EOF(SYNOPSYS_FLAGS):
case YY_STATE_EOF(IMPORT_DPI):
    yyterminate();

    case YY_END_OF_BUFFER:
        {
        /* Amount of text matched not including the EOB char. */
        int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

        /* Undo the effects of YY_DO_BEFORE_ACTION. */
        *yy_cp = (yy_hold_char);
        YY_RESTORE_YY_MORE_OFFSET

        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
            {
            /* We're scanning a new file or input source.  It's
             * possible that this happened because the user
             * just pointed frontend_verilog_yyin at a new source and called
             * frontend_verilog_yylex().  If so, then we have to assure
             * consistency between YY_CURRENT_BUFFER and our
             * globals.  Here is the right place to do so, because
             * this is the first action (other than possibly a
             * back-up) that will match for the new input source.
             */
            (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
            YY_CURRENT_BUFFER_LVALUE->yy_input_file = frontend_verilog_yyin;
            YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
            }

        /* Note that here we test for yy_c_buf_p "<=" to the position
         * of the first EOB in the buffer, since yy_c_buf_p will
         * already have been incremented past the NUL character
         * (since all states make transitions on EOB to the
         * end-of-buffer state).  Contrast this with the test
         * in input().
         */
        if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
            { /* This was really a NUL. */
            yy_state_type yy_next_state;

            (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

            yy_current_state = yy_get_previous_state(  );

            /* Okay, we're now positioned to make the NUL
             * transition.  We couldn't have
             * yy_get_previous_state() go ahead and do it
             * for us because it doesn't know how to deal
             * with the possibility of jamming (and we don't
             * want to build jamming into it because then it
             * will run more slowly).
             */

            yy_next_state = yy_try_NUL_trans( yy_current_state );

            yy_bp = (yytext_ptr) + YY_MORE_ADJ;

            if ( yy_next_state )
                {
                /* Consume the NUL. */
                yy_cp = ++(yy_c_buf_p);
                yy_current_state = yy_next_state;
                goto yy_match;
                }

            else
                {
                yy_cp = (yy_c_buf_p);
                goto yy_find_action;
                }
            }

        else switch ( yy_get_next_buffer(  ) )
            {
            case EOB_ACT_END_OF_FILE:
                {
                (yy_did_buffer_switch_on_eof) = 0;

                if ( frontend_verilog_yywrap( ) )
                    {
                    /* Note: because we've taken care in
                     * yy_get_next_buffer() to have set up
                     * frontend_verilog_yytext, we can now set up
                     * yy_c_buf_p so that if some total
                     * hoser (like flex itself) wants to
                     * call the scanner after we return the
                     * YY_NULL, it'll still work - another
                     * YY_NULL will get returned.
                     */
                    (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                    yy_act = YY_STATE_EOF(YY_START);
                    goto do_action;
                    }

                else
                    {
                    if ( ! (yy_did_buffer_switch_on_eof) )
                        YY_NEW_FILE;
                    }
                break;
                }

            case EOB_ACT_CONTINUE_SCAN:
                (yy_c_buf_p) =
                    (yytext_ptr) + yy_amount_of_matched_text;

                yy_current_state = yy_get_previous_state(  );

                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                goto yy_match;

            case EOB_ACT_LAST_MATCH:
                (yy_c_buf_p) =
                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                yy_current_state = yy_get_previous_state(  );

                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                goto yy_find_action;
            }
        break;
        }

    default:
        YY_FATAL_ERROR(
            "fatal flex scanner internal error--no action found" );
    } /* end of action switch */
        } /* end of scanning one token */

Here is the call graph for this function:

static void yy_fatal_error ( yyconst char  msg[] )

static

static void yy_fatal_error ( yyconst char *  msg )

static

Definition at line 2777 of file verilog_lexer.cc.

{
        (void) fprintf( stderr, "%s\n", msg );
    exit( YY_EXIT_FAILURE );
}

static int yy_get_next_buffer ( void  )

static

Definition at line 2152 of file verilog_lexer.cc.

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    register char *source = (yytext_ptr);
    register int number_to_move, i;
    int ret_val;

    if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
        YY_FATAL_ERROR(
        "fatal flex scanner internal error--end of buffer missed" );

    if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
        { /* Don't try to fill the buffer, so this is an EOF. */
        if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
            {
            /* We matched a single character, the EOB, so
             * treat this as a final EOF.
             */
            return EOB_ACT_END_OF_FILE;
            }

        else
            {
            /* We matched some text prior to the EOB, first
             * process it.
             */
            return EOB_ACT_LAST_MATCH;
            }
        }

    /* Try to read more data. */

    /* First move last chars to start of buffer. */
    number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;

    for ( i = 0; i < number_to_move; ++i )
        *(dest++) = *(source++);

    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
        /* don't do the read, it's not guaranteed to return an EOF,
         * just force an EOF
         */
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;

    else
        {
            int num_to_read =
            YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

        while ( num_to_read <= 0 )
            { /* Not enough room in the buffer - grow it. */

            /* just a shorter name for the current buffer */
            YY_BUFFER_STATE b = YY_CURRENT_BUFFER;

            int yy_c_buf_p_offset =
                (int) ((yy_c_buf_p) - b->yy_ch_buf);

            if ( b->yy_is_our_buffer )
                {
                int new_size = b->yy_buf_size * 2;

                if ( new_size <= 0 )
                    b->yy_buf_size += b->yy_buf_size / 8;
                else
                    b->yy_buf_size *= 2;

                b->yy_ch_buf = (char *)
                    /* Include room in for 2 EOB chars. */
                    frontend_verilog_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                }
            else
                /* Can't grow it, we don't own it. */
                b->yy_ch_buf = 0;

            if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR(
                "fatal error - scanner input buffer overflow" );

            (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

            num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                        number_to_move - 1;

            }

        if ( num_to_read > YY_READ_BUF_SIZE )
            num_to_read = YY_READ_BUF_SIZE;

        /* Read in more data. */
        YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
            (yy_n_chars), (size_t) num_to_read );

        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    if ( (yy_n_chars) == 0 )
        {
        if ( number_to_move == YY_MORE_ADJ )
            {
            ret_val = EOB_ACT_END_OF_FILE;
            frontend_verilog_yyrestart(frontend_verilog_yyin  );
            }

        else
            {
            ret_val = EOB_ACT_LAST_MATCH;
            YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                YY_BUFFER_EOF_PENDING;
            }
        }

    else
        ret_val = EOB_ACT_CONTINUE_SCAN;

    if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
        /* Extend the array by 50%, plus the number we really need. */
        yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) frontend_verilog_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
        if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    }

    (yy_n_chars) += number_to_move;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

    (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 2286 of file verilog_lexer.cc.

{
    register yy_state_type yy_current_state;
    register char *yy_cp;
    
    yy_current_state = (yy_start);

    for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
        {
        register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
        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 >= 569 )
                yy_c = yy_meta[(unsigned int) yy_c];
            }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        }

    return yy_current_state;
}

Here is the caller graph for this function:

static int yy_init_globals ( void  )

static

Definition at line 2880 of file verilog_lexer.cc.

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from frontend_verilog_yylex_destroy(), so don't allocate here.
     */

    /* We do not touch frontend_verilog_yylineno unless the option is enabled. */
    frontend_verilog_yylineno =  1;
    
    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

/* Defined in main.c */
#ifdef YY_STDINIT
    frontend_verilog_yyin = stdin;
    frontend_verilog_yyout = stdout;
#else
    frontend_verilog_yyin = (FILE *) 0;
    frontend_verilog_yyout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * frontend_verilog_yylex_init()
     */
    return 0;
}

Here is the caller graph for this function:

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 2318 of file verilog_lexer.cc.

{
    register int yy_is_jam;
        register char *yy_cp = (yy_c_buf_p);

    register YY_CHAR yy_c = 1;
    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 >= 569 )
            yy_c = yy_meta[(unsigned int) yy_c];
        }
    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    yy_is_jam = (yy_current_state == 568);

    return yy_is_jam ? 0 : yy_current_state;
}

Here is the caller graph for this function:

Variable Documentation

int frontend_verilog_yy_flex_debug = 0

Definition at line 934 of file verilog_lexer.cc.

FILE * frontend_verilog_yyin = (FILE *) 0

Definition at line 381 of file verilog_lexer.cc.

int frontend_verilog_yyleng

Definition at line 316 of file verilog_lexer.cc.

int frontend_verilog_yylineno = 1

Definition at line 387 of file verilog_lexer.cc.

FILE * frontend_verilog_yyout = (FILE *) 0

Definition at line 381 of file verilog_lexer.cc.

char * frontend_verilog_yytext

Definition at line 945 of file verilog_lexer.cc.

yyconst flex_int16_t yy_accept[569]

static

Definition at line 417 of file verilog_lexer.cc.

register int yy_act

Definition at line 1207 of file verilog_lexer.cc.

yyconst flex_int16_t yy_base[592]

static

Definition at line 526 of file verilog_lexer.cc.

register char * yy_bp

Definition at line 1206 of file verilog_lexer.cc.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 296 of file verilog_lexer.cc.

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 295 of file verilog_lexer.cc.

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 294 of file verilog_lexer.cc.

char* yy_c_buf_p = (char *) 0

static

Definition at line 319 of file verilog_lexer.cc.

yyconst flex_int16_t yy_chk[1121]

static

Definition at line 793 of file verilog_lexer.cc.

register char* yy_cp

Definition at line 1206 of file verilog_lexer.cc.

YY_DECL

Initial value:

{
    register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 1204 of file verilog_lexer.cc.

yyconst flex_int16_t yy_def[592]

static

Definition at line 596 of file verilog_lexer.cc.

int yy_did_buffer_switch_on_eof

static

Definition at line 326 of file verilog_lexer.cc.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 483 of file verilog_lexer.cc.

char yy_hold_char

static

Definition at line 314 of file verilog_lexer.cc.

int yy_init = 0

static

Definition at line 320 of file verilog_lexer.cc.

char* yy_last_accepting_cpos

static

Definition at line 931 of file verilog_lexer.cc.

yy_state_type yy_last_accepting_state

static

Definition at line 930 of file verilog_lexer.cc.

yyconst flex_int32_t yy_meta[67]

static

Initial value:

=
    {   0,
        1,    2,    3,    4,    5,    1,    1,    1,    6,    1,
        1,    1,    1,    1,    1,    1,    7,    8,    9,    9,
        9,    1,    1,    1,    1,    1,   10,   11,   11,   11,
       11,    6,    6,    6,    1,    1,   11,    1,   11,   11,
       11,   11,   11,   11,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,   11,
        6,   11,    1,    1,    1,    1
    }

Definition at line 515 of file verilog_lexer.cc.

int yy_more_flag = 0

static

Definition at line 940 of file verilog_lexer.cc.

int yy_more_len = 0

static

Definition at line 941 of file verilog_lexer.cc.

int yy_n_chars

static

Definition at line 315 of file verilog_lexer.cc.

yyconst flex_int16_t yy_nxt[1121]

static

Definition at line 666 of file verilog_lexer.cc.

yyconst flex_int32_t yy_rule_can_match_eol[116]

static

Initial value:

=
    {   0,
0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0,     }

Definition at line 921 of file verilog_lexer.cc.

int yy_start = 0

static

Definition at line 321 of file verilog_lexer.cc.