|
k-dot-p 0.1
|
|
k-dot-p 0.1
|
#include <stdio.h>#include <string.h>#include <errno.h>#include <stdlib.h>#include <glib.h>#include <gio/gio.h>#include <libmodelxx/grid.h++>#include <libmodelxx/continuous_structure.h++>#include "lexer_parser_enums.h++"#include "structspec_parser.h"#include <unistd.h>
Include dependency graph for structspec_lexer.c++:Go to the source code of this file.
Classes | |
| struct | yy_buffer_state |
| struct | yy_trans_info |
Defines | |
| #define | YY_INT_ALIGNED short int |
| #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 yyrestart(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 yy_flush_buffer(YY_CURRENT_BUFFER ) |
| #define | yy_new_buffer 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 | yywrap(n) 1 |
| #define | YY_SKIP_YYWRAP |
| #define | yytext_ptr yytext |
| #define | YY_DO_BEFORE_ACTION |
| #define | YY_NUM_RULES 29 |
| #define | YY_END_OF_BUFFER 30 |
| #define | REJECT reject_used_but_not_detected |
| #define | yymore() yymore_used_but_not_detected |
| #define | YY_MORE_ADJ 0 |
| #define | YY_RESTORE_YY_MORE_OFFSET |
| #define | YY_INPUT(buf, result, max_size) (gio_yy_input(buf, &result, max_size)) |
| #define | INITIAL 0 |
| #define | STRINGREAD 1 |
| #define | COMMENT 2 |
| #define | YY_EXTRA_TYPE void * |
| #define | YY_READ_BUF_SIZE 8192 |
| #define | ECHO do { if (fwrite( yytext, yyleng, 1, 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 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 | yyrestart (FILE *input_file) |
| void | yy_switch_to_buffer (YY_BUFFER_STATE new_buffer) |
| YY_BUFFER_STATE | yy_create_buffer (FILE *file, int size) |
| void | yy_delete_buffer (YY_BUFFER_STATE b) |
| void | yy_flush_buffer (YY_BUFFER_STATE b) |
| void | yypush_buffer_state (YY_BUFFER_STATE new_buffer) |
| void | yypop_buffer_state (void) |
| static void | yyensure_buffer_stack (void) |
| static void | yy_load_buffer_state (void) |
| static void | yy_init_buffer (YY_BUFFER_STATE b, FILE *file) |
| YY_BUFFER_STATE | yy_scan_buffer (char *base, yy_size_t size) |
| YY_BUFFER_STATE | yy_scan_string (yyconst char *yy_str) |
| YY_BUFFER_STATE | yy_scan_bytes (yyconst char *bytes, int len) |
| void * | yyalloc (yy_size_t) |
| void * | yyrealloc (void *, yy_size_t) |
| void | 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[]) |
| void | gio_yy_input (char *buf, int *result, int max_size) |
| static int | yy_init_globals (void) |
| int | yylex_destroy (void) |
| int | yyget_debug (void) |
| void | yyset_debug (int debug_flag) |
| YY_EXTRA_TYPE | yyget_extra (void) |
| void | yyset_extra (YY_EXTRA_TYPE user_defined) |
| FILE * | yyget_in (void) |
| void | yyset_in (FILE *in_str) |
| FILE * | yyget_out (void) |
| void | yyset_out (FILE *out_str) |
| int | yyget_leng (void) |
| char * | yyget_text (void) |
| int | yyget_lineno (void) |
| void | yyset_lineno (int line_number) |
| static void | yyunput (int c, char *buf_ptr) |
| static int | input (void) |
| int | yylex (void) |
| if (!(yy_init)) | |
| while (1) | |
| static void | yyunput (int c, register char *yy_bp) |
| int | isatty (int) |
| static void | yy_fatal_error (yyconst char *msg) |
| void | remove_yyinput_not_used_error (void) |
Variables | |
| int | yyleng |
| FILE * | yyin = (FILE *) 0 |
| FILE * | 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 | yylineno = 1 |
| char * | yytext |
| static yyconst flex_int16_t | yy_accept [101] |
| static yyconst flex_int32_t | yy_ec [256] |
| static yyconst flex_int32_t | yy_meta [31] |
| static yyconst flex_int16_t | yy_base [105] |
| static yyconst flex_int16_t | yy_def [105] |
| static yyconst flex_int16_t | yy_nxt [163] |
| static yyconst flex_int16_t | yy_chk [163] |
| static yyconst flex_int32_t | yy_rule_can_match_eol [30] |
| static yy_state_type | yy_last_accepting_state |
| static char * | yy_last_accepting_cpos |
| int | yy_flex_debug = 0 |
| GString * | gstr |
| int | oldstate |
| GInputStream * | instream |
| YY_DECL register yy_state_type | yy_current_state |
| register char * | yy_cp |
| register char * | yy_bp |
| register int | yy_act |
| #define BEGIN (yy_start) = 1 + 2 * |
Definition at line 125 of file structspec_lexer.c++.
Referenced by while().
| #define COMMENT 2 |
Definition at line 604 of file structspec_lexer.c++.
Referenced by while().
Definition at line 696 of file structspec_lexer.c++.
Referenced by while().
| #define EOB_ACT_CONTINUE_SCAN 0 |
Definition at line 168 of file structspec_lexer.c++.
Referenced by input(), while(), and yy_get_next_buffer().
| #define EOB_ACT_END_OF_FILE 1 |
Definition at line 169 of file structspec_lexer.c++.
Referenced by input(), while(), and yy_get_next_buffer().
| #define EOB_ACT_LAST_MATCH 2 |
Definition at line 170 of file structspec_lexer.c++.
Referenced by input(), while(), and yy_get_next_buffer().
| #define FLEX_BETA |
Definition at line 13 of file structspec_lexer.c++.
| #define FLEX_SCANNER |
Definition at line 8 of file structspec_lexer.c++.
| #define FLEXINT_H |
Definition at line 29 of file structspec_lexer.c++.
| #define INITIAL 0 |
Definition at line 602 of file structspec_lexer.c++.
Referenced by while().
| #define INT16_MAX (32767) |
Definition at line 71 of file structspec_lexer.c++.
| #define INT16_MIN (-32767-1) |
Definition at line 62 of file structspec_lexer.c++.
| #define INT32_MAX (2147483647) |
Definition at line 74 of file structspec_lexer.c++.
| #define INT32_MIN (-2147483647-1) |
Definition at line 65 of file structspec_lexer.c++.
| #define INT8_MAX (127) |
Definition at line 68 of file structspec_lexer.c++.
| #define INT8_MIN (-128) |
Definition at line 59 of file structspec_lexer.c++.
| #define REJECT reject_used_but_not_detected |
Definition at line 541 of file structspec_lexer.c++.
| #define STRINGREAD 1 |
Definition at line 603 of file structspec_lexer.c++.
Referenced by while().
| #define UINT16_MAX (65535U) |
Definition at line 80 of file structspec_lexer.c++.
| #define UINT32_MAX (4294967295U) |
Definition at line 83 of file structspec_lexer.c++.
| #define UINT8_MAX (255U) |
Definition at line 77 of file structspec_lexer.c++.
| #define unput | ( | c | ) | yyunput( c, (yytext_ptr) ) |
Definition at line 201 of file structspec_lexer.c++.
| #define YY_AT_BOL | ( | ) | (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) |
Definition at line 352 of file structspec_lexer.c++.
| #define YY_BREAK break; |
Definition at line 775 of file structspec_lexer.c++.
Referenced by while().
| #define YY_BUF_SIZE 16384 |
Definition at line 151 of file structspec_lexer.c++.
Referenced by if(), and yyrestart().
| #define YY_BUFFER_EOF_PENDING 2 |
Definition at line 268 of file structspec_lexer.c++.
Referenced by yy_get_next_buffer().
| #define YY_BUFFER_NEW 0 |
Definition at line 256 of file structspec_lexer.c++.
Referenced by while(), yy_flush_buffer(), and yy_scan_buffer().
| #define YY_BUFFER_NORMAL 1 |
Definition at line 257 of file structspec_lexer.c++.
Referenced by while().
| #define YY_CURRENT_BUFFER |
( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL)
Definition at line 284 of file structspec_lexer.c++.
Referenced by if(), yy_delete_buffer(), yy_flush_buffer(), yy_get_next_buffer(), yy_init_buffer(), yy_switch_to_buffer(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().
| #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] |
Definition at line 291 of file structspec_lexer.c++.
Referenced by if(), input(), while(), yy_delete_buffer(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), yyrestart(), and yyunput().
| #define YY_DECL int yylex (void) |
Definition at line 763 of file structspec_lexer.c++.
| #define YY_DECL_IS_OURS 1 |
Definition at line 759 of file structspec_lexer.c++.
| #define YY_DO_BEFORE_ACTION |
(yytext_ptr) = yy_bp; \ yyleng = (size_t) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp;
Definition at line 380 of file structspec_lexer.c++.
Referenced by while().
| #define YY_END_OF_BUFFER 30 |
Definition at line 388 of file structspec_lexer.c++.
Referenced by while().
| #define YY_END_OF_BUFFER_CHAR 0 |
Definition at line 140 of file structspec_lexer.c++.
Referenced by input(), yy_flush_buffer(), yy_get_next_buffer(), yy_scan_buffer(), and yy_scan_bytes().
| #define YY_EXIT_FAILURE 2 |
Definition at line 1851 of file structspec_lexer.c++.
Referenced by yy_fatal_error().
| #define YY_EXTRA_TYPE void * |
Definition at line 615 of file structspec_lexer.c++.
| #define YY_FATAL_ERROR | ( | msg | ) | yy_fatal_error( msg ) |
Definition at line 750 of file structspec_lexer.c++.
Referenced by while(), yy_create_buffer(), yy_get_next_buffer(), yy_scan_buffer(), yy_scan_bytes(), yyensure_buffer_stack(), and yyunput().
| #define YY_FLEX_MAJOR_VERSION 2 |
Definition at line 9 of file structspec_lexer.c++.
| #define YY_FLEX_MINOR_VERSION 5 |
Definition at line 10 of file structspec_lexer.c++.
| #define YY_FLEX_SUBMINOR_VERSION 35 |
Definition at line 11 of file structspec_lexer.c++.
| #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) |
Definition at line 320 of file structspec_lexer.c++.
| #define YY_INPUT | ( | buf, | |
| result, | |||
| max_size | |||
| ) | (gio_yy_input(buf, &result, max_size)) |
Definition at line 592 of file structspec_lexer.c++.
Referenced by yy_get_next_buffer().
| #define YY_INT_ALIGNED short int |
Definition at line 4 of file structspec_lexer.c++.
| #define YY_LESS_LINENO | ( | n | ) |
do { \ int yyl;\ for ( yyl = n; yyl < yyleng; ++yyl )\ if ( yytext[yyl] == '\n' )\ --yylineno;\ }while(0)
Definition at line 179 of file structspec_lexer.c++.
| #define YY_MORE_ADJ 0 |
Definition at line 543 of file structspec_lexer.c++.
Referenced by while(), yy_get_next_buffer(), and yy_get_previous_state().
| #define yy_new_buffer yy_create_buffer |
Definition at line 330 of file structspec_lexer.c++.
| #define YY_NEW_FILE yyrestart(yyin ) |
Definition at line 138 of file structspec_lexer.c++.
| #define YY_NULL 0 |
Definition at line 112 of file structspec_lexer.c++.
| #define YY_NUM_RULES 29 |
Definition at line 387 of file structspec_lexer.c++.
| #define YY_READ_BUF_SIZE 8192 |
Definition at line 687 of file structspec_lexer.c++.
Referenced by yy_get_next_buffer().
| #define YY_RESTORE_YY_MORE_OFFSET |
Definition at line 544 of file structspec_lexer.c++.
Referenced by while().
| #define YY_RULE_SETUP YY_USER_ACTION |
Definition at line 778 of file structspec_lexer.c++.
Referenced by while().
| #define YY_SC_TO_UI | ( | c | ) | ((unsigned int) (unsigned char) c) |
Definition at line 119 of file structspec_lexer.c++.
Referenced by while(), and yy_get_previous_state().
| #define yy_set_bol | ( | at_bol | ) |
{ \
if ( ! YY_CURRENT_BUFFER ){\
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer(yyin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
Definition at line 342 of file structspec_lexer.c++.
| #define yy_set_interactive | ( | is_interactive | ) |
{ \
if ( ! YY_CURRENT_BUFFER ){ \
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer(yyin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
Definition at line 332 of file structspec_lexer.c++.
| #define YY_SKIP_YYWRAP |
Definition at line 357 of file structspec_lexer.c++.
| #define YY_START (((yy_start) - 1) / 2) |
Definition at line 131 of file structspec_lexer.c++.
Referenced by while().
| #define YY_START_STACK_INCR 25 |
Definition at line 745 of file structspec_lexer.c++.
| #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) |
Definition at line 157 of file structspec_lexer.c++.
| #define YY_STATE_EOF | ( | state | ) | (YY_END_OF_BUFFER + state + 1) |
Definition at line 135 of file structspec_lexer.c++.
Referenced by while().
| #define YY_STRUCT_YY_BUFFER_STATE |
Definition at line 209 of file structspec_lexer.c++.
| #define YY_TYPEDEF_YY_BUFFER_STATE |
Definition at line 160 of file structspec_lexer.c++.
| #define YY_TYPEDEF_YY_SIZE_T |
Definition at line 204 of file structspec_lexer.c++.
| #define YY_USER_ACTION |
Definition at line 770 of file structspec_lexer.c++.
| #define yyconst |
Definition at line 108 of file structspec_lexer.c++.
| #define yyless | ( | n | ) |
do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = (yy_hold_char); \ (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 )
Definition at line 1863 of file structspec_lexer.c++.
| #define yyless | ( | n | ) |
do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 )
Definition at line 1863 of file structspec_lexer.c++.
| #define yymore | ( | ) | yymore_used_but_not_detected |
Definition at line 542 of file structspec_lexer.c++.
| #define YYSTATE YY_START |
Definition at line 132 of file structspec_lexer.c++.
| #define YYTABLES_NAME "yytables" |
Definition at line 2056 of file structspec_lexer.c++.
| #define yyterminate | ( | ) | return YY_NULL |
Definition at line 740 of file structspec_lexer.c++.
Referenced by while().
| #define yytext_ptr yytext |
Definition at line 370 of file structspec_lexer.c++.
Referenced by input(), while(), yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state(), and yyunput().
| #define yywrap | ( | n | ) | 1 |
Definition at line 356 of file structspec_lexer.c++.
| typedef short int flex_int16_t |
Definition at line 51 of file structspec_lexer.c++.
| typedef int flex_int32_t |
Definition at line 52 of file structspec_lexer.c++.
| typedef signed char flex_int8_t |
Definition at line 50 of file structspec_lexer.c++.
| typedef unsigned short int flex_uint16_t |
Definition at line 54 of file structspec_lexer.c++.
| typedef unsigned int flex_uint32_t |
Definition at line 55 of file structspec_lexer.c++.
| typedef unsigned char flex_uint8_t |
Definition at line 53 of file structspec_lexer.c++.
| typedef struct yy_buffer_state* YY_BUFFER_STATE |
Definition at line 161 of file structspec_lexer.c++.
| typedef unsigned char YY_CHAR |
Definition at line 359 of file structspec_lexer.c++.
| typedef size_t yy_size_t |
Definition at line 205 of file structspec_lexer.c++.
| typedef int yy_state_type |
Definition at line 363 of file structspec_lexer.c++.
| void gio_yy_input | ( | char * | buf, |
| int * | result, | ||
| int | max_size | ||
| ) |
Definition at line 582 of file structspec_lexer.c++.
{
GError *err = NULL;
gssize got_chars = g_input_stream_read(instream, buf, max_size, NULL, &err);
if(err != NULL) {
fprintf(stderr, "structspec_lexer: ERROR reading from file: %s", err->message);
*result = -1;
}
*result = got_chars;
}
| if | ( | ! | yy_init | ) |
Definition at line 793 of file structspec_lexer.c++.
References YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init, yy_load_buffer_state(), yy_start, yyensure_buffer_stack(), yyin, and yyout.
Referenced by yyunput().
{
(yy_init) = 1;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! (yy_start) )
(yy_start) = 1; /* first start state */
if ( ! yyin )
yyin = stdin;
if ( ! yyout )
yyout = stdout;
if ( ! YY_CURRENT_BUFFER ) {
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer(yyin,YY_BUF_SIZE );
}
yy_load_buffer_state( );
}
Here is the call graph for this function: Here is the caller graph for this function:| static int input | ( | void | ) | [static] |
Definition at line 1422 of file structspec_lexer.c++.
References kdp::constants::c, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, yy_get_next_buffer(), yy_hold_char, yy_n_chars, YY_NEW_FILE, yyin, yyrestart(), yytext_ptr, and yywrap.
{
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. */
yyrestart(yyin );
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE:
{
if ( 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 yytext */
(yy_hold_char) = *++(yy_c_buf_p);
if ( c == '\n' )
yylineno++;
;
return c;
}
Here is the call graph for this function:| int isatty | ( | int | ) |
| void remove_yyinput_not_used_error | ( | void | ) |
Definition at line 2065 of file structspec_lexer.c++.
References yyunput().
{yyunput(0, (char*)"bugmenot");}
Here is the call graph for this function:| while | ( | 1 | ) |
Definition at line 819 of file structspec_lexer.c++.
References BEGIN, kdotp::libmodelxx::grid::CARTESIAN, COMMENT, ECHO, YYSTYPE::energy, kdotp::libmodelxx::continuous_structure::energy_from_str(), EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, YYSTYPE::fval, YYSTYPE::gt, INITIAL, YYSTYPE::ival, YYSTYPE::len, kdotp::libmodelxx::continuous_structure::length_from_str(), YYSTYPE::str, STRINGREAD, TOK_CONST, TOK_DOPING, TOK_ENERGY, TOK_FLOAT, TOK_GRID, TOK_GRID_TYPE, TOK_IDENTIFIER, TOK_INT, TOK_LENGTH, TOK_POTENTIAL, TOK_REGION, TOK_SHAPE, TOK_STRING, TOK_STRUCTURE, YY_BREAK, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_c_buf_p, yy_cp, YY_CURRENT_BUFFER_LVALUE, yy_current_state, yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_hold_char, yy_last_accepting_cpos, yy_last_accepting_state, YY_MORE_ADJ, yy_n_chars, YY_NEW_FILE, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, yy_start, YY_STATE_EOF, yy_try_NUL_trans(), yyin, yyleng, yylval, yyterminate, yytext_ptr, and yywrap.
{
yy_cp = (yy_c_buf_p);
/* Support of yytext. */
*yy_cp = (yy_hold_char);
/* yy_bp points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
yy_current_state = (yy_start);
yy_match:
do
{
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 >= 101 )
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] != 132 );
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 = 0; yyl < yyleng; ++yyl )
if ( yytext[yyl] == '\n' )
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:
#line 64 "structspec_lexer.l++"
case 2:
#line 65 "structspec_lexer.l++"
case 3:
YY_RULE_SETUP
#line 65 "structspec_lexer.l++"
{yylval.fval = atof(yytext);
/*
fprintf(stderr, "float: %g\n", yylval.fval);
*/
return TOK_FLOAT;}
YY_BREAK
case 4:
YY_RULE_SETUP
#line 70 "structspec_lexer.l++"
{yylval.ival = atoi(yytext);
/*
fprintf(stderr, "int: %d", yylval.ival);
*/
return TOK_INT;}
YY_BREAK
case 5:
YY_RULE_SETUP
#line 75 "structspec_lexer.l++"
{yylval.len=length_from_str(yytext); return TOK_LENGTH;}
YY_BREAK
case 6:
YY_RULE_SETUP
#line 76 "structspec_lexer.l++"
{yylval.energy=energy_from_str(yytext); return TOK_ENERGY;}
YY_BREAK
case 7:
YY_RULE_SETUP
#line 77 "structspec_lexer.l++"
{oldstate=YY_START; BEGIN(STRINGREAD); gstr=g_string_new("");
fprintf(stderr, "BEGIN(STRINGREAD)\n");
}
YY_BREAK
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
#line 80 "structspec_lexer.l++"
{gstr = g_string_append(gstr, yytext);
fprintf(stderr, "got string piece %s\n", gstr->str);
}
YY_BREAK
case 9:
YY_RULE_SETUP
#line 83 "structspec_lexer.l++"
{gstr = g_string_append(gstr, "\""); fprintf(stderr, "Got escaped quote\n");}
YY_BREAK
case 10:
YY_RULE_SETUP
#line 84 "structspec_lexer.l++"
{gstr = g_string_append(gstr, "\\"); fprintf(stderr, "Got escaped backslash.\n");}
YY_BREAK
case 11:
YY_RULE_SETUP
#line 85 "structspec_lexer.l++"
{BEGIN(oldstate); yylval.str = gstr->str; g_string_free(gstr, FALSE); fprintf(stderr, "Got total string: (%s)\n", gstr->str); return TOK_STRING;}
YY_BREAK
case 12:
YY_RULE_SETUP
#line 86 "structspec_lexer.l++"
{fprintf(stderr, "STRUCTSPEC PARSING ERROR: while reading in a string, couldn't recognize characters \"%s\"\n", yytext); return 1;}
YY_BREAK
case 13:
YY_RULE_SETUP
#line 87 "structspec_lexer.l++"
{oldstate=YY_START; BEGIN(COMMENT);}
YY_BREAK
case 14:
/* rule 14 can match eol */
YY_RULE_SETUP
#line 88 "structspec_lexer.l++"
{BEGIN(oldstate); yylineno++;}
YY_BREAK
case 15:
YY_RULE_SETUP
#line 89 "structspec_lexer.l++"
{}
YY_BREAK
case 16:
YY_RULE_SETUP
#line 90 "structspec_lexer.l++"
{return TOK_STRUCTURE;}
YY_BREAK
case 17:
YY_RULE_SETUP
#line 91 "structspec_lexer.l++"
{return TOK_GRID;}
YY_BREAK
case 18:
YY_RULE_SETUP
#line 92 "structspec_lexer.l++"
{return TOK_REGION;}
YY_BREAK
case 19:
YY_RULE_SETUP
#line 93 "structspec_lexer.l++"
{return TOK_SHAPE;}
YY_BREAK
case 20:
YY_RULE_SETUP
#line 94 "structspec_lexer.l++"
{yylval.gt = CARTESIAN; return TOK_GRID_TYPE;}
YY_BREAK
case 21:
YY_RULE_SETUP
#line 95 "structspec_lexer.l++"
{return TOK_CONST;}
YY_BREAK
case 22:
YY_RULE_SETUP
#line 96 "structspec_lexer.l++"
{return TOK_CONST;}
YY_BREAK
case 23:
YY_RULE_SETUP
#line 97 "structspec_lexer.l++"
{return TOK_DOPING;}
YY_BREAK
case 24:
YY_RULE_SETUP
#line 98 "structspec_lexer.l++"
{return TOK_POTENTIAL;}
YY_BREAK
case 25:
YY_RULE_SETUP
#line 99 "structspec_lexer.l++"
{
fprintf(stderr, "identifier=%s\n", yytext);
yylval.str = strdup(yytext);
return TOK_IDENTIFIER;
}
YY_BREAK
case 26:
YY_RULE_SETUP
#line 104 "structspec_lexer.l++"
{}
YY_BREAK
case 27:
/* rule 27 can match eol */
YY_RULE_SETUP
#line 105 "structspec_lexer.l++"
{yylineno++;}
YY_BREAK
case 28:
YY_RULE_SETUP
#line 106 "structspec_lexer.l++"
{
/*
fprintf(stderr, "char=%c\n", yytext[0]);
*/
return yytext[0];}
YY_BREAK
case 29:
YY_RULE_SETUP
#line 111 "structspec_lexer.l++"
ECHO;
YY_BREAK
#line 1047 "kdotp/structspec_lexer.c++"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(STRINGREAD):
case YY_STATE_EOF(COMMENT):
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 yyin at a new source and called
* 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 = 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 ( yywrap( ) )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
* 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:| YY_BUFFER_STATE yy_create_buffer | ( | FILE * | file, |
| int | size | ||
| ) |
Allocate and initialize an input buffer state.
| file | A readable stream. |
| size | The character buffer size in bytes. When in doubt, use YY_BUF_SIZE. |
Definition at line 1564 of file structspec_lexer.c++.
References yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yy_init_buffer(), yy_buffer_state::yy_is_our_buffer, and yyalloc().
Referenced by if(), and yyrestart().
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in 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 *) yyalloc(b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer(b,file );
return b;
}
Here is the call graph for this function: Here is the caller graph for this function:| void yy_delete_buffer | ( | YY_BUFFER_STATE | b | ) |
Destroy the buffer.
| b | a buffer created with yy_create_buffer() |
Definition at line 1592 of file structspec_lexer.c++.
References yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_buffer_state::yy_is_our_buffer, and yyfree().
Referenced by yylex_destroy(), and yypop_buffer_state().
{
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 )
yyfree((void *) b->yy_ch_buf );
yyfree((void *) b );
}
Here is the call graph for this function: Here is the caller 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 1854 of file structspec_lexer.c++.
References YY_EXIT_FAILURE.
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
| void yy_flush_buffer | ( | YY_BUFFER_STATE | b | ) |
Discard all buffered characters. On the next scan, YY_INPUT will be called.
| b | the buffer state to be flushed, usually YY_CURRENT_BUFFER. |
Definition at line 1643 of file structspec_lexer.c++.
References yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, yy_load_buffer_state(), and yy_buffer_state::yy_n_chars.
Referenced by yy_init_buffer().
{
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 )
yy_load_buffer_state( );
}
Here is the call graph for this function: Here is the caller graph for this function:| static int yy_get_next_buffer | ( | void | ) | [static] |
Definition at line 1188 of file structspec_lexer.c++.
References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yy_c_buf_p, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yy_n_chars, YY_READ_BUF_SIZE, yyin, yyrealloc(), yyrestart(), and yytext_ptr.
Referenced by input(), and while().
{
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. */
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;
yyrestart(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 *) 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 1322 of file structspec_lexer.c++.
References yy_c_buf_p, yy_cp, yy_current_state, yy_last_accepting_cpos, yy_last_accepting_state, YY_MORE_ADJ, YY_SC_TO_UI, yy_start, and yytext_ptr.
Referenced by while().
{
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 >= 101 )
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 void yy_init_buffer | ( | YY_BUFFER_STATE | b, |
| FILE * | file | ||
| ) | [static] |
Definition at line 1615 of file structspec_lexer.c++.
References isatty(), yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_flush_buffer(), yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.
Referenced by yy_create_buffer(), and yyrestart().
{
int oerrno = errno;
yy_flush_buffer(b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_
* called from 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 int yy_init_globals | ( | void | ) | [static] |
Definition at line 1957 of file structspec_lexer.c++.
References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_c_buf_p, yy_init, yy_start, yyin, and yyout.
Referenced by yylex_destroy().
{
/* Initialization is the same as for the non-reentrant scanner.
* This function is called from yylex_destroy(), so don't allocate here.
*/
/* We do not touch yylineno unless the option is enabled. */
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
yyin = stdin;
yyout = stdout;
#else
yyin = (FILE *) 0;
yyout = (FILE *) 0;
#endif
/* For future reference: Set errno on error, since we are called by
* yylex_init()
*/
return 0;
}
Here is the caller graph for this function:| static void yy_load_buffer_state | ( | void | ) | [static] |
Definition at line 1550 of file structspec_lexer.c++.
References yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_hold_char, yy_n_chars, yyin, and yytext_ptr.
Referenced by if(), yy_flush_buffer(), yy_switch_to_buffer(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().
{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
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 yy_scan_buffer | ( | char * | base, |
| yy_size_t | size | ||
| ) |
Setup the input buffer state to scan directly from a user-specified character buffer.
| base | the character buffer |
| size | the size in bytes of the character buffer |
Definition at line 1770 of file structspec_lexer.c++.
References yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, yy_buffer_state::yy_buf_size, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, yy_buffer_state::yy_is_interactive, yy_buffer_state::yy_is_our_buffer, yy_buffer_state::yy_n_chars, yy_switch_to_buffer(), and yyalloc().
Referenced by yy_scan_bytes().
{
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) yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in 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;
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 yy_scan_bytes | ( | yyconst char * | yybytes, |
| int | _yybytes_len | ||
| ) |
Setup the input buffer state to scan the given bytes. The next call to yylex() will scan from a copy of bytes.
| yybytes | the byte buffer to scan |
| _yybytes_len | the number of bytes in the buffer pointed to by bytes. |
Definition at line 1820 of file structspec_lexer.c++.
References YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_is_our_buffer, yy_scan_buffer(), and yyalloc().
Referenced by yy_scan_string().
{
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 *) yyalloc(n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in 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 = yy_scan_buffer(buf,n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in 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 yy_scan_string | ( | yyconst char * | yystr | ) |
Setup the input buffer state to scan a string. The next call to yylex() will scan from a copy of str.
| yystr | a NUL-terminated string to scan |
Definition at line 1807 of file structspec_lexer.c++.
References yy_scan_bytes().
{
return yy_scan_bytes(yystr,strlen(yystr) );
}
Here is the call graph for this function:| void yy_switch_to_buffer | ( | YY_BUFFER_STATE | new_buffer | ) |
Switch to a different input buffer.
| new_buffer | The new input buffer. |
Definition at line 1519 of file structspec_lexer.c++.
References yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().
Referenced by yy_scan_buffer().
{
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
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;
yy_load_buffer_state( );
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
* is looked at is after 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:| static yy_state_type yy_try_NUL_trans | ( | yy_state_type | current_state | ) | [static] |
Definition at line 1354 of file structspec_lexer.c++.
References yy_c_buf_p, yy_current_state, yy_last_accepting_cpos, and yy_last_accepting_state.
Referenced by while().
{
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 >= 101 )
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 == 100);
return yy_is_jam ? 0 : yy_current_state;
}
Here is the caller graph for this function:Definition at line 2034 of file structspec_lexer.c++.
Referenced by yy_create_buffer(), yy_scan_buffer(), yy_scan_bytes(), yyensure_buffer_stack(), and yyparse().
{
return (void *) malloc( size );
}
Here is the caller graph for this function:| static void yyensure_buffer_stack | ( | void | ) | [static] |
Definition at line 1721 of file structspec_lexer.c++.
References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, YY_FATAL_ERROR, yyalloc(), and yyrealloc().
Referenced by if(), yy_switch_to_buffer(), yypush_buffer_state(), and yyrestart().
{
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**)yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in 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**)yyrealloc
((yy_buffer_stack),
num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in 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 yyfree | ( | void * | ptr | ) |
Definition at line 2051 of file structspec_lexer.c++.
Referenced by yy_delete_buffer(), and yylex_destroy().
{
free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
}
Here is the caller graph for this function:| int yyget_debug | ( | void | ) |
Definition at line 1947 of file structspec_lexer.c++.
References yy_flex_debug.
{
return yy_flex_debug;
}
| YY_EXTRA_TYPE yyget_extra | ( | void | ) |
| FILE * yyget_in | ( | void | ) |
Get the input stream.
Definition at line 1891 of file structspec_lexer.c++.
References yyin.
{
return yyin;
}
| int yyget_leng | ( | void | ) |
Get the length of the current token.
Definition at line 1907 of file structspec_lexer.c++.
References yyleng.
{
return yyleng;
}
| int yyget_lineno | ( | void | ) |
Get the current line number.
Definition at line 1882 of file structspec_lexer.c++.
References yylineno.
{
return yylineno;
}
| FILE * yyget_out | ( | void | ) |
Get the output stream.
Definition at line 1899 of file structspec_lexer.c++.
References yyout.
{
return yyout;
}
| char * yyget_text | ( | void | ) |
Get the current token.
Definition at line 1916 of file structspec_lexer.c++.
References yytext.
{
return yytext;
}
| int yylex | ( | void | ) |
| int yylex_destroy | ( | void | ) |
Definition at line 1989 of file structspec_lexer.c++.
References yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_init_globals(), yyfree(), and yypop_buffer_state().
{
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state();
}
/* Destroy the stack itself. */
yyfree((yy_buffer_stack) );
(yy_buffer_stack) = NULL;
/* Reset the globals. This is important in a non-reentrant scanner so the next time
* yylex() is called, initialization will occur. */
yy_init_globals( );
return 0;
}
Here is the call graph for this function:| void yypop_buffer_state | ( | void | ) |
Removes and deletes the top of the stack, if present. The next element becomes the new top.
Definition at line 1702 of file structspec_lexer.c++.
References yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_did_buffer_switch_on_eof, and yy_load_buffer_state().
Referenced by yylex_destroy().
{
if (!YY_CURRENT_BUFFER)
return;
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) {
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 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.
| new_buffer | The new state. |
Definition at line 1672 of file structspec_lexer.c++.
References yy_buffer_stack_top, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from 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 yy_switch_to_buffer. */
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
Here is the call graph for this function:| void * yyrealloc | ( | void * | ptr, |
| yy_size_t | size | ||
| ) |
Definition at line 2039 of file structspec_lexer.c++.
Referenced by yy_get_next_buffer(), and yyensure_buffer_stack().
{
/* 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 yyrestart | ( | FILE * | input_file | ) |
Immediately switch to a different input stream.
| input_file | A readable stream. |
INITIAL . Definition at line 1502 of file structspec_lexer.c++.
References YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_buffer(), yy_load_buffer_state(), yyensure_buffer_stack(), and yyin.
Referenced by input(), and yy_get_next_buffer().
{
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer(yyin,YY_BUF_SIZE );
}
yy_init_buffer(YY_CURRENT_BUFFER,input_file );
yy_load_buffer_state( );
}
Here is the call graph for this function: Here is the caller graph for this function:| void yyset_debug | ( | int | debug_flag | ) |
Definition at line 1952 of file structspec_lexer.c++.
{
yy_flex_debug = bdebug ;
}
| void yyset_extra | ( | YY_EXTRA_TYPE | user_defined | ) |
| void yyset_in | ( | FILE * | in_str | ) |
Set the input stream. This does not discard the current input buffer.
| in_str | A readable stream. |
Definition at line 1937 of file structspec_lexer.c++.
References yyin.
{
yyin = in_str ;
}
| void yyset_lineno | ( | int | line_number | ) |
Set the current line number.
| line_number |
Definition at line 1925 of file structspec_lexer.c++.
{
yylineno = line_number;
}
| void yyset_out | ( | FILE * | out_str | ) |
| static void yyunput | ( | int | c, |
| char * | buf_ptr | ||
| ) | [static] |
| static void yyunput | ( | int | c, |
| register char * | yy_bp | ||
| ) | [static] |
Definition at line 1377 of file structspec_lexer.c++.
References if(), yy_c_buf_p, yy_cp, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yy_hold_char, yy_n_chars, yylineno, and yytext_ptr.
{
register char *yy_cp;
yy_cp = (yy_c_buf_p);
/* undo effects of setting up yytext */
*yy_cp = (yy_hold_char);
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
if ( c == '\n' ){
--yylineno;
}
(yytext_ptr) = yy_bp;
(yy_hold_char) = *yy_cp;
(yy_c_buf_p) = yy_cp;
}
Here is the call graph for this function:| GString* gstr |
Definition at line 577 of file structspec_lexer.c++.
| GInputStream* instream |
Definition at line 580 of file structspec_lexer.c++.
Referenced by main(), and process_args().
| int oldstate |
Definition at line 578 of file structspec_lexer.c++.
yyconst flex_int16_t yy_accept[101] [static] |
{ 0,
0, 0, 0, 0, 0, 0, 30, 28, 26, 27,
7, 13, 28, 4, 5, 25, 25, 6, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25, 8, 8,
11, 12, 15, 14, 3, 1, 4, 0, 25, 6,
25, 25, 25, 25, 25, 5, 25, 25, 25, 25,
8, 9, 10, 0, 1, 0, 2, 25, 25, 25,
25, 25, 25, 25, 25, 0, 3, 25, 25, 25,
17, 25, 25, 25, 25, 25, 21, 25, 25, 25,
19, 25, 25, 25, 23, 25, 18, 25, 25, 25,
25, 25, 25, 22, 25, 25, 20, 24, 16, 0
}
Definition at line 396 of file structspec_lexer.c++.
| register int yy_act |
Definition at line 787 of file structspec_lexer.c++.
yyconst flex_int16_t yy_base[105] [static] |
{ 0,
0, 0, 28, 30, 128, 127, 129, 132, 132, 132,
132, 132, 120, 28, 0, 0, 107, 0, 22, 101,
25, 98, 101, 100, 97, 103, 20, 97, 0, 0,
132, 37, 132, 132, 37, 42, 50, 48, 0, 0,
92, 94, 91, 97, 94, 0, 85, 94, 97, 84,
0, 132, 132, 56, 55, 102, 101, 79, 79, 85,
88, 86, 82, 76, 71, 92, 91, 80, 68, 72,
0, 71, 69, 75, 76, 63, 75, 70, 59, 63,
0, 57, 64, 60, 0, 62, 0, 51, 57, 42,
55, 42, 43, 0, 43, 41, 0, 0, 0, 132,
73, 76, 40, 79
}
Definition at line 450 of file structspec_lexer.c++.
| register char * yy_bp |
Definition at line 786 of file structspec_lexer.c++.
YY_BUFFER_STATE* yy_buffer_stack = 0 [static] |
Stack as an array.
Definition at line 276 of file structspec_lexer.c++.
Referenced by yy_init_globals(), yyensure_buffer_stack(), and yylex_destroy().
size_t yy_buffer_stack_max = 0 [static] |
capacity of stack.
Definition at line 275 of file structspec_lexer.c++.
Referenced by yy_init_globals(), and yyensure_buffer_stack().
size_t yy_buffer_stack_top = 0 [static] |
index of top of stack.
Definition at line 274 of file structspec_lexer.c++.
Referenced by yy_init_globals(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().
char* yy_c_buf_p = (char *) 0 [static] |
Definition at line 299 of file structspec_lexer.c++.
Referenced by input(), while(), yy_get_next_buffer(), yy_get_previous_state(), yy_init_globals(), yy_load_buffer_state(), yy_switch_to_buffer(), yy_try_NUL_trans(), yypush_buffer_state(), and yyunput().
yyconst flex_int16_t yy_chk[163] [static] |
{ 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,
3, 3, 4, 4, 14, 14, 19, 21, 14, 27,
32, 3, 103, 4, 35, 14, 19, 35, 27, 36,
32, 21, 36, 38, 35, 38, 37, 37, 96, 36,
37, 54, 55, 54, 95, 55, 93, 37, 92, 91,
90, 89, 55, 101, 101, 101, 102, 102, 102, 104,
88, 104, 86, 84, 83, 82, 80, 79, 78, 77,
76, 75, 74, 73, 72, 70, 69, 68, 67, 66,
65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
50, 49, 48, 47, 45, 44, 43, 42, 41, 28,
26, 25, 24, 23, 22, 20, 17, 13, 7, 6,
5, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100
}
Definition at line 504 of file structspec_lexer.c++.
| register char* yy_cp |
Definition at line 786 of file structspec_lexer.c++.
Referenced by while(), yy_get_previous_state(), and yyunput().
| YY_DECL register yy_state_type yy_current_state |
The main scanner function which does all the work.
Definition at line 785 of file structspec_lexer.c++.
Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().
yyconst flex_int16_t yy_def[105] [static] |
{ 0,
100, 1, 101, 101, 102, 102, 100, 100, 100, 100,
100, 100, 100, 100, 103, 103, 103, 103, 103, 103,
103, 103, 103, 103, 103, 103, 103, 103, 104, 104,
100, 100, 100, 100, 100, 100, 100, 100, 103, 103,
103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
104, 100, 100, 100, 100, 100, 100, 103, 103, 103,
103, 103, 103, 103, 103, 100, 100, 103, 103, 103,
103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
103, 103, 103, 103, 103, 103, 103, 103, 103, 0,
100, 100, 100, 100
}
Definition at line 466 of file structspec_lexer.c++.
int yy_did_buffer_switch_on_eof [static] |
Definition at line 306 of file structspec_lexer.c++.
Referenced by input(), while(), yy_switch_to_buffer(), yypop_buffer_state(), and yypush_buffer_state().
yyconst flex_int32_t yy_ec[256] [static] |
Definition at line 411 of file structspec_lexer.c++.
| int yy_flex_debug = 0 |
Definition at line 536 of file structspec_lexer.c++.
Referenced by yyget_debug().
char yy_hold_char [static] |
Definition at line 294 of file structspec_lexer.c++.
Referenced by input(), while(), yy_load_buffer_state(), yy_switch_to_buffer(), yypush_buffer_state(), and yyunput().
int yy_init = 0 [static] |
Definition at line 300 of file structspec_lexer.c++.
Referenced by if(), and yy_init_globals().
char* yy_last_accepting_cpos [static] |
Definition at line 533 of file structspec_lexer.c++.
Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().
yy_state_type yy_last_accepting_state [static] |
Definition at line 532 of file structspec_lexer.c++.
Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().
yyconst flex_int32_t yy_meta[31] [static] |
{ 0,
1, 1, 1, 2, 1, 1, 1, 3, 3, 3,
3, 3, 3, 2, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3
}
Definition at line 443 of file structspec_lexer.c++.
int yy_n_chars [static] |
Definition at line 295 of file structspec_lexer.c++.
Referenced by input(), while(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yypush_buffer_state(), and yyunput().
yyconst flex_int16_t yy_nxt[163] [static] |
{ 0,
8, 9, 10, 11, 12, 8, 13, 14, 15, 16,
17, 18, 16, 8, 16, 19, 20, 21, 22, 16,
16, 16, 23, 24, 16, 25, 26, 27, 16, 28,
30, 31, 30, 31, 36, 37, 41, 40, 38, 49,
52, 32, 39, 32, 35, 38, 42, 54, 50, 55,
53, 44, 38, 56, 54, 57, 36, 37, 99, 38,
38, 66, 55, 67, 98, 38, 97, 38, 96, 95,
94, 93, 38, 29, 29, 29, 33, 33, 33, 51,
92, 51, 91, 90, 89, 88, 87, 86, 85, 84,
83, 82, 81, 80, 79, 78, 77, 76, 67, 67,
75, 74, 73, 72, 71, 70, 69, 68, 57, 57,
65, 64, 63, 62, 61, 40, 60, 59, 58, 46,
48, 47, 46, 46, 45, 43, 40, 35, 100, 34,
34, 7, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100
}
Definition at line 482 of file structspec_lexer.c++.
yyconst flex_int32_t yy_rule_can_match_eol[30] [static] |
{ 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, }
Definition at line 527 of file structspec_lexer.c++.
int yy_start = 0 [static] |
Definition at line 301 of file structspec_lexer.c++.
Referenced by if(), while(), yy_get_previous_state(), and yy_init_globals().
| FILE * yyin = (FILE *) 0 |
Definition at line 361 of file structspec_lexer.c++.
Referenced by if(), input(), while(), yy_get_next_buffer(), yy_init_globals(), yy_load_buffer_state(), yyget_in(), yyrestart(), and yyset_in().
| int yyleng |
Definition at line 296 of file structspec_lexer.c++.
Referenced by while(), and yyget_leng().
| int yylineno = 1 |
Definition at line 367 of file structspec_lexer.c++.
Referenced by yyget_lineno(), and yyunput().
| FILE * yyout = (FILE *) 0 |
Definition at line 361 of file structspec_lexer.c++.
Referenced by if(), yy_init_globals(), yyget_out(), and yyset_out().
| char * yytext |
Definition at line 545 of file structspec_lexer.c++.
Referenced by yyget_text().
1.7.3