"Fossies" - the Fresh Open Source Software Archive

Member "mlr-5.6.2/c/parsing/mlr_dsl_lexer.c" (22 Sep 2019, 92586 Bytes) of package /linux/misc/mlr-5.6.2.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "mlr_dsl_lexer.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 5.6.0_vs_5.6.2.

    1 #line 2 "mlr_dsl_lexer.c"
    2 
    3 #line 4 "mlr_dsl_lexer.c"
    4 
    5 #define  YY_INT_ALIGNED short int
    6 
    7 /* A lexical scanner generated by flex */
    8 
    9 #define FLEX_SCANNER
   10 #define YY_FLEX_MAJOR_VERSION 2
   11 #define YY_FLEX_MINOR_VERSION 6
   12 #define YY_FLEX_SUBMINOR_VERSION 4
   13 #if YY_FLEX_SUBMINOR_VERSION > 0
   14 #define FLEX_BETA
   15 #endif
   16 
   17 #ifdef yy_create_buffer
   18 #define mlr_dsl_lexer__create_buffer_ALREADY_DEFINED
   19 #else
   20 #define yy_create_buffer mlr_dsl_lexer__create_buffer
   21 #endif
   22 
   23 #ifdef yy_delete_buffer
   24 #define mlr_dsl_lexer__delete_buffer_ALREADY_DEFINED
   25 #else
   26 #define yy_delete_buffer mlr_dsl_lexer__delete_buffer
   27 #endif
   28 
   29 #ifdef yy_scan_buffer
   30 #define mlr_dsl_lexer__scan_buffer_ALREADY_DEFINED
   31 #else
   32 #define yy_scan_buffer mlr_dsl_lexer__scan_buffer
   33 #endif
   34 
   35 #ifdef yy_scan_string
   36 #define mlr_dsl_lexer__scan_string_ALREADY_DEFINED
   37 #else
   38 #define yy_scan_string mlr_dsl_lexer__scan_string
   39 #endif
   40 
   41 #ifdef yy_scan_bytes
   42 #define mlr_dsl_lexer__scan_bytes_ALREADY_DEFINED
   43 #else
   44 #define yy_scan_bytes mlr_dsl_lexer__scan_bytes
   45 #endif
   46 
   47 #ifdef yy_init_buffer
   48 #define mlr_dsl_lexer__init_buffer_ALREADY_DEFINED
   49 #else
   50 #define yy_init_buffer mlr_dsl_lexer__init_buffer
   51 #endif
   52 
   53 #ifdef yy_flush_buffer
   54 #define mlr_dsl_lexer__flush_buffer_ALREADY_DEFINED
   55 #else
   56 #define yy_flush_buffer mlr_dsl_lexer__flush_buffer
   57 #endif
   58 
   59 #ifdef yy_load_buffer_state
   60 #define mlr_dsl_lexer__load_buffer_state_ALREADY_DEFINED
   61 #else
   62 #define yy_load_buffer_state mlr_dsl_lexer__load_buffer_state
   63 #endif
   64 
   65 #ifdef yy_switch_to_buffer
   66 #define mlr_dsl_lexer__switch_to_buffer_ALREADY_DEFINED
   67 #else
   68 #define yy_switch_to_buffer mlr_dsl_lexer__switch_to_buffer
   69 #endif
   70 
   71 #ifdef yypush_buffer_state
   72 #define mlr_dsl_lexer_push_buffer_state_ALREADY_DEFINED
   73 #else
   74 #define yypush_buffer_state mlr_dsl_lexer_push_buffer_state
   75 #endif
   76 
   77 #ifdef yypop_buffer_state
   78 #define mlr_dsl_lexer_pop_buffer_state_ALREADY_DEFINED
   79 #else
   80 #define yypop_buffer_state mlr_dsl_lexer_pop_buffer_state
   81 #endif
   82 
   83 #ifdef yyensure_buffer_stack
   84 #define mlr_dsl_lexer_ensure_buffer_stack_ALREADY_DEFINED
   85 #else
   86 #define yyensure_buffer_stack mlr_dsl_lexer_ensure_buffer_stack
   87 #endif
   88 
   89 #ifdef yylex
   90 #define mlr_dsl_lexer_lex_ALREADY_DEFINED
   91 #else
   92 #define yylex mlr_dsl_lexer_lex
   93 #endif
   94 
   95 #ifdef yyrestart
   96 #define mlr_dsl_lexer_restart_ALREADY_DEFINED
   97 #else
   98 #define yyrestart mlr_dsl_lexer_restart
   99 #endif
  100 
  101 #ifdef yylex_init
  102 #define mlr_dsl_lexer_lex_init_ALREADY_DEFINED
  103 #else
  104 #define yylex_init mlr_dsl_lexer_lex_init
  105 #endif
  106 
  107 #ifdef yylex_init_extra
  108 #define mlr_dsl_lexer_lex_init_extra_ALREADY_DEFINED
  109 #else
  110 #define yylex_init_extra mlr_dsl_lexer_lex_init_extra
  111 #endif
  112 
  113 #ifdef yylex_destroy
  114 #define mlr_dsl_lexer_lex_destroy_ALREADY_DEFINED
  115 #else
  116 #define yylex_destroy mlr_dsl_lexer_lex_destroy
  117 #endif
  118 
  119 #ifdef yyget_debug
  120 #define mlr_dsl_lexer_get_debug_ALREADY_DEFINED
  121 #else
  122 #define yyget_debug mlr_dsl_lexer_get_debug
  123 #endif
  124 
  125 #ifdef yyset_debug
  126 #define mlr_dsl_lexer_set_debug_ALREADY_DEFINED
  127 #else
  128 #define yyset_debug mlr_dsl_lexer_set_debug
  129 #endif
  130 
  131 #ifdef yyget_extra
  132 #define mlr_dsl_lexer_get_extra_ALREADY_DEFINED
  133 #else
  134 #define yyget_extra mlr_dsl_lexer_get_extra
  135 #endif
  136 
  137 #ifdef yyset_extra
  138 #define mlr_dsl_lexer_set_extra_ALREADY_DEFINED
  139 #else
  140 #define yyset_extra mlr_dsl_lexer_set_extra
  141 #endif
  142 
  143 #ifdef yyget_in
  144 #define mlr_dsl_lexer_get_in_ALREADY_DEFINED
  145 #else
  146 #define yyget_in mlr_dsl_lexer_get_in
  147 #endif
  148 
  149 #ifdef yyset_in
  150 #define mlr_dsl_lexer_set_in_ALREADY_DEFINED
  151 #else
  152 #define yyset_in mlr_dsl_lexer_set_in
  153 #endif
  154 
  155 #ifdef yyget_out
  156 #define mlr_dsl_lexer_get_out_ALREADY_DEFINED
  157 #else
  158 #define yyget_out mlr_dsl_lexer_get_out
  159 #endif
  160 
  161 #ifdef yyset_out
  162 #define mlr_dsl_lexer_set_out_ALREADY_DEFINED
  163 #else
  164 #define yyset_out mlr_dsl_lexer_set_out
  165 #endif
  166 
  167 #ifdef yyget_leng
  168 #define mlr_dsl_lexer_get_leng_ALREADY_DEFINED
  169 #else
  170 #define yyget_leng mlr_dsl_lexer_get_leng
  171 #endif
  172 
  173 #ifdef yyget_text
  174 #define mlr_dsl_lexer_get_text_ALREADY_DEFINED
  175 #else
  176 #define yyget_text mlr_dsl_lexer_get_text
  177 #endif
  178 
  179 #ifdef yyget_lineno
  180 #define mlr_dsl_lexer_get_lineno_ALREADY_DEFINED
  181 #else
  182 #define yyget_lineno mlr_dsl_lexer_get_lineno
  183 #endif
  184 
  185 #ifdef yyset_lineno
  186 #define mlr_dsl_lexer_set_lineno_ALREADY_DEFINED
  187 #else
  188 #define yyset_lineno mlr_dsl_lexer_set_lineno
  189 #endif
  190 
  191 #ifdef yyget_column
  192 #define mlr_dsl_lexer_get_column_ALREADY_DEFINED
  193 #else
  194 #define yyget_column mlr_dsl_lexer_get_column
  195 #endif
  196 
  197 #ifdef yyset_column
  198 #define mlr_dsl_lexer_set_column_ALREADY_DEFINED
  199 #else
  200 #define yyset_column mlr_dsl_lexer_set_column
  201 #endif
  202 
  203 #ifdef yywrap
  204 #define mlr_dsl_lexer_wrap_ALREADY_DEFINED
  205 #else
  206 #define yywrap mlr_dsl_lexer_wrap
  207 #endif
  208 
  209 #ifdef yyalloc
  210 #define mlr_dsl_lexer_alloc_ALREADY_DEFINED
  211 #else
  212 #define yyalloc mlr_dsl_lexer_alloc
  213 #endif
  214 
  215 #ifdef yyrealloc
  216 #define mlr_dsl_lexer_realloc_ALREADY_DEFINED
  217 #else
  218 #define yyrealloc mlr_dsl_lexer_realloc
  219 #endif
  220 
  221 #ifdef yyfree
  222 #define mlr_dsl_lexer_free_ALREADY_DEFINED
  223 #else
  224 #define yyfree mlr_dsl_lexer_free
  225 #endif
  226 
  227 /* First, we deal with  platform-specific or compiler-specific issues. */
  228 
  229 /* begin standard C headers. */
  230 #include <stdio.h>
  231 #include <string.h>
  232 #include <errno.h>
  233 #include <stdlib.h>
  234 
  235 /* end standard C headers. */
  236 
  237 /* flex integer type definitions */
  238 
  239 #ifndef FLEXINT_H
  240 #define FLEXINT_H
  241 
  242 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  243 
  244 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  245 
  246 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  247  * if you want the limit (max/min) macros for int types. 
  248  */
  249 #ifndef __STDC_LIMIT_MACROS
  250 #define __STDC_LIMIT_MACROS 1
  251 #endif
  252 
  253 #include <inttypes.h>
  254 typedef int8_t flex_int8_t;
  255 typedef uint8_t flex_uint8_t;
  256 typedef int16_t flex_int16_t;
  257 typedef uint16_t flex_uint16_t;
  258 typedef int32_t flex_int32_t;
  259 typedef uint32_t flex_uint32_t;
  260 #else
  261 typedef signed char flex_int8_t;
  262 typedef short int flex_int16_t;
  263 typedef int flex_int32_t;
  264 typedef unsigned char flex_uint8_t; 
  265 typedef unsigned short int flex_uint16_t;
  266 typedef unsigned int flex_uint32_t;
  267 
  268 /* Limits of integral types. */
  269 #ifndef INT8_MIN
  270 #define INT8_MIN               (-128)
  271 #endif
  272 #ifndef INT16_MIN
  273 #define INT16_MIN              (-32767-1)
  274 #endif
  275 #ifndef INT32_MIN
  276 #define INT32_MIN              (-2147483647-1)
  277 #endif
  278 #ifndef INT8_MAX
  279 #define INT8_MAX               (127)
  280 #endif
  281 #ifndef INT16_MAX
  282 #define INT16_MAX              (32767)
  283 #endif
  284 #ifndef INT32_MAX
  285 #define INT32_MAX              (2147483647)
  286 #endif
  287 #ifndef UINT8_MAX
  288 #define UINT8_MAX              (255U)
  289 #endif
  290 #ifndef UINT16_MAX
  291 #define UINT16_MAX             (65535U)
  292 #endif
  293 #ifndef UINT32_MAX
  294 #define UINT32_MAX             (4294967295U)
  295 #endif
  296 
  297 #ifndef SIZE_MAX
  298 #define SIZE_MAX               (~(size_t)0)
  299 #endif
  300 
  301 #endif /* ! C99 */
  302 
  303 #endif /* ! FLEXINT_H */
  304 
  305 /* begin standard C++ headers. */
  306 
  307 /* TODO: this is always defined, so inline it */
  308 #define yyconst const
  309 
  310 #if defined(__GNUC__) && __GNUC__ >= 3
  311 #define yynoreturn __attribute__((__noreturn__))
  312 #else
  313 #define yynoreturn
  314 #endif
  315 
  316 /* Returned upon end-of-file. */
  317 #define YY_NULL 0
  318 
  319 /* Promotes a possibly negative, possibly signed char to an
  320  *   integer in range [0..255] for use as an array index.
  321  */
  322 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
  323 
  324 /* An opaque pointer. */
  325 #ifndef YY_TYPEDEF_YY_SCANNER_T
  326 #define YY_TYPEDEF_YY_SCANNER_T
  327 typedef void* yyscan_t;
  328 #endif
  329 
  330 /* For convenience, these vars (plus the bison vars far below)
  331    are macros in the reentrant scanner. */
  332 #define yyin yyg->yyin_r
  333 #define yyout yyg->yyout_r
  334 #define yyextra yyg->yyextra_r
  335 #define yyleng yyg->yyleng_r
  336 #define yytext yyg->yytext_r
  337 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
  338 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
  339 #define yy_flex_debug yyg->yy_flex_debug_r
  340 
  341 /* Enter a start condition.  This macro really ought to take a parameter,
  342  * but we do it the disgusting crufty way forced on us by the ()-less
  343  * definition of BEGIN.
  344  */
  345 #define BEGIN yyg->yy_start = 1 + 2 *
  346 /* Translate the current start state into a value that can be later handed
  347  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  348  * compatibility.
  349  */
  350 #define YY_START ((yyg->yy_start - 1) / 2)
  351 #define YYSTATE YY_START
  352 /* Action number for EOF rule of a given start state. */
  353 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  354 /* Special action meaning "start processing a new file". */
  355 #define YY_NEW_FILE yyrestart( yyin , yyscanner )
  356 #define YY_END_OF_BUFFER_CHAR 0
  357 
  358 /* Size of default input buffer. */
  359 #ifndef YY_BUF_SIZE
  360 #ifdef __ia64__
  361 /* On IA-64, the buffer size is 16k, not 8k.
  362  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
  363  * Ditto for the __ia64__ case accordingly.
  364  */
  365 #define YY_BUF_SIZE 32768
  366 #else
  367 #define YY_BUF_SIZE 16384
  368 #endif /* __ia64__ */
  369 #endif
  370 
  371 /* The state buf must be large enough to hold one state per character in the main buffer.
  372  */
  373 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
  374 
  375 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
  376 #define YY_TYPEDEF_YY_BUFFER_STATE
  377 typedef struct yy_buffer_state *YY_BUFFER_STATE;
  378 #endif
  379 
  380 #ifndef YY_TYPEDEF_YY_SIZE_T
  381 #define YY_TYPEDEF_YY_SIZE_T
  382 typedef size_t yy_size_t;
  383 #endif
  384 
  385 #define EOB_ACT_CONTINUE_SCAN 0
  386 #define EOB_ACT_END_OF_FILE 1
  387 #define EOB_ACT_LAST_MATCH 2
  388     
  389     #define YY_LESS_LINENO(n)
  390     #define YY_LINENO_REWIND_TO(ptr)
  391     
  392 /* Return all but the first "n" matched characters back to the input stream. */
  393 #define yyless(n) \
  394     do \
  395         { \
  396         /* Undo effects of setting up yytext. */ \
  397         int yyless_macro_arg = (n); \
  398         YY_LESS_LINENO(yyless_macro_arg);\
  399         *yy_cp = yyg->yy_hold_char; \
  400         YY_RESTORE_YY_MORE_OFFSET \
  401         yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
  402         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  403         } \
  404     while ( 0 )
  405 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
  406 
  407 #ifndef YY_STRUCT_YY_BUFFER_STATE
  408 #define YY_STRUCT_YY_BUFFER_STATE
  409 struct yy_buffer_state
  410     {
  411     FILE *yy_input_file;
  412 
  413     char *yy_ch_buf;        /* input buffer */
  414     char *yy_buf_pos;       /* current position in input buffer */
  415 
  416     /* Size of input buffer in bytes, not including room for EOB
  417      * characters.
  418      */
  419     int yy_buf_size;
  420 
  421     /* Number of characters read into yy_ch_buf, not including EOB
  422      * characters.
  423      */
  424     int yy_n_chars;
  425 
  426     /* Whether we "own" the buffer - i.e., we know we created it,
  427      * and can realloc() it to grow it, and should free() it to
  428      * delete it.
  429      */
  430     int yy_is_our_buffer;
  431 
  432     /* Whether this is an "interactive" input source; if so, and
  433      * if we're using stdio for input, then we want to use getc()
  434      * instead of fread(), to make sure we stop fetching input after
  435      * each newline.
  436      */
  437     int yy_is_interactive;
  438 
  439     /* Whether we're considered to be at the beginning of a line.
  440      * If so, '^' rules will be active on the next match, otherwise
  441      * not.
  442      */
  443     int yy_at_bol;
  444 
  445     int yy_bs_lineno; /**< The line count. */
  446     int yy_bs_column; /**< The column count. */
  447 
  448     /* Whether to try to fill the input buffer when we reach the
  449      * end of it.
  450      */
  451     int yy_fill_buffer;
  452 
  453     int yy_buffer_status;
  454 
  455 #define YY_BUFFER_NEW 0
  456 #define YY_BUFFER_NORMAL 1
  457     /* When an EOF's been seen but there's still some text to process
  458      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  459      * shouldn't try reading from the input source any more.  We might
  460      * still have a bunch of tokens to match, though, because of
  461      * possible backing-up.
  462      *
  463      * When we actually see the EOF, we change the status to "new"
  464      * (via yyrestart()), so that the user can continue scanning by
  465      * just pointing yyin at a new input file.
  466      */
  467 #define YY_BUFFER_EOF_PENDING 2
  468 
  469     };
  470 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
  471 
  472 /* We provide macros for accessing buffer states in case in the
  473  * future we want to put the buffer states in a more general
  474  * "scanner state".
  475  *
  476  * Returns the top of the stack, or NULL.
  477  */
  478 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
  479                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
  480                           : NULL)
  481 /* Same as previous macro, but useful when we know that the buffer stack is not
  482  * NULL or when we need an lvalue. For internal use only.
  483  */
  484 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
  485 
  486 void yyrestart ( FILE *input_file , yyscan_t yyscanner );
  487 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
  488 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
  489 void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
  490 void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
  491 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
  492 void yypop_buffer_state ( yyscan_t yyscanner );
  493 
  494 static void yyensure_buffer_stack ( yyscan_t yyscanner );
  495 static void yy_load_buffer_state ( yyscan_t yyscanner );
  496 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
  497 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
  498 
  499 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
  500 YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
  501 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
  502 
  503 void *yyalloc ( yy_size_t , yyscan_t yyscanner );
  504 void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
  505 void yyfree ( void * , yyscan_t yyscanner );
  506 
  507 #define yy_new_buffer yy_create_buffer
  508 #define yy_set_interactive(is_interactive) \
  509     { \
  510     if ( ! YY_CURRENT_BUFFER ){ \
  511         yyensure_buffer_stack (yyscanner); \
  512         YY_CURRENT_BUFFER_LVALUE =    \
  513             yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
  514     } \
  515     YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  516     }
  517 #define yy_set_bol(at_bol) \
  518     { \
  519     if ( ! YY_CURRENT_BUFFER ){\
  520         yyensure_buffer_stack (yyscanner); \
  521         YY_CURRENT_BUFFER_LVALUE =    \
  522             yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
  523     } \
  524     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  525     }
  526 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
  527 
  528 /* Begin user sect3 */
  529 
  530 #define mlr_dsl_lexer_wrap(yyscanner) (/*CONSTCOND*/1)
  531 #define YY_SKIP_YYWRAP
  532 typedef flex_uint8_t YY_CHAR;
  533 
  534 typedef int yy_state_type;
  535 
  536 #define yytext_ptr yytext_r
  537 
  538 static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
  539 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
  540 static int yy_get_next_buffer ( yyscan_t yyscanner );
  541 static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
  542 
  543 /* Done after the current pattern has been matched and before the
  544  * corresponding action - sets up yytext.
  545  */
  546 #define YY_DO_BEFORE_ACTION \
  547     yyg->yytext_ptr = yy_bp; \
  548     yyleng = (int) (yy_cp - yy_bp); \
  549     yyg->yy_hold_char = *yy_cp; \
  550     *yy_cp = '\0'; \
  551     yyg->yy_c_buf_p = yy_cp;
  552 #define YY_NUM_RULES 133
  553 #define YY_END_OF_BUFFER 134
  554 /* This struct is not used in this scanner,
  555    but its presence is necessary. */
  556 struct yy_trans_info
  557     {
  558     flex_int32_t yy_verify;
  559     flex_int32_t yy_nxt;
  560     };
  561 static const flex_int16_t yy_accept[289] =
  562     {   0,
  563         0,    0,  134,  132,  131,  131,   85,  132,  132,   90,
  564        83,   55,  127,  128,   67,   61,  129,   63,   65,   69,
  565        99,   99,   36,    1,   49,    4,   47,   35,   95,  126,
  566       126,  126,  126,  126,  126,  126,   97,   98,   53,  126,
  567       126,  126,  126,  126,  126,  126,  126,  126,  126,  126,
  568       126,  126,  126,  126,  126,    2,   51,    3,   86,   46,
  569         0,  101,    0,    0,  130,   89,   91,    0,   84,   41,
  570        56,   87,   68,   62,   64,   77,   73,   75,   79,   99,
  571        66,   71,   70,   99,   99,    0,    0,   57,   50,   45,
  572        43,   48,   59,   96,   93,    0,  126,  126,  126,  126,
  573 
  574       126,  126,  126,  126,  118,  119,  126,  126,  126,   54,
  575        39,  126,  126,  126,  126,  126,  126,   26,  126,  126,
  576       126,  126,  126,  126,  126,  126,  126,  126,  126,   32,
  577        29,  126,  126,  126,  126,  126,  126,  126,  126,  126,
  578       126,  126,   52,   37,   44,  102,    0,    0,   92,   42,
  579        88,   78,   74,   76,   81,   80,    0,   72,   99,    0,
  580         0,   99,  100,   58,   60,    0,    0,   94,  125,  126,
  581       120,  113,  112,  114,  124,  126,  116,  115,  117,   40,
  582        25,  126,  126,  126,  126,  126,  126,  126,  126,  126,
  583       126,   24,  126,  126,  126,  126,   28,  126,  106,  103,
  584 
  585       105,  126,  126,  126,  109,  126,    7,  126,  126,  104,
  586       126,   38,    0,    0,   92,   82,    0,   99,    0,    0,
  587        99,   99,    0,    0,   94,  126,  123,  126,  108,  126,
  588        21,  126,   11,  126,   33,   34,   10,  126,  126,  126,
  589       126,   19,  126,  126,  126,  126,   20,  110,  126,  126,
  590        99,    0,   99,   99,  126,   23,   30,  126,   12,    8,
  591         9,  126,  111,  126,  107,   13,  126,  126,  126,    6,
  592        27,   99,  126,  126,  126,   15,    5,   14,   22,   18,
  593        17,  126,  122,  126,   16,  121,   31,    0
  594     } ;
  595 
  596 static const YY_CHAR yy_ec[256] =
  597     {   0,
  598         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  599         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
  600         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  601         1,    2,    4,    5,    6,    7,    8,    9,    1,   10,
  602        11,   12,   13,   14,   15,   16,   17,   18,   19,   19,
  603        19,   19,   19,   19,   19,   19,   19,   20,   21,   22,
  604        23,   24,   25,   26,   27,   28,   28,   28,   29,   30,
  605        31,   31,   32,   31,   31,   33,   34,   35,   36,   37,
  606        31,   38,   39,   31,   40,   41,   31,   31,   31,   31,
  607        42,   43,   44,   45,   46,    1,   47,   48,   49,   50,
  608 
  609        51,   52,   53,   54,   55,   31,   56,   57,   58,   59,
  610        60,   61,   31,   62,   63,   64,   65,   66,   67,   68,
  611        31,   31,   69,   70,   71,   72,    1,    1,    1,    1,
  612         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  613         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  614         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  615         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  616         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  617         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  618         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  619 
  620         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  621         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  622         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  623         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  624         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  625         1,    1,    1,    1,    1
  626     } ;
  627 
  628 static const YY_CHAR yy_meta[73] =
  629     {   0,
  630         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  631         1,    2,    1,    1,    1,    1,    1,    3,    3,    1,
  632         1,    1,    1,    1,    1,    1,    3,    3,    3,    3,
  633         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
  634         4,    1,    1,    1,    1,    4,    3,    3,    3,    3,
  635         3,    3,    4,    4,    4,    4,    4,    4,    4,    4,
  636         4,    4,    4,    4,    4,    4,    4,    4,    2,    1,
  637         1,    1
  638     } ;
  639 
  640 static const flex_int16_t yy_base[299] =
  641     {   0,
  642         0,    0,  397,  398,  398,  398,  373,   68,  392,   62,
  643       371,   66,  398,  398,   64,  370,  398,  369,   65,   62,
  644        74,   78,  398,  398,   76,   58,   77,  398,   74,    0,
  645       356,   70,   76,  344,   74,   78,  398,  398,   72,  332,
  646        58,   63,   59,   76,   81,   80,  341,  322,  324,  334,
  647        57,   89,  325,  336,  328,  398,  104,  398,  398,  309,
  648       139,  325,  376,  375,  398,  398,   79,  102,  398,  354,
  649       398,  353,  398,  398,  398,  352,  351,  350,  130,  136,
  650       398,  349,  398,  138,  142,  144,    0,  348,  398,  398,
  651       398,  398,  347,  398,  137,  107,    0,  328,  335,  329,
  652 
  653       327,  326,  325,  135,    0,    0,  324,  323,  322,  398,
  654       337,  302,  305,  297,  305,  298,  295,    0,  295,  287,
  655       113,  296,  300,  287,  291,  290,  286,  283,  285,    0,
  656       279,  281,  283,  285,  275,  119,  290,  286,  271,  272,
  657       272,  278,  398,  309,  398,  398,  109,  167,  398,  398,
  658       398,  398,  398,  398,  308,  398,  173,  398,  165,  180,
  659       167,  178,    0,  398,  398,  132,  174,  398,    0,  301,
  660         0,    0,    0,    0,    0,  297,    0,    0,    0,  398,
  661         0,  273,  270,  279,  268,  260,  262,  264,  269,  269,
  662       255,    0,  263,  254,  252,  268,    0,  265,    0,    0,
  663 
  664         0,  254,  247,  149,    0,  249,    0,  259,  258,    0,
  665       251,  398,  136,  187,  158,  398,  186,  193,  200,  195,
  666       202,  204,  165,  199,  181,  272,    0,  247,    0,  249,
  667         0,  249,    0,  242,    0,    0,  173,  210,  217,  216,
  668       202,    0,  201,  202,  201,  197,    0,    0,  197,  209,
  669       208,  213,  221,  225,  201,    0,    0,  200,    0,    0,
  670         0,  193,    0,  194,    0,  196,  195,  191,  187,    0,
  671         0,  228,  216,  215,  183,  178,    0,    0,    0,    0,
  672         0,  206,    0,  182,    0,    0,    0,  398,  270,  274,
  673       277,  280,  282,  286,  163,  290,  294,  298
  674 
  675     } ;
  676 
  677 static const flex_int16_t yy_def[299] =
  678     {   0,
  679       288,    1,  288,  288,  288,  288,  288,  289,  290,  291,
  680       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  681       288,  288,  288,  288,  288,  288,  288,  288,  292,  293,
  682       293,  293,  293,  293,  293,  293,  288,  288,  288,  293,
  683       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  684       293,  293,  293,  293,  293,  288,  288,  288,  288,  288,
  685       289,  288,  289,  290,  288,  288,  291,  294,  288,  288,
  686       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  687       288,  288,  288,  288,  288,  288,  295,  288,  288,  288,
  688       288,  288,  288,  288,  292,  296,  293,  293,  293,  293,
  689 
  690       293,  293,  293,  293,  293,  293,  293,  293,  293,  288,
  691       288,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  692       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  693       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  694       293,  293,  288,  288,  288,  288,  294,  297,  288,  288,
  695       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  696       288,  288,  295,  288,  288,  296,  298,  288,  293,  293,
  697       293,  293,  293,  293,  293,  293,  293,  293,  293,  288,
  698       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  699       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  700 
  701       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  702       293,  288,  294,  297,  294,  288,  288,  288,  288,  288,
  703       288,  288,  296,  298,  296,  293,  293,  293,  293,  293,
  704       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  705       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  706       288,  288,  288,  288,  293,  293,  293,  293,  293,  293,
  707       293,  293,  293,  293,  293,  293,  293,  293,  293,  293,
  708       293,  288,  293,  293,  293,  293,  293,  293,  293,  293,
  709       293,  293,  293,  293,  293,  293,  293,    0,  288,  288,
  710       288,  288,  288,  288,  288,  288,  288,  288
  711 
  712     } ;
  713 
  714 static const flex_int16_t yy_nxt[471] =
  715     {   0,
  716         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  717        14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
  718        24,   25,   26,   27,   28,   29,   30,   30,   31,   32,
  719        30,   33,   30,   34,   35,   36,   30,   30,   30,   30,
  720        30,   37,    4,   38,   39,   30,   40,   41,   42,   43,
  721        44,   45,   30,   30,   46,   30,   30,   47,   48,   30,
  722        49,   50,   51,   52,   53,   54,   55,   30,   56,   57,
  723        58,   59,   62,   66,   70,   72,   76,   77,   82,   78,
  724        90,   79,   80,   80,   83,   94,   73,   81,   71,   84,
  725       288,   85,   85,   84,  110,   85,   85,   88,   89,   92,
  726 
  727        93,   99,   86,  105,  100,  101,   86,  107,  113,  116,
  728        63,  106,  102,  103,  108,  109,  111,  114,  118,  115,
  729       136,  137,  117,  119,   86,  120,  143,  125,   86,   91,
  730        68,  130,  121,  122,  123,  126,  124,  127,  131,  138,
  731       128,   87,   96,   62,  148,  129,  155,  288,  288,  167,
  732       139,  148,  156,   80,   80,  159,  159,   84,  161,   85,
  733        85,  162,  162,  175,  157,  163,  160,  189,  204,  147,
  734        86,  176,  149,  144,  167,  190,  166,  168,  148,  149,
  735       205,   63,  159,  159,  222,  222,  157,  217,  160,  147,
  736       218,  218,   86,  219,  220,  162,  162,  221,  221,  245,
  737 
  738       148,  166,  168,  251,  251,  288,  149,  167,  246,  214,
  739       218,  218,  254,  254,  252,  219,  224,  253,  253,  221,
  740       221,  222,  222,  167,  260,  251,  251,  273,  149,  214,
  741       272,  272,  287,  261,  286,  168,  285,  215,  253,  253,
  742       274,  224,  254,  254,  225,  272,  272,  284,  283,  282,
  743       281,  168,  280,  279,  278,  277,  276,  215,  275,  271,
  744       270,  269,  268,  267,  266,  265,  264,  263,  262,  225,
  745        61,   61,   61,   61,   64,   64,   64,   64,   67,   67,
  746        67,   95,   95,   95,   97,   97,  147,  147,  147,  147,
  747       166,  166,  166,  166,  213,  213,  213,  213,  223,  223,
  748 
  749       223,  223,  259,  258,  257,  256,  255,  250,  249,  248,
  750       247,  244,  243,  242,  241,  240,  239,  238,  237,  236,
  751       235,  234,  233,  232,  231,  230,  229,  228,  227,  226,
  752       216,  212,  211,  210,  209,  208,  207,  206,  203,  202,
  753       201,  200,  199,  198,  197,  196,  195,  194,  193,  192,
  754       191,  188,  187,  186,  185,  184,  183,  182,  181,  180,
  755       179,  178,  177,  174,  173,  172,  171,  170,  169,  165,
  756       164,  158,  154,  153,  152,  151,  150,   65,  288,  146,
  757       145,  142,  141,  140,  135,  134,  133,  132,  112,  104,
  758        98,   75,   74,   69,   65,   60,  288,    3,  288,  288,
  759 
  760       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  761       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  762       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  763       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  764       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  765       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  766       288,  288,  288,  288,  288,  288,  288,  288,  288,  288
  767     } ;
  768 
  769 static const flex_int16_t yy_chk[471] =
  770     {   0,
  771         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  772         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  773         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  774         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  775         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  776         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  777         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  778         1,    1,    8,   10,   12,   15,   19,   19,   20,   19,
  779        26,   19,   19,   19,   20,   29,   15,   19,   12,   21,
  780        67,   21,   21,   22,   39,   22,   22,   25,   25,   27,
  781 
  782        27,   32,   21,   35,   32,   33,   22,   36,   41,   42,
  783         8,   35,   33,   33,   36,   36,   39,   41,   43,   41,
  784        51,   51,   42,   43,   21,   44,   57,   45,   22,   26,
  785        10,   46,   44,   44,   44,   45,   44,   45,   46,   52,
  786        45,   21,   29,   61,   68,   45,   79,   67,   95,   96,
  787        52,  147,   79,   80,   80,   84,   84,   85,   86,   85,
  788        85,   86,   86,  104,   80,  295,   84,  121,  136,  148,
  789        85,  104,   68,   57,  166,  121,  167,   96,  213,  147,
  790       136,   61,  159,  159,  161,  161,   80,  157,   84,  214,
  791       157,  157,   85,  159,  160,  162,  162,  160,  160,  204,
  792 
  793       215,  224,  166,  217,  217,   95,  213,  223,  204,  148,
  794       218,  218,  220,  220,  219,  159,  167,  219,  219,  221,
  795       221,  222,  222,  225,  237,  251,  251,  255,  215,  214,
  796       252,  252,  284,  237,  282,  223,  276,  148,  253,  253,
  797       255,  224,  254,  254,  167,  272,  272,  275,  274,  273,
  798       269,  225,  268,  267,  266,  264,  262,  214,  258,  250,
  799       249,  246,  245,  244,  243,  241,  240,  239,  238,  224,
  800       289,  289,  289,  289,  290,  290,  290,  290,  291,  291,
  801       291,  292,  292,  292,  293,  293,  294,  294,  294,  294,
  802       296,  296,  296,  296,  297,  297,  297,  297,  298,  298,
  803 
  804       298,  298,  234,  232,  230,  228,  226,  211,  209,  208,
  805       206,  203,  202,  198,  196,  195,  194,  193,  191,  190,
  806       189,  188,  187,  186,  185,  184,  183,  182,  176,  170,
  807       155,  144,  142,  141,  140,  139,  138,  137,  135,  134,
  808       133,  132,  131,  129,  128,  127,  126,  125,  124,  123,
  809       122,  120,  119,  117,  116,  115,  114,  113,  112,  111,
  810       109,  108,  107,  103,  102,  101,  100,   99,   98,   93,
  811        88,   82,   78,   77,   76,   72,   70,   64,   63,   62,
  812        60,   55,   54,   53,   50,   49,   48,   47,   40,   34,
  813        31,   18,   16,   11,    9,    7,    3,  288,  288,  288,
  814 
  815       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  816       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  817       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  818       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  819       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  820       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
  821       288,  288,  288,  288,  288,  288,  288,  288,  288,  288
  822     } ;
  823 
  824 /* The intent behind this definition is that it'll catch
  825  * any uses of REJECT which flex missed.
  826  */
  827 #define REJECT reject_used_but_not_detected
  828 #define yymore() yymore_used_but_not_detected
  829 #define YY_MORE_ADJ 0
  830 #define YY_RESTORE_YY_MORE_OFFSET
  831 #line 1 "mlr_dsl_lexer.l"
  832 #line 2 "mlr_dsl_lexer.l"
  833 #include "stdio.h"  // for fileno() prototype
  834 #include "string.h" // for strdup() prototype
  835 #include "mlr_dsl_parse.h"
  836 #include "../dsl/mlr_dsl_ast.h"
  837 // http://flex.sourceforge.net/manual/Extra-Data.html
  838 
  839 // NOTE: any new keywords defined here should also be documented
  840 // in dsl/mlr_dsl_cst.c's mlr_dsl_keyword_usage() et al.
  841 #line 842 "mlr_dsl_lexer.c"
  842 #line 843 "mlr_dsl_lexer.c"
  843 
  844 #define INITIAL 0
  845 
  846 #ifndef YY_NO_UNISTD_H
  847 /* Special case for "unistd.h", since it is non-ANSI. We include it way
  848  * down here because we want the user's section 1 to have been scanned first.
  849  * The user has a chance to override it with an option.
  850  */
  851 #include <unistd.h>
  852 #endif
  853 
  854 #define YY_EXTRA_TYPE struct _mlr_dsl_ast_node_t **
  855 
  856 /* Holds the entire state of the reentrant scanner. */
  857 struct yyguts_t
  858     {
  859 
  860     /* User-defined. Not touched by flex. */
  861     YY_EXTRA_TYPE yyextra_r;
  862 
  863     /* The rest are the same as the globals declared in the non-reentrant scanner. */
  864     FILE *yyin_r, *yyout_r;
  865     size_t yy_buffer_stack_top; /**< index of top of stack. */
  866     size_t yy_buffer_stack_max; /**< capacity of stack. */
  867     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
  868     char yy_hold_char;
  869     int yy_n_chars;
  870     int yyleng_r;
  871     char *yy_c_buf_p;
  872     int yy_init;
  873     int yy_start;
  874     int yy_did_buffer_switch_on_eof;
  875     int yy_start_stack_ptr;
  876     int yy_start_stack_depth;
  877     int *yy_start_stack;
  878     yy_state_type yy_last_accepting_state;
  879     char* yy_last_accepting_cpos;
  880 
  881     int yylineno_r;
  882     int yy_flex_debug_r;
  883 
  884     char *yytext_r;
  885     int yy_more_flag;
  886     int yy_more_len;
  887 
  888     }; /* end struct yyguts_t */
  889 
  890 static int yy_init_globals ( yyscan_t yyscanner );
  891 
  892 int yylex_init (yyscan_t* scanner);
  893 
  894 int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
  895 
  896 /* Accessor methods to globals.
  897    These are made visible to non-reentrant scanners for convenience. */
  898 
  899 int yylex_destroy ( yyscan_t yyscanner );
  900 
  901 int yyget_debug ( yyscan_t yyscanner );
  902 
  903 void yyset_debug ( int debug_flag , yyscan_t yyscanner );
  904 
  905 YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
  906 
  907 void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
  908 
  909 FILE *yyget_in ( yyscan_t yyscanner );
  910 
  911 void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
  912 
  913 FILE *yyget_out ( yyscan_t yyscanner );
  914 
  915 void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
  916 
  917             int yyget_leng ( yyscan_t yyscanner );
  918 
  919 char *yyget_text ( yyscan_t yyscanner );
  920 
  921 int yyget_lineno ( yyscan_t yyscanner );
  922 
  923 void yyset_lineno ( int _line_number , yyscan_t yyscanner );
  924 
  925 int yyget_column  ( yyscan_t yyscanner );
  926 
  927 void yyset_column ( int _column_no , yyscan_t yyscanner );
  928 
  929 /* Macros after this point can all be overridden by user definitions in
  930  * section 1.
  931  */
  932 
  933 #ifndef YY_SKIP_YYWRAP
  934 #ifdef __cplusplus
  935 extern "C" int yywrap ( yyscan_t yyscanner );
  936 #else
  937 extern int yywrap ( yyscan_t yyscanner );
  938 #endif
  939 #endif
  940 
  941 #ifndef YY_NO_UNPUT
  942     
  943     static void yyunput ( int c, char *buf_ptr  , yyscan_t yyscanner);
  944     
  945 #endif
  946 
  947 #ifndef yytext_ptr
  948 static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
  949 #endif
  950 
  951 #ifdef YY_NEED_STRLEN
  952 static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
  953 #endif
  954 
  955 #ifndef YY_NO_INPUT
  956 #ifdef __cplusplus
  957 static int yyinput ( yyscan_t yyscanner );
  958 #else
  959 static int input ( yyscan_t yyscanner );
  960 #endif
  961 
  962 #endif
  963 
  964 /* Amount of stuff to slurp up with each read. */
  965 #ifndef YY_READ_BUF_SIZE
  966 #ifdef __ia64__
  967 /* On IA-64, the buffer size is 16k, not 8k */
  968 #define YY_READ_BUF_SIZE 16384
  969 #else
  970 #define YY_READ_BUF_SIZE 8192
  971 #endif /* __ia64__ */
  972 #endif
  973 
  974 /* Copy whatever the last rule matched to the standard output. */
  975 #ifndef ECHO
  976 /* This used to be an fputs(), but since the string might contain NUL's,
  977  * we now use fwrite().
  978  */
  979 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
  980 #endif
  981 
  982 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  983  * is returned in "result".
  984  */
  985 #ifndef YY_INPUT
  986 #define YY_INPUT(buf,result,max_size) \
  987     if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
  988         { \
  989         int c = '*'; \
  990         int n; \
  991         for ( n = 0; n < max_size && \
  992                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  993             buf[n] = (char) c; \
  994         if ( c == '\n' ) \
  995             buf[n++] = (char) c; \
  996         if ( c == EOF && ferror( yyin ) ) \
  997             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  998         result = n; \
  999         } \
 1000     else \
 1001         { \
 1002         errno=0; \
 1003         while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
 1004             { \
 1005             if( errno != EINTR) \
 1006                 { \
 1007                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 1008                 break; \
 1009                 } \
 1010             errno=0; \
 1011             clearerr(yyin); \
 1012             } \
 1013         }\
 1014 \
 1015 
 1016 #endif
 1017 
 1018 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 1019  * we don't want an extra ';' after the "return" because that will cause
 1020  * some compilers to complain about unreachable statements.
 1021  */
 1022 #ifndef yyterminate
 1023 #define yyterminate() return YY_NULL
 1024 #endif
 1025 
 1026 /* Number of entries by which start-condition stack grows. */
 1027 #ifndef YY_START_STACK_INCR
 1028 #define YY_START_STACK_INCR 25
 1029 #endif
 1030 
 1031 /* Report a fatal error. */
 1032 #ifndef YY_FATAL_ERROR
 1033 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 1034 #endif
 1035 
 1036 /* end tables serialization structures and prototypes */
 1037 
 1038 /* Default declaration of generated scanner - a define so the user can
 1039  * easily add parameters.
 1040  */
 1041 #ifndef YY_DECL
 1042 #define YY_DECL_IS_OURS 1
 1043 
 1044 extern int yylex (yyscan_t yyscanner);
 1045 
 1046 #define YY_DECL int yylex (yyscan_t yyscanner)
 1047 #endif /* !YY_DECL */
 1048 
 1049 /* Code executed at the beginning of each rule, after yytext and yyleng
 1050  * have been set up.
 1051  */
 1052 #ifndef YY_USER_ACTION
 1053 #define YY_USER_ACTION
 1054 #endif
 1055 
 1056 /* Code executed at the end of each rule. */
 1057 #ifndef YY_BREAK
 1058 #define YY_BREAK /*LINTED*/break;
 1059 #endif
 1060 
 1061 #define YY_RULE_SETUP \
 1062     YY_USER_ACTION
 1063 
 1064 /** The main scanner function which does all the work.
 1065  */
 1066 YY_DECL
 1067 {
 1068     yy_state_type yy_current_state;
 1069     char *yy_cp, *yy_bp;
 1070     int yy_act;
 1071     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 1072 
 1073     if ( !yyg->yy_init )
 1074         {
 1075         yyg->yy_init = 1;
 1076 
 1077 #ifdef YY_USER_INIT
 1078         YY_USER_INIT;
 1079 #endif
 1080 
 1081         if ( ! yyg->yy_start )
 1082             yyg->yy_start = 1;  /* first start state */
 1083 
 1084         if ( ! yyin )
 1085             yyin = stdin;
 1086 
 1087         if ( ! yyout )
 1088             yyout = stdout;
 1089 
 1090         if ( ! YY_CURRENT_BUFFER ) {
 1091             yyensure_buffer_stack (yyscanner);
 1092             YY_CURRENT_BUFFER_LVALUE =
 1093                 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
 1094         }
 1095 
 1096         yy_load_buffer_state( yyscanner );
 1097         }
 1098 
 1099     {
 1100 #line 16 "mlr_dsl_lexer.l"
 1101 
 1102 
 1103 #line 1104 "mlr_dsl_lexer.c"
 1104 
 1105     while ( /*CONSTCOND*/1 )        /* loops until end-of-file is reached */
 1106         {
 1107         yy_cp = yyg->yy_c_buf_p;
 1108 
 1109         /* Support of yytext. */
 1110         *yy_cp = yyg->yy_hold_char;
 1111 
 1112         /* yy_bp points to the position in yy_ch_buf of the start of
 1113          * the current run.
 1114          */
 1115         yy_bp = yy_cp;
 1116 
 1117         yy_current_state = yyg->yy_start;
 1118 yy_match:
 1119         do
 1120             {
 1121             YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
 1122             if ( yy_accept[yy_current_state] )
 1123                 {
 1124                 yyg->yy_last_accepting_state = yy_current_state;
 1125                 yyg->yy_last_accepting_cpos = yy_cp;
 1126                 }
 1127             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 1128                 {
 1129                 yy_current_state = (int) yy_def[yy_current_state];
 1130                 if ( yy_current_state >= 289 )
 1131                     yy_c = yy_meta[yy_c];
 1132                 }
 1133             yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 1134             ++yy_cp;
 1135             }
 1136         while ( yy_base[yy_current_state] != 398 );
 1137 
 1138 yy_find_action:
 1139         yy_act = yy_accept[yy_current_state];
 1140         if ( yy_act == 0 )
 1141             { /* have to back up */
 1142             yy_cp = yyg->yy_last_accepting_cpos;
 1143             yy_current_state = yyg->yy_last_accepting_state;
 1144             yy_act = yy_accept[yy_current_state];
 1145             }
 1146 
 1147         YY_DO_BEFORE_ACTION;
 1148 
 1149 do_action:  /* This label is used only to access EOF actions. */
 1150 
 1151         switch ( yy_act )
 1152     { /* beginning of action switch */
 1153             case 0: /* must back up */
 1154             /* undo the effects of YY_DO_BEFORE_ACTION */
 1155             *yy_cp = yyg->yy_hold_char;
 1156             yy_cp = yyg->yy_last_accepting_cpos;
 1157             yy_current_state = yyg->yy_last_accepting_state;
 1158             goto yy_find_action;
 1159 
 1160 case 1:
 1161 YY_RULE_SETUP
 1162 #line 18 "mlr_dsl_lexer.l"
 1163 {
 1164     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1165     return MD_TOKEN_SEMICOLON;
 1166 }
 1167     YY_BREAK
 1168 case 2:
 1169 YY_RULE_SETUP
 1170 #line 22 "mlr_dsl_lexer.l"
 1171 {
 1172     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1173     return MD_TOKEN_LBRACE;
 1174 }
 1175     YY_BREAK
 1176 case 3:
 1177 YY_RULE_SETUP
 1178 #line 26 "mlr_dsl_lexer.l"
 1179 {
 1180     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1181     return MD_TOKEN_RBRACE;
 1182 }
 1183     YY_BREAK
 1184 case 4:
 1185 YY_RULE_SETUP
 1186 #line 31 "mlr_dsl_lexer.l"
 1187 {
 1188     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_SREC_ASSIGNMENT);
 1189     return MD_TOKEN_ASSIGN;
 1190 }
 1191     YY_BREAK
 1192 case 5:
 1193 YY_RULE_SETUP
 1194 #line 35 "mlr_dsl_lexer.l"
 1195 {
 1196     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FILTER);
 1197     return MD_TOKEN_FILTER;
 1198 }
 1199     YY_BREAK
 1200 case 6:
 1201 YY_RULE_SETUP
 1202 #line 39 "mlr_dsl_lexer.l"
 1203 {
 1204     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_UNSET);
 1205     return MD_TOKEN_UNSET;
 1206 }
 1207     YY_BREAK
 1208 case 7:
 1209 YY_RULE_SETUP
 1210 #line 43 "mlr_dsl_lexer.l"
 1211 {
 1212     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_TEE);
 1213     return MD_TOKEN_TEE;
 1214 }
 1215     YY_BREAK
 1216 case 8:
 1217 YY_RULE_SETUP
 1218 #line 47 "mlr_dsl_lexer.l"
 1219 {
 1220     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EMITF);
 1221     return MD_TOKEN_EMITF;
 1222 }
 1223     YY_BREAK
 1224 case 9:
 1225 YY_RULE_SETUP
 1226 #line 51 "mlr_dsl_lexer.l"
 1227 {
 1228     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EMITP);
 1229     return MD_TOKEN_EMITP;
 1230 }
 1231     YY_BREAK
 1232 case 10:
 1233 YY_RULE_SETUP
 1234 #line 55 "mlr_dsl_lexer.l"
 1235 {
 1236     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EMIT);
 1237     return MD_TOKEN_EMIT;
 1238 }
 1239     YY_BREAK
 1240 case 11:
 1241 YY_RULE_SETUP
 1242 #line 59 "mlr_dsl_lexer.l"
 1243 {
 1244     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_DUMP);
 1245     return MD_TOKEN_DUMP;
 1246 }
 1247     YY_BREAK
 1248 case 12:
 1249 YY_RULE_SETUP
 1250 #line 63 "mlr_dsl_lexer.l"
 1251 {
 1252     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EDUMP);
 1253     return MD_TOKEN_EDUMP;
 1254 }
 1255     YY_BREAK
 1256 case 13:
 1257 YY_RULE_SETUP
 1258 #line 67 "mlr_dsl_lexer.l"
 1259 {
 1260     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_PRINT);
 1261     return MD_TOKEN_PRINT;
 1262 }
 1263     YY_BREAK
 1264 case 14:
 1265 YY_RULE_SETUP
 1266 #line 71 "mlr_dsl_lexer.l"
 1267 {
 1268     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_PRINTN);
 1269     return MD_TOKEN_PRINTN;
 1270 }
 1271     YY_BREAK
 1272 case 15:
 1273 YY_RULE_SETUP
 1274 #line 75 "mlr_dsl_lexer.l"
 1275 {
 1276     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EPRINT);
 1277     return MD_TOKEN_EPRINT;
 1278 }
 1279     YY_BREAK
 1280 case 16:
 1281 YY_RULE_SETUP
 1282 #line 79 "mlr_dsl_lexer.l"
 1283 {
 1284     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_EPRINTN);
 1285     return MD_TOKEN_EPRINTN;
 1286 }
 1287     YY_BREAK
 1288 case 17:
 1289 YY_RULE_SETUP
 1290 #line 83 "mlr_dsl_lexer.l"
 1291 {
 1292     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STDOUT);
 1293     return MD_TOKEN_STDOUT;
 1294 }
 1295     YY_BREAK
 1296 case 18:
 1297 YY_RULE_SETUP
 1298 #line 87 "mlr_dsl_lexer.l"
 1299 {
 1300     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STDERR);
 1301     return MD_TOKEN_STDERR;
 1302 }
 1303     YY_BREAK
 1304 case 19:
 1305 YY_RULE_SETUP
 1306 #line 92 "mlr_dsl_lexer.l"
 1307 {
 1308     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1309     return MD_TOKEN_FUNC_DEF;
 1310 }
 1311     YY_BREAK
 1312 case 20:
 1313 YY_RULE_SETUP
 1314 #line 96 "mlr_dsl_lexer.l"
 1315 {
 1316     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1317     return MD_TOKEN_SUBR_DEF;
 1318 }
 1319     YY_BREAK
 1320 case 21:
 1321 YY_RULE_SETUP
 1322 #line 100 "mlr_dsl_lexer.l"
 1323 {
 1324     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1325     return MD_TOKEN_SUBR_CALL;
 1326 }
 1327     YY_BREAK
 1328 case 22:
 1329 YY_RULE_SETUP
 1330 #line 104 "mlr_dsl_lexer.l"
 1331 {
 1332     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1333     return MD_TOKEN_RETURN;
 1334 }
 1335     YY_BREAK
 1336 case 23:
 1337 YY_RULE_SETUP
 1338 #line 108 "mlr_dsl_lexer.l"
 1339 {
 1340     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1341     return MD_TOKEN_BEGIN;
 1342 }
 1343     YY_BREAK
 1344 case 24:
 1345 YY_RULE_SETUP
 1346 #line 112 "mlr_dsl_lexer.l"
 1347 {
 1348     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1349     return MD_TOKEN_END;
 1350 }
 1351     YY_BREAK
 1352 case 25:
 1353 YY_RULE_SETUP
 1354 #line 116 "mlr_dsl_lexer.l"
 1355 {
 1356     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_ALL);
 1357     return MD_TOKEN_ALL;
 1358 }
 1359     YY_BREAK
 1360 case 26:
 1361 YY_RULE_SETUP
 1362 #line 121 "mlr_dsl_lexer.l"
 1363 {
 1364     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_DO_WHILE);
 1365     return MD_TOKEN_DO;
 1366 }
 1367     YY_BREAK
 1368 case 27:
 1369 YY_RULE_SETUP
 1370 #line 125 "mlr_dsl_lexer.l"
 1371 {
 1372     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_WHILE);
 1373     return MD_TOKEN_WHILE;
 1374 }
 1375     YY_BREAK
 1376 case 28:
 1377 YY_RULE_SETUP
 1378 #line 129 "mlr_dsl_lexer.l"
 1379 {
 1380     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1381     return MD_TOKEN_FOR;
 1382 }
 1383     YY_BREAK
 1384 case 29:
 1385 YY_RULE_SETUP
 1386 #line 133 "mlr_dsl_lexer.l"
 1387 {
 1388     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_IN);
 1389     return MD_TOKEN_IN;
 1390 }
 1391     YY_BREAK
 1392 case 30:
 1393 YY_RULE_SETUP
 1394 #line 137 "mlr_dsl_lexer.l"
 1395 {
 1396     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_BREAK);
 1397     return MD_TOKEN_BREAK;
 1398 }
 1399     YY_BREAK
 1400 case 31:
 1401 YY_RULE_SETUP
 1402 #line 141 "mlr_dsl_lexer.l"
 1403 {
 1404     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTINUE);
 1405     return MD_TOKEN_CONTINUE;
 1406 }
 1407     YY_BREAK
 1408 case 32:
 1409 YY_RULE_SETUP
 1410 #line 145 "mlr_dsl_lexer.l"
 1411 {
 1412     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_IF_ITEM);
 1413     return MD_TOKEN_IF;
 1414 }
 1415     YY_BREAK
 1416 case 33:
 1417 YY_RULE_SETUP
 1418 #line 149 "mlr_dsl_lexer.l"
 1419 {
 1420     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_IF_ITEM);
 1421     return MD_TOKEN_ELIF;
 1422 }
 1423     YY_BREAK
 1424 case 34:
 1425 YY_RULE_SETUP
 1426 #line 153 "mlr_dsl_lexer.l"
 1427 {
 1428     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_IF_ITEM);
 1429     return MD_TOKEN_ELSE;
 1430 }
 1431     YY_BREAK
 1432 case 35:
 1433 YY_RULE_SETUP
 1434 #line 158 "mlr_dsl_lexer.l"
 1435 {
 1436     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1437     return MD_TOKEN_QUESTION_MARK;
 1438 }
 1439     YY_BREAK
 1440 case 36:
 1441 YY_RULE_SETUP
 1442 #line 163 "mlr_dsl_lexer.l"
 1443 {
 1444     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1445     return MD_TOKEN_COLON;
 1446 }
 1447     YY_BREAK
 1448 case 37:
 1449 YY_RULE_SETUP
 1450 #line 168 "mlr_dsl_lexer.l"
 1451 {
 1452     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1453     return MD_TOKEN_LOGICAL_OR;
 1454 }
 1455     YY_BREAK
 1456 case 38:
 1457 YY_RULE_SETUP
 1458 #line 172 "mlr_dsl_lexer.l"
 1459 {
 1460     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1461     return MD_TOKEN_LOGICAL_OR_EQUALS;
 1462 }
 1463     YY_BREAK
 1464 case 39:
 1465 YY_RULE_SETUP
 1466 #line 176 "mlr_dsl_lexer.l"
 1467 {
 1468     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1469     return MD_TOKEN_LOGICAL_XOR;
 1470 }
 1471     YY_BREAK
 1472 case 40:
 1473 YY_RULE_SETUP
 1474 #line 180 "mlr_dsl_lexer.l"
 1475 {
 1476     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1477     return MD_TOKEN_LOGICAL_XOR_EQUALS;
 1478 }
 1479     YY_BREAK
 1480 case 41:
 1481 YY_RULE_SETUP
 1482 #line 184 "mlr_dsl_lexer.l"
 1483 {
 1484     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1485     return MD_TOKEN_LOGICAL_AND;
 1486 }
 1487     YY_BREAK
 1488 case 42:
 1489 YY_RULE_SETUP
 1490 #line 188 "mlr_dsl_lexer.l"
 1491 {
 1492     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1493     return MD_TOKEN_LOGICAL_AND_EQUALS;
 1494 }
 1495     YY_BREAK
 1496 case 43:
 1497 YY_RULE_SETUP
 1498 #line 193 "mlr_dsl_lexer.l"
 1499 {
 1500     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1501     return MD_TOKEN_MATCHES;
 1502 }
 1503     YY_BREAK
 1504 case 44:
 1505 YY_RULE_SETUP
 1506 #line 197 "mlr_dsl_lexer.l"
 1507 {
 1508     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1509     return MD_TOKEN_DOES_NOT_MATCH;
 1510 }
 1511     YY_BREAK
 1512 case 45:
 1513 YY_RULE_SETUP
 1514 #line 201 "mlr_dsl_lexer.l"
 1515 {
 1516     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1517     return MD_TOKEN_EQ;
 1518 }
 1519     YY_BREAK
 1520 case 46:
 1521 YY_RULE_SETUP
 1522 #line 205 "mlr_dsl_lexer.l"
 1523 {
 1524     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1525     return MD_TOKEN_NE;
 1526 }
 1527     YY_BREAK
 1528 case 47:
 1529 YY_RULE_SETUP
 1530 #line 210 "mlr_dsl_lexer.l"
 1531 {
 1532     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1533     return MD_TOKEN_GT;
 1534 }
 1535     YY_BREAK
 1536 case 48:
 1537 YY_RULE_SETUP
 1538 #line 214 "mlr_dsl_lexer.l"
 1539 {
 1540     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1541     return MD_TOKEN_GE;
 1542 }
 1543     YY_BREAK
 1544 case 49:
 1545 YY_RULE_SETUP
 1546 #line 218 "mlr_dsl_lexer.l"
 1547 {
 1548     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1549     return MD_TOKEN_LT;
 1550 }
 1551     YY_BREAK
 1552 case 50:
 1553 YY_RULE_SETUP
 1554 #line 222 "mlr_dsl_lexer.l"
 1555 {
 1556     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1557     return MD_TOKEN_LE;
 1558 }
 1559     YY_BREAK
 1560 case 51:
 1561 YY_RULE_SETUP
 1562 #line 227 "mlr_dsl_lexer.l"
 1563 {
 1564     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1565     return MD_TOKEN_BITWISE_OR;
 1566 }
 1567     YY_BREAK
 1568 case 52:
 1569 YY_RULE_SETUP
 1570 #line 231 "mlr_dsl_lexer.l"
 1571 {
 1572     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1573     return MD_TOKEN_BITWISE_OR_EQUALS;
 1574 }
 1575     YY_BREAK
 1576 case 53:
 1577 YY_RULE_SETUP
 1578 #line 236 "mlr_dsl_lexer.l"
 1579 {
 1580     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1581     return MD_TOKEN_BITWISE_XOR;
 1582 }
 1583     YY_BREAK
 1584 case 54:
 1585 YY_RULE_SETUP
 1586 #line 240 "mlr_dsl_lexer.l"
 1587 {
 1588     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1589     return MD_TOKEN_BITWISE_XOR_EQUALS;
 1590 }
 1591     YY_BREAK
 1592 case 55:
 1593 YY_RULE_SETUP
 1594 #line 245 "mlr_dsl_lexer.l"
 1595 {
 1596     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1597     return MD_TOKEN_BITWISE_AND;
 1598 }
 1599     YY_BREAK
 1600 case 56:
 1601 YY_RULE_SETUP
 1602 #line 249 "mlr_dsl_lexer.l"
 1603 {
 1604     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1605     return MD_TOKEN_BITWISE_AND_EQUALS;
 1606 }
 1607     YY_BREAK
 1608 case 57:
 1609 YY_RULE_SETUP
 1610 #line 254 "mlr_dsl_lexer.l"
 1611 {
 1612     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1613     return MD_TOKEN_BITWISE_LSH;
 1614 }
 1615     YY_BREAK
 1616 case 58:
 1617 YY_RULE_SETUP
 1618 #line 258 "mlr_dsl_lexer.l"
 1619 {
 1620     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1621     return MD_TOKEN_BITWISE_LSH_EQUALS;
 1622 }
 1623     YY_BREAK
 1624 case 59:
 1625 YY_RULE_SETUP
 1626 #line 262 "mlr_dsl_lexer.l"
 1627 {
 1628     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1629     return MD_TOKEN_BITWISE_RSH;
 1630 }
 1631     YY_BREAK
 1632 case 60:
 1633 YY_RULE_SETUP
 1634 #line 266 "mlr_dsl_lexer.l"
 1635 {
 1636     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1637     return MD_TOKEN_BITWISE_RSH_EQUALS;
 1638 }
 1639     YY_BREAK
 1640 case 61:
 1641 YY_RULE_SETUP
 1642 #line 271 "mlr_dsl_lexer.l"
 1643 {
 1644     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1645     return MD_TOKEN_PLUS;
 1646 }
 1647     YY_BREAK
 1648 case 62:
 1649 YY_RULE_SETUP
 1650 #line 275 "mlr_dsl_lexer.l"
 1651 {
 1652     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1653     return MD_TOKEN_PLUS_EQUALS;
 1654 }
 1655     YY_BREAK
 1656 case 63:
 1657 YY_RULE_SETUP
 1658 #line 279 "mlr_dsl_lexer.l"
 1659 {
 1660     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1661     return MD_TOKEN_MINUS;
 1662 }
 1663     YY_BREAK
 1664 case 64:
 1665 YY_RULE_SETUP
 1666 #line 283 "mlr_dsl_lexer.l"
 1667 {
 1668     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1669     return MD_TOKEN_MINUS_EQUALS;
 1670 }
 1671     YY_BREAK
 1672 case 65:
 1673 YY_RULE_SETUP
 1674 #line 287 "mlr_dsl_lexer.l"
 1675 {
 1676     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1677     return MD_TOKEN_DOT;
 1678 }
 1679     YY_BREAK
 1680 case 66:
 1681 YY_RULE_SETUP
 1682 #line 291 "mlr_dsl_lexer.l"
 1683 {
 1684     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1685     return MD_TOKEN_DOT_EQUALS;
 1686 }
 1687     YY_BREAK
 1688 case 67:
 1689 YY_RULE_SETUP
 1690 #line 295 "mlr_dsl_lexer.l"
 1691 {
 1692     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1693     return MD_TOKEN_TIMES;
 1694 }
 1695     YY_BREAK
 1696 case 68:
 1697 YY_RULE_SETUP
 1698 #line 299 "mlr_dsl_lexer.l"
 1699 {
 1700     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1701     return MD_TOKEN_TIMES_EQUALS;
 1702 }
 1703     YY_BREAK
 1704 case 69:
 1705 YY_RULE_SETUP
 1706 #line 303 "mlr_dsl_lexer.l"
 1707 {
 1708     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1709     return MD_TOKEN_DIVIDE;
 1710 }
 1711     YY_BREAK
 1712 case 70:
 1713 YY_RULE_SETUP
 1714 #line 307 "mlr_dsl_lexer.l"
 1715 {
 1716     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1717     return MD_TOKEN_DIVIDE_EQUALS;
 1718 }
 1719     YY_BREAK
 1720 case 71:
 1721 YY_RULE_SETUP
 1722 #line 311 "mlr_dsl_lexer.l"
 1723 {
 1724     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1725     return MD_TOKEN_INT_DIVIDE;
 1726 }
 1727     YY_BREAK
 1728 case 72:
 1729 YY_RULE_SETUP
 1730 #line 315 "mlr_dsl_lexer.l"
 1731 {
 1732     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1733     return MD_TOKEN_INT_DIVIDE_EQUALS;
 1734 }
 1735     YY_BREAK
 1736 case 73:
 1737 YY_RULE_SETUP
 1738 #line 320 "mlr_dsl_lexer.l"
 1739 {
 1740     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1741     return MD_TOKEN_OPLUS;
 1742 }
 1743     YY_BREAK
 1744 case 74:
 1745 YY_RULE_SETUP
 1746 #line 324 "mlr_dsl_lexer.l"
 1747 {
 1748     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1749     return MD_TOKEN_OPLUS_EQUALS;
 1750 }
 1751     YY_BREAK
 1752 case 75:
 1753 YY_RULE_SETUP
 1754 #line 328 "mlr_dsl_lexer.l"
 1755 {
 1756     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1757     return MD_TOKEN_OMINUS;
 1758 }
 1759     YY_BREAK
 1760 case 76:
 1761 YY_RULE_SETUP
 1762 #line 332 "mlr_dsl_lexer.l"
 1763 {
 1764     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1765     return MD_TOKEN_OMINUS_EQUALS;
 1766 }
 1767     YY_BREAK
 1768 case 77:
 1769 YY_RULE_SETUP
 1770 #line 336 "mlr_dsl_lexer.l"
 1771 {
 1772     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1773     return MD_TOKEN_OTIMES;
 1774 }
 1775     YY_BREAK
 1776 case 78:
 1777 YY_RULE_SETUP
 1778 #line 340 "mlr_dsl_lexer.l"
 1779 {
 1780     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1781     return MD_TOKEN_OTIMES_EQUALS;
 1782 }
 1783     YY_BREAK
 1784 case 79:
 1785 YY_RULE_SETUP
 1786 #line 344 "mlr_dsl_lexer.l"
 1787 {
 1788     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1789     return MD_TOKEN_ODIVIDE;
 1790 }
 1791     YY_BREAK
 1792 case 80:
 1793 YY_RULE_SETUP
 1794 #line 348 "mlr_dsl_lexer.l"
 1795 {
 1796     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1797     return MD_TOKEN_ODIVIDE_EQUALS;
 1798 }
 1799     YY_BREAK
 1800 case 81:
 1801 YY_RULE_SETUP
 1802 #line 352 "mlr_dsl_lexer.l"
 1803 {
 1804     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1805     return MD_TOKEN_INT_ODIVIDE;
 1806 }
 1807     YY_BREAK
 1808 case 82:
 1809 YY_RULE_SETUP
 1810 #line 356 "mlr_dsl_lexer.l"
 1811 {
 1812     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1813     return MD_TOKEN_INT_ODIVIDE_EQUALS;
 1814 }
 1815     YY_BREAK
 1816 case 83:
 1817 YY_RULE_SETUP
 1818 #line 361 "mlr_dsl_lexer.l"
 1819 {
 1820     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1821     return MD_TOKEN_MOD;
 1822 }
 1823     YY_BREAK
 1824 case 84:
 1825 YY_RULE_SETUP
 1826 #line 365 "mlr_dsl_lexer.l"
 1827 {
 1828     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1829     return MD_TOKEN_MOD_EQUALS;
 1830 }
 1831     YY_BREAK
 1832 case 85:
 1833 YY_RULE_SETUP
 1834 #line 370 "mlr_dsl_lexer.l"
 1835 {
 1836     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1837     return MD_TOKEN_LOGICAL_NOT;
 1838 }
 1839     YY_BREAK
 1840 case 86:
 1841 YY_RULE_SETUP
 1842 #line 375 "mlr_dsl_lexer.l"
 1843 {
 1844     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1845     return MD_TOKEN_BITWISE_NOT;
 1846 }
 1847     YY_BREAK
 1848 case 87:
 1849 YY_RULE_SETUP
 1850 #line 380 "mlr_dsl_lexer.l"
 1851 {
 1852     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1853     return MD_TOKEN_POW;
 1854 }
 1855     YY_BREAK
 1856 case 88:
 1857 YY_RULE_SETUP
 1858 #line 384 "mlr_dsl_lexer.l"
 1859 {
 1860     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OPERATOR);
 1861     return MD_TOKEN_POW_EQUALS;
 1862 }
 1863     YY_BREAK
 1864 case 89:
 1865 YY_RULE_SETUP
 1866 #line 389 "mlr_dsl_lexer.l"
 1867 {
 1868     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FULL_SREC);
 1869     return MD_TOKEN_FULL_SREC;
 1870 }
 1871     YY_BREAK
 1872 case 90:
 1873 YY_RULE_SETUP
 1874 #line 393 "mlr_dsl_lexer.l"
 1875 {
 1876     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1877     return MD_TOKEN_DOLLAR_SIGN;
 1878 }
 1879     YY_BREAK
 1880 case 91:
 1881 YY_RULE_SETUP
 1882 #line 398 "mlr_dsl_lexer.l"
 1883 {
 1884     // Note: the parser depends on the dollar sign being here. If this is changed,
 1885     // that needs to be changed as well.
 1886     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FIELD_NAME);
 1887     return MD_TOKEN_FIELD_NAME;
 1888 }
 1889     YY_BREAK
 1890 case 92:
 1891 /* rule 92 can match eol */
 1892 YY_RULE_SETUP
 1893 #line 404 "mlr_dsl_lexer.l"
 1894 {
 1895     // Note: the parser depends on the dollar sign being here. If this is changed,
 1896     // that needs to be changed as well.
 1897     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FIELD_NAME);
 1898     return MD_TOKEN_BRACED_FIELD_NAME;
 1899 }
 1900     YY_BREAK
 1901 case 93:
 1902 YY_RULE_SETUP
 1903 #line 411 "mlr_dsl_lexer.l"
 1904 {
 1905     // Note: the parser depends on the at-sign being here. If this is changed,
 1906     // that needs to be changed as well.
 1907     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRING_LITERAL);
 1908     return MD_TOKEN_UNBRACED_OOSVAR_NAME;
 1909 }
 1910     YY_BREAK
 1911 case 94:
 1912 /* rule 94 can match eol */
 1913 YY_RULE_SETUP
 1914 #line 417 "mlr_dsl_lexer.l"
 1915 {
 1916     // Note: the parser depends on the percent-sign being here. If this is changed,
 1917     // that needs to be changed as well.
 1918     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRING_LITERAL);
 1919     return MD_TOKEN_BRACED_OOSVAR_NAME;
 1920 }
 1921     YY_BREAK
 1922 case 95:
 1923 YY_RULE_SETUP
 1924 #line 423 "mlr_dsl_lexer.l"
 1925 {
 1926     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1927     return MD_TOKEN_AT_SIGN;
 1928 }
 1929     YY_BREAK
 1930 case 96:
 1931 YY_RULE_SETUP
 1932 #line 427 "mlr_dsl_lexer.l"
 1933 {
 1934     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FULL_OOSVAR);
 1935     return MD_TOKEN_FULL_OOSVAR;
 1936 }
 1937     YY_BREAK
 1938 case 97:
 1939 YY_RULE_SETUP
 1940 #line 432 "mlr_dsl_lexer.l"
 1941 {
 1942     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1943     return MD_TOKEN_LEFT_BRACKET;
 1944 }
 1945     YY_BREAK
 1946 case 98:
 1947 YY_RULE_SETUP
 1948 #line 436 "mlr_dsl_lexer.l"
 1949 {
 1950     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 1951     return MD_TOKEN_RIGHT_BRACKET;
 1952 }
 1953     YY_BREAK
 1954 case 99:
 1955 YY_RULE_SETUP
 1956 #line 441 "mlr_dsl_lexer.l"
 1957 {
 1958     // Leading minus sign is handled via the unary-minus operator, not here.
 1959     // 123
 1960     // 123. 123.4
 1961     // .234
 1962     // 1e2
 1963     // 1e-2
 1964     // 1.2e3 1.e3
 1965     // 1.2e-3 1.e-3
 1966     // .2e3
 1967     // .2e-3 1.e-3
 1968     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_NUMERIC_LITERAL);
 1969     return MD_TOKEN_NUMBER;
 1970 }
 1971     YY_BREAK
 1972 case 100:
 1973 YY_RULE_SETUP
 1974 #line 455 "mlr_dsl_lexer.l"
 1975 {
 1976     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_NUMERIC_LITERAL);
 1977     return MD_TOKEN_NUMBER;
 1978 }
 1979     YY_BREAK
 1980 case 101:
 1981 /* rule 101 can match eol */
 1982 YY_RULE_SETUP
 1983 #line 460 "mlr_dsl_lexer.l"
 1984 {
 1985     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRING_LITERAL);
 1986     return MD_TOKEN_STRING;
 1987 }
 1988     YY_BREAK
 1989 case 102:
 1990 /* rule 102 can match eol */
 1991 YY_RULE_SETUP
 1992 #line 465 "mlr_dsl_lexer.l"
 1993 {
 1994     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_REGEXI);
 1995     return MD_TOKEN_REGEXI;
 1996 }
 1997     YY_BREAK
 1998 case 103:
 1999 YY_RULE_SETUP
 2000 #line 470 "mlr_dsl_lexer.l"
 2001 {
 2002     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 2003     return MD_TOKEN_MAP;
 2004 }
 2005     YY_BREAK
 2006 case 104:
 2007 YY_RULE_SETUP
 2008 #line 474 "mlr_dsl_lexer.l"
 2009 {
 2010     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 2011     return MD_TOKEN_VAR;
 2012 }
 2013     YY_BREAK
 2014 case 105:
 2015 YY_RULE_SETUP
 2016 #line 478 "mlr_dsl_lexer.l"
 2017 {
 2018     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_NUMERIC_LOCAL_DEFINITION);
 2019     return MD_TOKEN_NUMERIC;
 2020 }
 2021     YY_BREAK
 2022 case 106:
 2023 YY_RULE_SETUP
 2024 #line 482 "mlr_dsl_lexer.l"
 2025 {
 2026     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_INT_LOCAL_DEFINITION);
 2027     return MD_TOKEN_INT;
 2028 }
 2029     YY_BREAK
 2030 case 107:
 2031 YY_RULE_SETUP
 2032 #line 486 "mlr_dsl_lexer.l"
 2033 {
 2034     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_FLOAT_LOCAL_DEFINITION);
 2035     return MD_TOKEN_FLOAT;
 2036 }
 2037     YY_BREAK
 2038 case 108:
 2039 YY_RULE_SETUP
 2040 #line 490 "mlr_dsl_lexer.l"
 2041 {
 2042     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_BOOLEAN_LOCAL_DEFINITION);
 2043     return MD_TOKEN_BOOLEAN;
 2044 }
 2045     YY_BREAK
 2046 case 109:
 2047 YY_RULE_SETUP
 2048 #line 494 "mlr_dsl_lexer.l"
 2049 {
 2050     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRING_LOCAL_DEFINITION);
 2051     return MD_TOKEN_STRING;
 2052 }
 2053     YY_BREAK
 2054 case 110:
 2055 YY_RULE_SETUP
 2056 #line 499 "mlr_dsl_lexer.l"
 2057 {
 2058     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_BOOLEAN_LITERAL);
 2059     return MD_TOKEN_TRUE;
 2060 }
 2061     YY_BREAK
 2062 case 111:
 2063 YY_RULE_SETUP
 2064 #line 503 "mlr_dsl_lexer.l"
 2065 {
 2066     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_BOOLEAN_LITERAL);
 2067     return MD_TOKEN_FALSE;
 2068 }
 2069     YY_BREAK
 2070 case 112:
 2071 YY_RULE_SETUP
 2072 #line 508 "mlr_dsl_lexer.l"
 2073 {
 2074     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2075     return MD_TOKEN_CONTEXT_VARIABLE;
 2076 }
 2077     YY_BREAK
 2078 case 113:
 2079 YY_RULE_SETUP
 2080 #line 512 "mlr_dsl_lexer.l"
 2081 {
 2082     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2083     return MD_TOKEN_CONTEXT_VARIABLE;
 2084 }
 2085     YY_BREAK
 2086 case 114:
 2087 YY_RULE_SETUP
 2088 #line 516 "mlr_dsl_lexer.l"
 2089 {
 2090     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2091     return MD_TOKEN_CONTEXT_VARIABLE;
 2092 }
 2093     YY_BREAK
 2094 case 115:
 2095 YY_RULE_SETUP
 2096 #line 520 "mlr_dsl_lexer.l"
 2097 {
 2098     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2099     return MD_TOKEN_CONTEXT_VARIABLE;
 2100 }
 2101     YY_BREAK
 2102 case 116:
 2103 YY_RULE_SETUP
 2104 #line 524 "mlr_dsl_lexer.l"
 2105 {
 2106     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2107     return MD_TOKEN_CONTEXT_VARIABLE;
 2108 }
 2109     YY_BREAK
 2110 case 117:
 2111 YY_RULE_SETUP
 2112 #line 528 "mlr_dsl_lexer.l"
 2113 {
 2114     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2115     return MD_TOKEN_CONTEXT_VARIABLE;
 2116 }
 2117     YY_BREAK
 2118 case 118:
 2119 YY_RULE_SETUP
 2120 #line 533 "mlr_dsl_lexer.l"
 2121 {
 2122     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2123     return MD_TOKEN_CONTEXT_VARIABLE;
 2124 }
 2125     YY_BREAK
 2126 case 119:
 2127 YY_RULE_SETUP
 2128 #line 537 "mlr_dsl_lexer.l"
 2129 {
 2130     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2131     return MD_TOKEN_CONTEXT_VARIABLE;
 2132 }
 2133     YY_BREAK
 2134 case 120:
 2135 YY_RULE_SETUP
 2136 #line 541 "mlr_dsl_lexer.l"
 2137 {
 2138     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2139     return MD_TOKEN_CONTEXT_VARIABLE;
 2140 }
 2141     YY_BREAK
 2142 case 121:
 2143 YY_RULE_SETUP
 2144 #line 545 "mlr_dsl_lexer.l"
 2145 {
 2146     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2147     return MD_TOKEN_CONTEXT_VARIABLE;
 2148 }
 2149     YY_BREAK
 2150 case 122:
 2151 YY_RULE_SETUP
 2152 #line 549 "mlr_dsl_lexer.l"
 2153 {
 2154     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2155     return MD_TOKEN_CONTEXT_VARIABLE;
 2156 }
 2157     YY_BREAK
 2158 case 123:
 2159 YY_RULE_SETUP
 2160 #line 553 "mlr_dsl_lexer.l"
 2161 {
 2162     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2163     return MD_TOKEN_CONTEXT_VARIABLE;
 2164 }
 2165     YY_BREAK
 2166 case 124:
 2167 YY_RULE_SETUP
 2168 #line 557 "mlr_dsl_lexer.l"
 2169 {
 2170     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_CONTEXT_VARIABLE);
 2171     return MD_TOKEN_CONTEXT_VARIABLE;
 2172 }
 2173     YY_BREAK
 2174 case 125:
 2175 YY_RULE_SETUP
 2176 #line 561 "mlr_dsl_lexer.l"
 2177 {
 2178     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_ENV);
 2179     return MD_TOKEN_ENV;
 2180 }
 2181     YY_BREAK
 2182 case 126:
 2183 YY_RULE_SETUP
 2184 #line 566 "mlr_dsl_lexer.l"
 2185 {
 2186     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_NON_SIGIL_NAME);
 2187     return MD_TOKEN_NON_SIGIL_NAME;
 2188 }
 2189     YY_BREAK
 2190 case 127:
 2191 YY_RULE_SETUP
 2192 #line 571 "mlr_dsl_lexer.l"
 2193 {
 2194     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 2195     return MD_TOKEN_LPAREN;
 2196 }
 2197     YY_BREAK
 2198 case 128:
 2199 YY_RULE_SETUP
 2200 #line 575 "mlr_dsl_lexer.l"
 2201 {
 2202     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 2203     return MD_TOKEN_RPAREN;
 2204 }
 2205     YY_BREAK
 2206 case 129:
 2207 YY_RULE_SETUP
 2208 #line 580 "mlr_dsl_lexer.l"
 2209 {
 2210     *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY);
 2211     return MD_TOKEN_COMMA;
 2212 }
 2213     YY_BREAK
 2214 case 130:
 2215 /* rule 130 can match eol */
 2216 YY_RULE_SETUP
 2217 #line 585 "mlr_dsl_lexer.l"
 2218 { }
 2219     YY_BREAK
 2220 case 131:
 2221 /* rule 131 can match eol */
 2222 YY_RULE_SETUP
 2223 #line 587 "mlr_dsl_lexer.l"
 2224 { }
 2225     YY_BREAK
 2226 case 132:
 2227 YY_RULE_SETUP
 2228 #line 589 "mlr_dsl_lexer.l"
 2229 {
 2230     return -1;
 2231 }
 2232     YY_BREAK
 2233 case 133:
 2234 YY_RULE_SETUP
 2235 #line 592 "mlr_dsl_lexer.l"
 2236 ECHO;
 2237     YY_BREAK
 2238 #line 2239 "mlr_dsl_lexer.c"
 2239 case YY_STATE_EOF(INITIAL):
 2240     yyterminate();
 2241 
 2242     case YY_END_OF_BUFFER:
 2243         {
 2244         /* Amount of text matched not including the EOB char. */
 2245         int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
 2246 
 2247         /* Undo the effects of YY_DO_BEFORE_ACTION. */
 2248         *yy_cp = yyg->yy_hold_char;
 2249         YY_RESTORE_YY_MORE_OFFSET
 2250 
 2251         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 2252             {
 2253             /* We're scanning a new file or input source.  It's
 2254              * possible that this happened because the user
 2255              * just pointed yyin at a new source and called
 2256              * yylex().  If so, then we have to assure
 2257              * consistency between YY_CURRENT_BUFFER and our
 2258              * globals.  Here is the right place to do so, because
 2259              * this is the first action (other than possibly a
 2260              * back-up) that will match for the new input source.
 2261              */
 2262             yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 2263             YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 2264             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 2265             }
 2266 
 2267         /* Note that here we test for yy_c_buf_p "<=" to the position
 2268          * of the first EOB in the buffer, since yy_c_buf_p will
 2269          * already have been incremented past the NUL character
 2270          * (since all states make transitions on EOB to the
 2271          * end-of-buffer state).  Contrast this with the test
 2272          * in input().
 2273          */
 2274         if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 2275             { /* This was really a NUL. */
 2276             yy_state_type yy_next_state;
 2277 
 2278             yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
 2279 
 2280             yy_current_state = yy_get_previous_state( yyscanner );
 2281 
 2282             /* Okay, we're now positioned to make the NUL
 2283              * transition.  We couldn't have
 2284              * yy_get_previous_state() go ahead and do it
 2285              * for us because it doesn't know how to deal
 2286              * with the possibility of jamming (and we don't
 2287              * want to build jamming into it because then it
 2288              * will run more slowly).
 2289              */
 2290 
 2291             yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
 2292 
 2293             yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 2294 
 2295             if ( yy_next_state )
 2296                 {
 2297                 /* Consume the NUL. */
 2298                 yy_cp = ++yyg->yy_c_buf_p;
 2299                 yy_current_state = yy_next_state;
 2300                 goto yy_match;
 2301                 }
 2302 
 2303             else
 2304                 {
 2305                 yy_cp = yyg->yy_c_buf_p;
 2306                 goto yy_find_action;
 2307                 }
 2308             }
 2309 
 2310         else switch ( yy_get_next_buffer( yyscanner ) )
 2311             {
 2312             case EOB_ACT_END_OF_FILE:
 2313                 {
 2314                 yyg->yy_did_buffer_switch_on_eof = 0;
 2315 
 2316                 if ( yywrap( yyscanner ) )
 2317                     {
 2318                     /* Note: because we've taken care in
 2319                      * yy_get_next_buffer() to have set up
 2320                      * yytext, we can now set up
 2321                      * yy_c_buf_p so that if some total
 2322                      * hoser (like flex itself) wants to
 2323                      * call the scanner after we return the
 2324                      * YY_NULL, it'll still work - another
 2325                      * YY_NULL will get returned.
 2326                      */
 2327                     yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
 2328 
 2329                     yy_act = YY_STATE_EOF(YY_START);
 2330                     goto do_action;
 2331                     }
 2332 
 2333                 else
 2334                     {
 2335                     if ( ! yyg->yy_did_buffer_switch_on_eof )
 2336                         YY_NEW_FILE;
 2337                     }
 2338                 break;
 2339                 }
 2340 
 2341             case EOB_ACT_CONTINUE_SCAN:
 2342                 yyg->yy_c_buf_p =
 2343                     yyg->yytext_ptr + yy_amount_of_matched_text;
 2344 
 2345                 yy_current_state = yy_get_previous_state( yyscanner );
 2346 
 2347                 yy_cp = yyg->yy_c_buf_p;
 2348                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 2349                 goto yy_match;
 2350 
 2351             case EOB_ACT_LAST_MATCH:
 2352                 yyg->yy_c_buf_p =
 2353                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
 2354 
 2355                 yy_current_state = yy_get_previous_state( yyscanner );
 2356 
 2357                 yy_cp = yyg->yy_c_buf_p;
 2358                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 2359                 goto yy_find_action;
 2360             }
 2361         break;
 2362         }
 2363 
 2364     default:
 2365         YY_FATAL_ERROR(
 2366             "fatal flex scanner internal error--no action found" );
 2367     } /* end of action switch */
 2368         } /* end of scanning one token */
 2369     } /* end of user's declarations */
 2370 } /* end of yylex */
 2371 
 2372 /* yy_get_next_buffer - try to read in a new buffer
 2373  *
 2374  * Returns a code representing an action:
 2375  *  EOB_ACT_LAST_MATCH -
 2376  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 2377  *  EOB_ACT_END_OF_FILE - end of file
 2378  */
 2379 static int yy_get_next_buffer (yyscan_t yyscanner)
 2380 {
 2381     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2382     char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 2383     char *source = yyg->yytext_ptr;
 2384     int number_to_move, i;
 2385     int ret_val;
 2386 
 2387     if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
 2388         YY_FATAL_ERROR(
 2389         "fatal flex scanner internal error--end of buffer missed" );
 2390 
 2391     if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 2392         { /* Don't try to fill the buffer, so this is an EOF. */
 2393         if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
 2394             {
 2395             /* We matched a single character, the EOB, so
 2396              * treat this as a final EOF.
 2397              */
 2398             return EOB_ACT_END_OF_FILE;
 2399             }
 2400 
 2401         else
 2402             {
 2403             /* We matched some text prior to the EOB, first
 2404              * process it.
 2405              */
 2406             return EOB_ACT_LAST_MATCH;
 2407             }
 2408         }
 2409 
 2410     /* Try to read more data. */
 2411 
 2412     /* First move last chars to start of buffer. */
 2413     number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
 2414 
 2415     for ( i = 0; i < number_to_move; ++i )
 2416         *(dest++) = *(source++);
 2417 
 2418     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 2419         /* don't do the read, it's not guaranteed to return an EOF,
 2420          * just force an EOF
 2421          */
 2422         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
 2423 
 2424     else
 2425         {
 2426             int num_to_read =
 2427             YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 2428 
 2429         while ( num_to_read <= 0 )
 2430             { /* Not enough room in the buffer - grow it. */
 2431 
 2432             /* just a shorter name for the current buffer */
 2433             YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 2434 
 2435             int yy_c_buf_p_offset =
 2436                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 2437 
 2438             if ( b->yy_is_our_buffer )
 2439                 {
 2440                 int new_size = b->yy_buf_size * 2;
 2441 
 2442                 if ( new_size <= 0 )
 2443                     b->yy_buf_size += b->yy_buf_size / 8;
 2444                 else
 2445                     b->yy_buf_size *= 2;
 2446 
 2447                 b->yy_ch_buf = (char *)
 2448                     /* Include room in for 2 EOB chars. */
 2449                     yyrealloc( (void *) b->yy_ch_buf,
 2450                              (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
 2451                 }
 2452             else
 2453                 /* Can't grow it, we don't own it. */
 2454                 b->yy_ch_buf = NULL;
 2455 
 2456             if ( ! b->yy_ch_buf )
 2457                 YY_FATAL_ERROR(
 2458                 "fatal error - scanner input buffer overflow" );
 2459 
 2460             yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 2461 
 2462             num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 2463                         number_to_move - 1;
 2464 
 2465             }
 2466 
 2467         if ( num_to_read > YY_READ_BUF_SIZE )
 2468             num_to_read = YY_READ_BUF_SIZE;
 2469 
 2470         /* Read in more data. */
 2471         YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
 2472             yyg->yy_n_chars, num_to_read );
 2473 
 2474         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 2475         }
 2476 
 2477     if ( yyg->yy_n_chars == 0 )
 2478         {
 2479         if ( number_to_move == YY_MORE_ADJ )
 2480             {
 2481             ret_val = EOB_ACT_END_OF_FILE;
 2482             yyrestart( yyin  , yyscanner);
 2483             }
 2484 
 2485         else
 2486             {
 2487             ret_val = EOB_ACT_LAST_MATCH;
 2488             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 2489                 YY_BUFFER_EOF_PENDING;
 2490             }
 2491         }
 2492 
 2493     else
 2494         ret_val = EOB_ACT_CONTINUE_SCAN;
 2495 
 2496     if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 2497         /* Extend the array by 50%, plus the number we really need. */
 2498         int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
 2499         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
 2500             (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
 2501         if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 2502             YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
 2503         /* "- 2" to take care of EOB's */
 2504         YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
 2505     }
 2506 
 2507     yyg->yy_n_chars += number_to_move;
 2508     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
 2509     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 2510 
 2511     yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 2512 
 2513     return ret_val;
 2514 }
 2515 
 2516 /* yy_get_previous_state - get the state just before the EOB char was reached */
 2517 
 2518     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
 2519 {
 2520     yy_state_type yy_current_state;
 2521     char *yy_cp;
 2522     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2523 
 2524     yy_current_state = yyg->yy_start;
 2525 
 2526     for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
 2527         {
 2528         YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 2529         if ( yy_accept[yy_current_state] )
 2530             {
 2531             yyg->yy_last_accepting_state = yy_current_state;
 2532             yyg->yy_last_accepting_cpos = yy_cp;
 2533             }
 2534         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 2535             {
 2536             yy_current_state = (int) yy_def[yy_current_state];
 2537             if ( yy_current_state >= 289 )
 2538                 yy_c = yy_meta[yy_c];
 2539             }
 2540         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 2541         }
 2542 
 2543     return yy_current_state;
 2544 }
 2545 
 2546 /* yy_try_NUL_trans - try to make a transition on the NUL character
 2547  *
 2548  * synopsis
 2549  *  next_state = yy_try_NUL_trans( current_state );
 2550  */
 2551     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
 2552 {
 2553     int yy_is_jam;
 2554     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
 2555     char *yy_cp = yyg->yy_c_buf_p;
 2556 
 2557     YY_CHAR yy_c = 1;
 2558     if ( yy_accept[yy_current_state] )
 2559         {
 2560         yyg->yy_last_accepting_state = yy_current_state;
 2561         yyg->yy_last_accepting_cpos = yy_cp;
 2562         }
 2563     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 2564         {
 2565         yy_current_state = (int) yy_def[yy_current_state];
 2566         if ( yy_current_state >= 289 )
 2567             yy_c = yy_meta[yy_c];
 2568         }
 2569     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 2570     yy_is_jam = (yy_current_state == 288);
 2571 
 2572     (void)yyg;
 2573     return yy_is_jam ? 0 : yy_current_state;
 2574 }
 2575 
 2576 #ifndef YY_NO_UNPUT
 2577 
 2578     static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
 2579 {
 2580     char *yy_cp;
 2581     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2582 
 2583     yy_cp = yyg->yy_c_buf_p;
 2584 
 2585     /* undo effects of setting up yytext */
 2586     *yy_cp = yyg->yy_hold_char;
 2587 
 2588     if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 2589         { /* need to shift things up to make room */
 2590         /* +2 for EOB chars. */
 2591         int number_to_move = yyg->yy_n_chars + 2;
 2592         char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
 2593                     YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 2594         char *source =
 2595                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 2596 
 2597         while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 2598             *--dest = *--source;
 2599 
 2600         yy_cp += (int) (dest - source);
 2601         yy_bp += (int) (dest - source);
 2602         YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
 2603             yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 2604 
 2605         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 2606             YY_FATAL_ERROR( "flex scanner push-back overflow" );
 2607         }
 2608 
 2609     *--yy_cp = (char) c;
 2610 
 2611     yyg->yytext_ptr = yy_bp;
 2612     yyg->yy_hold_char = *yy_cp;
 2613     yyg->yy_c_buf_p = yy_cp;
 2614 }
 2615 
 2616 #endif
 2617 
 2618 #ifndef YY_NO_INPUT
 2619 #ifdef __cplusplus
 2620     static int yyinput (yyscan_t yyscanner)
 2621 #else
 2622     static int input  (yyscan_t yyscanner)
 2623 #endif
 2624 
 2625 {
 2626     int c;
 2627     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2628 
 2629     *yyg->yy_c_buf_p = yyg->yy_hold_char;
 2630 
 2631     if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
 2632         {
 2633         /* yy_c_buf_p now points to the character we want to return.
 2634          * If this occurs *before* the EOB characters, then it's a
 2635          * valid NUL; if not, then we've hit the end of the buffer.
 2636          */
 2637         if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 2638             /* This was really a NUL. */
 2639             *yyg->yy_c_buf_p = '\0';
 2640 
 2641         else
 2642             { /* need more input */
 2643             int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
 2644             ++yyg->yy_c_buf_p;
 2645 
 2646             switch ( yy_get_next_buffer( yyscanner ) )
 2647                 {
 2648                 case EOB_ACT_LAST_MATCH:
 2649                     /* This happens because yy_g_n_b()
 2650                      * sees that we've accumulated a
 2651                      * token and flags that we need to
 2652                      * try matching the token before
 2653                      * proceeding.  But for input(),
 2654                      * there's no matching to consider.
 2655                      * So convert the EOB_ACT_LAST_MATCH
 2656                      * to EOB_ACT_END_OF_FILE.
 2657                      */
 2658 
 2659                     /* Reset buffer status. */
 2660                     yyrestart( yyin , yyscanner);
 2661 
 2662                     /*FALLTHROUGH*/
 2663 
 2664                 case EOB_ACT_END_OF_FILE:
 2665                     {
 2666                     if ( yywrap( yyscanner ) )
 2667                         return 0;
 2668 
 2669                     if ( ! yyg->yy_did_buffer_switch_on_eof )
 2670                         YY_NEW_FILE;
 2671 #ifdef __cplusplus
 2672                     return yyinput(yyscanner);
 2673 #else
 2674                     return input(yyscanner);
 2675 #endif
 2676                     }
 2677 
 2678                 case EOB_ACT_CONTINUE_SCAN:
 2679                     yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
 2680                     break;
 2681                 }
 2682             }
 2683         }
 2684 
 2685     c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
 2686     *yyg->yy_c_buf_p = '\0';    /* preserve yytext */
 2687     yyg->yy_hold_char = *++yyg->yy_c_buf_p;
 2688 
 2689     return c;
 2690 }
 2691 #endif  /* ifndef YY_NO_INPUT */
 2692 
 2693 /** Immediately switch to a different input stream.
 2694  * @param input_file A readable stream.
 2695  * @param yyscanner The scanner object.
 2696  * @note This function does not reset the start condition to @c INITIAL .
 2697  */
 2698     void yyrestart  (FILE * input_file , yyscan_t yyscanner)
 2699 {
 2700     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2701 
 2702     if ( ! YY_CURRENT_BUFFER ){
 2703         yyensure_buffer_stack (yyscanner);
 2704         YY_CURRENT_BUFFER_LVALUE =
 2705             yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
 2706     }
 2707 
 2708     yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
 2709     yy_load_buffer_state( yyscanner );
 2710 }
 2711 
 2712 /** Switch to a different input buffer.
 2713  * @param new_buffer The new input buffer.
 2714  * @param yyscanner The scanner object.
 2715  */
 2716     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
 2717 {
 2718     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2719 
 2720     /* TODO. We should be able to replace this entire function body
 2721      * with
 2722      *      yypop_buffer_state();
 2723      *      yypush_buffer_state(new_buffer);
 2724      */
 2725     yyensure_buffer_stack (yyscanner);
 2726     if ( YY_CURRENT_BUFFER == new_buffer )
 2727         return;
 2728 
 2729     if ( YY_CURRENT_BUFFER )
 2730         {
 2731         /* Flush out information for old buffer. */
 2732         *yyg->yy_c_buf_p = yyg->yy_hold_char;
 2733         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
 2734         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 2735         }
 2736 
 2737     YY_CURRENT_BUFFER_LVALUE = new_buffer;
 2738     yy_load_buffer_state( yyscanner );
 2739 
 2740     /* We don't actually know whether we did this switch during
 2741      * EOF (yywrap()) processing, but the only time this flag
 2742      * is looked at is after yywrap() is called, so it's safe
 2743      * to go ahead and always set it.
 2744      */
 2745     yyg->yy_did_buffer_switch_on_eof = 1;
 2746 }
 2747 
 2748 static void yy_load_buffer_state  (yyscan_t yyscanner)
 2749 {
 2750     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2751     yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 2752     yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
 2753     yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
 2754     yyg->yy_hold_char = *yyg->yy_c_buf_p;
 2755 }
 2756 
 2757 /** Allocate and initialize an input buffer state.
 2758  * @param file A readable stream.
 2759  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 2760  * @param yyscanner The scanner object.
 2761  * @return the allocated buffer state.
 2762  */
 2763     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
 2764 {
 2765     YY_BUFFER_STATE b;
 2766     
 2767     b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
 2768     if ( ! b )
 2769         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 2770 
 2771     b->yy_buf_size = size;
 2772 
 2773     /* yy_ch_buf has to be 2 characters longer than the size given because
 2774      * we need to put in 2 end-of-buffer characters.
 2775      */
 2776     b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
 2777     if ( ! b->yy_ch_buf )
 2778         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 2779 
 2780     b->yy_is_our_buffer = 1;
 2781 
 2782     yy_init_buffer( b, file , yyscanner);
 2783 
 2784     return b;
 2785 }
 2786 
 2787 /** Destroy the buffer.
 2788  * @param b a buffer created with yy_create_buffer()
 2789  * @param yyscanner The scanner object.
 2790  */
 2791     void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
 2792 {
 2793     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2794 
 2795     if ( ! b )
 2796         return;
 2797 
 2798     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
 2799         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 2800 
 2801     if ( b->yy_is_our_buffer )
 2802         yyfree( (void *) b->yy_ch_buf , yyscanner );
 2803 
 2804     yyfree( (void *) b , yyscanner );
 2805 }
 2806 
 2807 /* Initializes or reinitializes a buffer.
 2808  * This function is sometimes called more than once on the same buffer,
 2809  * such as during a yyrestart() or at EOF.
 2810  */
 2811     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
 2812 
 2813 {
 2814     int oerrno = errno;
 2815     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2816 
 2817     yy_flush_buffer( b , yyscanner);
 2818 
 2819     b->yy_input_file = file;
 2820     b->yy_fill_buffer = 1;
 2821 
 2822     /* If b is the current buffer, then yy_init_buffer was _probably_
 2823      * called from yyrestart() or through yy_get_next_buffer.
 2824      * In that case, we don't want to reset the lineno or column.
 2825      */
 2826     if (b != YY_CURRENT_BUFFER){
 2827         b->yy_bs_lineno = 1;
 2828         b->yy_bs_column = 0;
 2829     }
 2830 
 2831         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
 2832     
 2833     errno = oerrno;
 2834 }
 2835 
 2836 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 2837  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 2838  * @param yyscanner The scanner object.
 2839  */
 2840     void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
 2841 {
 2842     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2843     if ( ! b )
 2844         return;
 2845 
 2846     b->yy_n_chars = 0;
 2847 
 2848     /* We always need two end-of-buffer characters.  The first causes
 2849      * a transition to the end-of-buffer state.  The second causes
 2850      * a jam in that state.
 2851      */
 2852     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
 2853     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 2854 
 2855     b->yy_buf_pos = &b->yy_ch_buf[0];
 2856 
 2857     b->yy_at_bol = 1;
 2858     b->yy_buffer_status = YY_BUFFER_NEW;
 2859 
 2860     if ( b == YY_CURRENT_BUFFER )
 2861         yy_load_buffer_state( yyscanner );
 2862 }
 2863 
 2864 /** Pushes the new state onto the stack. The new state becomes
 2865  *  the current state. This function will allocate the stack
 2866  *  if necessary.
 2867  *  @param new_buffer The new state.
 2868  *  @param yyscanner The scanner object.
 2869  */
 2870 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
 2871 {
 2872     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2873     if (new_buffer == NULL)
 2874         return;
 2875 
 2876     yyensure_buffer_stack(yyscanner);
 2877 
 2878     /* This block is copied from yy_switch_to_buffer. */
 2879     if ( YY_CURRENT_BUFFER )
 2880         {
 2881         /* Flush out information for old buffer. */
 2882         *yyg->yy_c_buf_p = yyg->yy_hold_char;
 2883         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
 2884         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 2885         }
 2886 
 2887     /* Only push if top exists. Otherwise, replace top. */
 2888     if (YY_CURRENT_BUFFER)
 2889         yyg->yy_buffer_stack_top++;
 2890     YY_CURRENT_BUFFER_LVALUE = new_buffer;
 2891 
 2892     /* copied from yy_switch_to_buffer. */
 2893     yy_load_buffer_state( yyscanner );
 2894     yyg->yy_did_buffer_switch_on_eof = 1;
 2895 }
 2896 
 2897 /** Removes and deletes the top of the stack, if present.
 2898  *  The next element becomes the new top.
 2899  *  @param yyscanner The scanner object.
 2900  */
 2901 void yypop_buffer_state (yyscan_t yyscanner)
 2902 {
 2903     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2904     if (!YY_CURRENT_BUFFER)
 2905         return;
 2906 
 2907     yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
 2908     YY_CURRENT_BUFFER_LVALUE = NULL;
 2909     if (yyg->yy_buffer_stack_top > 0)
 2910         --yyg->yy_buffer_stack_top;
 2911 
 2912     if (YY_CURRENT_BUFFER) {
 2913         yy_load_buffer_state( yyscanner );
 2914         yyg->yy_did_buffer_switch_on_eof = 1;
 2915     }
 2916 }
 2917 
 2918 /* Allocates the stack if it does not exist.
 2919  *  Guarantees space for at least one push.
 2920  */
 2921 static void yyensure_buffer_stack (yyscan_t yyscanner)
 2922 {
 2923     yy_size_t num_to_alloc;
 2924     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 2925 
 2926     if (!yyg->yy_buffer_stack) {
 2927 
 2928         /* First allocation is just for 2 elements, since we don't know if this
 2929          * scanner will even need a stack. We use 2 instead of 1 to avoid an
 2930          * immediate realloc on the next call.
 2931          */
 2932       num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
 2933         yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
 2934                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
 2935                                 , yyscanner);
 2936         if ( ! yyg->yy_buffer_stack )
 2937             YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 2938 
 2939         memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
 2940 
 2941         yyg->yy_buffer_stack_max = num_to_alloc;
 2942         yyg->yy_buffer_stack_top = 0;
 2943         return;
 2944     }
 2945 
 2946     if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
 2947 
 2948         /* Increase the buffer to prepare for a possible push. */
 2949         yy_size_t grow_size = 8 /* arbitrary grow size */;
 2950 
 2951         num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
 2952         yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
 2953                                 (yyg->yy_buffer_stack,
 2954                                 num_to_alloc * sizeof(struct yy_buffer_state*)
 2955                                 , yyscanner);
 2956         if ( ! yyg->yy_buffer_stack )
 2957             YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 2958 
 2959         /* zero only the new slots.*/
 2960         memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
 2961         yyg->yy_buffer_stack_max = num_to_alloc;
 2962     }
 2963 }
 2964 
 2965 /** Setup the input buffer state to scan directly from a user-specified character buffer.
 2966  * @param base the character buffer
 2967  * @param size the size in bytes of the character buffer
 2968  * @param yyscanner The scanner object.
 2969  * @return the newly allocated buffer state object.
 2970  */
 2971 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
 2972 {
 2973     YY_BUFFER_STATE b;
 2974     
 2975     if ( size < 2 ||
 2976          base[size-2] != YY_END_OF_BUFFER_CHAR ||
 2977          base[size-1] != YY_END_OF_BUFFER_CHAR )
 2978         /* They forgot to leave room for the EOB's. */
 2979         return NULL;
 2980 
 2981     b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
 2982     if ( ! b )
 2983         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 2984 
 2985     b->yy_buf_size = (int) (size - 2);  /* "- 2" to take care of EOB's */
 2986     b->yy_buf_pos = b->yy_ch_buf = base;
 2987     b->yy_is_our_buffer = 0;
 2988     b->yy_input_file = NULL;
 2989     b->yy_n_chars = b->yy_buf_size;
 2990     b->yy_is_interactive = 0;
 2991     b->yy_at_bol = 1;
 2992     b->yy_fill_buffer = 0;
 2993     b->yy_buffer_status = YY_BUFFER_NEW;
 2994 
 2995     yy_switch_to_buffer( b , yyscanner );
 2996 
 2997     return b;
 2998 }
 2999 
 3000 /** Setup the input buffer state to scan a string. The next call to yylex() will
 3001  * scan from a @e copy of @a str.
 3002  * @param yystr a NUL-terminated string to scan
 3003  * @param yyscanner The scanner object.
 3004  * @return the newly allocated buffer state object.
 3005  * @note If you want to scan bytes that may contain NUL values, then use
 3006  *       yy_scan_bytes() instead.
 3007  */
 3008 YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
 3009 {
 3010     
 3011     return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
 3012 }
 3013 
 3014 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 3015  * scan from a @e copy of @a bytes.
 3016  * @param yybytes the byte buffer to scan
 3017  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 3018  * @param yyscanner The scanner object.
 3019  * @return the newly allocated buffer state object.
 3020  */
 3021 YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
 3022 {
 3023     YY_BUFFER_STATE b;
 3024     char *buf;
 3025     yy_size_t n;
 3026     int i;
 3027     
 3028     /* Get memory for full buffer, including space for trailing EOB's. */
 3029     n = (yy_size_t) (_yybytes_len + 2);
 3030     buf = (char *) yyalloc( n , yyscanner );
 3031     if ( ! buf )
 3032         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 3033 
 3034     for ( i = 0; i < _yybytes_len; ++i )
 3035         buf[i] = yybytes[i];
 3036 
 3037     buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 3038 
 3039     b = yy_scan_buffer( buf, n , yyscanner);
 3040     if ( ! b )
 3041         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 3042 
 3043     /* It's okay to grow etc. this buffer, and we should throw it
 3044      * away when we're done.
 3045      */
 3046     b->yy_is_our_buffer = 1;
 3047 
 3048     return b;
 3049 }
 3050 
 3051 #ifndef YY_EXIT_FAILURE
 3052 #define YY_EXIT_FAILURE 2
 3053 #endif
 3054 
 3055 static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
 3056 {
 3057     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3058     (void)yyg;
 3059     fprintf( stderr, "%s\n", msg );
 3060     exit( YY_EXIT_FAILURE );
 3061 }
 3062 
 3063 /* Redefine yyless() so it works in section 3 code. */
 3064 
 3065 #undef yyless
 3066 #define yyless(n) \
 3067     do \
 3068         { \
 3069         /* Undo effects of setting up yytext. */ \
 3070         int yyless_macro_arg = (n); \
 3071         YY_LESS_LINENO(yyless_macro_arg);\
 3072         yytext[yyleng] = yyg->yy_hold_char; \
 3073         yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
 3074         yyg->yy_hold_char = *yyg->yy_c_buf_p; \
 3075         *yyg->yy_c_buf_p = '\0'; \
 3076         yyleng = yyless_macro_arg; \
 3077         } \
 3078     while ( 0 )
 3079 
 3080 /* Accessor  methods (get/set functions) to struct members. */
 3081 
 3082 /** Get the user-defined data for this scanner.
 3083  * @param yyscanner The scanner object.
 3084  */
 3085 YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
 3086 {
 3087     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3088     return yyextra;
 3089 }
 3090 
 3091 /** Get the current line number.
 3092  * @param yyscanner The scanner object.
 3093  */
 3094 int yyget_lineno  (yyscan_t yyscanner)
 3095 {
 3096     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3097 
 3098         if (! YY_CURRENT_BUFFER)
 3099             return 0;
 3100     
 3101     return yylineno;
 3102 }
 3103 
 3104 /** Get the current column number.
 3105  * @param yyscanner The scanner object.
 3106  */
 3107 int yyget_column  (yyscan_t yyscanner)
 3108 {
 3109     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3110 
 3111         if (! YY_CURRENT_BUFFER)
 3112             return 0;
 3113     
 3114     return yycolumn;
 3115 }
 3116 
 3117 /** Get the input stream.
 3118  * @param yyscanner The scanner object.
 3119  */
 3120 FILE *yyget_in  (yyscan_t yyscanner)
 3121 {
 3122     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3123     return yyin;
 3124 }
 3125 
 3126 /** Get the output stream.
 3127  * @param yyscanner The scanner object.
 3128  */
 3129 FILE *yyget_out  (yyscan_t yyscanner)
 3130 {
 3131     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3132     return yyout;
 3133 }
 3134 
 3135 /** Get the length of the current token.
 3136  * @param yyscanner The scanner object.
 3137  */
 3138 int yyget_leng  (yyscan_t yyscanner)
 3139 {
 3140     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3141     return yyleng;
 3142 }
 3143 
 3144 /** Get the current token.
 3145  * @param yyscanner The scanner object.
 3146  */
 3147 
 3148 char *yyget_text  (yyscan_t yyscanner)
 3149 {
 3150     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3151     return yytext;
 3152 }
 3153 
 3154 /** Set the user-defined data. This data is never touched by the scanner.
 3155  * @param user_defined The data to be associated with this scanner.
 3156  * @param yyscanner The scanner object.
 3157  */
 3158 void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
 3159 {
 3160     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3161     yyextra = user_defined ;
 3162 }
 3163 
 3164 /** Set the current line number.
 3165  * @param _line_number line number
 3166  * @param yyscanner The scanner object.
 3167  */
 3168 void yyset_lineno (int  _line_number , yyscan_t yyscanner)
 3169 {
 3170     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3171 
 3172         /* lineno is only valid if an input buffer exists. */
 3173         if (! YY_CURRENT_BUFFER )
 3174            YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
 3175     
 3176     yylineno = _line_number;
 3177 }
 3178 
 3179 /** Set the current column.
 3180  * @param _column_no column number
 3181  * @param yyscanner The scanner object.
 3182  */
 3183 void yyset_column (int  _column_no , yyscan_t yyscanner)
 3184 {
 3185     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3186 
 3187         /* column is only valid if an input buffer exists. */
 3188         if (! YY_CURRENT_BUFFER )
 3189            YY_FATAL_ERROR( "yyset_column called with no buffer" );
 3190     
 3191     yycolumn = _column_no;
 3192 }
 3193 
 3194 /** Set the input stream. This does not discard the current
 3195  * input buffer.
 3196  * @param _in_str A readable stream.
 3197  * @param yyscanner The scanner object.
 3198  * @see yy_switch_to_buffer
 3199  */
 3200 void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
 3201 {
 3202     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3203     yyin = _in_str ;
 3204 }
 3205 
 3206 void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
 3207 {
 3208     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3209     yyout = _out_str ;
 3210 }
 3211 
 3212 int yyget_debug  (yyscan_t yyscanner)
 3213 {
 3214     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3215     return yy_flex_debug;
 3216 }
 3217 
 3218 void yyset_debug (int  _bdebug , yyscan_t yyscanner)
 3219 {
 3220     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3221     yy_flex_debug = _bdebug ;
 3222 }
 3223 
 3224 /* Accessor methods for yylval and yylloc */
 3225 
 3226 /* User-visible API */
 3227 
 3228 /* yylex_init is special because it creates the scanner itself, so it is
 3229  * the ONLY reentrant function that doesn't take the scanner as the last argument.
 3230  * That's why we explicitly handle the declaration, instead of using our macros.
 3231  */
 3232 int yylex_init(yyscan_t* ptr_yy_globals)
 3233 {
 3234     if (ptr_yy_globals == NULL){
 3235         errno = EINVAL;
 3236         return 1;
 3237     }
 3238 
 3239     *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
 3240 
 3241     if (*ptr_yy_globals == NULL){
 3242         errno = ENOMEM;
 3243         return 1;
 3244     }
 3245 
 3246     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
 3247     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
 3248 
 3249     return yy_init_globals ( *ptr_yy_globals );
 3250 }
 3251 
 3252 /* yylex_init_extra has the same functionality as yylex_init, but follows the
 3253  * convention of taking the scanner as the last argument. Note however, that
 3254  * this is a *pointer* to a scanner, as it will be allocated by this call (and
 3255  * is the reason, too, why this function also must handle its own declaration).
 3256  * The user defined value in the first argument will be available to yyalloc in
 3257  * the yyextra field.
 3258  */
 3259 int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
 3260 {
 3261     struct yyguts_t dummy_yyguts;
 3262 
 3263     yyset_extra (yy_user_defined, &dummy_yyguts);
 3264 
 3265     if (ptr_yy_globals == NULL){
 3266         errno = EINVAL;
 3267         return 1;
 3268     }
 3269 
 3270     *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
 3271 
 3272     if (*ptr_yy_globals == NULL){
 3273         errno = ENOMEM;
 3274         return 1;
 3275     }
 3276 
 3277     /* By setting to 0xAA, we expose bugs in
 3278     yy_init_globals. Leave at 0x00 for releases. */
 3279     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
 3280 
 3281     yyset_extra (yy_user_defined, *ptr_yy_globals);
 3282 
 3283     return yy_init_globals ( *ptr_yy_globals );
 3284 }
 3285 
 3286 static int yy_init_globals (yyscan_t yyscanner)
 3287 {
 3288     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3289     /* Initialization is the same as for the non-reentrant scanner.
 3290      * This function is called from yylex_destroy(), so don't allocate here.
 3291      */
 3292 
 3293     yyg->yy_buffer_stack = NULL;
 3294     yyg->yy_buffer_stack_top = 0;
 3295     yyg->yy_buffer_stack_max = 0;
 3296     yyg->yy_c_buf_p = NULL;
 3297     yyg->yy_init = 0;
 3298     yyg->yy_start = 0;
 3299 
 3300     yyg->yy_start_stack_ptr = 0;
 3301     yyg->yy_start_stack_depth = 0;
 3302     yyg->yy_start_stack =  NULL;
 3303 
 3304 /* Defined in main.c */
 3305 #ifdef YY_STDINIT
 3306     yyin = stdin;
 3307     yyout = stdout;
 3308 #else
 3309     yyin = NULL;
 3310     yyout = NULL;
 3311 #endif
 3312 
 3313     /* For future reference: Set errno on error, since we are called by
 3314      * yylex_init()
 3315      */
 3316     return 0;
 3317 }
 3318 
 3319 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
 3320 int yylex_destroy  (yyscan_t yyscanner)
 3321 {
 3322     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3323 
 3324     /* Pop the buffer stack, destroying each element. */
 3325     while(YY_CURRENT_BUFFER){
 3326         yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
 3327         YY_CURRENT_BUFFER_LVALUE = NULL;
 3328         yypop_buffer_state(yyscanner);
 3329     }
 3330 
 3331     /* Destroy the stack itself. */
 3332     yyfree(yyg->yy_buffer_stack , yyscanner);
 3333     yyg->yy_buffer_stack = NULL;
 3334 
 3335     /* Destroy the start condition stack. */
 3336         yyfree( yyg->yy_start_stack , yyscanner );
 3337         yyg->yy_start_stack = NULL;
 3338 
 3339     /* Reset the globals. This is important in a non-reentrant scanner so the next time
 3340      * yylex() is called, initialization will occur. */
 3341     yy_init_globals( yyscanner);
 3342 
 3343     /* Destroy the main struct (reentrant only). */
 3344     yyfree ( yyscanner , yyscanner );
 3345     yyscanner = NULL;
 3346     return 0;
 3347 }
 3348 
 3349 /*
 3350  * Internal utility routines.
 3351  */
 3352 
 3353 #ifndef yytext_ptr
 3354 static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
 3355 {
 3356     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3357     (void)yyg;
 3358 
 3359     int i;
 3360     for ( i = 0; i < n; ++i )
 3361         s1[i] = s2[i];
 3362 }
 3363 #endif
 3364 
 3365 #ifdef YY_NEED_STRLEN
 3366 static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
 3367 {
 3368     int n;
 3369     for ( n = 0; s[n]; ++n )
 3370         ;
 3371 
 3372     return n;
 3373 }
 3374 #endif
 3375 
 3376 void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
 3377 {
 3378     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3379     (void)yyg;
 3380     return malloc(size);
 3381 }
 3382 
 3383 void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
 3384 {
 3385     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3386     (void)yyg;
 3387 
 3388     /* The cast to (char *) in the following accommodates both
 3389      * implementations that use char* generic pointers, and those
 3390      * that use void* generic pointers.  It works with the latter
 3391      * because both ANSI C and C++ allow castless assignment from
 3392      * any pointer type to void*, and deal with argument conversions
 3393      * as though doing an assignment.
 3394      */
 3395     return realloc(ptr, size);
 3396 }
 3397 
 3398 void yyfree (void * ptr , yyscan_t yyscanner)
 3399 {
 3400     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 3401     (void)yyg;
 3402     free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
 3403 }
 3404 
 3405 #define YYTABLES_NAME "yytables"
 3406 
 3407 #line 592 "mlr_dsl_lexer.l"
 3408 
 3409