version 1.33, 2008/02/26 19:03:15
|
version 1.34, 2008/12/02 20:34:01
|
|
|
|
/* To be inserted in other files to bypass the chksrc tests */ |
|
/* NOCHKSRC */ |
|
|
|
#line 2 "cimmof_lex.cpp" |
|
|
|
#line 4 "cimmof_lex.cpp" |
|
|
|
#define YY_INT_ALIGNED short int |
|
|
|
/* A lexical scanner generated by flex */ |
|
|
#define yy_create_buffer cimmof__create_buffer | #define yy_create_buffer cimmof__create_buffer |
#define yy_delete_buffer cimmof__delete_buffer | #define yy_delete_buffer cimmof__delete_buffer |
#define yy_scan_buffer cimmof__scan_buffer |
|
#define yy_scan_string cimmof__scan_string |
|
#define yy_scan_bytes cimmof__scan_bytes |
|
#define yy_flex_debug cimmof__flex_debug | #define yy_flex_debug cimmof__flex_debug |
#define yy_init_buffer cimmof__init_buffer | #define yy_init_buffer cimmof__init_buffer |
#define yy_flush_buffer cimmof__flush_buffer | #define yy_flush_buffer cimmof__flush_buffer |
|
|
#define yyin cimmof_in | #define yyin cimmof_in |
#define yyleng cimmof_leng | #define yyleng cimmof_leng |
#define yylex cimmof_lex | #define yylex cimmof_lex |
|
#define yylineno cimmof_lineno |
#define yyout cimmof_out | #define yyout cimmof_out |
#define yyrestart cimmof_restart | #define yyrestart cimmof_restart |
#define yytext cimmof_text | #define yytext cimmof_text |
#define yylineno cimmof_lineno |
|
#define yywrap cimmof_wrap | #define yywrap cimmof_wrap |
|
#define yyalloc cimmof_alloc |
#line 21 "cimmof_lex.cpp" |
#define yyrealloc cimmof_realloc |
/* A lexical scanner generated by flex*/ |
#define yyfree cimmof_free |
|
|
/* NOCHKSRC */ |
|
|
|
/* Scanner skeleton version: |
|
* $Header$ |
|
*/ |
|
| |
#define FLEX_SCANNER | #define FLEX_SCANNER |
#define YY_FLEX_MAJOR_VERSION 2 | #define YY_FLEX_MAJOR_VERSION 2 |
#define YY_FLEX_MINOR_VERSION 5 | #define YY_FLEX_MINOR_VERSION 5 |
|
#define YY_FLEX_SUBMINOR_VERSION 34 |
|
#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 <stdio.h> | #include <stdio.h> |
#include <unistd.h> |
#include <string.h> |
|
#include <errno.h> |
|
#include <stdlib.h> |
| |
|
/* end standard C headers. */ |
| |
/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ |
/* flex integer type definitions */ |
#ifdef c_plusplus |
|
#ifndef __cplusplus |
#ifndef FLEXINT_H |
#define __cplusplus |
#define FLEXINT_H |
#endif |
|
|
/* 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 | #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; |
|
#endif /* ! C99 */ |
| |
#ifdef __cplusplus |
/* 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 |
| |
#include <stdlib.h> |
#endif /* ! FLEXINT_H */ |
| |
/* Use prototypes in function declarations. */ |
#ifdef __cplusplus |
#define YY_USE_PROTOS |
|
| |
/* The "const" storage-class-modifier is valid. */ | /* The "const" storage-class-modifier is valid. */ |
#define YY_USE_CONST | #define YY_USE_CONST |
| |
#else /* ! __cplusplus */ | #else /* ! __cplusplus */ |
| |
#if __STDC__ |
/* C99 requires __STDC__ to be defined as 1. */ |
|
#if defined (__STDC__) |
| |
#define YY_USE_PROTOS |
|
#define YY_USE_CONST | #define YY_USE_CONST |
| |
#endif /* __STDC__ */ |
#endif /* defined (__STDC__) */ |
#endif /* ! __cplusplus */ | #endif /* ! __cplusplus */ |
| |
#ifdef __TURBOC__ |
|
#pragma warn -rch |
|
#pragma warn -use |
|
#include <io.h> |
|
#include <stdlib.h> |
|
#define YY_USE_CONST |
|
#define YY_USE_PROTOS |
|
#endif |
|
|
|
#ifdef YY_USE_CONST | #ifdef YY_USE_CONST |
#define yyconst const | #define yyconst const |
#else | #else |
#define yyconst | #define yyconst |
#endif | #endif |
| |
|
|
#ifdef YY_USE_PROTOS |
|
#define YY_PROTO(proto) proto |
|
#else |
|
#define YY_PROTO(proto) () |
|
#endif |
|
|
|
/* Returned upon end-of-file. */ | /* Returned upon end-of-file. */ |
#define YY_NULL 0 | #define YY_NULL 0 |
| |
|
|
* but we do it the disgusting crufty way forced on us by the ()-less | * but we do it the disgusting crufty way forced on us by the ()-less |
* definition of BEGIN. | * definition of BEGIN. |
*/ | */ |
#define BEGIN yy_start = 1 + 2 * |
#define BEGIN (yy_start) = 1 + 2 * |
| |
/* Translate the current start state into a value that can be later handed | /* 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 | * to BEGIN to return to the state. The YYSTATE alias is for lex |
* compatibility. | * compatibility. |
*/ | */ |
#define YY_START ((yy_start - 1) / 2) |
#define YY_START (((yy_start) - 1) / 2) |
#define YYSTATE YY_START | #define YYSTATE YY_START |
| |
/* Action number for EOF rule of a given start state. */ | /* Action number for EOF rule of a given start state. */ |
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) |
| |
/* Special action meaning "start processing a new file". */ | /* Special action meaning "start processing a new file". */ |
#define YY_NEW_FILE yyrestart( yyin ) |
#define YY_NEW_FILE cimmof_restart(cimmof_in ) |
| |
#define YY_END_OF_BUFFER_CHAR 0 | #define YY_END_OF_BUFFER_CHAR 0 |
| |
/* Size of default input buffer. */ | /* Size of default input buffer. */ |
|
#ifndef YY_BUF_SIZE |
#define YY_BUF_SIZE 16384 | #define YY_BUF_SIZE 16384 |
|
#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; | typedef struct yy_buffer_state *YY_BUFFER_STATE; |
|
#endif |
|
|
|
extern int cimmof_leng; |
| |
extern int yyleng; |
extern FILE *cimmof_in, *cimmof_out; |
extern FILE *yyin, *yyout; |
|
| |
#define EOB_ACT_CONTINUE_SCAN 0 | #define EOB_ACT_CONTINUE_SCAN 0 |
#define EOB_ACT_END_OF_FILE 1 | #define EOB_ACT_END_OF_FILE 1 |
#define EOB_ACT_LAST_MATCH 2 | #define EOB_ACT_LAST_MATCH 2 |
| |
/* The funky do-while in the following #define is used to turn the definition |
/* Note: We specifically omit the test for yy_rule_can_match_eol because it requires |
* int a single C statement (which needs a semi-colon terminator). This |
* access to the local variable yy_act. Since yyless() is a macro, it would break |
* avoids problems with code like: |
* existing scanners that call yyless() from OUTSIDE cimmof_lex. |
* |
* One obvious solution it to make yy_act a global. I tried that, and saw |
* if ( condition_holds ) |
* a 5% performance hit in a non-cimmof_lineno scanner, because yy_act is |
* yyless( 5 ); |
* normally declared as a register variable-- so it is not worth it. |
* else |
*/ |
* do_something_else(); |
#define YY_LESS_LINENO(n) \ |
* |
do { \ |
* Prior to using the do-while the compiler would get upset at the |
int yyl;\ |
* "else" because it interpreted the "if" statement as being all |
for ( yyl = n; yyl < cimmof_leng; ++yyl )\ |
* done when it reached the ';' after the yyless() call. |
if ( cimmof_text[yyl] == '\n' )\ |
*/ |
--cimmof_lineno;\ |
|
}while(0) |
/* Return all but the first 'n' matched characters back to the input stream. */ |
|
| |
|
/* Return all but the first "n" matched characters back to the input stream. */ |
#define yyless(n) \ | #define yyless(n) \ |
do \ | do \ |
{ \ | { \ |
/* Undo effects of setting up yytext. */ \ |
/* Undo effects of setting up cimmof_text. */ \ |
*yy_cp = yy_hold_char; \ |
int yyless_macro_arg = (n); \ |
|
YY_LESS_LINENO(yyless_macro_arg);\ |
|
*yy_cp = (yy_hold_char); \ |
YY_RESTORE_YY_MORE_OFFSET \ | YY_RESTORE_YY_MORE_OFFSET \ |
yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ |
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ |
YY_DO_BEFORE_ACTION; /* set up yytext again */ \ |
YY_DO_BEFORE_ACTION; /* set up cimmof_text again */ \ |
} \ | } \ |
while ( 0 ) | while ( 0 ) |
| |
#define unput(c) yyunput( c, yytext_ptr ) |
#define unput(c) yyunput( c, (yytext_ptr) ) |
|
|
/* Some routines like yy_flex_realloc() are emitted as static but are |
|
not called by all lexers. This generates warnings in some compilers, |
|
notably GCC. Arrange to suppress these. */ |
|
#ifdef __GNUC__ |
|
#define YY_MAY_BE_UNUSED __attribute__((unused)) |
|
#else |
|
#define YY_MAY_BE_UNUSED |
|
#endif |
|
| |
/* The following is because we cannot portably get our hands on size_t | /* The following is because we cannot portably get our hands on size_t |
* (without autoconf's help, which isn't available because we want | * (without autoconf's help, which isn't available because we want |
* flex-generated scanners to compile on their own). | * flex-generated scanners to compile on their own). |
|
* Given that the standard has decreed that size_t exists since 1989, |
|
* I guess we can afford to depend on it. Manoj. |
*/ | */ |
typedef unsigned int yy_size_t; |
|
| |
|
#ifndef YY_TYPEDEF_YY_SIZE_T |
|
#define YY_TYPEDEF_YY_SIZE_T |
|
typedef size_t yy_size_t; |
|
#endif |
| |
|
#ifndef YY_STRUCT_YY_BUFFER_STATE |
|
#define YY_STRUCT_YY_BUFFER_STATE |
struct yy_buffer_state | struct yy_buffer_state |
{ | { |
FILE *yy_input_file; | FILE *yy_input_file; |
|
|
*/ | */ |
int yy_at_bol; | 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 | /* Whether to try to fill the input buffer when we reach the |
* end of it. | * end of it. |
*/ | */ |
int yy_fill_buffer; | int yy_fill_buffer; |
| |
int yy_buffer_status; | int yy_buffer_status; |
|
|
#define YY_BUFFER_NEW 0 | #define YY_BUFFER_NEW 0 |
#define YY_BUFFER_NORMAL 1 | #define YY_BUFFER_NORMAL 1 |
/* When an EOF's been seen but there's still some text to process | /* When an EOF's been seen but there's still some text to process |
|
|
* possible backing-up. | * possible backing-up. |
* | * |
* When we actually see the EOF, we change the status to "new" | * When we actually see the EOF, we change the status to "new" |
* (via yyrestart()), so that the user can continue scanning by |
* (via cimmof_restart()), so that the user can continue scanning by |
* just pointing yyin at a new input file. |
* just pointing cimmof_in at a new input file. |
*/ | */ |
#define YY_BUFFER_EOF_PENDING 2 | #define YY_BUFFER_EOF_PENDING 2 |
|
|
}; | }; |
|
#endif /* !YY_STRUCT_YY_BUFFER_STATE */ |
| |
static YY_BUFFER_STATE yy_current_buffer = 0; |
/* 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 = 0; /**< Stack as an array. */ |
| |
/* We provide macros for accessing buffer states in case in the | /* We provide macros for accessing buffer states in case in the |
* future we want to put the buffer states in a more general | * future we want to put the buffer states in a more general |
* "scanner state". | * "scanner state". |
|
* |
|
* Returns the top of the stack, or NULL. |
*/ | */ |
#define YY_CURRENT_BUFFER yy_current_buffer |
#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. */ |
/* yy_hold_char holds the character lost when cimmof_text is formed. */ |
static char yy_hold_char; | static char yy_hold_char; |
|
|
static int yy_n_chars; /* number of characters read into yy_ch_buf */ | static int yy_n_chars; /* number of characters read into yy_ch_buf */ |
|
int cimmof_leng; |
|
|
int yyleng; |
|
| |
/* Points to current character in buffer. */ | /* Points to current character in buffer. */ |
static char *yy_c_buf_p = (char *) 0; | static char *yy_c_buf_p = (char *) 0; |
static int yy_init = 1; /* whether we need to initialize */ |
static int yy_init = 0; /* whether we need to initialize */ |
static int yy_start = 0; /* start state number */ | static int yy_start = 0; /* start state number */ |
| |
/* Flag which is used to allow yywrap()'s to do buffer switches |
/* Flag which is used to allow cimmof_wrap()'s to do buffer switches |
* instead of setting up a fresh yyin. A bit of a hack ... |
* instead of setting up a fresh cimmof_in. A bit of a hack ... |
*/ | */ |
static int yy_did_buffer_switch_on_eof; | static int yy_did_buffer_switch_on_eof; |
| |
void yyrestart YY_PROTO(( FILE *input_file )); |
void cimmof_restart (FILE *input_file ); |
|
void cimmof__switch_to_buffer (YY_BUFFER_STATE new_buffer ); |
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); |
YY_BUFFER_STATE cimmof__create_buffer (FILE *file,int size ); |
void yy_load_buffer_state YY_PROTO(( void )); |
void cimmof__delete_buffer (YY_BUFFER_STATE b ); |
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); |
void cimmof__flush_buffer (YY_BUFFER_STATE b ); |
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); |
void cimmof_push_buffer_state (YY_BUFFER_STATE new_buffer ); |
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); |
void cimmof_pop_buffer_state (void ); |
void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); |
|
#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) |
static void cimmof_ensure_buffer_stack (void ); |
|
static void cimmof__load_buffer_state (void ); |
YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); |
static void cimmof__init_buffer (YY_BUFFER_STATE b,FILE *file ); |
YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); |
|
YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); |
#define YY_FLUSH_BUFFER cimmof__flush_buffer(YY_CURRENT_BUFFER ) |
|
|
static void *yy_flex_alloc YY_PROTO(( yy_size_t )); |
YY_BUFFER_STATE cimmof__scan_buffer (char *base,yy_size_t size ); |
static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED; |
YY_BUFFER_STATE cimmof__scan_string (yyconst char *yy_str ); |
static void yy_flex_free YY_PROTO(( void * )); |
YY_BUFFER_STATE cimmof__scan_bytes (yyconst char *bytes,int len ); |
|
|
|
void *cimmof_alloc (yy_size_t ); |
|
void *cimmof_realloc (void *,yy_size_t ); |
|
void cimmof_free (void * ); |
| |
#define yy_new_buffer yy_create_buffer |
#define yy_new_buffer cimmof__create_buffer |
| |
#define yy_set_interactive(is_interactive) \ | #define yy_set_interactive(is_interactive) \ |
{ \ | { \ |
if ( ! yy_current_buffer ) \ |
if ( ! YY_CURRENT_BUFFER ){ \ |
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ |
cimmof_ensure_buffer_stack (); \ |
yy_current_buffer->yy_is_interactive = is_interactive; \ |
YY_CURRENT_BUFFER_LVALUE = \ |
|
cimmof__create_buffer(cimmof_in,YY_BUF_SIZE ); \ |
|
} \ |
|
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ |
} | } |
| |
#define yy_set_bol(at_bol) \ | #define yy_set_bol(at_bol) \ |
{ \ | { \ |
if ( ! yy_current_buffer ) \ |
if ( ! YY_CURRENT_BUFFER ){\ |
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ |
cimmof_ensure_buffer_stack (); \ |
yy_current_buffer->yy_at_bol = at_bol; \ |
YY_CURRENT_BUFFER_LVALUE = \ |
|
cimmof__create_buffer(cimmof_in,YY_BUF_SIZE ); \ |
|
} \ |
|
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ |
} | } |
| |
#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) |
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) |
| |
|
/* Begin user sect3 */ |
| |
#define YY_USES_REJECT |
|
typedef unsigned char YY_CHAR; | typedef unsigned char YY_CHAR; |
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; |
|
|
FILE *cimmof_in = (FILE *) 0, *cimmof_out = (FILE *) 0; |
|
|
typedef int yy_state_type; | typedef int yy_state_type; |
extern int yylineno; |
|
int yylineno = 1; |
extern int cimmof_lineno; |
extern char *yytext; |
|
#define yytext_ptr yytext |
int cimmof_lineno = 1; |
|
|
static yy_state_type yy_get_previous_state YY_PROTO(( void )); |
extern char *cimmof_text; |
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); |
#define yytext_ptr cimmof_text |
static int yy_get_next_buffer YY_PROTO(( void )); |
|
static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); |
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[] ); |
| |
/* Done after the current pattern has been matched and before the | /* Done after the current pattern has been matched and before the |
* corresponding action - sets up yytext. |
* corresponding action - sets up cimmof_text. |
*/ | */ |
#define YY_DO_BEFORE_ACTION \ | #define YY_DO_BEFORE_ACTION \ |
yytext_ptr = yy_bp; \ |
(yytext_ptr) = yy_bp; \ |
yyleng = (int) (yy_cp - yy_bp); \ |
cimmof_leng = (size_t) (yy_cp - yy_bp); \ |
yy_hold_char = *yy_cp; \ |
(yy_hold_char) = *yy_cp; \ |
*yy_cp = '\0'; \ | *yy_cp = '\0'; \ |
yy_c_buf_p = yy_cp; |
(yy_c_buf_p) = yy_cp; |
| |
#define YY_NUM_RULES 83 | #define YY_NUM_RULES 83 |
#define YY_END_OF_BUFFER 84 | #define YY_END_OF_BUFFER 84 |
static yyconst short int yy_acclist[419] = |
/* 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 yyconst flex_int16_t yy_accept[300] = |
{ 0, | { 0, |
84, 82, 83, 3, 82, 83, 1, 83, 22, 82, |
0, 0, 0, 0, 0, 0, 84, 82, 3, 1, |
83, 82, 83, 82, 83, 82, 83, 9, 82, 83, |
22, 82, 82, 82, 9, 10, 82, 20, 42, 82, |
10, 82, 83, 82, 83, 20, 82, 83, 42, 82, |
18, 17, 17, 11, 12, 19, 81, 81, 81, 81, |
83, 82, 83, 18, 82, 83, 17, 18, 82, 83, |
|
17, 18, 82, 83, 11, 82, 83, 12, 82, 83, |
|
19, 82, 83, 81, 82, 83, 81, 82, 83, 81, |
|
82, 83, 81, 82, 83, 81, 82, 83, 81, 82, |
|
83, 81, 82, 83, 81, 82, 83, 81, 82, 83, |
|
81, 82, 83, 81, 82, 83, 81, 82, 83, 81, |
|
82, 83, 81, 82, 83, 81, 82, 83, 81, 82, |
|
|
|
83, 81, 82, 83, 7, 82, 83, 8, 82, 83, |
|
81, 82, 83, 5, 82, 83, 6, 82, 83, 35, |
|
83, 24, 83, 23, 83, 83, 37, 83, 83, 36, |
|
37, 83, 64, 18, 18, 18, 13, 38, 2, 14, |
|
18, 14, 18, 16, 17, 18, 17, 18, 81, 81, |
|
65, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
|
81, 81, 45, 81, 81, 81, 81, 81, 81, 81, |
|
81, 81, 81, 81, 81, 35, 34, 31, 34, 30, |
|
34, 33, 34, 32, 34, 25, 34, 26, 34, 27, |
|
34, 28, 34, 29, 34, 36, 21, 2, 2, 15, |
|
|
|
55, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
|
81, 81, 81, 81, 81, 81, 81, 81, 81, 56, |
|
81, 81, 81, 81, 81, 81, 81, 81, 81, 81, | 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
81, 36, 13, 81, 81, 81, 81, 81, 81, 81, |
81, 81, 81, 7, 8, 81, 5, 6, 35, 24, |
81, 81, 81, 81, 81, 39, 81, 81, 81, 81, |
23, 83, 37, 83, 36, 0, 64, 0, 0, 18, |
81, 81, 81, 81, 81, 81, 81, 81, 81, 40, |
18, 18, 13, 38, 2, 14, 14, 16, 0, 17, |
81, 81, 81, 36, 81, 81, 81, 79, 81, 81, |
17, 81, 81, 65, 81, 81, 81, 81, 81, 81, |
81, 81, 41, 81, 81, 81, 81, 81, 81, 81, |
81, 81, 81, 81, 45, 81, 81, 81, 81, 81, |
81, 81, 81, 81, 81, 81, 81, 47, 81, 81, |
81, 81, 81, 81, 81, 81, 35, 34, 31, 30, |
81, 81, 73, 81, 81, 81, 81, 81, 81, 81, |
|
|
|
69, 81, 4, 81, 81, 81, 80, 81, 81, 81, |
|
81, 57, 81, 81, 81, 81, 53, 81, 81, 81, |
|
81, 77, 81, 78, 81, 81, 81, 48, 81, 74, |
|
81, 75, 81, 76, 81, 66, 81, 81, 81, 70, |
|
81, 71, 81, 72, 81, 43, 81, 67, 81, 81, |
|
81, 81, 63, 81, 81, 81, 81, 81, 81, 81, |
|
81, 81, 81, 81, 68, 81, 81, 81, 81, 44, |
|
81, 81, 51, 81, 81, 81, 81, 81, 81, 81, |
|
81, 81, 81, 54, 81, 46, 81, 52, 81, 81, |
|
81, 81, 81, 81, 81, 50, 81, 60, 81, 61, |
|
|
|
81, 81, 49, 81, 81, 81, 81, 81, 81, 62, |
|
81, 81, 81, 81, 58, 81, 59, 81 |
|
} ; |
|
| |
static yyconst short int yy_accept[301] = |
33, 32, 25, 26, 27, 28, 29, 36, 0, 21, |
{ 0, |
0, 2, 2, 15, 55, 81, 81, 81, 81, 81, |
1, 1, 1, 1, 1, 1, 1, 2, 4, 7, |
81, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
9, 12, 14, 16, 18, 21, 24, 26, 29, 32, |
81, 81, 56, 81, 81, 81, 81, 81, 81, 81, |
34, 37, 41, 45, 48, 51, 54, 57, 60, 63, |
81, 81, 81, 36, 0, 0, 13, 81, 81, 81, |
66, 69, 72, 75, 78, 81, 84, 87, 90, 93, |
81, 81, 81, 81, 81, 81, 81, 81, 81, 39, |
96, 99, 102, 105, 108, 111, 114, 117, 120, 122, |
81, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
124, 126, 127, 129, 130, 133, 133, 134, 134, 134, |
81, 81, 40, 81, 81, 36, 0, 81, 81, 81, |
135, 136, 137, 138, 139, 140, 142, 144, 145, 145, |
79, 81, 81, 81, 41, 81, 81, 81, 81, 81, |
147, 149, 150, 151, 153, 154, 155, 156, 157, 158, |
81, 81, 81, 81, 81, 81, 81, 81, 47, 81, |
159, 160, 161, 162, 163, 165, 166, 167, 168, 169, |
|
170, 171, 172, 173, 174, 175, 176, 177, 178, 180, |
81, 81, 73, 81, 81, 81, 81, 81, 81, 69, |
|
4, 0, 81, 81, 80, 81, 81, 81, 57, 81, |
182, 184, 186, 188, 190, 192, 194, 196, 197, 197, |
81, 81, 53, 81, 81, 81, 77, 78, 81, 81, |
198, 198, 199, 200, 201, 203, 204, 205, 206, 207, |
48, 74, 75, 76, 66, 81, 81, 70, 71, 72, |
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, |
43, 81, 67, 81, 81, 81, 63, 81, 81, 81, |
218, 219, 220, 222, 223, 224, 225, 226, 227, 228, |
81, 81, 81, 81, 81, 81, 81, 68, 81, 81, |
229, 230, 231, 232, 233, 233, 233, 234, 235, 236, |
81, 44, 81, 51, 81, 81, 81, 81, 81, 81, |
237, 238, 239, 240, 241, 242, 243, 244, 245, 246, |
81, 81, 81, 54, 46, 52, 81, 81, 81, 81, |
248, 249, 250, 251, 252, 253, 254, 255, 256, 257, |
81, 81, 50, 60, 61, 81, 49, 81, 81, 81, |
258, 259, 260, 262, 263, 264, 265, 265, 266, 267, |
81, 81, 62, 81, 81, 81, 58, 59, 0 |
268, 270, 271, 272, 273, 275, 276, 277, 278, 279, |
|
280, 281, 282, 283, 284, 285, 286, 287, 288, 290, |
|
|
|
291, 292, 293, 295, 296, 297, 298, 299, 300, 301, |
|
303, 305, 305, 306, 307, 309, 310, 311, 312, 314, |
|
315, 316, 317, 319, 320, 321, 322, 324, 326, 327, |
|
328, 330, 332, 334, 336, 338, 339, 340, 342, 344, |
|
346, 347, 348, 350, 351, 352, 353, 355, 356, 357, |
|
358, 359, 360, 361, 362, 363, 364, 365, 367, 368, |
|
369, 370, 372, 373, 375, 376, 377, 378, 379, 380, |
|
381, 382, 383, 384, 386, 388, 390, 391, 392, 393, |
|
394, 395, 396, 398, 400, 402, 403, 405, 406, 407, |
|
408, 409, 410, 412, 413, 414, 415, 417, 419, 419 |
|
| |
} ; | } ; |
| |
static yyconst int yy_ec[256] = |
static yyconst flex_int32_t yy_ec[256] = |
{ 0, | { 0, |
1, 1, 1, 1, 1, 1, 1, 1, 2, 3, | 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, |
1, 1, 4, 1, 1, 1, 1, 1, 1, 1, | 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, |
|
|
1, 1, 1, 1, 1 | 1, 1, 1, 1, 1 |
} ; | } ; |
| |
static yyconst int yy_meta[66] = |
static yyconst flex_int32_t yy_meta[66] = |
{ 0, | { 0, |
1, 1, 2, 1, 3, 1, 4, 1, 1, 1, | 1, 1, 2, 1, 3, 1, 4, 1, 1, 1, |
1, 5, 1, 6, 1, 7, 7, 7, 7, 7, | 1, 5, 1, 6, 1, 7, 7, 7, 7, 7, |
|
|
4, 4, 4, 1, 1 | 4, 4, 4, 1, 1 |
} ; | } ; |
| |
static yyconst short int yy_base[315] = |
static yyconst flex_int16_t yy_base[315] = |
{ 0, | { 0, |
0, 0, 63, 64, 114, 169, 595, 596, 596, 596, | 0, 0, 63, 64, 114, 169, 595, 596, 596, 596, |
596, 552, 0, 0, 596, 596, 56, 596, 58, 72, | 596, 552, 0, 0, 596, 596, 56, 596, 58, 72, |
|
|
519, 522, 527, 528 | 519, 522, 527, 528 |
} ; | } ; |
| |
static yyconst short int yy_def[315] = |
static yyconst flex_int16_t yy_def[315] = |
{ 0, | { 0, |
299, 1, 300, 300, 301, 301, 299, 299, 299, 299, | 299, 1, 300, 300, 301, 301, 299, 299, 299, 299, |
299, 299, 302, 303, 299, 299, 304, 299, 299, 299, | 299, 299, 302, 303, 299, 299, 304, 299, 299, 299, |
|
|
299, 299, 299, 299 | 299, 299, 299, 299 |
} ; | } ; |
| |
static yyconst short int yy_nxt[662] = |
static yyconst flex_int16_t yy_nxt[662] = |
{ 0, | { 0, |
8, 9, 10, 9, 11, 12, 13, 14, 15, 16, | 8, 9, 10, 9, 11, 12, 13, 14, 15, 16, |
8, 17, 18, 19, 20, 21, 22, 23, 23, 23, | 8, 17, 18, 19, 20, 21, 22, 23, 23, 23, |
|
|
299 | 299 |
} ; | } ; |
| |
static yyconst short int yy_chk[662] = |
static yyconst flex_int16_t yy_chk[662] = |
{ 0, | { 0, |
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, |
|
|
299 | 299 |
} ; | } ; |
| |
static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr; |
/* Table of booleans, true if rule could match eol. */ |
static char *yy_full_match; |
static yyconst flex_int32_t yy_rule_can_match_eol[84] = |
static int yy_lp; |
{ 0, |
#define REJECT \ |
1, 1, 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, 1, 0, 0, 0, 0, 0, |
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \ |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
yy_cp = yy_full_match; /* restore poss. backed-over text */ \ |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
++yy_lp; \ |
0, 0, 0, 0, }; |
goto find_rule; \ |
|
} |
static yy_state_type yy_last_accepting_state; |
|
static char *yy_last_accepting_cpos; |
|
|
|
extern int cimmof__flex_debug; |
|
int cimmof__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 yymore() yymore_used_but_not_detected |
#define YY_MORE_ADJ 0 | #define YY_MORE_ADJ 0 |
#define YY_RESTORE_YY_MORE_OFFSET | #define YY_RESTORE_YY_MORE_OFFSET |
char *yytext; |
char *cimmof_text; |
#line 1 "cimmof.l" | #line 1 "cimmof.l" |
#define INITIAL 0 |
/* |
/*//%2006////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
|
// |
|
// Licensed to The Open Group (TOG) under one or more contributor license |
|
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
|
// this work for additional information regarding copyright ownership. |
|
// Each contributor licenses this file to you under the OpenPegasus Open |
|
// Source License; you may not use this file except in compliance with the |
|
// License. |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Permission is hereby granted, free of charge, to any person obtaining a |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// copy of this software and associated documentation files (the "Software"), |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
// to deal in the Software without restriction, including without limitation |
// IBM Corp.; EMC Corporation, The Open Group. |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
// and/or sell copies of the Software, and to permit persons to whom the |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Software is furnished to do so, subject to the following conditions: |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
|
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
// The above copyright notice and this permission notice shall be included |
// of this software and associated documentation files (the "Software"), to |
// in all copies or substantial portions of the Software. |
// deal in the Software without restriction, including without limitation the |
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
|
// sell copies of the Software, and to permit persons to whom the Software is |
|
// furnished to do so, subject to the following conditions: |
|
// | // |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
// | // |
//============================================================================*/ |
////////////////////////////////////////////////////////////////////////// |
#define YY_NEVER_INTERACTIVE 1 |
*/ |
#define YY_STACK_USED 1 |
|
#line 36 "cimmof.l" | #line 36 "cimmof.l" |
| |
/* NOCHKSRC */ |
|
#include "cimmofParser.h" | #include "cimmofParser.h" |
#include "memobjs.h" | #include "memobjs.h" |
#include "cimmof_tab.h" | #include "cimmof_tab.h" |
|
|
| |
/* Avoid warn_unused_result warnings in Linux RPM build */ | /* Avoid warn_unused_result warnings in Linux RPM build */ |
#ifndef ECHO | #ifndef ECHO |
# define ECHO do { size_t ignored = fwrite(yytext, yyleng, 1, yyout); } while(0) |
# define ECHO do { size_t ignored = fwrite(cimmof_text, cimmof_leng, 1, cimmof_out); } while(0) |
#endif | #endif |
| |
/*---------------------------------------------------------------*/ | /*---------------------------------------------------------------*/ |
|
|
} | } |
| |
void * create_cimmof_buffer_wrapper(const FILE *f, int size) { | void * create_cimmof_buffer_wrapper(const FILE *f, int size) { |
return (void *)yy_create_buffer((FILE *)f, size); |
return (void *)cimmof__create_buffer((FILE *)f,size); |
} | } |
| |
int switch_to_buffer_wrapper(void *buffstate, Boolean closeCurrent) { | int switch_to_buffer_wrapper(void *buffstate, Boolean closeCurrent) { |
if (closeCurrent) | if (closeCurrent) |
{ | { |
if (yyin != NULL) |
if (cimmof_in != NULL) |
{ | { |
fflush(yyin); |
fflush(cimmof_in); |
fclose(yyin); |
fclose(cimmof_in); |
yyin = NULL; |
cimmof_in = NULL; |
} | } |
yy_delete_buffer(YY_CURRENT_BUFFER); |
cimmof__delete_buffer(YY_CURRENT_BUFFER); |
} | } |
yy_switch_to_buffer((YY_BUFFER_STATE)buffstate); |
cimmof__switch_to_buffer((YY_BUFFER_STATE)buffstate); |
return 0; | return 0; |
} | } |
| |
char strbuf[1024], *strbuf_p, slashx[2]; | char strbuf[1024], *strbuf_p, slashx[2]; |
| |
| |
|
|
|
#line 830 "cimmof_lex.cpp" |
|
|
|
#define INITIAL 0 |
#define myStr 1 | #define myStr 1 |
#define myHex 2 | #define myHex 2 |
| |
#line 785 "cimmof_lex.cpp" |
#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 ); |
| |
/* Macros after this point can all be overridden by user definitions in | /* Macros after this point can all be overridden by user definitions in |
* section 1. | * section 1. |
|
|
| |
#ifndef YY_SKIP_YYWRAP | #ifndef YY_SKIP_YYWRAP |
#ifdef __cplusplus | #ifdef __cplusplus |
extern "C" int yywrap YY_PROTO(( void )); |
extern "C" int cimmof_wrap (void ); |
#else | #else |
extern int yywrap YY_PROTO(( void )); |
extern int cimmof_wrap (void ); |
#endif | #endif |
#endif | #endif |
| |
#ifndef YY_NO_UNPUT |
static void yyunput (int c,char *buf_ptr ); |
static void yyunput YY_PROTO(( int c, char *buf_ptr )); |
|
#endif |
|
| |
#ifndef yytext_ptr | #ifndef yytext_ptr |
static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); |
static void yy_flex_strncpy (char *,yyconst char *,int ); |
#endif | #endif |
| |
#ifdef YY_NEED_STRLEN | #ifdef YY_NEED_STRLEN |
static int yy_flex_strlen YY_PROTO(( yyconst char * )); |
static int yy_flex_strlen (yyconst char * ); |
#endif | #endif |
| |
#ifndef YY_NO_INPUT | #ifndef YY_NO_INPUT |
|
|
#ifdef __cplusplus | #ifdef __cplusplus |
static int yyinput YY_PROTO(( void )); |
static int yyinput (void ); |
#else | #else |
static int input YY_PROTO(( void )); |
static int input (void ); |
#endif | #endif |
|
|
#endif | #endif |
| |
#if YY_STACK_USED |
|
static int yy_start_stack_ptr = 0; | static int yy_start_stack_ptr = 0; |
static int yy_start_stack_depth = 0; | static int yy_start_stack_depth = 0; |
static int *yy_start_stack = 0; |
static int *yy_start_stack = NULL; |
#ifndef YY_NO_PUSH_STATE |
|
static void yy_push_state YY_PROTO(( int new_state )); |
|
#endif |
|
#ifndef YY_NO_POP_STATE |
|
static void yy_pop_state YY_PROTO(( void )); |
|
#endif |
|
#ifndef YY_NO_TOP_STATE |
|
static int yy_top_state YY_PROTO(( void )); |
|
#endif |
|
| |
#else |
static void yy_push_state (int new_state ); |
#define YY_NO_PUSH_STATE 1 |
|
#define YY_NO_POP_STATE 1 |
|
#define YY_NO_TOP_STATE 1 |
|
#endif |
|
| |
#ifdef YY_MALLOC_DECL |
static void yy_pop_state (void ); |
YY_MALLOC_DECL |
|
#else |
static int yy_top_state (void ); |
#if __STDC__ |
|
#ifndef __cplusplus |
|
#include <stdlib.h> |
|
#endif |
|
#else |
|
/* Just try to get by without declaring the routines. This will fail |
|
* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) |
|
* or sizeof(void*) != sizeof(int). |
|
*/ |
|
#endif |
|
#endif |
|
| |
/* Amount of stuff to slurp up with each read. */ | /* Amount of stuff to slurp up with each read. */ |
#ifndef YY_READ_BUF_SIZE | #ifndef YY_READ_BUF_SIZE |
|
|
#endif | #endif |
| |
/* Copy whatever the last rule matched to the standard output. */ | /* Copy whatever the last rule matched to the standard output. */ |
|
|
#ifndef ECHO | #ifndef ECHO |
/* This used to be an fputs(), but since the string might contain NUL's, | /* This used to be an fputs(), but since the string might contain NUL's, |
* we now use fwrite(). | * we now use fwrite(). |
*/ | */ |
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) |
#define ECHO fwrite( cimmof_text, cimmof_leng, 1, cimmof_out ) |
#endif | #endif |
| |
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, | /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, |
|
|
*/ | */ |
#ifndef YY_INPUT | #ifndef YY_INPUT |
#define YY_INPUT(buf,result,max_size) \ | #define YY_INPUT(buf,result,max_size) \ |
if ( yy_current_buffer->yy_is_interactive ) \ |
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ |
{ \ | { \ |
int c = '*', n; \ |
int c = '*'; \ |
|
int n; \ |
for ( n = 0; n < max_size && \ | for ( n = 0; n < max_size && \ |
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \ |
(c = getc( cimmof_in )) != EOF && c != '\n'; ++n ) \ |
buf[n] = (char) c; \ | buf[n] = (char) c; \ |
if ( c == '\n' ) \ | if ( c == '\n' ) \ |
buf[n++] = (char) c; \ | buf[n++] = (char) c; \ |
if ( c == EOF && ferror( yyin ) ) \ |
if ( c == EOF && ferror( cimmof_in ) ) \ |
YY_FATAL_ERROR( "input in flex scanner failed" ); \ | YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
result = n; \ | result = n; \ |
} \ | } \ |
else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ |
else \ |
&& ferror( yyin ) ) \ |
{ \ |
YY_FATAL_ERROR( "input in flex scanner failed" ); |
errno=0; \ |
|
while ( (result = fread(buf, 1, max_size, cimmof_in))==0 && ferror(cimmof_in)) \ |
|
{ \ |
|
if( errno != EINTR) \ |
|
{ \ |
|
YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
|
break; \ |
|
} \ |
|
errno=0; \ |
|
clearerr(cimmof_in); \ |
|
} \ |
|
}\ |
|
\ |
|
|
#endif | #endif |
| |
/* No semi-colon after return; correct usage is to write "yyterminate();" - | /* No semi-colon after return; correct usage is to write "yyterminate();" - |
|
|
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) |
#endif | #endif |
| |
|
/* end tables serialization structures and prototypes */ |
|
|
/* Default declaration of generated scanner - a define so the user can | /* Default declaration of generated scanner - a define so the user can |
* easily add parameters. | * easily add parameters. |
*/ | */ |
#ifndef YY_DECL | #ifndef YY_DECL |
#define YY_DECL int yylex YY_PROTO(( void )) |
#define YY_DECL_IS_OURS 1 |
#endif |
|
|
extern int cimmof_lex (void); |
| |
/* Code executed at the beginning of each rule, after yytext and yyleng |
#define YY_DECL int cimmof_lex (void) |
|
#endif /* !YY_DECL */ |
|
|
|
/* Code executed at the beginning of each rule, after cimmof_text and cimmof_leng |
* have been set up. | * have been set up. |
*/ | */ |
#ifndef YY_USER_ACTION | #ifndef YY_USER_ACTION |
|
|
#define YY_RULE_SETUP \ | #define YY_RULE_SETUP \ |
YY_USER_ACTION | YY_USER_ACTION |
| |
|
/** The main scanner function which does all the work. |
|
*/ |
YY_DECL | YY_DECL |
{ | { |
register yy_state_type yy_current_state; | register yy_state_type yy_current_state; |
register char *yy_cp = NULL, *yy_bp = NULL; |
register char *yy_cp, *yy_bp; |
register int yy_act; | register int yy_act; |
| |
#line 90 "cimmof.l" | #line 90 "cimmof.l" |
| |
| |
| |
#line 940 "cimmof_lex.cpp" |
#line 999 "cimmof_lex.cpp" |
| |
if ( yy_init ) |
if ( !(yy_init) ) |
{ | { |
yy_init = 0; |
(yy_init) = 1; |
| |
#ifdef YY_USER_INIT | #ifdef YY_USER_INIT |
YY_USER_INIT; | YY_USER_INIT; |
#endif | #endif |
| |
if ( ! yy_start ) |
if ( ! (yy_start) ) |
yy_start = 1; /* first start state */ |
(yy_start) = 1; /* first start state */ |
| |
if ( ! yyin ) |
if ( ! cimmof_in ) |
yyin = stdin; |
cimmof_in = stdin; |
| |
if ( ! yyout ) |
if ( ! cimmof_out ) |
yyout = stdout; |
cimmof_out = stdout; |
| |
if ( ! yy_current_buffer ) |
if ( ! YY_CURRENT_BUFFER ) { |
yy_current_buffer = |
cimmof_ensure_buffer_stack (); |
yy_create_buffer( yyin, YY_BUF_SIZE ); |
YY_CURRENT_BUFFER_LVALUE = |
|
cimmof__create_buffer(cimmof_in,YY_BUF_SIZE ); |
|
} |
| |
yy_load_buffer_state(); |
cimmof__load_buffer_state( ); |
} | } |
| |
while ( 1 ) /* loops until end-of-file is reached */ | while ( 1 ) /* loops until end-of-file is reached */ |
{ | { |
yy_cp = yy_c_buf_p; |
yy_cp = (yy_c_buf_p); |
| |
/* Support of yytext. */ |
/* Support of cimmof_text. */ |
*yy_cp = yy_hold_char; |
*yy_cp = (yy_hold_char); |
| |
/* yy_bp points to the position in yy_ch_buf of the start of | /* yy_bp points to the position in yy_ch_buf of the start of |
* the current run. | * the current run. |
*/ | */ |
yy_bp = yy_cp; | yy_bp = yy_cp; |
| |
yy_current_state = yy_start; |
yy_current_state = (yy_start); |
yy_state_ptr = yy_state_buf; |
|
*yy_state_ptr++ = yy_current_state; |
|
yy_match: | yy_match: |
do | do |
{ | { |
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; | 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 ) | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
{ | { |
yy_current_state = (int) yy_def[yy_current_state]; | yy_current_state = (int) yy_def[yy_current_state]; |
|
|
yy_c = yy_meta[(unsigned int) yy_c]; | yy_c = yy_meta[(unsigned int) yy_c]; |
} | } |
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; | yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
*yy_state_ptr++ = yy_current_state; |
|
++yy_cp; | ++yy_cp; |
} | } |
while ( yy_base[yy_current_state] != 596 ); |
while ( yy_current_state != 299 ); |
|
yy_cp = (yy_last_accepting_cpos); |
|
yy_current_state = (yy_last_accepting_state); |
| |
yy_find_action: | yy_find_action: |
yy_current_state = *--yy_state_ptr; |
yy_act = yy_accept[yy_current_state]; |
yy_lp = yy_accept[yy_current_state]; |
|
find_rule: /* we branch to this label when backing up */ |
|
for ( ; ; ) /* until we find what rule we matched */ |
|
{ |
|
if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] ) |
|
{ |
|
yy_act = yy_acclist[yy_lp]; |
|
{ |
|
yy_full_match = yy_cp; |
|
break; |
|
} |
|
} |
|
--yy_cp; |
|
yy_current_state = *--yy_state_ptr; |
|
yy_lp = yy_accept[yy_current_state]; |
|
} |
|
| |
YY_DO_BEFORE_ACTION; | YY_DO_BEFORE_ACTION; |
| |
if ( yy_act != YY_END_OF_BUFFER ) |
if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) |
{ | { |
int yyl; | int yyl; |
for ( yyl = 0; yyl < yyleng; ++yyl ) |
for ( yyl = 0; yyl < cimmof_leng; ++yyl ) |
if ( yytext[yyl] == '\n' ) |
if ( cimmof_text[yyl] == '\n' ) |
++yylineno; |
|
|
cimmof_lineno++; |
|
; |
} | } |
| |
do_action: /* This label is used only to access EOF actions. */ | do_action: /* This label is used only to access EOF actions. */ |
| |
|
|
switch ( yy_act ) | switch ( yy_act ) |
{ /* beginning of action switch */ | { /* 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: | case 1: |
|
/* rule 1 can match eol */ |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 93 "cimmof.l" | #line 93 "cimmof.l" |
{ cimmofParser::Instance()->increment_lineno(); } | { cimmofParser::Instance()->increment_lineno(); } |
YY_BREAK | YY_BREAK |
case 2: | case 2: |
|
/* rule 2 can match eol */ |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 94 "cimmof.l" | #line 94 "cimmof.l" |
{ cimmofParser::Instance()->increment_lineno(); } | { cimmofParser::Instance()->increment_lineno(); } |
|
|
YY_RULE_SETUP | YY_RULE_SETUP |
#line 105 "cimmof.l" | #line 105 "cimmof.l" |
{ | { |
cimmof_lval.strval = new String(yytext); |
cimmof_lval.strval = new String(cimmof_text); |
return(TOK_REAL_VALUE); } | return(TOK_REAL_VALUE); } |
YY_BREAK | YY_BREAK |
case 14: | case 14: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 108 "cimmof.l" | #line 108 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_OCTAL_VALUE); } | return(TOK_OCTAL_VALUE); } |
YY_BREAK | YY_BREAK |
case 15: | case 15: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 110 "cimmof.l" | #line 110 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_HEX_VALUE); } | return(TOK_HEX_VALUE); } |
YY_BREAK | YY_BREAK |
case 16: | case 16: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 112 "cimmof.l" | #line 112 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_BINARY_VALUE); } | return(TOK_BINARY_VALUE); } |
YY_BREAK | YY_BREAK |
case 17: | case 17: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 114 "cimmof.l" | #line 114 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_POSITIVE_DECIMAL_VALUE); } | return(TOK_POSITIVE_DECIMAL_VALUE); } |
YY_BREAK | YY_BREAK |
case 18: | case 18: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 116 "cimmof.l" | #line 116 "cimmof.l" |
{ /* Note: All non-zero unsigned integers are handled above */ | { /* Note: All non-zero unsigned integers are handled above */ |
cimmof_lval.strval = new String(yytext); |
cimmof_lval.strval = new String(cimmof_text); |
return(TOK_SIGNED_DECIMAL_VALUE); } | return(TOK_SIGNED_DECIMAL_VALUE); } |
YY_BREAK | YY_BREAK |
case 19: | case 19: |
|
|
case 21: | case 21: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 121 "cimmof.l" | #line 121 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_CHAR_VALUE); } | return(TOK_CHAR_VALUE); } |
YY_BREAK | YY_BREAK |
/*--- bugzilla 544 fix; handle string escapes --- | /*--- bugzilla 544 fix; handle string escapes --- |
|
|
an impl. decision: invalid escape sequences | an impl. decision: invalid escape sequences |
are simply ignored, and left in the string. | are simply ignored, and left in the string. |
| |
an impl. decision: yyleng is set to the len |
an impl. decision: cimmof_leng is set to the len |
of resulting string, not the len of the matched | of resulting string, not the len of the matched |
token(s), since they are different, with escapes. | token(s), since they are different, with escapes. |
(but note; cimmof.y does not use yyleng!) |
(but note; cimmof.y does not use cimmof_leng!) |
| |
an impl. req't: strings are returned to parser | an impl. req't: strings are returned to parser |
with [no kidding!] enclosing "s. | with [no kidding!] enclosing "s. |
|
|
case YY_STATE_EOF(myStr): | case YY_STATE_EOF(myStr): |
#line 145 "cimmof.l" | #line 145 "cimmof.l" |
case 24: | case 24: |
|
/* rule 24 can match eol */ |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 146 "cimmof.l" | #line 146 "cimmof.l" |
{ BEGIN(INITIAL); | { BEGIN(INITIAL); |
|
|
YY_RULE_SETUP | YY_RULE_SETUP |
#line 159 "cimmof.l" | #line 159 "cimmof.l" |
{ yy_push_state(myHex); | { yy_push_state(myHex); |
memcpy(slashx,yytext,2); |
memcpy(slashx,cimmof_text,2); |
} | } |
YY_BREAK | YY_BREAK |
case 34: | case 34: |
|
/* rule 34 can match eol */ |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 162 "cimmof.l" | #line 162 "cimmof.l" |
{ *strbuf_p++ = '\\'; | { *strbuf_p++ = '\\'; |
*strbuf_p++ = yytext[1]; } |
*strbuf_p++ = cimmof_text[1]; } |
YY_BREAK | YY_BREAK |
case 35: | case 35: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 164 "cimmof.l" | #line 164 "cimmof.l" |
{ char *t = yytext; |
{ char *t = cimmof_text; |
while( *t ) *strbuf_p++ = *t++; | while( *t ) *strbuf_p++ = *t++; |
*strbuf_p = '\0'; } | *strbuf_p = '\0'; } |
YY_BREAK | YY_BREAK |
|
|
#line 167 "cimmof.l" | #line 167 "cimmof.l" |
{ /* get escaped hex digits */ | { /* get escaped hex digits */ |
char hexfmt[4]; unsigned int n; | char hexfmt[4]; unsigned int n; |
sprintf( hexfmt, "%%%dx", yyleng ); |
sprintf( hexfmt, "%%%dx", cimmof_leng ); |
sscanf(yytext, hexfmt, &n); |
sscanf(cimmof_text, hexfmt, &n); |
if (n>255) { | if (n>255) { |
memcpy(strbuf_p,slashx,2); | memcpy(strbuf_p,slashx,2); |
strbuf_p += 2; | strbuf_p += 2; |
char *t = yytext; |
char *t = cimmof_text; |
while( *t ) *strbuf_p++ = *t++; | while( *t ) *strbuf_p++ = *t++; |
} | } |
else *strbuf_p++ = (char)n; | else *strbuf_p++ = (char)n; |
|
|
#line 180 "cimmof.l" | #line 180 "cimmof.l" |
{ memcpy(strbuf_p,slashx,2); | { memcpy(strbuf_p,slashx,2); |
strbuf_p += 2; | strbuf_p += 2; |
*strbuf_p++ = *yytext; |
*strbuf_p++ = *cimmof_text; |
yy_pop_state(); | yy_pop_state(); |
} | } |
YY_BREAK | YY_BREAK |
|
|
case 64: | case 64: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 225 "cimmof.l" | #line 225 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return TOK_ALIAS_IDENTIFIER; } | return TOK_ALIAS_IDENTIFIER; } |
YY_BREAK | YY_BREAK |
case 65: | case 65: |
|
|
case 81: | case 81: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 243 "cimmof.l" | #line 243 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_SIMPLE_IDENTIFIER); } | return(TOK_SIMPLE_IDENTIFIER); } |
YY_BREAK | YY_BREAK |
case 82: | case 82: |
YY_RULE_SETUP | YY_RULE_SETUP |
#line 245 "cimmof.l" | #line 245 "cimmof.l" |
{ cimmof_lval.strval = new String(yytext); |
{ cimmof_lval.strval = new String(cimmof_text); |
return(TOK_UNEXPECTED_CHAR); } | return(TOK_UNEXPECTED_CHAR); } |
YY_BREAK | YY_BREAK |
case 83: | case 83: |
|
|
#line 248 "cimmof.l" | #line 248 "cimmof.l" |
ECHO; | ECHO; |
YY_BREAK | YY_BREAK |
#line 1518 "cimmof_lex.cpp" |
#line 1579 "cimmof_lex.cpp" |
| |
case YY_END_OF_BUFFER: | case YY_END_OF_BUFFER: |
{ | { |
/* Amount of text matched not including the EOB char. */ | /* Amount of text matched not including the EOB char. */ |
int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; |
int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; |
| |
/* Undo the effects of YY_DO_BEFORE_ACTION. */ | /* Undo the effects of YY_DO_BEFORE_ACTION. */ |
*yy_cp = yy_hold_char; |
*yy_cp = (yy_hold_char); |
YY_RESTORE_YY_MORE_OFFSET | YY_RESTORE_YY_MORE_OFFSET |
| |
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) |
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) |
{ | { |
/* We're scanning a new file or input source. It's | /* We're scanning a new file or input source. It's |
* possible that this happened because the user | * possible that this happened because the user |
* just pointed yyin at a new source and called |
* just pointed cimmof_in at a new source and called |
* yylex(). If so, then we have to assure |
* cimmof_lex(). If so, then we have to assure |
* consistency between yy_current_buffer and our |
* consistency between YY_CURRENT_BUFFER and our |
* globals. Here is the right place to do so, because | * globals. Here is the right place to do so, because |
* this is the first action (other than possibly a | * this is the first action (other than possibly a |
* back-up) that will match for the new input source. | * back-up) that will match for the new input source. |
*/ | */ |
yy_n_chars = yy_current_buffer->yy_n_chars; |
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
yy_current_buffer->yy_input_file = yyin; |
YY_CURRENT_BUFFER_LVALUE->yy_input_file = cimmof_in; |
yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; |
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; |
} | } |
| |
/* Note that here we test for yy_c_buf_p "<=" to the position | /* Note that here we test for yy_c_buf_p "<=" to the position |
|
|
* end-of-buffer state). Contrast this with the test | * end-of-buffer state). Contrast this with the test |
* in input(). | * in input(). |
*/ | */ |
if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) |
if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) |
{ /* This was really a NUL. */ | { /* This was really a NUL. */ |
yy_state_type yy_next_state; | yy_state_type yy_next_state; |
| |
yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; |
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; |
| |
yy_current_state = yy_get_previous_state(); | yy_current_state = yy_get_previous_state(); |
| |
|
|
| |
yy_next_state = yy_try_NUL_trans( yy_current_state ); | yy_next_state = yy_try_NUL_trans( yy_current_state ); |
| |
yy_bp = yytext_ptr + YY_MORE_ADJ; |
yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
| |
if ( yy_next_state ) | if ( yy_next_state ) |
{ | { |
/* Consume the NUL. */ | /* Consume the NUL. */ |
yy_cp = ++yy_c_buf_p; |
yy_cp = ++(yy_c_buf_p); |
yy_current_state = yy_next_state; | yy_current_state = yy_next_state; |
goto yy_match; | goto yy_match; |
} | } |
| |
else | else |
{ | { |
yy_cp = yy_c_buf_p; |
yy_cp = (yy_last_accepting_cpos); |
|
yy_current_state = (yy_last_accepting_state); |
goto yy_find_action; | goto yy_find_action; |
} | } |
} | } |
|
|
{ | { |
case EOB_ACT_END_OF_FILE: | case EOB_ACT_END_OF_FILE: |
{ | { |
yy_did_buffer_switch_on_eof = 0; |
(yy_did_buffer_switch_on_eof) = 0; |
| |
if ( yywrap() ) |
if ( cimmof_wrap( ) ) |
{ | { |
/* Note: because we've taken care in | /* Note: because we've taken care in |
* yy_get_next_buffer() to have set up | * yy_get_next_buffer() to have set up |
* yytext, we can now set up |
* cimmof_text, we can now set up |
* yy_c_buf_p so that if some total | * yy_c_buf_p so that if some total |
* hoser (like flex itself) wants to | * hoser (like flex itself) wants to |
* call the scanner after we return the | * call the scanner after we return the |
* YY_NULL, it'll still work - another | * YY_NULL, it'll still work - another |
* YY_NULL will get returned. | * YY_NULL will get returned. |
*/ | */ |
yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; |
(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; |
| |
yy_act = YY_STATE_EOF(YY_START); | yy_act = YY_STATE_EOF(YY_START); |
goto do_action; | goto do_action; |
|
|
| |
else | else |
{ | { |
if ( ! yy_did_buffer_switch_on_eof ) |
if ( ! (yy_did_buffer_switch_on_eof) ) |
YY_NEW_FILE; | YY_NEW_FILE; |
} | } |
break; | break; |
} | } |
| |
case EOB_ACT_CONTINUE_SCAN: | case EOB_ACT_CONTINUE_SCAN: |
yy_c_buf_p = |
(yy_c_buf_p) = |
yytext_ptr + yy_amount_of_matched_text; |
(yytext_ptr) + yy_amount_of_matched_text; |
| |
yy_current_state = yy_get_previous_state(); | yy_current_state = yy_get_previous_state(); |
| |
yy_cp = yy_c_buf_p; |
yy_cp = (yy_c_buf_p); |
yy_bp = yytext_ptr + YY_MORE_ADJ; |
yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
goto yy_match; | goto yy_match; |
| |
case EOB_ACT_LAST_MATCH: | case EOB_ACT_LAST_MATCH: |
yy_c_buf_p = |
(yy_c_buf_p) = |
&yy_current_buffer->yy_ch_buf[yy_n_chars]; |
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; |
| |
yy_current_state = yy_get_previous_state(); | yy_current_state = yy_get_previous_state(); |
| |
yy_cp = yy_c_buf_p; |
yy_cp = (yy_c_buf_p); |
yy_bp = yytext_ptr + YY_MORE_ADJ; |
yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
goto yy_find_action; | goto yy_find_action; |
} | } |
break; | break; |
|
|
"fatal flex scanner internal error--no action found" ); | "fatal flex scanner internal error--no action found" ); |
} /* end of action switch */ | } /* end of action switch */ |
} /* end of scanning one token */ | } /* end of scanning one token */ |
} /* end of yylex */ |
} /* end of cimmof_lex */ |
|
|
| |
/* yy_get_next_buffer - try to read in a new buffer | /* yy_get_next_buffer - try to read in a new buffer |
* | * |
|
|
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position | * EOB_ACT_CONTINUE_SCAN - continue scanning from current position |
* EOB_ACT_END_OF_FILE - end of file | * EOB_ACT_END_OF_FILE - end of file |
*/ | */ |
|
static int yy_get_next_buffer (void) |
static int yy_get_next_buffer() |
|
{ | { |
register char *dest = yy_current_buffer->yy_ch_buf; |
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; |
register char *source = yytext_ptr; |
register char *source = (yytext_ptr); |
register int number_to_move, i; | register int number_to_move, i; |
int ret_val; | int ret_val; |
| |
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) |
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) |
YY_FATAL_ERROR( | YY_FATAL_ERROR( |
"fatal flex scanner internal error--end of buffer missed" ); | "fatal flex scanner internal error--end of buffer missed" ); |
| |
if ( yy_current_buffer->yy_fill_buffer == 0 ) |
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) |
{ /* Don't try to fill the buffer, so this is an EOF. */ | { /* Don't try to fill the buffer, so this is an EOF. */ |
if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) |
if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) |
{ | { |
/* We matched a single character, the EOB, so | /* We matched a single character, the EOB, so |
* treat this as a final EOF. | * treat this as a final EOF. |
|
|
/* Try to read more data. */ | /* Try to read more data. */ |
| |
/* First move last chars to start of buffer. */ | /* First move last chars to start of buffer. */ |
number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; |
number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; |
| |
for ( i = 0; i < number_to_move; ++i ) | for ( i = 0; i < number_to_move; ++i ) |
*(dest++) = *(source++); | *(dest++) = *(source++); |
| |
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) |
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, | /* don't do the read, it's not guaranteed to return an EOF, |
* just force an EOF | * just force an EOF |
*/ | */ |
yy_current_buffer->yy_n_chars = yy_n_chars = 0; |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; |
| |
else | else |
{ | { |
int num_to_read = | int num_to_read = |
yy_current_buffer->yy_buf_size - number_to_move - 1; |
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; |
| |
while ( num_to_read <= 0 ) | while ( num_to_read <= 0 ) |
{ /* Not enough room in the buffer - grow it. */ | { /* Not enough room in the buffer - grow it. */ |
#ifdef YY_USES_REJECT |
|
YY_FATAL_ERROR( |
|
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); |
|
#else |
|
| |
/* just a shorter name for the current buffer */ | /* just a shorter name for the current buffer */ |
YY_BUFFER_STATE b = yy_current_buffer; |
YY_BUFFER_STATE b = YY_CURRENT_BUFFER; |
| |
int yy_c_buf_p_offset = | int yy_c_buf_p_offset = |
(int) (yy_c_buf_p - b->yy_ch_buf); |
(int) ((yy_c_buf_p) - b->yy_ch_buf); |
| |
if ( b->yy_is_our_buffer ) | if ( b->yy_is_our_buffer ) |
{ | { |
|
|
| |
b->yy_ch_buf = (char *) | b->yy_ch_buf = (char *) |
/* Include room in for 2 EOB chars. */ | /* Include room in for 2 EOB chars. */ |
yy_flex_realloc( (void *) b->yy_ch_buf, |
cimmof_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); |
b->yy_buf_size + 2 ); |
|
} | } |
else | else |
/* Can't grow it, we don't own it. */ | /* Can't grow it, we don't own it. */ |
|
|
YY_FATAL_ERROR( | YY_FATAL_ERROR( |
"fatal error - scanner input buffer overflow" ); | "fatal error - scanner input buffer overflow" ); |
| |
yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; |
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; |
| |
num_to_read = yy_current_buffer->yy_buf_size - |
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - |
number_to_move - 1; | number_to_move - 1; |
#endif |
|
} | } |
| |
if ( num_to_read > YY_READ_BUF_SIZE ) | if ( num_to_read > YY_READ_BUF_SIZE ) |
num_to_read = YY_READ_BUF_SIZE; | num_to_read = YY_READ_BUF_SIZE; |
| |
/* Read in more data. */ | /* Read in more data. */ |
YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), |
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), |
yy_n_chars, num_to_read ); |
(yy_n_chars), (size_t) num_to_read ); |
| |
yy_current_buffer->yy_n_chars = yy_n_chars; |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
} | } |
| |
if ( yy_n_chars == 0 ) |
if ( (yy_n_chars) == 0 ) |
{ | { |
if ( number_to_move == YY_MORE_ADJ ) | if ( number_to_move == YY_MORE_ADJ ) |
{ | { |
ret_val = EOB_ACT_END_OF_FILE; | ret_val = EOB_ACT_END_OF_FILE; |
yyrestart( yyin ); |
cimmof_restart(cimmof_in ); |
} | } |
| |
else | else |
{ | { |
ret_val = EOB_ACT_LAST_MATCH; | ret_val = EOB_ACT_LAST_MATCH; |
yy_current_buffer->yy_buffer_status = |
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = |
YY_BUFFER_EOF_PENDING; | YY_BUFFER_EOF_PENDING; |
} | } |
} | } |
|
|
else | else |
ret_val = EOB_ACT_CONTINUE_SCAN; | ret_val = EOB_ACT_CONTINUE_SCAN; |
| |
yy_n_chars += number_to_move; |
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { |
yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; |
/* Extend the array by 50%, plus the number we really need. */ |
yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; |
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); |
|
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cimmof_realloc((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->yy_ch_buf[0]; |
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; |
| |
return ret_val; | return ret_val; |
} | } |
| |
|
|
/* yy_get_previous_state - get the state just before the EOB char was reached */ | /* yy_get_previous_state - get the state just before the EOB char was reached */ |
| |
static yy_state_type yy_get_previous_state() |
static yy_state_type yy_get_previous_state (void) |
{ | { |
register yy_state_type yy_current_state; | register yy_state_type yy_current_state; |
register char *yy_cp; | register char *yy_cp; |
| |
yy_current_state = yy_start; |
yy_current_state = (yy_start); |
yy_state_ptr = yy_state_buf; |
|
*yy_state_ptr++ = yy_current_state; |
|
| |
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) |
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); | 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 ) | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
{ | { |
yy_current_state = (int) yy_def[yy_current_state]; | yy_current_state = (int) yy_def[yy_current_state]; |
|
|
yy_c = yy_meta[(unsigned int) yy_c]; | yy_c = yy_meta[(unsigned int) yy_c]; |
} | } |
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; | yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
*yy_state_ptr++ = yy_current_state; |
|
} | } |
| |
return yy_current_state; | return yy_current_state; |
} | } |
| |
|
|
/* yy_try_NUL_trans - try to make a transition on the NUL character | /* yy_try_NUL_trans - try to make a transition on the NUL character |
* | * |
* synopsis | * synopsis |
* next_state = yy_try_NUL_trans( current_state ); | * next_state = yy_try_NUL_trans( current_state ); |
*/ | */ |
|
|
#ifdef YY_USE_PROTOS |
|
static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) | static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) |
#else |
|
static yy_state_type yy_try_NUL_trans( yy_current_state ) |
|
yy_state_type yy_current_state; |
|
#endif |
|
{ | { |
register int yy_is_jam; | register int yy_is_jam; |
|
register char *yy_cp = (yy_c_buf_p); |
| |
register YY_CHAR yy_c = 1; | 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 ) | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
{ | { |
yy_current_state = (int) yy_def[yy_current_state]; | yy_current_state = (int) yy_def[yy_current_state]; |
|
|
} | } |
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; | yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
yy_is_jam = (yy_current_state == 299); | yy_is_jam = (yy_current_state == 299); |
if ( ! yy_is_jam ) |
|
*yy_state_ptr++ = yy_current_state; |
|
| |
return yy_is_jam ? 0 : yy_current_state; | return yy_is_jam ? 0 : yy_current_state; |
} | } |
| |
|
|
#ifndef YY_NO_UNPUT |
|
#ifdef YY_USE_PROTOS |
|
static void yyunput( int c, register char *yy_bp ) | static void yyunput( int c, register char *yy_bp ) |
#else |
|
static void yyunput( c, yy_bp ) |
|
int c; |
|
register char *yy_bp; |
|
#endif |
|
{ | { |
register char *yy_cp = yy_c_buf_p; |
register char *yy_cp; |
| |
/* undo effects of setting up yytext */ |
yy_cp = (yy_c_buf_p); |
*yy_cp = yy_hold_char; |
|
| |
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) |
/* undo effects of setting up cimmof_text */ |
|
*yy_cp = (yy_hold_char); |
|
|
|
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
{ /* need to shift things up to make room */ | { /* need to shift things up to make room */ |
/* +2 for EOB chars. */ | /* +2 for EOB chars. */ |
register int number_to_move = yy_n_chars + 2; |
register int number_to_move = (yy_n_chars) + 2; |
register char *dest = &yy_current_buffer->yy_ch_buf[ |
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ |
yy_current_buffer->yy_buf_size + 2]; |
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; |
register char *source = | register char *source = |
&yy_current_buffer->yy_ch_buf[number_to_move]; |
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; |
| |
while ( source > yy_current_buffer->yy_ch_buf ) |
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) |
*--dest = *--source; | *--dest = *--source; |
| |
yy_cp += (int) (dest - source); | yy_cp += (int) (dest - source); |
yy_bp += (int) (dest - source); | yy_bp += (int) (dest - source); |
yy_current_buffer->yy_n_chars = |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = |
yy_n_chars = yy_current_buffer->yy_buf_size; |
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; |
| |
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) |
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
YY_FATAL_ERROR( "flex scanner push-back overflow" ); | YY_FATAL_ERROR( "flex scanner push-back overflow" ); |
} | } |
| |
*--yy_cp = (char) c; | *--yy_cp = (char) c; |
| |
if ( c == '\n' ) |
if ( c == '\n' ){ |
--yylineno; |
--cimmof_lineno; |
|
|
yytext_ptr = yy_bp; |
|
yy_hold_char = *yy_cp; |
|
yy_c_buf_p = yy_cp; |
|
} | } |
#endif /* ifndef YY_NO_UNPUT */ |
|
| |
|
(yytext_ptr) = yy_bp; |
|
(yy_hold_char) = *yy_cp; |
|
(yy_c_buf_p) = yy_cp; |
|
} |
| |
#ifndef YY_NO_INPUT | #ifndef YY_NO_INPUT |
#ifdef __cplusplus | #ifdef __cplusplus |
static int yyinput() |
static int yyinput (void) |
#else | #else |
static int input() |
static int input (void) |
#endif | #endif |
|
|
{ | { |
int c; | int c; |
| |
*yy_c_buf_p = yy_hold_char; |
*(yy_c_buf_p) = (yy_hold_char); |
| |
if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) |
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) |
{ | { |
/* yy_c_buf_p now points to the character we want to return. | /* yy_c_buf_p now points to the character we want to return. |
* If this occurs *before* the EOB characters, then it's a | * If this occurs *before* the EOB characters, then it's a |
* valid NUL; if not, then we've hit the end of the buffer. | * valid NUL; if not, then we've hit the end of the buffer. |
*/ | */ |
if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) |
if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) |
/* This was really a NUL. */ | /* This was really a NUL. */ |
*yy_c_buf_p = '\0'; |
*(yy_c_buf_p) = '\0'; |
| |
else | else |
{ /* need more input */ | { /* need more input */ |
int offset = yy_c_buf_p - yytext_ptr; |
int offset = (yy_c_buf_p) - (yytext_ptr); |
++yy_c_buf_p; |
++(yy_c_buf_p); |
| |
switch ( yy_get_next_buffer() ) | switch ( yy_get_next_buffer() ) |
{ | { |
|
|
*/ | */ |
| |
/* Reset buffer status. */ | /* Reset buffer status. */ |
yyrestart( yyin ); |
cimmof_restart(cimmof_in ); |
| |
/* fall through */ |
/*FALLTHROUGH*/ |
| |
case EOB_ACT_END_OF_FILE: | case EOB_ACT_END_OF_FILE: |
{ | { |
if ( yywrap() ) |
if ( cimmof_wrap( ) ) |
return EOF; | return EOF; |
| |
if ( ! yy_did_buffer_switch_on_eof ) |
if ( ! (yy_did_buffer_switch_on_eof) ) |
YY_NEW_FILE; | YY_NEW_FILE; |
#ifdef __cplusplus | #ifdef __cplusplus |
return yyinput(); | return yyinput(); |
|
|
} | } |
| |
case EOB_ACT_CONTINUE_SCAN: | case EOB_ACT_CONTINUE_SCAN: |
yy_c_buf_p = yytext_ptr + offset; |
(yy_c_buf_p) = (yytext_ptr) + offset; |
break; | break; |
} | } |
} | } |
} | } |
| |
c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ |
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ |
*yy_c_buf_p = '\0'; /* preserve yytext */ |
*(yy_c_buf_p) = '\0'; /* preserve cimmof_text */ |
yy_hold_char = *++yy_c_buf_p; |
(yy_hold_char) = *++(yy_c_buf_p); |
| |
if ( c == '\n' ) | if ( c == '\n' ) |
++yylineno; |
|
|
cimmof_lineno++; |
|
; |
| |
return c; | return c; |
} | } |
#endif /* YY_NO_INPUT */ |
#endif /* ifndef YY_NO_INPUT */ |
| |
#ifdef YY_USE_PROTOS |
/** Immediately switch to a different input stream. |
void yyrestart( FILE *input_file ) |
* @param input_file A readable stream. |
#else |
* |
void yyrestart( input_file ) |
* @note This function does not reset the start condition to @c INITIAL . |
FILE *input_file; |
*/ |
#endif |
void cimmof_restart (FILE * input_file ) |
{ | { |
if ( ! yy_current_buffer ) |
|
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); |
|
| |
yy_init_buffer( yy_current_buffer, input_file ); |
if ( ! YY_CURRENT_BUFFER ){ |
yy_load_buffer_state(); |
cimmof_ensure_buffer_stack (); |
|
YY_CURRENT_BUFFER_LVALUE = |
|
cimmof__create_buffer(cimmof_in,YY_BUF_SIZE ); |
} | } |
| |
|
cimmof__init_buffer(YY_CURRENT_BUFFER,input_file ); |
|
cimmof__load_buffer_state( ); |
|
} |
| |
#ifdef YY_USE_PROTOS |
/** Switch to a different input buffer. |
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) |
* @param new_buffer The new input buffer. |
#else |
* |
void yy_switch_to_buffer( new_buffer ) |
*/ |
YY_BUFFER_STATE new_buffer; |
void cimmof__switch_to_buffer (YY_BUFFER_STATE new_buffer ) |
#endif |
|
{ | { |
if ( yy_current_buffer == new_buffer ) |
|
|
/* TODO. We should be able to replace this entire function body |
|
* with |
|
* cimmof_pop_buffer_state(); |
|
* cimmof_push_buffer_state(new_buffer); |
|
*/ |
|
cimmof_ensure_buffer_stack (); |
|
if ( YY_CURRENT_BUFFER == new_buffer ) |
return; | return; |
| |
if ( yy_current_buffer ) |
if ( YY_CURRENT_BUFFER ) |
{ | { |
/* Flush out information for old buffer. */ | /* Flush out information for old buffer. */ |
*yy_c_buf_p = yy_hold_char; |
*(yy_c_buf_p) = (yy_hold_char); |
yy_current_buffer->yy_buf_pos = yy_c_buf_p; |
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); |
yy_current_buffer->yy_n_chars = yy_n_chars; |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
} | } |
| |
yy_current_buffer = new_buffer; |
YY_CURRENT_BUFFER_LVALUE = new_buffer; |
yy_load_buffer_state(); |
cimmof__load_buffer_state( ); |
| |
/* We don't actually know whether we did this switch during | /* We don't actually know whether we did this switch during |
* EOF (yywrap()) processing, but the only time this flag |
* EOF (cimmof_wrap()) processing, but the only time this flag |
* is looked at is after yywrap() is called, so it's safe |
* is looked at is after cimmof_wrap() is called, so it's safe |
* to go ahead and always set it. | * to go ahead and always set it. |
*/ | */ |
yy_did_buffer_switch_on_eof = 1; |
(yy_did_buffer_switch_on_eof) = 1; |
} | } |
| |
|
static void cimmof__load_buffer_state (void) |
#ifdef YY_USE_PROTOS |
|
void yy_load_buffer_state( void ) |
|
#else |
|
void yy_load_buffer_state() |
|
#endif |
|
{ | { |
yy_n_chars = yy_current_buffer->yy_n_chars; |
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; |
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; |
yyin = yy_current_buffer->yy_input_file; |
cimmof_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; |
yy_hold_char = *yy_c_buf_p; |
(yy_hold_char) = *(yy_c_buf_p); |
} | } |
| |
|
/** Allocate and initialize an input buffer state. |
#ifdef YY_USE_PROTOS |
* @param file A readable stream. |
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) |
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. |
#else |
* |
YY_BUFFER_STATE yy_create_buffer( file, size ) |
* @return the allocated buffer state. |
FILE *file; |
*/ |
int size; |
YY_BUFFER_STATE cimmof__create_buffer (FILE * file, int size ) |
#endif |
|
{ | { |
YY_BUFFER_STATE b; | YY_BUFFER_STATE b; |
| |
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); |
b = (YY_BUFFER_STATE) cimmof_alloc(sizeof( struct yy_buffer_state ) ); |
if ( ! b ) | if ( ! b ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); |
YY_FATAL_ERROR( "out of dynamic memory in cimmof__create_buffer()" ); |
| |
b->yy_buf_size = size; | b->yy_buf_size = size; |
| |
/* yy_ch_buf has to be 2 characters longer than the size given because | /* yy_ch_buf has to be 2 characters longer than the size given because |
* we need to put in 2 end-of-buffer characters. | * we need to put in 2 end-of-buffer characters. |
*/ | */ |
b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); |
b->yy_ch_buf = (char *) cimmof_alloc(b->yy_buf_size + 2 ); |
if ( ! b->yy_ch_buf ) | if ( ! b->yy_ch_buf ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); |
YY_FATAL_ERROR( "out of dynamic memory in cimmof__create_buffer()" ); |
| |
b->yy_is_our_buffer = 1; | b->yy_is_our_buffer = 1; |
| |
yy_init_buffer( b, file ); |
cimmof__init_buffer(b,file ); |
| |
return b; | return b; |
} | } |
| |
|
/** Destroy the buffer. |
#ifdef YY_USE_PROTOS |
* @param b a buffer created with cimmof__create_buffer() |
void yy_delete_buffer( YY_BUFFER_STATE b ) |
* |
#else |
*/ |
void yy_delete_buffer( b ) |
void cimmof__delete_buffer (YY_BUFFER_STATE b ) |
YY_BUFFER_STATE b; |
|
#endif |
|
{ | { |
|
|
if ( ! b ) | if ( ! b ) |
return; | return; |
| |
if ( b == yy_current_buffer ) |
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ |
yy_current_buffer = (YY_BUFFER_STATE) 0; |
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; |
| |
if ( b->yy_is_our_buffer ) | if ( b->yy_is_our_buffer ) |
yy_flex_free( (void *) b->yy_ch_buf ); |
cimmof_free((void *) b->yy_ch_buf ); |
| |
yy_flex_free( (void *) b ); |
cimmof_free((void *) b ); |
} | } |
| |
|
/* Initializes or reinitializes a buffer. |
|
* This function is sometimes called more than once on the same buffer, |
#ifdef YY_USE_PROTOS |
* such as during a cimmof_restart() or at EOF. |
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) |
*/ |
#else |
static void cimmof__init_buffer (YY_BUFFER_STATE b, FILE * file ) |
void yy_init_buffer( b, file ) |
|
YY_BUFFER_STATE b; |
|
FILE *file; |
|
#endif |
|
|
|
| |
{ | { |
yy_flush_buffer( b ); |
int oerrno = errno; |
|
|
|
cimmof__flush_buffer(b ); |
| |
b->yy_input_file = file; | b->yy_input_file = file; |
b->yy_fill_buffer = 1; | b->yy_fill_buffer = 1; |
| |
#if YY_ALWAYS_INTERACTIVE |
/* If b is the current buffer, then cimmof__init_buffer was _probably_ |
b->yy_is_interactive = 1; |
* called from cimmof_restart() or through yy_get_next_buffer. |
#else |
* In that case, we don't want to reset the lineno or column. |
#if YY_NEVER_INTERACTIVE |
*/ |
b->yy_is_interactive = 0; |
if (b != YY_CURRENT_BUFFER){ |
#else |
b->yy_bs_lineno = 1; |
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; |
b->yy_bs_column = 0; |
#endif |
|
#endif |
|
} | } |
| |
|
b->yy_is_interactive = 0; |
| |
#ifdef YY_USE_PROTOS |
errno = oerrno; |
void yy_flush_buffer( YY_BUFFER_STATE b ) |
} |
#else |
|
void yy_flush_buffer( b ) |
|
YY_BUFFER_STATE b; |
|
#endif |
|
| |
|
/** Discard all buffered characters. On the next scan, YY_INPUT will be called. |
|
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. |
|
* |
|
*/ |
|
void cimmof__flush_buffer (YY_BUFFER_STATE b ) |
{ | { |
if ( ! b ) | if ( ! b ) |
return; | return; |
|
|
b->yy_at_bol = 1; | b->yy_at_bol = 1; |
b->yy_buffer_status = YY_BUFFER_NEW; | b->yy_buffer_status = YY_BUFFER_NEW; |
| |
if ( b == yy_current_buffer ) |
if ( b == YY_CURRENT_BUFFER ) |
yy_load_buffer_state(); |
cimmof__load_buffer_state( ); |
} | } |
| |
|
/** Pushes the new state onto the stack. The new state becomes |
|
* the current state. This function will allocate the stack |
|
* if necessary. |
|
* @param new_buffer The new state. |
|
* |
|
*/ |
|
void cimmof_push_buffer_state (YY_BUFFER_STATE new_buffer ) |
|
{ |
|
if (new_buffer == NULL) |
|
return; |
|
|
|
cimmof_ensure_buffer_stack(); |
| |
#ifndef YY_NO_SCAN_BUFFER |
/* This block is copied from cimmof__switch_to_buffer. */ |
#ifdef YY_USE_PROTOS |
if ( YY_CURRENT_BUFFER ) |
YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) |
{ |
#else |
/* Flush out information for old buffer. */ |
YY_BUFFER_STATE yy_scan_buffer( base, size ) |
*(yy_c_buf_p) = (yy_hold_char); |
char *base; |
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); |
yy_size_t size; |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
#endif |
} |
|
|
|
/* Only push if top exists. Otherwise, replace top. */ |
|
if (YY_CURRENT_BUFFER) |
|
(yy_buffer_stack_top)++; |
|
YY_CURRENT_BUFFER_LVALUE = new_buffer; |
|
|
|
/* copied from cimmof__switch_to_buffer. */ |
|
cimmof__load_buffer_state( ); |
|
(yy_did_buffer_switch_on_eof) = 1; |
|
} |
|
|
|
/** Removes and deletes the top of the stack, if present. |
|
* The next element becomes the new top. |
|
* |
|
*/ |
|
void cimmof_pop_buffer_state (void) |
|
{ |
|
if (!YY_CURRENT_BUFFER) |
|
return; |
|
|
|
cimmof__delete_buffer(YY_CURRENT_BUFFER ); |
|
YY_CURRENT_BUFFER_LVALUE = NULL; |
|
if ((yy_buffer_stack_top) > 0) |
|
--(yy_buffer_stack_top); |
|
|
|
if (YY_CURRENT_BUFFER) { |
|
cimmof__load_buffer_state( ); |
|
(yy_did_buffer_switch_on_eof) = 1; |
|
} |
|
} |
|
|
|
/* Allocates the stack if it does not exist. |
|
* Guarantees space for at least one push. |
|
*/ |
|
static void cimmof_ensure_buffer_stack (void) |
|
{ |
|
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**)cimmof_alloc |
|
(num_to_alloc * sizeof(struct yy_buffer_state*) |
|
); |
|
if ( ! (yy_buffer_stack) ) |
|
YY_FATAL_ERROR( "out of dynamic memory in cimmof_ensure_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**)cimmof_realloc |
|
((yy_buffer_stack), |
|
num_to_alloc * sizeof(struct yy_buffer_state*) |
|
); |
|
if ( ! (yy_buffer_stack) ) |
|
YY_FATAL_ERROR( "out of dynamic memory in cimmof_ensure_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; |
|
} |
|
} |
|
|
|
/** Setup the input buffer state to scan directly from a user-specified character buffer. |
|
* @param base the character buffer |
|
* @param size the size in bytes of the character buffer |
|
* |
|
* @return the newly allocated buffer state object. |
|
*/ |
|
YY_BUFFER_STATE cimmof__scan_buffer (char * base, yy_size_t size ) |
{ | { |
YY_BUFFER_STATE b; | YY_BUFFER_STATE b; |
| |
|
|
/* They forgot to leave room for the EOB's. */ | /* They forgot to leave room for the EOB's. */ |
return 0; | return 0; |
| |
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); |
b = (YY_BUFFER_STATE) cimmof_alloc(sizeof( struct yy_buffer_state ) ); |
if ( ! b ) | if ( ! b ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); |
YY_FATAL_ERROR( "out of dynamic memory in cimmof__scan_buffer()" ); |
| |
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ | b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ |
b->yy_buf_pos = b->yy_ch_buf = base; | b->yy_buf_pos = b->yy_ch_buf = base; |
|
|
b->yy_fill_buffer = 0; | b->yy_fill_buffer = 0; |
b->yy_buffer_status = YY_BUFFER_NEW; | b->yy_buffer_status = YY_BUFFER_NEW; |
| |
yy_switch_to_buffer( b ); |
cimmof__switch_to_buffer(b ); |
| |
return b; | return b; |
} | } |
#endif |
|
| |
|
/** Setup the input buffer state to scan a string. The next call to cimmof_lex() will |
#ifndef YY_NO_SCAN_STRING |
* scan from a @e copy of @a str. |
#ifdef YY_USE_PROTOS |
* @param yystr a NUL-terminated string to scan |
YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) |
* |
#else |
* @return the newly allocated buffer state object. |
YY_BUFFER_STATE yy_scan_string( yy_str ) |
* @note If you want to scan bytes that may contain NUL values, then use |
yyconst char *yy_str; |
* cimmof__scan_bytes() instead. |
#endif |
*/ |
|
YY_BUFFER_STATE cimmof__scan_string (yyconst char * yystr ) |
{ | { |
int len; |
|
for ( len = 0; yy_str[len]; ++len ) |
|
; |
|
| |
return yy_scan_bytes( yy_str, len ); |
return cimmof__scan_bytes(yystr,strlen(yystr) ); |
} | } |
#endif |
|
|
|
| |
#ifndef YY_NO_SCAN_BYTES |
/** Setup the input buffer state to scan the given bytes. The next call to cimmof_lex() will |
#ifdef YY_USE_PROTOS |
* scan from a @e copy of @a bytes. |
YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) |
* @param bytes the byte buffer to scan |
#else |
* @param len the number of bytes in the buffer pointed to by @a bytes. |
YY_BUFFER_STATE yy_scan_bytes( bytes, len ) |
* |
yyconst char *bytes; |
* @return the newly allocated buffer state object. |
int len; |
*/ |
#endif |
YY_BUFFER_STATE cimmof__scan_bytes (yyconst char * yybytes, int _yybytes_len ) |
{ | { |
YY_BUFFER_STATE b; | YY_BUFFER_STATE b; |
char *buf; | char *buf; |
|
|
int i; | int i; |
| |
/* Get memory for full buffer, including space for trailing EOB's. */ | /* Get memory for full buffer, including space for trailing EOB's. */ |
n = len + 2; |
n = _yybytes_len + 2; |
buf = (char *) yy_flex_alloc( n ); |
buf = (char *) cimmof_alloc(n ); |
if ( ! buf ) | if ( ! buf ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); |
YY_FATAL_ERROR( "out of dynamic memory in cimmof__scan_bytes()" ); |
| |
for ( i = 0; i < len; ++i ) |
for ( i = 0; i < _yybytes_len; ++i ) |
buf[i] = bytes[i]; |
buf[i] = yybytes[i]; |
| |
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; |
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; |
| |
b = yy_scan_buffer( buf, n ); |
b = cimmof__scan_buffer(buf,n ); |
if ( ! b ) | if ( ! b ) |
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); |
YY_FATAL_ERROR( "bad buffer in cimmof__scan_bytes()" ); |
| |
/* It's okay to grow etc. this buffer, and we should throw it | /* It's okay to grow etc. this buffer, and we should throw it |
* away when we're done. | * away when we're done. |
|
|
| |
return b; | return b; |
} | } |
#endif |
|
|
|
| |
#ifndef YY_NO_PUSH_STATE |
|
#ifdef YY_USE_PROTOS |
|
static void yy_push_state( int new_state ) | static void yy_push_state( int new_state ) |
#else |
|
static void yy_push_state( new_state ) |
|
int new_state; |
|
#endif |
|
{ | { |
if ( yy_start_stack_ptr >= yy_start_stack_depth ) |
if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) |
{ | { |
yy_size_t new_size; | yy_size_t new_size; |
| |
yy_start_stack_depth += YY_START_STACK_INCR; |
(yy_start_stack_depth) += YY_START_STACK_INCR; |
new_size = yy_start_stack_depth * sizeof( int ); |
new_size = (yy_start_stack_depth) * sizeof( int ); |
| |
if ( ! yy_start_stack ) |
if ( ! (yy_start_stack) ) |
yy_start_stack = (int *) yy_flex_alloc( new_size ); |
(yy_start_stack) = (int *) cimmof_alloc(new_size ); |
| |
else | else |
yy_start_stack = (int *) yy_flex_realloc( |
(yy_start_stack) = (int *) cimmof_realloc((void *) (yy_start_stack),new_size ); |
(void *) yy_start_stack, new_size ); |
|
| |
if ( ! yy_start_stack ) |
if ( ! (yy_start_stack) ) |
YY_FATAL_ERROR( |
YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); |
"out of memory expanding start-condition stack" ); |
|
} | } |
| |
yy_start_stack[yy_start_stack_ptr++] = YY_START; |
(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START; |
| |
BEGIN(new_state); | BEGIN(new_state); |
} | } |
#endif |
|
| |
|
static void yy_pop_state (void) |
#ifndef YY_NO_POP_STATE |
|
static void yy_pop_state() |
|
{ | { |
if ( --yy_start_stack_ptr < 0 ) |
if ( --(yy_start_stack_ptr) < 0 ) |
YY_FATAL_ERROR( "start-condition stack underflow" ); | YY_FATAL_ERROR( "start-condition stack underflow" ); |
| |
BEGIN(yy_start_stack[yy_start_stack_ptr]); |
BEGIN((yy_start_stack)[(yy_start_stack_ptr)]); |
} | } |
#endif |
|
| |
|
static int yy_top_state (void) |
#ifndef YY_NO_TOP_STATE |
|
static int yy_top_state() |
|
{ | { |
return yy_start_stack[yy_start_stack_ptr - 1]; |
return (yy_start_stack)[(yy_start_stack_ptr) - 1]; |
} | } |
#endif |
|
| |
#ifndef YY_EXIT_FAILURE | #ifndef YY_EXIT_FAILURE |
#define YY_EXIT_FAILURE 2 | #define YY_EXIT_FAILURE 2 |
#endif | #endif |
| |
#ifdef YY_USE_PROTOS |
static void yy_fatal_error (yyconst char* msg ) |
static void yy_fatal_error( yyconst char msg[] ) |
|
#else |
|
static void yy_fatal_error( msg ) |
|
char msg[]; |
|
#endif |
|
{ | { |
(void) fprintf( stderr, "%s\n", msg ); | (void) fprintf( stderr, "%s\n", msg ); |
exit( YY_EXIT_FAILURE ); | exit( YY_EXIT_FAILURE ); |
} | } |
| |
|
|
|
|
/* Redefine yyless() so it works in section 3 code. */ | /* Redefine yyless() so it works in section 3 code. */ |
| |
#undef yyless | #undef yyless |
#define yyless(n) \ | #define yyless(n) \ |
do \ | do \ |
{ \ | { \ |
/* Undo effects of setting up yytext. */ \ |
/* Undo effects of setting up cimmof_text. */ \ |
yytext[yyleng] = yy_hold_char; \ |
int yyless_macro_arg = (n); \ |
yy_c_buf_p = yytext + n; \ |
YY_LESS_LINENO(yyless_macro_arg);\ |
yy_hold_char = *yy_c_buf_p; \ |
cimmof_text[cimmof_leng] = (yy_hold_char); \ |
*yy_c_buf_p = '\0'; \ |
(yy_c_buf_p) = cimmof_text + yyless_macro_arg; \ |
yyleng = n; \ |
(yy_hold_char) = *(yy_c_buf_p); \ |
|
*(yy_c_buf_p) = '\0'; \ |
|
cimmof_leng = yyless_macro_arg; \ |
} \ | } \ |
while ( 0 ) | while ( 0 ) |
| |
|
/* Accessor methods (get/set functions) to struct members. */ |
| |
/* Internal utility routines. */ |
/** Get the current line number. |
|
* |
|
*/ |
|
int cimmof_get_lineno (void) |
|
{ |
| |
#ifndef yytext_ptr |
return cimmof_lineno; |
#ifdef YY_USE_PROTOS |
} |
static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) |
|
|
/** Get the input stream. |
|
* |
|
*/ |
|
FILE *cimmof_get_in (void) |
|
{ |
|
return cimmof_in; |
|
} |
|
|
|
/** Get the output stream. |
|
* |
|
*/ |
|
FILE *cimmof_get_out (void) |
|
{ |
|
return cimmof_out; |
|
} |
|
|
|
/** Get the length of the current token. |
|
* |
|
*/ |
|
int cimmof_get_leng (void) |
|
{ |
|
return cimmof_leng; |
|
} |
|
|
|
/** Get the current token. |
|
* |
|
*/ |
|
|
|
char *cimmof_get_text (void) |
|
{ |
|
return cimmof_text; |
|
} |
|
|
|
/** Set the current line number. |
|
* @param line_number |
|
* |
|
*/ |
|
void cimmof_set_lineno (int line_number ) |
|
{ |
|
|
|
cimmof_lineno = line_number; |
|
} |
|
|
|
/** Set the input stream. This does not discard the current |
|
* input buffer. |
|
* @param in_str A readable stream. |
|
* |
|
* @see cimmof__switch_to_buffer |
|
*/ |
|
void cimmof_set_in (FILE * in_str ) |
|
{ |
|
cimmof_in = in_str ; |
|
} |
|
|
|
void cimmof_set_out (FILE * out_str ) |
|
{ |
|
cimmof_out = out_str ; |
|
} |
|
|
|
int cimmof_get_debug (void) |
|
{ |
|
return cimmof__flex_debug; |
|
} |
|
|
|
void cimmof_set_debug (int bdebug ) |
|
{ |
|
cimmof__flex_debug = bdebug ; |
|
} |
|
|
|
static int yy_init_globals (void) |
|
{ |
|
/* Initialization is the same as for the non-reentrant scanner. |
|
* This function is called from cimmof_lex_destroy(), so don't allocate here. |
|
*/ |
|
|
|
/* We do not touch cimmof_lineno unless the option is enabled. */ |
|
cimmof_lineno = 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; |
|
|
|
(yy_start_stack_ptr) = 0; |
|
(yy_start_stack_depth) = 0; |
|
(yy_start_stack) = NULL; |
|
|
|
/* Defined in main.c */ |
|
#ifdef YY_STDINIT |
|
cimmof_in = stdin; |
|
cimmof_out = stdout; |
#else | #else |
static void yy_flex_strncpy( s1, s2, n ) |
cimmof_in = (FILE *) 0; |
char *s1; |
cimmof_out = (FILE *) 0; |
yyconst char *s2; |
|
int n; |
|
#endif | #endif |
|
|
|
/* For future reference: Set errno on error, since we are called by |
|
* cimmof_lex_init() |
|
*/ |
|
return 0; |
|
} |
|
|
|
/* cimmof_lex_destroy is for both reentrant and non-reentrant scanners. */ |
|
int cimmof_lex_destroy (void) |
|
{ |
|
|
|
/* Pop the buffer stack, destroying each element. */ |
|
while(YY_CURRENT_BUFFER){ |
|
cimmof__delete_buffer(YY_CURRENT_BUFFER ); |
|
YY_CURRENT_BUFFER_LVALUE = NULL; |
|
cimmof_pop_buffer_state(); |
|
} |
|
|
|
/* Destroy the stack itself. */ |
|
cimmof_free((yy_buffer_stack) ); |
|
(yy_buffer_stack) = NULL; |
|
|
|
/* Destroy the start condition stack. */ |
|
cimmof_free((yy_start_stack) ); |
|
(yy_start_stack) = NULL; |
|
|
|
/* Reset the globals. This is important in a non-reentrant scanner so the next time |
|
* cimmof_lex() is called, initialization will occur. */ |
|
yy_init_globals( ); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Internal utility routines. |
|
*/ |
|
|
|
#ifndef yytext_ptr |
|
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) |
{ | { |
register int i; | register int i; |
for ( i = 0; i < n; ++i ) | for ( i = 0; i < n; ++i ) |
|
|
#endif | #endif |
| |
#ifdef YY_NEED_STRLEN | #ifdef YY_NEED_STRLEN |
#ifdef YY_USE_PROTOS |
|
static int yy_flex_strlen( yyconst char *s ) | static int yy_flex_strlen( yyconst char *s ) |
#else |
|
static int yy_flex_strlen( s ) |
|
yyconst char *s; |
|
#endif |
|
{ | { |
register int n; | register int n; |
for ( n = 0; s[n]; ++n ) | for ( n = 0; s[n]; ++n ) |
|
|
} | } |
#endif | #endif |
| |
|
void *cimmof_alloc (yy_size_t size ) |
#ifdef YY_USE_PROTOS |
|
static void *yy_flex_alloc( yy_size_t size ) |
|
#else |
|
static void *yy_flex_alloc( size ) |
|
yy_size_t size; |
|
#endif |
|
{ | { |
return (void *) malloc( size ); | return (void *) malloc( size ); |
} | } |
| |
#ifdef YY_USE_PROTOS |
void *cimmof_realloc (void * ptr, yy_size_t size ) |
static void *yy_flex_realloc( void *ptr, yy_size_t size ) |
|
#else |
|
static void *yy_flex_realloc( ptr, size ) |
|
void *ptr; |
|
yy_size_t size; |
|
#endif |
|
{ | { |
/* The cast to (char *) in the following accommodates both | /* The cast to (char *) in the following accommodates both |
* implementations that use char* generic pointers, and those | * implementations that use char* generic pointers, and those |
|
|
return (void *) realloc( (char *) ptr, size ); | return (void *) realloc( (char *) ptr, size ); |
} | } |
| |
#ifdef YY_USE_PROTOS |
void cimmof_free (void * ptr ) |
static void yy_flex_free( void *ptr ) |
|
#else |
|
static void yy_flex_free( ptr ) |
|
void *ptr; |
|
#endif |
|
{ | { |
free( ptr ); |
free( (char *) ptr ); /* see cimmof_realloc() for (char *) cast */ |
} | } |
| |
#if YY_MAIN |
#define YYTABLES_NAME "yytables" |
int main() |
|
{ |
|
yylex(); |
|
return 0; |
|
} |
|
#endif |
|
#line 248 "cimmof.l" | #line 248 "cimmof.l" |
| |
| |
|
|
void cimmof_yy_less(int n) { yyless(n); } | void cimmof_yy_less(int n) { yyless(n); } |
|
|