--- /dev/null
+\r
+#line 3 "lex.yyfmi1.c"\r
+\r
+#define YY_INT_ALIGNED short int\r
+\r
+/* A lexical scanner generated by flex */\r
+\r
+#define FLEX_SCANNER\r
+#define YY_FLEX_MAJOR_VERSION 2\r
+#define YY_FLEX_MINOR_VERSION 5\r
+#define YY_FLEX_SUBMINOR_VERSION 37\r
+#if YY_FLEX_SUBMINOR_VERSION > 0\r
+#define FLEX_BETA\r
+#endif\r
+\r
+/* First, we deal with platform-specific or compiler-specific issues. */\r
+\r
+/* begin standard C headers. */\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#include <stdlib.h>\r
+\r
+/* end standard C headers. */\r
+\r
+/* flex integer type definitions */\r
+\r
+#ifndef FLEXINT_H\r
+#define FLEXINT_H\r
+\r
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */\r
+\r
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L\r
+\r
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,\r
+ * if you want the limit (max/min) macros for int types. \r
+ */\r
+#ifndef __STDC_LIMIT_MACROS\r
+#define __STDC_LIMIT_MACROS 1\r
+#endif\r
+\r
+#include <inttypes.h>\r
+typedef int8_t flex_int8_t;\r
+typedef uint8_t flex_uint8_t;\r
+typedef int16_t flex_int16_t;\r
+typedef uint16_t flex_uint16_t;\r
+typedef int32_t flex_int32_t;\r
+typedef uint32_t flex_uint32_t;\r
+#else\r
+typedef signed char flex_int8_t;\r
+typedef short int flex_int16_t;\r
+typedef int flex_int32_t;\r
+typedef unsigned char flex_uint8_t; \r
+typedef unsigned short int flex_uint16_t;\r
+typedef unsigned int flex_uint32_t;\r
+\r
+/* Limits of integral types. */\r
+#ifndef INT8_MIN\r
+#define INT8_MIN (-128)\r
+#endif\r
+#ifndef INT16_MIN\r
+#define INT16_MIN (-32767-1)\r
+#endif\r
+#ifndef INT32_MIN\r
+#define INT32_MIN (-2147483647-1)\r
+#endif\r
+#ifndef INT8_MAX\r
+#define INT8_MAX (127)\r
+#endif\r
+#ifndef INT16_MAX\r
+#define INT16_MAX (32767)\r
+#endif\r
+#ifndef INT32_MAX\r
+#define INT32_MAX (2147483647)\r
+#endif\r
+#ifndef UINT8_MAX\r
+#define UINT8_MAX (255U)\r
+#endif\r
+#ifndef UINT16_MAX\r
+#define UINT16_MAX (65535U)\r
+#endif\r
+#ifndef UINT32_MAX\r
+#define UINT32_MAX (4294967295U)\r
+#endif\r
+\r
+#endif /* ! C99 */\r
+\r
+#endif /* ! FLEXINT_H */\r
+\r
+#ifdef __cplusplus\r
+\r
+/* The "const" storage-class-modifier is valid. */\r
+#define YY_USE_CONST\r
+\r
+#else /* ! __cplusplus */\r
+\r
+/* C99 requires __STDC__ to be defined as 1. */\r
+#if defined (__STDC__)\r
+\r
+#define YY_USE_CONST\r
+\r
+#endif /* defined (__STDC__) */\r
+#endif /* ! __cplusplus */\r
+\r
+#ifdef YY_USE_CONST\r
+#define yyconst const\r
+#else\r
+#define yyconst\r
+#endif\r
+\r
+/* Returned upon end-of-file. */\r
+#define YY_NULL 0\r
+\r
+/* Promotes a possibly negative, possibly signed char to an unsigned\r
+ * integer for use as an array index. If the signed char is negative,\r
+ * we want to instead treat it as an 8-bit unsigned char, hence the\r
+ * double cast.\r
+ */\r
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)\r
+\r
+/* An opaque pointer. */\r
+#ifndef YY_TYPEDEF_YY_SCANNER_T\r
+#define YY_TYPEDEF_YY_SCANNER_T\r
+typedef void* yyscan_t;\r
+#endif\r
+\r
+/* For convenience, these vars (plus the bison vars far below)\r
+ are macros in the reentrant scanner. */\r
+#define yyin yyg->yyin_r\r
+#define yyout yyg->yyout_r\r
+#define yyextra yyg->yyextra_r\r
+#define yyleng yyg->yyleng_r\r
+#define yytext yyg->yytext_r\r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)\r
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)\r
+#define yy_flex_debug yyg->yy_flex_debug_r\r
+\r
+/* Enter a start condition. This macro really ought to take a parameter,\r
+ * but we do it the disgusting crufty way forced on us by the ()-less\r
+ * definition of BEGIN.\r
+ */\r
+#define BEGIN yyg->yy_start = 1 + 2 *\r
+\r
+/* Translate the current start state into a value that can be later handed\r
+ * to BEGIN to return to the state. The YYSTATE alias is for lex\r
+ * compatibility.\r
+ */\r
+#define YY_START ((yyg->yy_start - 1) / 2)\r
+#define YYSTATE YY_START\r
+\r
+/* Action number for EOF rule of a given start state. */\r
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)\r
+\r
+/* Special action meaning "start processing a new file". */\r
+#define YY_NEW_FILE yyfmi1restart(yyin ,yyscanner )\r
+\r
+#define YY_END_OF_BUFFER_CHAR 0\r
+\r
+/* Size of default input buffer. */\r
+#ifndef YY_BUF_SIZE\r
+#define YY_BUF_SIZE 16384\r
+#endif\r
+\r
+/* The state buf must be large enough to hold one state per character in the main buffer.\r
+ */\r
+#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))\r
+\r
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE\r
+#define YY_TYPEDEF_YY_BUFFER_STATE\r
+typedef struct yy_buffer_state *YY_BUFFER_STATE;\r
+#endif\r
+\r
+#ifndef YY_TYPEDEF_YY_SIZE_T\r
+#define YY_TYPEDEF_YY_SIZE_T\r
+typedef size_t yy_size_t;\r
+#endif\r
+\r
+#define EOB_ACT_CONTINUE_SCAN 0\r
+#define EOB_ACT_END_OF_FILE 1\r
+#define EOB_ACT_LAST_MATCH 2\r
+\r
+ #define YY_LESS_LINENO(n)\r
+ \r
+/* Return all but the first "n" matched characters back to the input stream. */\r
+#define yyless(n) \\r
+ do \\r
+ { \\r
+ /* Undo effects of setting up yytext. */ \\r
+ int yyless_macro_arg = (n); \\r
+ YY_LESS_LINENO(yyless_macro_arg);\\r
+ *yy_cp = yyg->yy_hold_char; \\r
+ YY_RESTORE_YY_MORE_OFFSET \\r
+ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \\r
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \\r
+ } \\r
+ while ( 0 )\r
+\r
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )\r
+\r
+#ifndef YY_STRUCT_YY_BUFFER_STATE\r
+#define YY_STRUCT_YY_BUFFER_STATE\r
+struct yy_buffer_state\r
+ {\r
+ FILE *yy_input_file;\r
+\r
+ char *yy_ch_buf; /* input buffer */\r
+ char *yy_buf_pos; /* current position in input buffer */\r
+\r
+ /* Size of input buffer in bytes, not including room for EOB\r
+ * characters.\r
+ */\r
+ yy_size_t yy_buf_size;\r
+\r
+ /* Number of characters read into yy_ch_buf, not including EOB\r
+ * characters.\r
+ */\r
+ yy_size_t yy_n_chars;\r
+\r
+ /* Whether we "own" the buffer - i.e., we know we created it,\r
+ * and can realloc() it to grow it, and should free() it to\r
+ * delete it.\r
+ */\r
+ int yy_is_our_buffer;\r
+\r
+ /* Whether this is an "interactive" input source; if so, and\r
+ * if we're using stdio for input, then we want to use getc()\r
+ * instead of fread(), to make sure we stop fetching input after\r
+ * each newline.\r
+ */\r
+ int yy_is_interactive;\r
+\r
+ /* Whether we're considered to be at the beginning of a line.\r
+ * If so, '^' rules will be active on the next match, otherwise\r
+ * not.\r
+ */\r
+ int yy_at_bol;\r
+\r
+ int yy_bs_lineno; /**< The line count. */\r
+ int yy_bs_column; /**< The column count. */\r
+ \r
+ /* Whether to try to fill the input buffer when we reach the\r
+ * end of it.\r
+ */\r
+ int yy_fill_buffer;\r
+\r
+ int yy_buffer_status;\r
+\r
+#define YY_BUFFER_NEW 0\r
+#define YY_BUFFER_NORMAL 1\r
+ /* When an EOF's been seen but there's still some text to process\r
+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we\r
+ * shouldn't try reading from the input source any more. We might\r
+ * still have a bunch of tokens to match, though, because of\r
+ * possible backing-up.\r
+ *\r
+ * When we actually see the EOF, we change the status to "new"\r
+ * (via yyfmi1restart()), so that the user can continue scanning by\r
+ * just pointing yyin at a new input file.\r
+ */\r
+#define YY_BUFFER_EOF_PENDING 2\r
+\r
+ };\r
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */\r
+\r
+/* We provide macros for accessing buffer states in case in the\r
+ * future we want to put the buffer states in a more general\r
+ * "scanner state".\r
+ *\r
+ * Returns the top of the stack, or NULL.\r
+ */\r
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \\r
+ ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \\r
+ : NULL)\r
+\r
+/* Same as previous macro, but useful when we know that the buffer stack is not\r
+ * NULL or when we need an lvalue. For internal use only.\r
+ */\r
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]\r
+\r
+void yyfmi1restart (FILE *input_file ,yyscan_t yyscanner );\r
+void yyfmi1_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );\r
+YY_BUFFER_STATE yyfmi1_create_buffer (FILE *file,int size ,yyscan_t yyscanner );\r
+void yyfmi1_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );\r
+void yyfmi1_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );\r
+void yyfmi1push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );\r
+void yyfmi1pop_buffer_state (yyscan_t yyscanner );\r
+\r
+static void yyfmi1ensure_buffer_stack (yyscan_t yyscanner );\r
+static void yyfmi1_load_buffer_state (yyscan_t yyscanner );\r
+static void yyfmi1_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );\r
+\r
+#define YY_FLUSH_BUFFER yyfmi1_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)\r
+\r
+YY_BUFFER_STATE yyfmi1_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );\r
+YY_BUFFER_STATE yyfmi1_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );\r
+YY_BUFFER_STATE yyfmi1_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );\r
+\r
+void *yyfmi1alloc (yy_size_t ,yyscan_t yyscanner );\r
+void *yyfmi1realloc (void *,yy_size_t ,yyscan_t yyscanner );\r
+void yyfmi1free (void * ,yyscan_t yyscanner );\r
+\r
+#define yy_new_buffer yyfmi1_create_buffer\r
+\r
+#define yy_set_interactive(is_interactive) \\r
+ { \\r
+ if ( ! YY_CURRENT_BUFFER ){ \\r
+ yyfmi1ensure_buffer_stack (yyscanner); \\r
+ YY_CURRENT_BUFFER_LVALUE = \\r
+ yyfmi1_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \\r
+ } \\r
+ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \\r
+ }\r
+\r
+#define yy_set_bol(at_bol) \\r
+ { \\r
+ if ( ! YY_CURRENT_BUFFER ){\\r
+ yyfmi1ensure_buffer_stack (yyscanner); \\r
+ YY_CURRENT_BUFFER_LVALUE = \\r
+ yyfmi1_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \\r
+ } \\r
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \\r
+ }\r
+\r
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)\r
+\r
+#define yyfmi1wrap(yyscanner) 1\r
+#define YY_SKIP_YYWRAP\r
+\r
+typedef unsigned char YY_CHAR;\r
+\r
+typedef int yy_state_type;\r
+\r
+#define yytext_ptr yytext_r\r
+\r
+static yy_state_type yy_get_previous_state (yyscan_t yyscanner );\r
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);\r
+static int yy_get_next_buffer (yyscan_t yyscanner );\r
+static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );\r
+\r
+/* Done after the current pattern has been matched and before the\r
+ * corresponding action - sets up yytext.\r
+ */\r
+#define YY_DO_BEFORE_ACTION \\r
+ yyg->yytext_ptr = yy_bp; \\r
+ yyleng = (size_t) (yy_cp - yy_bp); \\r
+ yyg->yy_hold_char = *yy_cp; \\r
+ *yy_cp = '\0'; \\r
+ yyg->yy_c_buf_p = yy_cp;\r
+\r
+#define YY_NUM_RULES 13\r
+#define YY_END_OF_BUFFER 14\r
+/* This struct is not used in this scanner,\r
+ but its presence is necessary. */\r
+struct yy_trans_info\r
+ {\r
+ flex_int32_t yy_verify;\r
+ flex_int32_t yy_nxt;\r
+ };\r
+static yyconst flex_int16_t yy_accept[27] =\r
+ { 0,\r
+ 0, 0, 14, 12, 13, 12, 2, 3, 5, 6,\r
+ 11, 10, 7, 8, 10, 0, 0, 0, 4, 11,\r
+ 0, 9, 0, 0, 1, 0\r
+ } ;\r
+\r
+static yyconst flex_int32_t yy_ec[256] =\r
+ { 0,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 3, 1, 4, 1, 1, 1, 1, 5, 6,\r
+ 7, 1, 1, 8, 1, 9, 1, 10, 10, 10,\r
+ 10, 10, 10, 10, 10, 10, 10, 1, 1, 1,\r
+ 1, 1, 11, 1, 12, 12, 12, 12, 12, 12,\r
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\r
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\r
+ 13, 14, 15, 1, 12, 1, 16, 17, 12, 18,\r
+\r
+ 19, 20, 12, 12, 12, 12, 12, 12, 12, 21,\r
+ 12, 12, 12, 22, 12, 23, 12, 24, 12, 12,\r
+ 12, 12, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1\r
+ } ;\r
+\r
+static yyconst flex_int32_t yy_meta[25] =\r
+ { 0,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1\r
+ } ;\r
+\r
+static yyconst flex_int16_t yy_base[27] =\r
+ { 0,\r
+ 0, 0, 63, 70, 70, 24, 70, 70, 57, 70,\r
+ 48, 70, 70, 70, 38, 50, 49, 45, 70, 43,\r
+ 30, 70, 46, 23, 70, 70\r
+ } ;\r
+\r
+static yyconst flex_int16_t yy_def[27] =\r
+ { 0,\r
+ 26, 1, 26, 26, 26, 26, 26, 26, 26, 26,\r
+ 26, 26, 26, 26, 26, 6, 6, 26, 26, 26,\r
+ 26, 26, 6, 26, 26, 0\r
+ } ;\r
+\r
+static yyconst flex_int16_t yy_nxt[95] =\r
+ { 0,\r
+ 4, 5, 4, 4, 6, 7, 8, 9, 10, 11,\r
+ 4, 12, 13, 4, 14, 12, 12, 15, 12, 12,\r
+ 12, 12, 12, 12, 16, 16, 16, 16, 25, 16,\r
+ 16, 16, 16, 17, 16, 17, 16, 18, 16, 17,\r
+ 17, 17, 17, 17, 17, 17, 17, 17, 23, 23,\r
+ 22, 24, 20, 22, 22, 23, 21, 20, 23, 19,\r
+ 23, 23, 26, 26, 23, 23, 23, 23, 23, 3,\r
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\r
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\r
+ 26, 26, 26, 26\r
+\r
+ } ;\r
+\r
+static yyconst flex_int16_t yy_chk[95] =\r
+ { 0,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 6, 6, 6, 6, 24, 6,\r
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\r
+ 6, 6, 6, 6, 6, 6, 6, 6, 18, 18,\r
+ 23, 21, 20, 17, 16, 18, 15, 11, 18, 9,\r
+ 18, 18, 3, 0, 18, 18, 18, 18, 18, 26,\r
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\r
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\r
+ 26, 26, 26, 26\r
+\r
+ } ;\r
+\r
+/* The intent behind this definition is that it'll catch\r
+ * any uses of REJECT which flex missed.\r
+ */\r
+#define REJECT reject_used_but_not_detected\r
+#define yymore() yymore_used_but_not_detected\r
+#define YY_MORE_ADJ 0\r
+#define YY_RESTORE_YY_MORE_OFFSET\r
+/*\r
+ Copyright (C) 2012 Modelon AB\r
+\r
+ This program is free software: you can redistribute it and/or modify\r
+ it under the terms of the BSD style license.\r
+\r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ FMILIB_License.txt file for more details.\r
+\r
+ You should have received a copy of the FMILIB_License.txt file\r
+ along with this program. If not, contact Modelon AB <http://www.modelon.com>.\r
+*/\r
+#include "fmi1_xml_variable_name_parser.tab.h"\r
+#define YYSTYPE YYFMI1STYPE\r
+\r
+#define LEX_VAL(ID_NAME) return ID_NAME;\r
+\r
+#define INITIAL 0\r
+\r
+#ifndef YY_NO_UNISTD_H\r
+/* Special case for "unistd.h", since it is non-ANSI. We include it way\r
+ * down here because we want the user's section 1 to have been scanned first.\r
+ * The user has a chance to override it with an option.\r
+ */\r
+#include <unistd.h>\r
+#else\r
+/*windows compatibility case*/\r
+#include <io.h>\r
+#define isatty _isatty\r
+#define fileno _fileno\r
+#endif\r
+ \r
+#ifndef YY_EXTRA_TYPE\r
+#define YY_EXTRA_TYPE void *\r
+#endif\r
+\r
+/* Holds the entire state of the reentrant scanner. */\r
+struct yyguts_t\r
+ {\r
+\r
+ /* User-defined. Not touched by flex. */\r
+ YY_EXTRA_TYPE yyextra_r;\r
+\r
+ /* The rest are the same as the globals declared in the non-reentrant scanner. */\r
+ FILE *yyin_r, *yyout_r;\r
+ size_t yy_buffer_stack_top; /**< index of top of stack. */\r
+ size_t yy_buffer_stack_max; /**< capacity of stack. */\r
+ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */\r
+ char yy_hold_char;\r
+ yy_size_t yy_n_chars;\r
+ yy_size_t yyleng_r;\r
+ char *yy_c_buf_p;\r
+ int yy_init;\r
+ int yy_start;\r
+ int yy_did_buffer_switch_on_eof;\r
+ int yy_start_stack_ptr;\r
+ int yy_start_stack_depth;\r
+ int *yy_start_stack;\r
+ yy_state_type yy_last_accepting_state;\r
+ char* yy_last_accepting_cpos;\r
+\r
+ int yylineno_r;\r
+ int yy_flex_debug_r;\r
+\r
+ char *yytext_r;\r
+ int yy_more_flag;\r
+ int yy_more_len;\r
+\r
+ YYSTYPE * yylval_r;\r
+\r
+ }; /* end struct yyguts_t */\r
+\r
+static int yy_init_globals (yyscan_t yyscanner );\r
+\r
+ /* This must go here because YYSTYPE and YYLTYPE are included\r
+ * from bison output in section 1.*/\r
+ # define yylval yyg->yylval_r\r
+ \r
+int yyfmi1lex_init (yyscan_t* scanner);\r
+\r
+int yyfmi1lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);\r
+\r
+/* Accessor methods to globals.\r
+ These are made visible to non-reentrant scanners for convenience. */\r
+\r
+int yyfmi1lex_destroy (yyscan_t yyscanner );\r
+\r
+int yyfmi1get_debug (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_debug (int debug_flag ,yyscan_t yyscanner );\r
+\r
+YY_EXTRA_TYPE yyfmi1get_extra (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );\r
+\r
+FILE *yyfmi1get_in (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_in (FILE * in_str ,yyscan_t yyscanner );\r
+\r
+FILE *yyfmi1get_out (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_out (FILE * out_str ,yyscan_t yyscanner );\r
+\r
+yy_size_t yyfmi1get_leng (yyscan_t yyscanner );\r
+\r
+char *yyfmi1get_text (yyscan_t yyscanner );\r
+\r
+int yyfmi1get_lineno (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_lineno (int line_number ,yyscan_t yyscanner );\r
+\r
+int yyfmi1get_column (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_column (int column_no ,yyscan_t yyscanner );\r
+\r
+YYSTYPE * yyfmi1get_lval (yyscan_t yyscanner );\r
+\r
+void yyfmi1set_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );\r
+\r
+/* Macros after this point can all be overridden by user definitions in\r
+ * section 1.\r
+ */\r
+\r
+#ifndef YY_SKIP_YYWRAP\r
+#ifdef __cplusplus\r
+extern "C" int yyfmi1wrap (yyscan_t yyscanner );\r
+#else\r
+extern int yyfmi1wrap (yyscan_t yyscanner );\r
+#endif\r
+#endif\r
+\r
+ static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);\r
+ \r
+#ifndef yytext_ptr\r
+static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);\r
+#endif\r
+\r
+#ifdef YY_NEED_STRLEN\r
+static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);\r
+#endif\r
+\r
+#ifndef YY_NO_INPUT\r
+\r
+#ifdef __cplusplus\r
+static int yyinput (yyscan_t yyscanner );\r
+#else\r
+static int input (yyscan_t yyscanner );\r
+#endif\r
+\r
+#endif\r
+\r
+/* Amount of stuff to slurp up with each read. */\r
+#ifndef YY_READ_BUF_SIZE\r
+#define YY_READ_BUF_SIZE 8192\r
+#endif\r
+\r
+/* Copy whatever the last rule matched to the standard output. */\r
+#ifndef ECHO\r
+/* This used to be an fputs(), but since the string might contain NUL's,\r
+ * we now use fwrite().\r
+ */\r
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)\r
+#endif\r
+\r
+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,\r
+ * is returned in "result".\r
+ */\r
+#ifndef YY_INPUT\r
+#define YY_INPUT(buf,result,max_size) \\r
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\r
+ { \\r
+ int c = '*'; \\r
+ size_t n; \\r
+ for ( n = 0; n < max_size && \\r
+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \\r
+ buf[n] = (char) c; \\r
+ if ( c == '\n' ) \\r
+ buf[n++] = (char) c; \\r
+ if ( c == EOF && ferror( yyin ) ) \\r
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \\r
+ result = n; \\r
+ } \\r
+ else \\r
+ { \\r
+ errno=0; \\r
+ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\r
+ { \\r
+ if( errno != EINTR) \\r
+ { \\r
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \\r
+ break; \\r
+ } \\r
+ errno=0; \\r
+ clearerr(yyin); \\r
+ } \\r
+ }\\r
+\\r
+\r
+#endif\r
+\r
+/* No semi-colon after return; correct usage is to write "yyterminate();" -\r
+ * we don't want an extra ';' after the "return" because that will cause\r
+ * some compilers to complain about unreachable statements.\r
+ */\r
+#ifndef yyterminate\r
+#define yyterminate() return YY_NULL\r
+#endif\r
+\r
+/* Number of entries by which start-condition stack grows. */\r
+#ifndef YY_START_STACK_INCR\r
+#define YY_START_STACK_INCR 25\r
+#endif\r
+\r
+/* Report a fatal error. */\r
+#ifndef YY_FATAL_ERROR\r
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)\r
+#endif\r
+\r
+/* end tables serialization structures and prototypes */\r
+\r
+/* Default declaration of generated scanner - a define so the user can\r
+ * easily add parameters.\r
+ */\r
+#ifndef YY_DECL\r
+#define YY_DECL_IS_OURS 1\r
+\r
+extern int yyfmi1lex \\r
+ (YYSTYPE * yylval_param ,yyscan_t yyscanner);\r
+\r
+#define YY_DECL int yyfmi1lex \\r
+ (YYSTYPE * yylval_param , yyscan_t yyscanner)\r
+#endif /* !YY_DECL */\r
+\r
+/* Code executed at the beginning of each rule, after yytext and yyleng\r
+ * have been set up.\r
+ */\r
+#ifndef YY_USER_ACTION\r
+#define YY_USER_ACTION\r
+#endif\r
+\r
+/* Code executed at the end of each rule. */\r
+#ifndef YY_BREAK\r
+#define YY_BREAK break;\r
+#endif\r
+\r
+#define YY_RULE_SETUP \\r
+ YY_USER_ACTION\r
+\r
+/** The main scanner function which does all the work.\r
+ */\r
+YY_DECL\r
+{\r
+ register yy_state_type yy_current_state;\r
+ register char *yy_cp, *yy_bp;\r
+ register int yy_act;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ yylval = yylval_param;\r
+\r
+ if ( !yyg->yy_init )\r
+ {\r
+ yyg->yy_init = 1;\r
+\r
+#ifdef YY_USER_INIT\r
+ YY_USER_INIT;\r
+#endif\r
+\r
+ if ( ! yyg->yy_start )\r
+ yyg->yy_start = 1; /* first start state */\r
+\r
+ if ( ! yyin )\r
+ yyin = stdin;\r
+\r
+ if ( ! yyout )\r
+ yyout = stdout;\r
+\r
+ if ( ! YY_CURRENT_BUFFER ) {\r
+ yyfmi1ensure_buffer_stack (yyscanner);\r
+ YY_CURRENT_BUFFER_LVALUE =\r
+ yyfmi1_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);\r
+ }\r
+\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+ }\r
+\r
+ while ( 1 ) /* loops until end-of-file is reached */\r
+ {\r
+ yy_cp = yyg->yy_c_buf_p;\r
+\r
+ /* Support of yytext. */\r
+ *yy_cp = yyg->yy_hold_char;\r
+\r
+ /* yy_bp points to the position in yy_ch_buf of the start of\r
+ * the current run.\r
+ */\r
+ yy_bp = yy_cp;\r
+\r
+ yy_current_state = yyg->yy_start;\r
+yy_match:\r
+ do\r
+ {\r
+ register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];\r
+ if ( yy_accept[yy_current_state] )\r
+ {\r
+ yyg->yy_last_accepting_state = yy_current_state;\r
+ yyg->yy_last_accepting_cpos = yy_cp;\r
+ }\r
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
+ {\r
+ yy_current_state = (int) yy_def[yy_current_state];\r
+ if ( yy_current_state >= 27 )\r
+ yy_c = yy_meta[(unsigned int) yy_c];\r
+ }\r
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
+ ++yy_cp;\r
+ }\r
+ while ( yy_base[yy_current_state] != 70 );\r
+\r
+yy_find_action:\r
+ yy_act = yy_accept[yy_current_state];\r
+ if ( yy_act == 0 )\r
+ { /* have to back up */\r
+ yy_cp = yyg->yy_last_accepting_cpos;\r
+ yy_current_state = yyg->yy_last_accepting_state;\r
+ yy_act = yy_accept[yy_current_state];\r
+ }\r
+\r
+ YY_DO_BEFORE_ACTION;\r
+\r
+do_action: /* This label is used only to access EOF actions. */\r
+\r
+ switch ( yy_act )\r
+ { /* beginning of action switch */\r
+ case 0: /* must back up */\r
+ /* undo the effects of YY_DO_BEFORE_ACTION */\r
+ *yy_cp = yyg->yy_hold_char;\r
+ yy_cp = yyg->yy_last_accepting_cpos;\r
+ yy_current_state = yyg->yy_last_accepting_state;\r
+ goto yy_find_action;\r
+\r
+case 1:\r
+YY_RULE_SETUP\r
+{LEX_VAL(DER)}\r
+ YY_BREAK\r
+case 2:\r
+YY_RULE_SETUP\r
+{LEX_VAL('(')}\r
+ YY_BREAK\r
+case 3:\r
+YY_RULE_SETUP\r
+{LEX_VAL(')')}\r
+ YY_BREAK\r
+case 4:\r
+YY_RULE_SETUP\r
+{LEX_VAL(',')}\r
+ YY_BREAK\r
+case 5:\r
+YY_RULE_SETUP\r
+{LEX_VAL(',')}\r
+ YY_BREAK\r
+case 6:\r
+YY_RULE_SETUP\r
+{LEX_VAL('.')}\r
+ YY_BREAK\r
+case 7:\r
+YY_RULE_SETUP\r
+{LEX_VAL('[')}\r
+ YY_BREAK\r
+case 8:\r
+YY_RULE_SETUP\r
+{LEX_VAL(']')}\r
+ YY_BREAK\r
+case 9:\r
+/* rule 9 can match eol */\r
+YY_RULE_SETUP\r
+{LEX_VAL(Q_NAME)}\r
+ YY_BREAK\r
+case 10:\r
+YY_RULE_SETUP\r
+{LEX_VAL(NONDIGIT)}\r
+ YY_BREAK\r
+case 11:\r
+YY_RULE_SETUP\r
+{LEX_VAL(UNSIGNED_INTEGER)}\r
+ YY_BREAK\r
+case 12:\r
+YY_RULE_SETUP\r
+{LEX_VAL(*yytext)}\r
+ YY_BREAK\r
+\r
+case 13:\r
+YY_RULE_SETUP\r
+ECHO;\r
+ YY_BREAK\r
+case YY_STATE_EOF(INITIAL):\r
+ yyterminate();\r
+\r
+ case YY_END_OF_BUFFER:\r
+ {\r
+ /* Amount of text matched not including the EOB char. */\r
+ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;\r
+\r
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */\r
+ *yy_cp = yyg->yy_hold_char;\r
+ YY_RESTORE_YY_MORE_OFFSET\r
+\r
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )\r
+ {\r
+ /* We're scanning a new file or input source. It's\r
+ * possible that this happened because the user\r
+ * just pointed yyin at a new source and called\r
+ * yyfmi1lex(). If so, then we have to assure\r
+ * consistency between YY_CURRENT_BUFFER and our\r
+ * globals. Here is the right place to do so, because\r
+ * this is the first action (other than possibly a\r
+ * back-up) that will match for the new input source.\r
+ */\r
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;\r
+ }\r
+\r
+ /* Note that here we test for yy_c_buf_p "<=" to the position\r
+ * of the first EOB in the buffer, since yy_c_buf_p will\r
+ * already have been incremented past the NUL character\r
+ * (since all states make transitions on EOB to the\r
+ * end-of-buffer state). Contrast this with the test\r
+ * in input().\r
+ */\r
+ if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )\r
+ { /* This was really a NUL. */\r
+ yy_state_type yy_next_state;\r
+\r
+ yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;\r
+\r
+ yy_current_state = yy_get_previous_state( yyscanner );\r
+\r
+ /* Okay, we're now positioned to make the NUL\r
+ * transition. We couldn't have\r
+ * yy_get_previous_state() go ahead and do it\r
+ * for us because it doesn't know how to deal\r
+ * with the possibility of jamming (and we don't\r
+ * want to build jamming into it because then it\r
+ * will run more slowly).\r
+ */\r
+\r
+ yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);\r
+\r
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;\r
+\r
+ if ( yy_next_state )\r
+ {\r
+ /* Consume the NUL. */\r
+ yy_cp = ++yyg->yy_c_buf_p;\r
+ yy_current_state = yy_next_state;\r
+ goto yy_match;\r
+ }\r
+\r
+ else\r
+ {\r
+ yy_cp = yyg->yy_c_buf_p;\r
+ goto yy_find_action;\r
+ }\r
+ }\r
+\r
+ else switch ( yy_get_next_buffer( yyscanner ) )\r
+ {\r
+ case EOB_ACT_END_OF_FILE:\r
+ {\r
+ yyg->yy_did_buffer_switch_on_eof = 0;\r
+\r
+ if ( yyfmi1wrap(yyscanner ) )\r
+ {\r
+ /* Note: because we've taken care in\r
+ * yy_get_next_buffer() to have set up\r
+ * yytext, we can now set up\r
+ * yy_c_buf_p so that if some total\r
+ * hoser (like flex itself) wants to\r
+ * call the scanner after we return the\r
+ * YY_NULL, it'll still work - another\r
+ * YY_NULL will get returned.\r
+ */\r
+ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;\r
+\r
+ yy_act = YY_STATE_EOF(YY_START);\r
+ goto do_action;\r
+ }\r
+\r
+ else\r
+ {\r
+ if ( ! yyg->yy_did_buffer_switch_on_eof )\r
+ YY_NEW_FILE;\r
+ }\r
+ break;\r
+ }\r
+\r
+ case EOB_ACT_CONTINUE_SCAN:\r
+ yyg->yy_c_buf_p =\r
+ yyg->yytext_ptr + yy_amount_of_matched_text;\r
+\r
+ yy_current_state = yy_get_previous_state( yyscanner );\r
+\r
+ yy_cp = yyg->yy_c_buf_p;\r
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;\r
+ goto yy_match;\r
+\r
+ case EOB_ACT_LAST_MATCH:\r
+ yyg->yy_c_buf_p =\r
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];\r
+\r
+ yy_current_state = yy_get_previous_state( yyscanner );\r
+\r
+ yy_cp = yyg->yy_c_buf_p;\r
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;\r
+ goto yy_find_action;\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ YY_FATAL_ERROR(\r
+ "fatal flex scanner internal error--no action found" );\r
+ } /* end of action switch */\r
+ } /* end of scanning one token */\r
+} /* end of yyfmi1lex */\r
+\r
+/* yy_get_next_buffer - try to read in a new buffer\r
+ *\r
+ * Returns a code representing an action:\r
+ * EOB_ACT_LAST_MATCH -\r
+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position\r
+ * EOB_ACT_END_OF_FILE - end of file\r
+ */\r
+static int yy_get_next_buffer (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;\r
+ register char *source = yyg->yytext_ptr;\r
+ register int number_to_move, i;\r
+ int ret_val;\r
+\r
+ if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )\r
+ YY_FATAL_ERROR(\r
+ "fatal flex scanner internal error--end of buffer missed" );\r
+\r
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )\r
+ { /* Don't try to fill the buffer, so this is an EOF. */\r
+ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )\r
+ {\r
+ /* We matched a single character, the EOB, so\r
+ * treat this as a final EOF.\r
+ */\r
+ return EOB_ACT_END_OF_FILE;\r
+ }\r
+\r
+ else\r
+ {\r
+ /* We matched some text prior to the EOB, first\r
+ * process it.\r
+ */\r
+ return EOB_ACT_LAST_MATCH;\r
+ }\r
+ }\r
+\r
+ /* Try to read more data. */\r
+\r
+ /* First move last chars to start of buffer. */\r
+ number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;\r
+\r
+ for ( i = 0; i < number_to_move; ++i )\r
+ *(dest++) = *(source++);\r
+\r
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )\r
+ /* don't do the read, it's not guaranteed to return an EOF,\r
+ * just force an EOF\r
+ */\r
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;\r
+\r
+ else\r
+ {\r
+ yy_size_t num_to_read =\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;\r
+\r
+ while ( num_to_read <= 0 )\r
+ { /* Not enough room in the buffer - grow it. */\r
+\r
+ /* just a shorter name for the current buffer */\r
+ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;\r
+\r
+ int yy_c_buf_p_offset =\r
+ (int) (yyg->yy_c_buf_p - b->yy_ch_buf);\r
+\r
+ if ( b->yy_is_our_buffer )\r
+ {\r
+ yy_size_t new_size = b->yy_buf_size * 2;\r
+\r
+ if ( new_size <= 0 )\r
+ b->yy_buf_size += b->yy_buf_size / 8;\r
+ else\r
+ b->yy_buf_size *= 2;\r
+\r
+ b->yy_ch_buf = (char *)\r
+ /* Include room in for 2 EOB chars. */\r
+ yyfmi1realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );\r
+ }\r
+ else\r
+ /* Can't grow it, we don't own it. */\r
+ b->yy_ch_buf = 0;\r
+\r
+ if ( ! b->yy_ch_buf )\r
+ YY_FATAL_ERROR(\r
+ "fatal error - scanner input buffer overflow" );\r
+\r
+ yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];\r
+\r
+ num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -\r
+ number_to_move - 1;\r
+\r
+ }\r
+\r
+ if ( num_to_read > YY_READ_BUF_SIZE )\r
+ num_to_read = YY_READ_BUF_SIZE;\r
+\r
+ /* Read in more data. */\r
+ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),\r
+ yyg->yy_n_chars, num_to_read );\r
+\r
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;\r
+ }\r
+\r
+ if ( yyg->yy_n_chars == 0 )\r
+ {\r
+ if ( number_to_move == YY_MORE_ADJ )\r
+ {\r
+ ret_val = EOB_ACT_END_OF_FILE;\r
+ yyfmi1restart(yyin ,yyscanner);\r
+ }\r
+\r
+ else\r
+ {\r
+ ret_val = EOB_ACT_LAST_MATCH;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =\r
+ YY_BUFFER_EOF_PENDING;\r
+ }\r
+ }\r
+\r
+ else\r
+ ret_val = EOB_ACT_CONTINUE_SCAN;\r
+\r
+ if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {\r
+ /* Extend the array by 50%, plus the number we really need. */\r
+ yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);\r
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyfmi1realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );\r
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );\r
+ }\r
+\r
+ yyg->yy_n_chars += number_to_move;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;\r
+\r
+ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];\r
+\r
+ return ret_val;\r
+}\r
+\r
+/* yy_get_previous_state - get the state just before the EOB char was reached */\r
+\r
+ static yy_state_type yy_get_previous_state (yyscan_t yyscanner)\r
+{\r
+ register yy_state_type yy_current_state;\r
+ register char *yy_cp;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ yy_current_state = yyg->yy_start;\r
+\r
+ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )\r
+ {\r
+ register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);\r
+ if ( yy_accept[yy_current_state] )\r
+ {\r
+ yyg->yy_last_accepting_state = yy_current_state;\r
+ yyg->yy_last_accepting_cpos = yy_cp;\r
+ }\r
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
+ {\r
+ yy_current_state = (int) yy_def[yy_current_state];\r
+ if ( yy_current_state >= 27 )\r
+ yy_c = yy_meta[(unsigned int) yy_c];\r
+ }\r
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
+ }\r
+\r
+ return yy_current_state;\r
+}\r
+\r
+/* yy_try_NUL_trans - try to make a transition on the NUL character\r
+ *\r
+ * synopsis\r
+ * next_state = yy_try_NUL_trans( current_state );\r
+ */\r
+ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)\r
+{\r
+ register int yy_is_jam;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */\r
+ register char *yy_cp = yyg->yy_c_buf_p;\r
+\r
+ register YY_CHAR yy_c = 1;\r
+ if ( yy_accept[yy_current_state] )\r
+ {\r
+ yyg->yy_last_accepting_state = yy_current_state;\r
+ yyg->yy_last_accepting_cpos = yy_cp;\r
+ }\r
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
+ {\r
+ yy_current_state = (int) yy_def[yy_current_state];\r
+ if ( yy_current_state >= 27 )\r
+ yy_c = yy_meta[(unsigned int) yy_c];\r
+ }\r
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
+ yy_is_jam = (yy_current_state == 26);\r
+\r
+ (void)yyg;\r
+ return yy_is_jam ? 0 : yy_current_state;\r
+}\r
+\r
+ static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)\r
+{\r
+ register char *yy_cp;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ yy_cp = yyg->yy_c_buf_p;\r
+\r
+ /* undo effects of setting up yytext */\r
+ *yy_cp = yyg->yy_hold_char;\r
+\r
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )\r
+ { /* need to shift things up to make room */\r
+ /* +2 for EOB chars. */\r
+ register yy_size_t number_to_move = yyg->yy_n_chars + 2;\r
+ register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];\r
+ register char *source =\r
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];\r
+\r
+ while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )\r
+ *--dest = *--source;\r
+\r
+ yy_cp += (int) (dest - source);\r
+ yy_bp += (int) (dest - source);\r
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars =\r
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;\r
+\r
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )\r
+ YY_FATAL_ERROR( "flex scanner push-back overflow" );\r
+ }\r
+\r
+ *--yy_cp = (char) c;\r
+\r
+ yyg->yytext_ptr = yy_bp;\r
+ yyg->yy_hold_char = *yy_cp;\r
+ yyg->yy_c_buf_p = yy_cp;\r
+}\r
+\r
+#ifndef YY_NO_INPUT\r
+#ifdef __cplusplus\r
+ static int yyinput (yyscan_t yyscanner)\r
+#else\r
+ static int input (yyscan_t yyscanner)\r
+#endif\r
+\r
+{\r
+ int c;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;\r
+\r
+ if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )\r
+ {\r
+ /* yy_c_buf_p now points to the character we want to return.\r
+ * If this occurs *before* the EOB characters, then it's a\r
+ * valid NUL; if not, then we've hit the end of the buffer.\r
+ */\r
+ if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )\r
+ /* This was really a NUL. */\r
+ *yyg->yy_c_buf_p = '\0';\r
+\r
+ else\r
+ { /* need more input */\r
+ yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;\r
+ ++yyg->yy_c_buf_p;\r
+\r
+ switch ( yy_get_next_buffer( yyscanner ) )\r
+ {\r
+ case EOB_ACT_LAST_MATCH:\r
+ /* This happens because yy_g_n_b()\r
+ * sees that we've accumulated a\r
+ * token and flags that we need to\r
+ * try matching the token before\r
+ * proceeding. But for input(),\r
+ * there's no matching to consider.\r
+ * So convert the EOB_ACT_LAST_MATCH\r
+ * to EOB_ACT_END_OF_FILE.\r
+ */\r
+\r
+ /* Reset buffer status. */\r
+ yyfmi1restart(yyin ,yyscanner);\r
+\r
+ /*FALLTHROUGH*/\r
+\r
+ case EOB_ACT_END_OF_FILE:\r
+ {\r
+ if ( yyfmi1wrap(yyscanner ) )\r
+ return EOF;\r
+\r
+ if ( ! yyg->yy_did_buffer_switch_on_eof )\r
+ YY_NEW_FILE;\r
+#ifdef __cplusplus\r
+ return yyinput(yyscanner);\r
+#else\r
+ return input(yyscanner);\r
+#endif\r
+ }\r
+\r
+ case EOB_ACT_CONTINUE_SCAN:\r
+ yyg->yy_c_buf_p = yyg->yytext_ptr + offset;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */\r
+ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */\r
+ yyg->yy_hold_char = *++yyg->yy_c_buf_p;\r
+\r
+ return c;\r
+}\r
+#endif /* ifndef YY_NO_INPUT */\r
+\r
+/** Immediately switch to a different input stream.\r
+ * @param input_file A readable stream.\r
+ * @param yyscanner The scanner object.\r
+ * @note This function does not reset the start condition to @c INITIAL .\r
+ */\r
+ void yyfmi1restart (FILE * input_file , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ if ( ! YY_CURRENT_BUFFER ){\r
+ yyfmi1ensure_buffer_stack (yyscanner);\r
+ YY_CURRENT_BUFFER_LVALUE =\r
+ yyfmi1_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);\r
+ }\r
+\r
+ yyfmi1_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+}\r
+\r
+/** Switch to a different input buffer.\r
+ * @param new_buffer The new input buffer.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+ void yyfmi1_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ /* TODO. We should be able to replace this entire function body\r
+ * with\r
+ * yyfmi1pop_buffer_state();\r
+ * yyfmi1push_buffer_state(new_buffer);\r
+ */\r
+ yyfmi1ensure_buffer_stack (yyscanner);\r
+ if ( YY_CURRENT_BUFFER == new_buffer )\r
+ return;\r
+\r
+ if ( YY_CURRENT_BUFFER )\r
+ {\r
+ /* Flush out information for old buffer. */\r
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;\r
+ }\r
+\r
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+\r
+ /* We don't actually know whether we did this switch during\r
+ * EOF (yyfmi1wrap()) processing, but the only time this flag\r
+ * is looked at is after yyfmi1wrap() is called, so it's safe\r
+ * to go ahead and always set it.\r
+ */\r
+ yyg->yy_did_buffer_switch_on_eof = 1;\r
+}\r
+\r
+static void yyfmi1_load_buffer_state (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;\r
+ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;\r
+ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;\r
+ yyg->yy_hold_char = *yyg->yy_c_buf_p;\r
+}\r
+\r
+/** Allocate and initialize an input buffer state.\r
+ * @param file A readable stream.\r
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.\r
+ * @param yyscanner The scanner object.\r
+ * @return the allocated buffer state.\r
+ */\r
+ YY_BUFFER_STATE yyfmi1_create_buffer (FILE * file, int size , yyscan_t yyscanner)\r
+{\r
+ YY_BUFFER_STATE b;\r
+ \r
+ b = (YY_BUFFER_STATE) yyfmi1alloc(sizeof( struct yy_buffer_state ) ,yyscanner );\r
+ if ( ! b )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1_create_buffer()" );\r
+\r
+ b->yy_buf_size = size;\r
+\r
+ /* yy_ch_buf has to be 2 characters longer than the size given because\r
+ * we need to put in 2 end-of-buffer characters.\r
+ */\r
+ b->yy_ch_buf = (char *) yyfmi1alloc(b->yy_buf_size + 2 ,yyscanner );\r
+ if ( ! b->yy_ch_buf )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1_create_buffer()" );\r
+\r
+ b->yy_is_our_buffer = 1;\r
+\r
+ yyfmi1_init_buffer(b,file ,yyscanner);\r
+\r
+ return b;\r
+}\r
+\r
+/** Destroy the buffer.\r
+ * @param b a buffer created with yyfmi1_create_buffer()\r
+ * @param yyscanner The scanner object.\r
+ */\r
+ void yyfmi1_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ if ( ! b )\r
+ return;\r
+\r
+ if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */\r
+ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;\r
+\r
+ if ( b->yy_is_our_buffer )\r
+ yyfmi1free((void *) b->yy_ch_buf ,yyscanner );\r
+\r
+ yyfmi1free((void *) b ,yyscanner );\r
+}\r
+\r
+/* Initializes or reinitializes a buffer.\r
+ * This function is sometimes called more than once on the same buffer,\r
+ * such as during a yyfmi1restart() or at EOF.\r
+ */\r
+ static void yyfmi1_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)\r
+\r
+{\r
+ int oerrno = errno;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ yyfmi1_flush_buffer(b ,yyscanner);\r
+\r
+ b->yy_input_file = file;\r
+ b->yy_fill_buffer = 1;\r
+\r
+ /* If b is the current buffer, then yyfmi1_init_buffer was _probably_\r
+ * called from yyfmi1restart() or through yy_get_next_buffer.\r
+ * In that case, we don't want to reset the lineno or column.\r
+ */\r
+ if (b != YY_CURRENT_BUFFER){\r
+ b->yy_bs_lineno = 1;\r
+ b->yy_bs_column = 0;\r
+ }\r
+\r
+ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;\r
+ \r
+ errno = oerrno;\r
+}\r
+\r
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.\r
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+ void yyfmi1_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ if ( ! b )\r
+ return;\r
+\r
+ b->yy_n_chars = 0;\r
+\r
+ /* We always need two end-of-buffer characters. The first causes\r
+ * a transition to the end-of-buffer state. The second causes\r
+ * a jam in that state.\r
+ */\r
+ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;\r
+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;\r
+\r
+ b->yy_buf_pos = &b->yy_ch_buf[0];\r
+\r
+ b->yy_at_bol = 1;\r
+ b->yy_buffer_status = YY_BUFFER_NEW;\r
+\r
+ if ( b == YY_CURRENT_BUFFER )\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+}\r
+\r
+/** Pushes the new state onto the stack. The new state becomes\r
+ * the current state. This function will allocate the stack\r
+ * if necessary.\r
+ * @param new_buffer The new state.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+void yyfmi1push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ if (new_buffer == NULL)\r
+ return;\r
+\r
+ yyfmi1ensure_buffer_stack(yyscanner);\r
+\r
+ /* This block is copied from yyfmi1_switch_to_buffer. */\r
+ if ( YY_CURRENT_BUFFER )\r
+ {\r
+ /* Flush out information for old buffer. */\r
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;\r
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;\r
+ }\r
+\r
+ /* Only push if top exists. Otherwise, replace top. */\r
+ if (YY_CURRENT_BUFFER)\r
+ yyg->yy_buffer_stack_top++;\r
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;\r
+\r
+ /* copied from yyfmi1_switch_to_buffer. */\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+ yyg->yy_did_buffer_switch_on_eof = 1;\r
+}\r
+\r
+/** Removes and deletes the top of the stack, if present.\r
+ * The next element becomes the new top.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+void yyfmi1pop_buffer_state (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ if (!YY_CURRENT_BUFFER)\r
+ return;\r
+\r
+ yyfmi1_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);\r
+ YY_CURRENT_BUFFER_LVALUE = NULL;\r
+ if (yyg->yy_buffer_stack_top > 0)\r
+ --yyg->yy_buffer_stack_top;\r
+\r
+ if (YY_CURRENT_BUFFER) {\r
+ yyfmi1_load_buffer_state(yyscanner );\r
+ yyg->yy_did_buffer_switch_on_eof = 1;\r
+ }\r
+}\r
+\r
+/* Allocates the stack if it does not exist.\r
+ * Guarantees space for at least one push.\r
+ */\r
+static void yyfmi1ensure_buffer_stack (yyscan_t yyscanner)\r
+{\r
+ yy_size_t num_to_alloc;\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ if (!yyg->yy_buffer_stack) {\r
+\r
+ /* First allocation is just for 2 elements, since we don't know if this\r
+ * scanner will even need a stack. We use 2 instead of 1 to avoid an\r
+ * immediate realloc on the next call.\r
+ */\r
+ num_to_alloc = 1;\r
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyfmi1alloc\r
+ (num_to_alloc * sizeof(struct yy_buffer_state*)\r
+ , yyscanner);\r
+ if ( ! yyg->yy_buffer_stack )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1ensure_buffer_stack()" );\r
+ \r
+ memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));\r
+ \r
+ yyg->yy_buffer_stack_max = num_to_alloc;\r
+ yyg->yy_buffer_stack_top = 0;\r
+ return;\r
+ }\r
+\r
+ if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){\r
+\r
+ /* Increase the buffer to prepare for a possible push. */\r
+ int grow_size = 8 /* arbitrary grow size */;\r
+\r
+ num_to_alloc = yyg->yy_buffer_stack_max + grow_size;\r
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyfmi1realloc\r
+ (yyg->yy_buffer_stack,\r
+ num_to_alloc * sizeof(struct yy_buffer_state*)\r
+ , yyscanner);\r
+ if ( ! yyg->yy_buffer_stack )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1ensure_buffer_stack()" );\r
+\r
+ /* zero only the new slots.*/\r
+ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));\r
+ yyg->yy_buffer_stack_max = num_to_alloc;\r
+ }\r
+}\r
+\r
+/** Setup the input buffer state to scan directly from a user-specified character buffer.\r
+ * @param base the character buffer\r
+ * @param size the size in bytes of the character buffer\r
+ * @param yyscanner The scanner object.\r
+ * @return the newly allocated buffer state object. \r
+ */\r
+YY_BUFFER_STATE yyfmi1_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)\r
+{\r
+ YY_BUFFER_STATE b;\r
+ \r
+ if ( size < 2 ||\r
+ base[size-2] != YY_END_OF_BUFFER_CHAR ||\r
+ base[size-1] != YY_END_OF_BUFFER_CHAR )\r
+ /* They forgot to leave room for the EOB's. */\r
+ return 0;\r
+\r
+ b = (YY_BUFFER_STATE) yyfmi1alloc(sizeof( struct yy_buffer_state ) ,yyscanner );\r
+ if ( ! b )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1_scan_buffer()" );\r
+\r
+ b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */\r
+ b->yy_buf_pos = b->yy_ch_buf = base;\r
+ b->yy_is_our_buffer = 0;\r
+ b->yy_input_file = 0;\r
+ b->yy_n_chars = b->yy_buf_size;\r
+ b->yy_is_interactive = 0;\r
+ b->yy_at_bol = 1;\r
+ b->yy_fill_buffer = 0;\r
+ b->yy_buffer_status = YY_BUFFER_NEW;\r
+\r
+ yyfmi1_switch_to_buffer(b ,yyscanner );\r
+\r
+ return b;\r
+}\r
+\r
+/** Setup the input buffer state to scan a string. The next call to yyfmi1lex() will\r
+ * scan from a @e copy of @a str.\r
+ * @param yystr a NUL-terminated string to scan\r
+ * @param yyscanner The scanner object.\r
+ * @return the newly allocated buffer state object.\r
+ * @note If you want to scan bytes that may contain NUL values, then use\r
+ * yyfmi1_scan_bytes() instead.\r
+ */\r
+YY_BUFFER_STATE yyfmi1_scan_string (yyconst char * yystr , yyscan_t yyscanner)\r
+{\r
+ \r
+ return yyfmi1_scan_bytes(yystr,strlen(yystr) ,yyscanner);\r
+}\r
+\r
+/** Setup the input buffer state to scan the given bytes. The next call to yyfmi1lex() will\r
+ * scan from a @e copy of @a bytes.\r
+ * @param yybytes the byte buffer to scan\r
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.\r
+ * @param yyscanner The scanner object.\r
+ * @return the newly allocated buffer state object.\r
+ */\r
+YY_BUFFER_STATE yyfmi1_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)\r
+{\r
+ YY_BUFFER_STATE b;\r
+ char *buf;\r
+ yy_size_t n;\r
+ yy_size_t i;\r
+ \r
+ /* Get memory for full buffer, including space for trailing EOB's. */\r
+ n = _yybytes_len + 2;\r
+ buf = (char *) yyfmi1alloc(n ,yyscanner );\r
+ if ( ! buf )\r
+ YY_FATAL_ERROR( "out of dynamic memory in yyfmi1_scan_bytes()" );\r
+\r
+ for ( i = 0; i < _yybytes_len; ++i )\r
+ buf[i] = yybytes[i];\r
+\r
+ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;\r
+\r
+ b = yyfmi1_scan_buffer(buf,n ,yyscanner);\r
+ if ( ! b )\r
+ YY_FATAL_ERROR( "bad buffer in yyfmi1_scan_bytes()" );\r
+\r
+ /* It's okay to grow etc. this buffer, and we should throw it\r
+ * away when we're done.\r
+ */\r
+ b->yy_is_our_buffer = 1;\r
+\r
+ return b;\r
+}\r
+\r
+#ifndef YY_EXIT_FAILURE\r
+#define YY_EXIT_FAILURE 2\r
+#endif\r
+\r
+static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)\r
+{\r
+ (void) fprintf( stderr, "%s\n", msg );\r
+ exit( YY_EXIT_FAILURE );\r
+}\r
+\r
+/* Redefine yyless() so it works in section 3 code. */\r
+\r
+#undef yyless\r
+#define yyless(n) \\r
+ do \\r
+ { \\r
+ /* Undo effects of setting up yytext. */ \\r
+ int yyless_macro_arg = (n); \\r
+ YY_LESS_LINENO(yyless_macro_arg);\\r
+ yytext[yyleng] = yyg->yy_hold_char; \\r
+ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \\r
+ yyg->yy_hold_char = *yyg->yy_c_buf_p; \\r
+ *yyg->yy_c_buf_p = '\0'; \\r
+ yyleng = yyless_macro_arg; \\r
+ } \\r
+ while ( 0 )\r
+\r
+/* Accessor methods (get/set functions) to struct members. */\r
+\r
+/** Get the user-defined data for this scanner.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+YY_EXTRA_TYPE yyfmi1get_extra (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yyextra;\r
+}\r
+\r
+/** Get the current line number.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+int yyfmi1get_lineno (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ \r
+ if (! YY_CURRENT_BUFFER)\r
+ return 0;\r
+ \r
+ return yylineno;\r
+}\r
+\r
+/** Get the current column number.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+int yyfmi1get_column (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ \r
+ if (! YY_CURRENT_BUFFER)\r
+ return 0;\r
+ \r
+ return yycolumn;\r
+}\r
+\r
+/** Get the input stream.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+FILE *yyfmi1get_in (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yyin;\r
+}\r
+\r
+/** Get the output stream.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+FILE *yyfmi1get_out (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yyout;\r
+}\r
+\r
+/** Get the length of the current token.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+yy_size_t yyfmi1get_leng (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yyleng;\r
+}\r
+\r
+/** Get the current token.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+\r
+char *yyfmi1get_text (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yytext;\r
+}\r
+\r
+/** Set the user-defined data. This data is never touched by the scanner.\r
+ * @param user_defined The data to be associated with this scanner.\r
+ * @param yyscanner The scanner object.\r
+ */\r
+void yyfmi1set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yyextra = user_defined ;\r
+}\r
+\r
+/** Set the current line number.\r
+ * @param line_number\r
+ * @param yyscanner The scanner object.\r
+ */\r
+void yyfmi1set_lineno (int line_number , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ /* lineno is only valid if an input buffer exists. */\r
+ if (! YY_CURRENT_BUFFER )\r
+ YY_FATAL_ERROR( "yyfmi1set_lineno called with no buffer" );\r
+ \r
+ yylineno = line_number;\r
+}\r
+\r
+/** Set the current column.\r
+ * @param line_number\r
+ * @param yyscanner The scanner object.\r
+ */\r
+void yyfmi1set_column (int column_no , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ /* column is only valid if an input buffer exists. */\r
+ if (! YY_CURRENT_BUFFER )\r
+ YY_FATAL_ERROR( "yyfmi1set_column called with no buffer" );\r
+ \r
+ yycolumn = column_no;\r
+}\r
+\r
+/** Set the input stream. This does not discard the current\r
+ * input buffer.\r
+ * @param in_str A readable stream.\r
+ * @param yyscanner The scanner object.\r
+ * @see yyfmi1_switch_to_buffer\r
+ */\r
+void yyfmi1set_in (FILE * in_str , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yyin = in_str ;\r
+}\r
+\r
+void yyfmi1set_out (FILE * out_str , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yyout = out_str ;\r
+}\r
+\r
+int yyfmi1get_debug (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yy_flex_debug;\r
+}\r
+\r
+void yyfmi1set_debug (int bdebug , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yy_flex_debug = bdebug ;\r
+}\r
+\r
+/* Accessor methods for yylval and yylloc */\r
+\r
+YYSTYPE * yyfmi1get_lval (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ return yylval;\r
+}\r
+\r
+void yyfmi1set_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ yylval = yylval_param;\r
+}\r
+\r
+/* User-visible API */\r
+\r
+/* yyfmi1lex_init is special because it creates the scanner itself, so it is\r
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.\r
+ * That's why we explicitly handle the declaration, instead of using our macros.\r
+ */\r
+\r
+int yyfmi1lex_init(yyscan_t* ptr_yy_globals)\r
+\r
+{\r
+ if (ptr_yy_globals == NULL){\r
+ errno = EINVAL;\r
+ return 1;\r
+ }\r
+\r
+ *ptr_yy_globals = (yyscan_t) yyfmi1alloc ( sizeof( struct yyguts_t ), NULL );\r
+\r
+ if (*ptr_yy_globals == NULL){\r
+ errno = ENOMEM;\r
+ return 1;\r
+ }\r
+\r
+ /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */\r
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));\r
+\r
+ return yy_init_globals ( *ptr_yy_globals );\r
+}\r
+\r
+/* yyfmi1lex_init_extra has the same functionality as yyfmi1lex_init, but follows the\r
+ * convention of taking the scanner as the last argument. Note however, that\r
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and\r
+ * is the reason, too, why this function also must handle its own declaration).\r
+ * The user defined value in the first argument will be available to yyfmi1alloc in\r
+ * the yyextra field.\r
+ */\r
+\r
+int yyfmi1lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )\r
+\r
+{\r
+ struct yyguts_t dummy_yyguts;\r
+\r
+ yyfmi1set_extra (yy_user_defined, &dummy_yyguts);\r
+\r
+ if (ptr_yy_globals == NULL){\r
+ errno = EINVAL;\r
+ return 1;\r
+ }\r
+ \r
+ *ptr_yy_globals = (yyscan_t) yyfmi1alloc ( sizeof( struct yyguts_t ), &dummy_yyguts );\r
+ \r
+ if (*ptr_yy_globals == NULL){\r
+ errno = ENOMEM;\r
+ return 1;\r
+ }\r
+ \r
+ /* By setting to 0xAA, we expose bugs in\r
+ yy_init_globals. Leave at 0x00 for releases. */\r
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));\r
+ \r
+ yyfmi1set_extra (yy_user_defined, *ptr_yy_globals);\r
+ \r
+ return yy_init_globals ( *ptr_yy_globals );\r
+}\r
+\r
+static int yy_init_globals (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+ /* Initialization is the same as for the non-reentrant scanner.\r
+ * This function is called from yyfmi1lex_destroy(), so don't allocate here.\r
+ */\r
+\r
+ yyg->yy_buffer_stack = 0;\r
+ yyg->yy_buffer_stack_top = 0;\r
+ yyg->yy_buffer_stack_max = 0;\r
+ yyg->yy_c_buf_p = (char *) 0;\r
+ yyg->yy_init = 0;\r
+ yyg->yy_start = 0;\r
+\r
+ yyg->yy_start_stack_ptr = 0;\r
+ yyg->yy_start_stack_depth = 0;\r
+ yyg->yy_start_stack = NULL;\r
+\r
+/* Defined in main.c */\r
+#ifdef YY_STDINIT\r
+ yyin = stdin;\r
+ yyout = stdout;\r
+#else\r
+ yyin = (FILE *) 0;\r
+ yyout = (FILE *) 0;\r
+#endif\r
+\r
+ /* For future reference: Set errno on error, since we are called by\r
+ * yyfmi1lex_init()\r
+ */\r
+ return 0;\r
+}\r
+\r
+/* yyfmi1lex_destroy is for both reentrant and non-reentrant scanners. */\r
+int yyfmi1lex_destroy (yyscan_t yyscanner)\r
+{\r
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;\r
+\r
+ /* Pop the buffer stack, destroying each element. */\r
+ while(YY_CURRENT_BUFFER){\r
+ yyfmi1_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );\r
+ YY_CURRENT_BUFFER_LVALUE = NULL;\r
+ yyfmi1pop_buffer_state(yyscanner);\r
+ }\r
+\r
+ /* Destroy the stack itself. */\r
+ yyfmi1free(yyg->yy_buffer_stack ,yyscanner);\r
+ yyg->yy_buffer_stack = NULL;\r
+\r
+ /* Destroy the start condition stack. */\r
+ yyfmi1free(yyg->yy_start_stack ,yyscanner );\r
+ yyg->yy_start_stack = NULL;\r
+\r
+ /* Reset the globals. This is important in a non-reentrant scanner so the next time\r
+ * yyfmi1lex() is called, initialization will occur. */\r
+ yy_init_globals( yyscanner);\r
+\r
+ /* Destroy the main struct (reentrant only). */\r
+ yyfmi1free ( yyscanner , yyscanner );\r
+ yyscanner = NULL;\r
+ return 0;\r
+}\r
+\r
+/*\r
+ * Internal utility routines.\r
+ */\r
+\r
+#ifndef yytext_ptr\r
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)\r
+{\r
+ register int i;\r
+ for ( i = 0; i < n; ++i )\r
+ s1[i] = s2[i];\r
+}\r
+#endif\r
+\r
+#ifdef YY_NEED_STRLEN\r
+static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)\r
+{\r
+ register int n;\r
+ for ( n = 0; s[n]; ++n )\r
+ ;\r
+\r
+ return n;\r
+}\r
+#endif\r
+\r
+void *yyfmi1alloc (yy_size_t size , yyscan_t yyscanner)\r
+{\r
+ return (void *) malloc( size );\r
+}\r
+\r
+void *yyfmi1realloc (void * ptr, yy_size_t size , yyscan_t yyscanner)\r
+{\r
+ /* The cast to (char *) in the following accommodates both\r
+ * implementations that use char* generic pointers, and those\r
+ * that use void* generic pointers. It works with the latter\r
+ * because both ANSI C and C++ allow castless assignment from\r
+ * any pointer type to void*, and deal with argument conversions\r
+ * as though doing an assignment.\r
+ */\r
+ return (void *) realloc( (char *) ptr, size );\r
+}\r
+\r
+void yyfmi1free (void * ptr , yyscan_t yyscanner)\r
+{\r
+ free( (char *) ptr ); /* see yyfmi1realloc() for (char *) cast */\r
+}\r
+\r
+#define YYTABLES_NAME "yytables"\r
+\r
Code Review / simantics / fmil.git / blobdiff