LCOV - code coverage report
Current view: top level - bin/default/source3/rpc_server/mdssvc - sparql_lexer.lex.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 0 404 0.0 %
Date: 2021-08-25 13:27:56 Functions: 0 33 0.0 %

          Line data    Source code
       1             : 
       2             : #define  YY_INT_ALIGNED short int
       3             : 
       4             : /* A lexical scanner generated by flex */
       5             : 
       6             : #define yy_create_buffer mdsyy_create_buffer
       7             : #define yy_delete_buffer mdsyy_delete_buffer
       8             : #define yy_scan_buffer mdsyy_scan_buffer
       9             : #define yy_scan_string mdsyy_scan_string
      10             : #define yy_scan_bytes mdsyy_scan_bytes
      11             : #define yy_init_buffer mdsyy_init_buffer
      12             : #define yy_flush_buffer mdsyy_flush_buffer
      13             : #define yy_load_buffer_state mdsyy_load_buffer_state
      14             : #define yy_switch_to_buffer mdsyy_switch_to_buffer
      15             : #define yypush_buffer_state mdsyypush_buffer_state
      16             : #define yypop_buffer_state mdsyypop_buffer_state
      17             : #define yyensure_buffer_stack mdsyyensure_buffer_stack
      18             : #define yy_flex_debug mdsyy_flex_debug
      19             : #define yyin mdsyyin
      20             : #define yyleng mdsyyleng
      21             : #define yylex mdsyylex
      22             : #define yylineno mdsyylineno
      23             : #define yyout mdsyyout
      24             : #define yyrestart mdsyyrestart
      25             : #define yytext mdsyytext
      26             : #define yywrap mdsyywrap
      27             : #define yyalloc mdsyyalloc
      28             : #define yyrealloc mdsyyrealloc
      29             : #define yyfree mdsyyfree
      30             : 
      31             : #define FLEX_SCANNER
      32             : #define YY_FLEX_MAJOR_VERSION 2
      33             : #define YY_FLEX_MINOR_VERSION 6
      34             : #define YY_FLEX_SUBMINOR_VERSION 4
      35             : #if YY_FLEX_SUBMINOR_VERSION > 0
      36             : #define FLEX_BETA
      37             : #endif
      38             : 
      39             : #ifdef yy_create_buffer
      40             : #define mdsyy_create_buffer_ALREADY_DEFINED
      41             : #else
      42             : #define yy_create_buffer mdsyy_create_buffer
      43             : #endif
      44             : 
      45             : #ifdef yy_delete_buffer
      46             : #define mdsyy_delete_buffer_ALREADY_DEFINED
      47             : #else
      48             : #define yy_delete_buffer mdsyy_delete_buffer
      49             : #endif
      50             : 
      51             : #ifdef yy_scan_buffer
      52             : #define mdsyy_scan_buffer_ALREADY_DEFINED
      53             : #else
      54             : #define yy_scan_buffer mdsyy_scan_buffer
      55             : #endif
      56             : 
      57             : #ifdef yy_scan_string
      58             : #define mdsyy_scan_string_ALREADY_DEFINED
      59             : #else
      60             : #define yy_scan_string mdsyy_scan_string
      61             : #endif
      62             : 
      63             : #ifdef yy_scan_bytes
      64             : #define mdsyy_scan_bytes_ALREADY_DEFINED
      65             : #else
      66             : #define yy_scan_bytes mdsyy_scan_bytes
      67             : #endif
      68             : 
      69             : #ifdef yy_init_buffer
      70             : #define mdsyy_init_buffer_ALREADY_DEFINED
      71             : #else
      72             : #define yy_init_buffer mdsyy_init_buffer
      73             : #endif
      74             : 
      75             : #ifdef yy_flush_buffer
      76             : #define mdsyy_flush_buffer_ALREADY_DEFINED
      77             : #else
      78             : #define yy_flush_buffer mdsyy_flush_buffer
      79             : #endif
      80             : 
      81             : #ifdef yy_load_buffer_state
      82             : #define mdsyy_load_buffer_state_ALREADY_DEFINED
      83             : #else
      84             : #define yy_load_buffer_state mdsyy_load_buffer_state
      85             : #endif
      86             : 
      87             : #ifdef yy_switch_to_buffer
      88             : #define mdsyy_switch_to_buffer_ALREADY_DEFINED
      89             : #else
      90             : #define yy_switch_to_buffer mdsyy_switch_to_buffer
      91             : #endif
      92             : 
      93             : #ifdef yypush_buffer_state
      94             : #define mdsyypush_buffer_state_ALREADY_DEFINED
      95             : #else
      96             : #define yypush_buffer_state mdsyypush_buffer_state
      97             : #endif
      98             : 
      99             : #ifdef yypop_buffer_state
     100             : #define mdsyypop_buffer_state_ALREADY_DEFINED
     101             : #else
     102             : #define yypop_buffer_state mdsyypop_buffer_state
     103             : #endif
     104             : 
     105             : #ifdef yyensure_buffer_stack
     106             : #define mdsyyensure_buffer_stack_ALREADY_DEFINED
     107             : #else
     108             : #define yyensure_buffer_stack mdsyyensure_buffer_stack
     109             : #endif
     110             : 
     111             : #ifdef yylex
     112             : #define mdsyylex_ALREADY_DEFINED
     113             : #else
     114             : #define yylex mdsyylex
     115             : #endif
     116             : 
     117             : #ifdef yyrestart
     118             : #define mdsyyrestart_ALREADY_DEFINED
     119             : #else
     120             : #define yyrestart mdsyyrestart
     121             : #endif
     122             : 
     123             : #ifdef yylex_init
     124             : #define mdsyylex_init_ALREADY_DEFINED
     125             : #else
     126             : #define yylex_init mdsyylex_init
     127             : #endif
     128             : 
     129             : #ifdef yylex_init_extra
     130             : #define mdsyylex_init_extra_ALREADY_DEFINED
     131             : #else
     132             : #define yylex_init_extra mdsyylex_init_extra
     133             : #endif
     134             : 
     135             : #ifdef yylex_destroy
     136             : #define mdsyylex_destroy_ALREADY_DEFINED
     137             : #else
     138             : #define yylex_destroy mdsyylex_destroy
     139             : #endif
     140             : 
     141             : #ifdef yyget_debug
     142             : #define mdsyyget_debug_ALREADY_DEFINED
     143             : #else
     144             : #define yyget_debug mdsyyget_debug
     145             : #endif
     146             : 
     147             : #ifdef yyset_debug
     148             : #define mdsyyset_debug_ALREADY_DEFINED
     149             : #else
     150             : #define yyset_debug mdsyyset_debug
     151             : #endif
     152             : 
     153             : #ifdef yyget_extra
     154             : #define mdsyyget_extra_ALREADY_DEFINED
     155             : #else
     156             : #define yyget_extra mdsyyget_extra
     157             : #endif
     158             : 
     159             : #ifdef yyset_extra
     160             : #define mdsyyset_extra_ALREADY_DEFINED
     161             : #else
     162             : #define yyset_extra mdsyyset_extra
     163             : #endif
     164             : 
     165             : #ifdef yyget_in
     166             : #define mdsyyget_in_ALREADY_DEFINED
     167             : #else
     168             : #define yyget_in mdsyyget_in
     169             : #endif
     170             : 
     171             : #ifdef yyset_in
     172             : #define mdsyyset_in_ALREADY_DEFINED
     173             : #else
     174             : #define yyset_in mdsyyset_in
     175             : #endif
     176             : 
     177             : #ifdef yyget_out
     178             : #define mdsyyget_out_ALREADY_DEFINED
     179             : #else
     180             : #define yyget_out mdsyyget_out
     181             : #endif
     182             : 
     183             : #ifdef yyset_out
     184             : #define mdsyyset_out_ALREADY_DEFINED
     185             : #else
     186             : #define yyset_out mdsyyset_out
     187             : #endif
     188             : 
     189             : #ifdef yyget_leng
     190             : #define mdsyyget_leng_ALREADY_DEFINED
     191             : #else
     192             : #define yyget_leng mdsyyget_leng
     193             : #endif
     194             : 
     195             : #ifdef yyget_text
     196             : #define mdsyyget_text_ALREADY_DEFINED
     197             : #else
     198             : #define yyget_text mdsyyget_text
     199             : #endif
     200             : 
     201             : #ifdef yyget_lineno
     202             : #define mdsyyget_lineno_ALREADY_DEFINED
     203             : #else
     204             : #define yyget_lineno mdsyyget_lineno
     205             : #endif
     206             : 
     207             : #ifdef yyset_lineno
     208             : #define mdsyyset_lineno_ALREADY_DEFINED
     209             : #else
     210             : #define yyset_lineno mdsyyset_lineno
     211             : #endif
     212             : 
     213             : #ifdef yywrap
     214             : #define mdsyywrap_ALREADY_DEFINED
     215             : #else
     216             : #define yywrap mdsyywrap
     217             : #endif
     218             : 
     219             : #ifdef yyalloc
     220             : #define mdsyyalloc_ALREADY_DEFINED
     221             : #else
     222             : #define yyalloc mdsyyalloc
     223             : #endif
     224             : 
     225             : #ifdef yyrealloc
     226             : #define mdsyyrealloc_ALREADY_DEFINED
     227             : #else
     228             : #define yyrealloc mdsyyrealloc
     229             : #endif
     230             : 
     231             : #ifdef yyfree
     232             : #define mdsyyfree_ALREADY_DEFINED
     233             : #else
     234             : #define yyfree mdsyyfree
     235             : #endif
     236             : 
     237             : #ifdef yytext
     238             : #define mdsyytext_ALREADY_DEFINED
     239             : #else
     240             : #define yytext mdsyytext
     241             : #endif
     242             : 
     243             : #ifdef yyleng
     244             : #define mdsyyleng_ALREADY_DEFINED
     245             : #else
     246             : #define yyleng mdsyyleng
     247             : #endif
     248             : 
     249             : #ifdef yyin
     250             : #define mdsyyin_ALREADY_DEFINED
     251             : #else
     252             : #define yyin mdsyyin
     253             : #endif
     254             : 
     255             : #ifdef yyout
     256             : #define mdsyyout_ALREADY_DEFINED
     257             : #else
     258             : #define yyout mdsyyout
     259             : #endif
     260             : 
     261             : #ifdef yy_flex_debug
     262             : #define mdsyy_flex_debug_ALREADY_DEFINED
     263             : #else
     264             : #define yy_flex_debug mdsyy_flex_debug
     265             : #endif
     266             : 
     267             : #ifdef yylineno
     268             : #define mdsyylineno_ALREADY_DEFINED
     269             : #else
     270             : #define yylineno mdsyylineno
     271             : #endif
     272             : 
     273             : /* First, we deal with  platform-specific or compiler-specific issues. */
     274             : 
     275             : /* begin standard C headers. */
     276             : #include <stdio.h>
     277             : #include <string.h>
     278             : #include <errno.h>
     279             : #include <stdlib.h>
     280             : 
     281             : /* end standard C headers. */
     282             : 
     283             : /* flex integer type definitions */
     284             : 
     285             : #ifndef FLEXINT_H
     286             : #define FLEXINT_H
     287             : 
     288             : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
     289             : 
     290             : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
     291             : 
     292             : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
     293             :  * if you want the limit (max/min) macros for int types. 
     294             :  */
     295             : #ifndef __STDC_LIMIT_MACROS
     296             : #define __STDC_LIMIT_MACROS 1
     297             : #endif
     298             : 
     299             : #include <inttypes.h>
     300             : typedef int8_t flex_int8_t;
     301             : typedef uint8_t flex_uint8_t;
     302             : typedef int16_t flex_int16_t;
     303             : typedef uint16_t flex_uint16_t;
     304             : typedef int32_t flex_int32_t;
     305             : typedef uint32_t flex_uint32_t;
     306             : #else
     307             : typedef signed char flex_int8_t;
     308             : typedef short int flex_int16_t;
     309             : typedef int flex_int32_t;
     310             : typedef unsigned char flex_uint8_t; 
     311             : typedef unsigned short int flex_uint16_t;
     312             : typedef unsigned int flex_uint32_t;
     313             : 
     314             : /* Limits of integral types. */
     315             : #ifndef INT8_MIN
     316             : #define INT8_MIN               (-128)
     317             : #endif
     318             : #ifndef INT16_MIN
     319             : #define INT16_MIN              (-32767-1)
     320             : #endif
     321             : #ifndef INT32_MIN
     322             : #define INT32_MIN              (-2147483647-1)
     323             : #endif
     324             : #ifndef INT8_MAX
     325             : #define INT8_MAX               (127)
     326             : #endif
     327             : #ifndef INT16_MAX
     328             : #define INT16_MAX              (32767)
     329             : #endif
     330             : #ifndef INT32_MAX
     331             : #define INT32_MAX              (2147483647)
     332             : #endif
     333             : #ifndef UINT8_MAX
     334             : #define UINT8_MAX              (255U)
     335             : #endif
     336             : #ifndef UINT16_MAX
     337             : #define UINT16_MAX             (65535U)
     338             : #endif
     339             : #ifndef UINT32_MAX
     340             : #define UINT32_MAX             (4294967295U)
     341             : #endif
     342             : 
     343             : #ifndef SIZE_MAX
     344             : #define SIZE_MAX               (~(size_t)0)
     345             : #endif
     346             : 
     347             : #endif /* ! C99 */
     348             : 
     349             : #endif /* ! FLEXINT_H */
     350             : 
     351             : /* begin standard C++ headers. */
     352             : 
     353             : /* TODO: this is always defined, so inline it */
     354             : #define yyconst const
     355             : 
     356             : #if defined(__GNUC__) && __GNUC__ >= 3
     357             : #define yynoreturn __attribute__((__noreturn__))
     358             : #else
     359             : #define yynoreturn
     360             : #endif
     361             : 
     362             : /* Returned upon end-of-file. */
     363             : #define YY_NULL 0
     364             : 
     365             : /* Promotes a possibly negative, possibly signed char to an
     366             :  *   integer in range [0..255] for use as an array index.
     367             :  */
     368             : #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
     369             : 
     370             : /* Enter a start condition.  This macro really ought to take a parameter,
     371             :  * but we do it the disgusting crufty way forced on us by the ()-less
     372             :  * definition of BEGIN.
     373             :  */
     374             : #define BEGIN (yy_start) = 1 + 2 *
     375             : /* Translate the current start state into a value that can be later handed
     376             :  * to BEGIN to return to the state.  The YYSTATE alias is for lex
     377             :  * compatibility.
     378             :  */
     379             : #define YY_START (((yy_start) - 1) / 2)
     380             : #define YYSTATE YY_START
     381             : /* Action number for EOF rule of a given start state. */
     382             : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
     383             : /* Special action meaning "start processing a new file". */
     384             : #define YY_NEW_FILE yyrestart( yyin  )
     385             : #define YY_END_OF_BUFFER_CHAR 0
     386             : 
     387             : /* Size of default input buffer. */
     388             : #ifndef YY_BUF_SIZE
     389             : #ifdef __ia64__
     390             : /* On IA-64, the buffer size is 16k, not 8k.
     391             :  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
     392             :  * Ditto for the __ia64__ case accordingly.
     393             :  */
     394             : #define YY_BUF_SIZE 32768
     395             : #else
     396             : #define YY_BUF_SIZE 16384
     397             : #endif /* __ia64__ */
     398             : #endif
     399             : 
     400             : /* The state buf must be large enough to hold one state per character in the main buffer.
     401             :  */
     402             : #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
     403             : 
     404             : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
     405             : #define YY_TYPEDEF_YY_BUFFER_STATE
     406             : typedef struct yy_buffer_state *YY_BUFFER_STATE;
     407             : #endif
     408             : 
     409             : #ifndef YY_TYPEDEF_YY_SIZE_T
     410             : #define YY_TYPEDEF_YY_SIZE_T
     411             : typedef size_t yy_size_t;
     412             : #endif
     413             : 
     414             : extern int yyleng;
     415             : 
     416             : extern FILE *yyin, *yyout;
     417             : 
     418             : #define EOB_ACT_CONTINUE_SCAN 0
     419             : #define EOB_ACT_END_OF_FILE 1
     420             : #define EOB_ACT_LAST_MATCH 2
     421             :     
     422             :     #define YY_LESS_LINENO(n)
     423             :     #define YY_LINENO_REWIND_TO(ptr)
     424             :     
     425             : /* Return all but the first "n" matched characters back to the input stream. */
     426             : #define yyless(n) \
     427             :         do \
     428             :                 { \
     429             :                 /* Undo effects of setting up yytext. */ \
     430             :         int yyless_macro_arg = (n); \
     431             :         YY_LESS_LINENO(yyless_macro_arg);\
     432             :                 *yy_cp = (yy_hold_char); \
     433             :                 YY_RESTORE_YY_MORE_OFFSET \
     434             :                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
     435             :                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
     436             :                 } \
     437             :         while ( 0 )
     438             : #define unput(c) yyunput( c, (yytext_ptr)  )
     439             : 
     440             : #ifndef YY_STRUCT_YY_BUFFER_STATE
     441             : #define YY_STRUCT_YY_BUFFER_STATE
     442             : struct yy_buffer_state
     443             :         {
     444             :         FILE *yy_input_file;
     445             : 
     446             :         char *yy_ch_buf;                /* input buffer */
     447             :         char *yy_buf_pos;               /* current position in input buffer */
     448             : 
     449             :         /* Size of input buffer in bytes, not including room for EOB
     450             :          * characters.
     451             :          */
     452             :         int yy_buf_size;
     453             : 
     454             :         /* Number of characters read into yy_ch_buf, not including EOB
     455             :          * characters.
     456             :          */
     457             :         int yy_n_chars;
     458             : 
     459             :         /* Whether we "own" the buffer - i.e., we know we created it,
     460             :          * and can realloc() it to grow it, and should free() it to
     461             :          * delete it.
     462             :          */
     463             :         int yy_is_our_buffer;
     464             : 
     465             :         /* Whether this is an "interactive" input source; if so, and
     466             :          * if we're using stdio for input, then we want to use getc()
     467             :          * instead of fread(), to make sure we stop fetching input after
     468             :          * each newline.
     469             :          */
     470             :         int yy_is_interactive;
     471             : 
     472             :         /* Whether we're considered to be at the beginning of a line.
     473             :          * If so, '^' rules will be active on the next match, otherwise
     474             :          * not.
     475             :          */
     476             :         int yy_at_bol;
     477             : 
     478             :     int yy_bs_lineno; /**< The line count. */
     479             :     int yy_bs_column; /**< The column count. */
     480             : 
     481             :         /* Whether to try to fill the input buffer when we reach the
     482             :          * end of it.
     483             :          */
     484             :         int yy_fill_buffer;
     485             : 
     486             :         int yy_buffer_status;
     487             : 
     488             : #define YY_BUFFER_NEW 0
     489             : #define YY_BUFFER_NORMAL 1
     490             :         /* When an EOF's been seen but there's still some text to process
     491             :          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
     492             :          * shouldn't try reading from the input source any more.  We might
     493             :          * still have a bunch of tokens to match, though, because of
     494             :          * possible backing-up.
     495             :          *
     496             :          * When we actually see the EOF, we change the status to "new"
     497             :          * (via yyrestart()), so that the user can continue scanning by
     498             :          * just pointing yyin at a new input file.
     499             :          */
     500             : #define YY_BUFFER_EOF_PENDING 2
     501             : 
     502             :         };
     503             : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
     504             : 
     505             : /* Stack of input buffers. */
     506             : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
     507             : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
     508             : static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
     509             : 
     510             : /* We provide macros for accessing buffer states in case in the
     511             :  * future we want to put the buffer states in a more general
     512             :  * "scanner state".
     513             :  *
     514             :  * Returns the top of the stack, or NULL.
     515             :  */
     516             : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
     517             :                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
     518             :                           : NULL)
     519             : /* Same as previous macro, but useful when we know that the buffer stack is not
     520             :  * NULL or when we need an lvalue. For internal use only.
     521             :  */
     522             : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
     523             : 
     524             : /* yy_hold_char holds the character lost when yytext is formed. */
     525             : static char yy_hold_char;
     526             : static int yy_n_chars;          /* number of characters read into yy_ch_buf */
     527             : int yyleng;
     528             : 
     529             : /* Points to current character in buffer. */
     530             : static char *yy_c_buf_p = NULL;
     531             : static int yy_init = 0;         /* whether we need to initialize */
     532             : static int yy_start = 0;        /* start state number */
     533             : 
     534             : /* Flag which is used to allow yywrap()'s to do buffer switches
     535             :  * instead of setting up a fresh yyin.  A bit of a hack ...
     536             :  */
     537             : static int yy_did_buffer_switch_on_eof;
     538             : 
     539             : void yyrestart ( FILE *input_file  );
     540             : void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
     541             : YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
     542             : void yy_delete_buffer ( YY_BUFFER_STATE b  );
     543             : void yy_flush_buffer ( YY_BUFFER_STATE b  );
     544             : void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
     545             : void yypop_buffer_state ( void );
     546             : 
     547             : static void yyensure_buffer_stack ( void );
     548             : static void yy_load_buffer_state ( void );
     549             : static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
     550             : #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
     551             : 
     552             : YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
     553             : YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
     554             : YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
     555             : 
     556             : void *yyalloc ( yy_size_t  );
     557             : void *yyrealloc ( void *, yy_size_t  );
     558             : void yyfree ( void *  );
     559             : 
     560             : #define yy_new_buffer yy_create_buffer
     561             : #define yy_set_interactive(is_interactive) \
     562             :         { \
     563             :         if ( ! YY_CURRENT_BUFFER ){ \
     564             :         yyensure_buffer_stack (); \
     565             :                 YY_CURRENT_BUFFER_LVALUE =    \
     566             :             yy_create_buffer( yyin, YY_BUF_SIZE ); \
     567             :         } \
     568             :         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
     569             :         }
     570             : #define yy_set_bol(at_bol) \
     571             :         { \
     572             :         if ( ! YY_CURRENT_BUFFER ){\
     573             :         yyensure_buffer_stack (); \
     574             :                 YY_CURRENT_BUFFER_LVALUE =    \
     575             :             yy_create_buffer( yyin, YY_BUF_SIZE ); \
     576             :         } \
     577             :         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
     578             :         }
     579             : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
     580             : 
     581             : /* Begin user sect3 */
     582             : typedef flex_uint8_t YY_CHAR;
     583             : 
     584             : FILE *yyin = NULL, *yyout = NULL;
     585             : 
     586             : typedef int yy_state_type;
     587             : 
     588             : extern int yylineno;
     589             : int yylineno = 1;
     590             : 
     591             : extern char *yytext;
     592             : #ifdef yytext_ptr
     593             : #undef yytext_ptr
     594             : #endif
     595             : #define yytext_ptr yytext
     596             : 
     597             : static yy_state_type yy_get_previous_state ( void );
     598             : static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
     599             : static int yy_get_next_buffer ( void );
     600             : static void yynoreturn yy_fatal_error ( const char* msg  );
     601             : 
     602             : /* Done after the current pattern has been matched and before the
     603             :  * corresponding action - sets up yytext.
     604             :  */
     605             : #define YY_DO_BEFORE_ACTION \
     606             :         (yytext_ptr) = yy_bp; \
     607             :         yyleng = (int) (yy_cp - yy_bp); \
     608             :         (yy_hold_char) = *yy_cp; \
     609             :         *yy_cp = '\0'; \
     610             :         (yy_c_buf_p) = yy_cp;
     611             : #define YY_NUM_RULES 18
     612             : #define YY_END_OF_BUFFER 19
     613             : /* This struct is not used in this scanner,
     614             :    but its presence is necessary. */
     615             : struct yy_trans_info
     616             :         {
     617             :         flex_int32_t yy_verify;
     618             :         flex_int32_t yy_nxt;
     619             :         };
     620             : static const flex_int16_t yy_accept[57] =
     621             :     {   0,
     622             :         0,    0,   19,   18,   17,   18,    5,   18,   18,    6,
     623             :         7,   16,   15,   13,   12,   14,   16,   16,   16,   18,
     624             :        18,   18,   18,   11,    0,    8,   16,    0,    0,    0,
     625             :        10,   16,   16,   16,    9,    0,    0,    0,   16,   16,
     626             :        16,    0,    0,   16,   16,    4,    0,   16,    3,    0,
     627             :        16,    0,    1,    0,    2,    0
     628             :     } ;
     629             : 
     630             : static const YY_CHAR yy_ec[256] =
     631             :     {   0,
     632             :         1,    1,    1,    1,    1,    1,    1,    1,    2,    2,
     633             :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     634             :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     635             :         1,    2,    3,    4,    1,    5,    1,    6,    1,    7,
     636             :         8,    9,    1,   10,    9,   11,    1,    9,    9,    9,
     637             :         9,    9,    9,    9,    9,    9,    9,    9,    1,   12,
     638             :        13,   14,    1,    1,    9,    9,    9,    9,    9,    9,
     639             :         9,    9,   15,    9,    9,    9,    9,    9,    9,    9,
     640             :         9,   16,    9,    9,    9,    9,    9,    9,    9,    9,
     641             :         1,    1,    1,    1,    9,    1,   17,    9,    9,    9,
     642             : 
     643             :        18,   19,   20,    9,   21,    9,    9,   22,   23,   24,
     644             :        25,    9,    9,   26,   27,   28,   29,    9,    9,    9,
     645             :         9,    9,    1,   30,    1,    1,    1,   31,   31,   31,
     646             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     647             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     648             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     649             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     650             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     651             :        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
     652             :        31,    1,    1,   32,   32,   32,   32,   32,   32,   32,
     653             : 
     654             :        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
     655             :        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
     656             :        32,   32,   32,   33,   33,   33,   33,   33,   33,   33,
     657             :        33,   33,   33,   33,   33,   33,   33,   33,   33,   34,
     658             :        34,   34,   34,   34,    1,    1,    1,    1,    1,    1,
     659             :         1,    1,    1,    1,    1
     660             :     } ;
     661             : 
     662             : static const YY_CHAR yy_meta[35] =
     663             :     {   0,
     664             :         1,    1,    1,    1,    1,    1,    1,    1,    2,    1,
     665             :         2,    1,    1,    1,    2,    2,    2,    2,    2,    2,
     666             :         2,    2,    2,    2,    2,    2,    2,    2,    2,    1,
     667             :         1,    2,    2,    2
     668             :     } ;
     669             : 
     670             : static const flex_int16_t yy_base[58] =
     671             :     {   0,
     672             :         0,    0,   91,   92,   92,   77,   92,   61,   82,   92,
     673             :        92,    3,   92,   92,   74,   92,   14,   25,   15,   56,
     674             :        54,   53,   52,   92,   61,   92,   57,   49,   48,   47,
     675             :        92,   27,   28,   16,   92,   46,   45,   52,   36,   30,
     676             :        37,   43,   55,   48,   38,   47,   59,   39,   45,   47,
     677             :        40,   40,   42,   40,   92,   92,   42
     678             :     } ;
     679             : 
     680             : static const flex_int16_t yy_def[58] =
     681             :     {   0,
     682             :        56,    1,   56,   56,   56,   56,   56,   56,   56,   56,
     683             :        56,   57,   56,   56,   56,   56,   57,   17,   17,   56,
     684             :        56,   56,   56,   56,   56,   56,   17,   56,   56,   56,
     685             :        56,   17,   17,   17,   56,   56,   56,   56,   17,   17,
     686             :        17,   56,   56,   17,   17,   17,   56,   17,   17,   56,
     687             :        17,   56,   17,   56,   56,    0,   56
     688             :     } ;
     689             : 
     690             : static const flex_int16_t yy_nxt[127] =
     691             :     {   0,
     692             :         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
     693             :        12,   14,   15,   16,   17,   12,   12,   12,   18,   12,
     694             :        12,   12,   12,   12,   12,   12,   12,   19,   12,   20,
     695             :         4,   21,   22,   23,   28,   29,   30,   32,   27,   27,
     696             :        34,   33,   39,   27,   41,   28,   29,   30,   27,   40,
     697             :        27,   27,   44,   27,   46,   49,   45,   53,   51,   27,
     698             :        27,   27,   27,   27,   55,   27,   54,   52,   27,   50,
     699             :        27,   48,   47,   27,   43,   42,   27,   37,   36,   27,
     700             :        27,   38,   37,   36,   27,   35,   31,   26,   25,   24,
     701             :        56,    3,   56,   56,   56,   56,   56,   56,   56,   56,
     702             : 
     703             :        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
     704             :        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
     705             :        56,   56,   56,   56,   56,   56
     706             :     } ;
     707             : 
     708             : static const flex_int16_t yy_chk[127] =
     709             :     {   0,
     710             :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     711             :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     712             :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     713             :         1,    1,    1,    1,   12,   12,   12,   17,   19,   34,
     714             :        19,   18,   32,   57,   34,   17,   17,   17,   18,   33,
     715             :        32,   33,   39,   40,   41,   45,   40,   51,   48,   39,
     716             :        41,   45,   48,   51,   54,   53,   52,   50,   49,   47,
     717             :        46,   44,   43,   42,   38,   37,   36,   30,   29,   28,
     718             :        27,   25,   23,   22,   21,   20,   15,    9,    8,    6,
     719             :         3,   56,   56,   56,   56,   56,   56,   56,   56,   56,
     720             : 
     721             :        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
     722             :        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
     723             :        56,   56,   56,   56,   56,   56
     724             :     } ;
     725             : 
     726             : static yy_state_type yy_last_accepting_state;
     727             : static char *yy_last_accepting_cpos;
     728             : 
     729             : extern int yy_flex_debug;
     730             : int yy_flex_debug = 0;
     731             : 
     732             : /* The intent behind this definition is that it'll catch
     733             :  * any uses of REJECT which flex missed.
     734             :  */
     735             : #define REJECT reject_used_but_not_detected
     736             : #define yymore() yymore_used_but_not_detected
     737             : #define YY_MORE_ADJ 0
     738             : #define YY_RESTORE_YY_MORE_OFFSET
     739             : char *yytext;
     740             : /*
     741             :    Unix SMB/CIFS implementation.
     742             :    Main metadata server / Spotlight routines
     743             : 
     744             :    Copyright (C) Ralph Boehme                   2012-2014
     745             : 
     746             :    This program is free software; you can redistribute it and/or modify
     747             :    it under the terms of the GNU General Public License as published by
     748             :    the Free Software Foundation; either version 3 of the License, or
     749             :    (at your option) any later version.
     750             : 
     751             :    This program is distributed in the hope that it will be useful,
     752             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
     753             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     754             :    GNU General Public License for more details.
     755             : 
     756             :    You should have received a copy of the GNU General Public License
     757             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
     758             : */
     759             : #include "includes.h"
     760             : #include "rpc_server/mdssvc/sparql_parser.tab.h"
     761             : 
     762             : #define YY_NO_INPUT
     763             : 
     764             : #define INITIAL 0
     765             : 
     766             : #ifndef YY_NO_UNISTD_H
     767             : /* Special case for "unistd.h", since it is non-ANSI. We include it way
     768             :  * down here because we want the user's section 1 to have been scanned first.
     769             :  * The user has a chance to override it with an option.
     770             :  */
     771             : #include <unistd.h>
     772             : #endif
     773             : 
     774             : #ifndef YY_EXTRA_TYPE
     775             : #define YY_EXTRA_TYPE void *
     776             : #endif
     777             : 
     778             : static int yy_init_globals ( void );
     779             : 
     780             : /* Accessor methods to globals.
     781             :    These are made visible to non-reentrant scanners for convenience. */
     782             : 
     783             : int yylex_destroy ( void );
     784             : 
     785             : int yyget_debug ( void );
     786             : 
     787             : void yyset_debug ( int debug_flag  );
     788             : 
     789             : YY_EXTRA_TYPE yyget_extra ( void );
     790             : 
     791             : void yyset_extra ( YY_EXTRA_TYPE user_defined  );
     792             : 
     793             : FILE *yyget_in ( void );
     794             : 
     795             : void yyset_in  ( FILE * _in_str  );
     796             : 
     797             : FILE *yyget_out ( void );
     798             : 
     799             : void yyset_out  ( FILE * _out_str  );
     800             : 
     801             :                         int yyget_leng ( void );
     802             : 
     803             : char *yyget_text ( void );
     804             : 
     805             : int yyget_lineno ( void );
     806             : 
     807             : void yyset_lineno ( int _line_number  );
     808             : 
     809             : /* Macros after this point can all be overridden by user definitions in
     810             :  * section 1.
     811             :  */
     812             : 
     813             : #ifndef YY_SKIP_YYWRAP
     814             : #ifdef __cplusplus
     815             : extern "C" int yywrap ( void );
     816             : #else
     817             : extern int yywrap ( void );
     818             : #endif
     819             : #endif
     820             : 
     821             : #ifndef YY_NO_UNPUT
     822             :     
     823             : #endif
     824             : 
     825             : #ifndef yytext_ptr
     826             : static void yy_flex_strncpy ( char *, const char *, int );
     827             : #endif
     828             : 
     829             : #ifdef YY_NEED_STRLEN
     830             : static int yy_flex_strlen ( const char * );
     831             : #endif
     832             : 
     833             : #ifndef YY_NO_INPUT
     834             : #ifdef __cplusplus
     835             : static int yyinput ( void );
     836             : #else
     837             : static int input ( void );
     838             : #endif
     839             : 
     840             : #endif
     841             : 
     842             : /* Amount of stuff to slurp up with each read. */
     843             : #ifndef YY_READ_BUF_SIZE
     844             : #ifdef __ia64__
     845             : /* On IA-64, the buffer size is 16k, not 8k */
     846             : #define YY_READ_BUF_SIZE 16384
     847             : #else
     848             : #define YY_READ_BUF_SIZE 8192
     849             : #endif /* __ia64__ */
     850             : #endif
     851             : 
     852             : /* Copy whatever the last rule matched to the standard output. */
     853             : #ifndef ECHO
     854             : /* This used to be an fputs(), but since the string might contain NUL's,
     855             :  * we now use fwrite().
     856             :  */
     857             : #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
     858             : #endif
     859             : 
     860             : /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
     861             :  * is returned in "result".
     862             :  */
     863             : #ifndef YY_INPUT
     864             : #define YY_INPUT(buf,result,max_size) \
     865             :         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
     866             :                 { \
     867             :                 int c = '*'; \
     868             :                 int n; \
     869             :                 for ( n = 0; n < max_size && \
     870             :                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
     871             :                         buf[n] = (char) c; \
     872             :                 if ( c == '\n' ) \
     873             :                         buf[n++] = (char) c; \
     874             :                 if ( c == EOF && ferror( yyin ) ) \
     875             :                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
     876             :                 result = n; \
     877             :                 } \
     878             :         else \
     879             :                 { \
     880             :                 errno=0; \
     881             :                 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
     882             :                         { \
     883             :                         if( errno != EINTR) \
     884             :                                 { \
     885             :                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
     886             :                                 break; \
     887             :                                 } \
     888             :                         errno=0; \
     889             :                         clearerr(yyin); \
     890             :                         } \
     891             :                 }\
     892             : \
     893             : 
     894             : #endif
     895             : 
     896             : /* No semi-colon after return; correct usage is to write "yyterminate();" -
     897             :  * we don't want an extra ';' after the "return" because that will cause
     898             :  * some compilers to complain about unreachable statements.
     899             :  */
     900             : #ifndef yyterminate
     901             : #define yyterminate() return YY_NULL
     902             : #endif
     903             : 
     904             : /* Number of entries by which start-condition stack grows. */
     905             : #ifndef YY_START_STACK_INCR
     906             : #define YY_START_STACK_INCR 25
     907             : #endif
     908             : 
     909             : /* Report a fatal error. */
     910             : #ifndef YY_FATAL_ERROR
     911             : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
     912             : #endif
     913             : 
     914             : /* end tables serialization structures and prototypes */
     915             : 
     916             : /* Default declaration of generated scanner - a define so the user can
     917             :  * easily add parameters.
     918             :  */
     919             : #ifndef YY_DECL
     920             : #define YY_DECL_IS_OURS 1
     921             : 
     922             : extern int yylex (void);
     923             : 
     924             : #define YY_DECL int yylex (void)
     925             : #endif /* !YY_DECL */
     926             : 
     927             : /* Code executed at the beginning of each rule, after yytext and yyleng
     928             :  * have been set up.
     929             :  */
     930             : #ifndef YY_USER_ACTION
     931             : #define YY_USER_ACTION
     932             : #endif
     933             : 
     934             : /* Code executed at the end of each rule. */
     935             : #ifndef YY_BREAK
     936             : #define YY_BREAK /*LINTED*/break;
     937             : #endif
     938             : 
     939             : #define YY_RULE_SETUP \
     940             :         YY_USER_ACTION
     941             : 
     942             : /** The main scanner function which does all the work.
     943             :  */
     944           0 : YY_DECL
     945             : {
     946             :         yy_state_type yy_current_state;
     947             :         char *yy_cp, *yy_bp;
     948             :         int yy_act;
     949             :     
     950           0 :         if ( !(yy_init) )
     951             :                 {
     952           0 :                 (yy_init) = 1;
     953             : 
     954             : #ifdef YY_USER_INIT
     955             :                 YY_USER_INIT;
     956             : #endif
     957             : 
     958           0 :                 if ( ! (yy_start) )
     959           0 :                         (yy_start) = 1; /* first start state */
     960             : 
     961           0 :                 if ( ! yyin )
     962           0 :                         yyin = stdin;
     963             : 
     964           0 :                 if ( ! yyout )
     965           0 :                         yyout = stdout;
     966             : 
     967           0 :                 if ( ! YY_CURRENT_BUFFER ) {
     968           0 :                         yyensure_buffer_stack ();
     969           0 :                         YY_CURRENT_BUFFER_LVALUE =
     970           0 :                                 yy_create_buffer( yyin, YY_BUF_SIZE );
     971             :                 }
     972             : 
     973           0 :                 yy_load_buffer_state(  );
     974             :                 }
     975             : 
     976             :         {
     977             : 
     978             :         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
     979             :                 {
     980           0 :                 yy_cp = (yy_c_buf_p);
     981             : 
     982             :                 /* Support of yytext. */
     983           0 :                 *yy_cp = (yy_hold_char);
     984             : 
     985             :                 /* yy_bp points to the position in yy_ch_buf of the start of
     986             :                  * the current run.
     987             :                  */
     988           0 :                 yy_bp = yy_cp;
     989             : 
     990           0 :                 yy_current_state = (yy_start);
     991           0 : yy_match:
     992             :                 do
     993             :                         {
     994           0 :                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
     995           0 :                         if ( yy_accept[yy_current_state] )
     996             :                                 {
     997           0 :                                 (yy_last_accepting_state) = yy_current_state;
     998           0 :                                 (yy_last_accepting_cpos) = yy_cp;
     999             :                                 }
    1000           0 :                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1001             :                                 {
    1002           0 :                                 yy_current_state = (int) yy_def[yy_current_state];
    1003           0 :                                 if ( yy_current_state >= 57 )
    1004           0 :                                         yy_c = yy_meta[yy_c];
    1005             :                                 }
    1006           0 :                         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1007           0 :                         ++yy_cp;
    1008             :                         }
    1009           0 :                 while ( yy_base[yy_current_state] != 92 );
    1010             : 
    1011           0 : yy_find_action:
    1012           0 :                 yy_act = yy_accept[yy_current_state];
    1013           0 :                 if ( yy_act == 0 )
    1014             :                         { /* have to back up */
    1015           0 :                         yy_cp = (yy_last_accepting_cpos);
    1016           0 :                         yy_current_state = (yy_last_accepting_state);
    1017           0 :                         yy_act = yy_accept[yy_current_state];
    1018             :                         }
    1019             : 
    1020           0 :                 YY_DO_BEFORE_ACTION;
    1021             : 
    1022           0 : do_action:      /* This label is used only to access EOF actions. */
    1023             : 
    1024           0 :                 switch ( yy_act )
    1025             :         { /* beginning of action switch */
    1026           0 :                         case 0: /* must back up */
    1027             :                         /* undo the effects of YY_DO_BEFORE_ACTION */
    1028           0 :                         *yy_cp = (yy_hold_char);
    1029           0 :                         yy_cp = (yy_last_accepting_cpos);
    1030           0 :                         yy_current_state = (yy_last_accepting_state);
    1031           0 :                         goto yy_find_action;
    1032             : 
    1033           0 : case 1:
    1034             : YY_RULE_SETUP
    1035           0 : return FUNC_INRANGE;
    1036             :         YY_BREAK
    1037           0 : case 2:
    1038             : YY_RULE_SETUP
    1039           0 : return DATE_ISO;
    1040             :         YY_BREAK
    1041           0 : case 3:
    1042             : YY_RULE_SETUP
    1043           0 : {mdsyylval.bval = false; return BOOL;}
    1044             :         YY_BREAK
    1045           0 : case 4:
    1046             : YY_RULE_SETUP
    1047           0 : {mdsyylval.bval = true; return BOOL;}
    1048             :         YY_BREAK
    1049           0 : case 5:
    1050             : YY_RULE_SETUP
    1051           0 : return QUOTE;
    1052             :         YY_BREAK
    1053           0 : case 6:
    1054             : YY_RULE_SETUP
    1055           0 : return OBRACE;
    1056             :         YY_BREAK
    1057           0 : case 7:
    1058             : YY_RULE_SETUP
    1059           0 : return CBRACE;
    1060             :         YY_BREAK
    1061           0 : case 8:
    1062             : YY_RULE_SETUP
    1063           0 : return AND;
    1064             :         YY_BREAK
    1065           0 : case 9:
    1066             : YY_RULE_SETUP
    1067           0 : return OR;
    1068             :         YY_BREAK
    1069           0 : case 10:
    1070             : YY_RULE_SETUP
    1071           0 : return EQUAL;
    1072             :         YY_BREAK
    1073           0 : case 11:
    1074             : YY_RULE_SETUP
    1075           0 : return UNEQUAL;
    1076             :         YY_BREAK
    1077           0 : case 12:
    1078             : YY_RULE_SETUP
    1079           0 : return EQUAL;
    1080             :         YY_BREAK
    1081           0 : case 13:
    1082             : YY_RULE_SETUP
    1083           0 : return LT;
    1084             :         YY_BREAK
    1085           0 : case 14:
    1086             : YY_RULE_SETUP
    1087           0 : return GT;
    1088             :         YY_BREAK
    1089           0 : case 15:
    1090             : YY_RULE_SETUP
    1091           0 : return COMMA;
    1092             :         YY_BREAK
    1093           0 : case 16:
    1094             : YY_RULE_SETUP
    1095           0 : {mdsyylval.sval = talloc_strdup(talloc_tos(), mdsyytext); return WORD;}
    1096             :         YY_BREAK
    1097           0 : case 17:
    1098             : /* rule 17 can match eol */
    1099             : YY_RULE_SETUP
    1100             : /* ignore */
    1101           0 :         YY_BREAK
    1102           0 : case 18:
    1103             : YY_RULE_SETUP
    1104           0 : ECHO;
    1105           0 :         YY_BREAK
    1106           0 : case YY_STATE_EOF(INITIAL):
    1107           0 :         yyterminate();
    1108             : 
    1109           0 :         case YY_END_OF_BUFFER:
    1110             :                 {
    1111             :                 /* Amount of text matched not including the EOB char. */
    1112           0 :                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
    1113             : 
    1114             :                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
    1115           0 :                 *yy_cp = (yy_hold_char);
    1116             :                 YY_RESTORE_YY_MORE_OFFSET
    1117             : 
    1118           0 :                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    1119             :                         {
    1120             :                         /* We're scanning a new file or input source.  It's
    1121             :                          * possible that this happened because the user
    1122             :                          * just pointed yyin at a new source and called
    1123             :                          * yylex().  If so, then we have to assure
    1124             :                          * consistency between YY_CURRENT_BUFFER and our
    1125             :                          * globals.  Here is the right place to do so, because
    1126             :                          * this is the first action (other than possibly a
    1127             :                          * back-up) that will match for the new input source.
    1128             :                          */
    1129           0 :                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1130           0 :                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
    1131           0 :                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    1132             :                         }
    1133             : 
    1134             :                 /* Note that here we test for yy_c_buf_p "<=" to the position
    1135             :                  * of the first EOB in the buffer, since yy_c_buf_p will
    1136             :                  * already have been incremented past the NUL character
    1137             :                  * (since all states make transitions on EOB to the
    1138             :                  * end-of-buffer state).  Contrast this with the test
    1139             :                  * in input().
    1140             :                  */
    1141           0 :                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    1142             :                         { /* This was really a NUL. */
    1143             :                         yy_state_type yy_next_state;
    1144             : 
    1145           0 :                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
    1146             : 
    1147           0 :                         yy_current_state = yy_get_previous_state(  );
    1148             : 
    1149             :                         /* Okay, we're now positioned to make the NUL
    1150             :                          * transition.  We couldn't have
    1151             :                          * yy_get_previous_state() go ahead and do it
    1152             :                          * for us because it doesn't know how to deal
    1153             :                          * with the possibility of jamming (and we don't
    1154             :                          * want to build jamming into it because then it
    1155             :                          * will run more slowly).
    1156             :                          */
    1157             : 
    1158           0 :                         yy_next_state = yy_try_NUL_trans( yy_current_state );
    1159             : 
    1160           0 :                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1161             : 
    1162           0 :                         if ( yy_next_state )
    1163             :                                 {
    1164             :                                 /* Consume the NUL. */
    1165           0 :                                 yy_cp = ++(yy_c_buf_p);
    1166           0 :                                 yy_current_state = yy_next_state;
    1167           0 :                                 goto yy_match;
    1168             :                                 }
    1169             : 
    1170             :                         else
    1171             :                                 {
    1172           0 :                                 yy_cp = (yy_c_buf_p);
    1173           0 :                                 goto yy_find_action;
    1174             :                                 }
    1175             :                         }
    1176             : 
    1177           0 :                 else switch ( yy_get_next_buffer(  ) )
    1178             :                         {
    1179           0 :                         case EOB_ACT_END_OF_FILE:
    1180             :                                 {
    1181           0 :                                 (yy_did_buffer_switch_on_eof) = 0;
    1182             : 
    1183           0 :                                 if ( yywrap(  ) )
    1184             :                                         {
    1185             :                                         /* Note: because we've taken care in
    1186             :                                          * yy_get_next_buffer() to have set up
    1187             :                                          * yytext, we can now set up
    1188             :                                          * yy_c_buf_p so that if some total
    1189             :                                          * hoser (like flex itself) wants to
    1190             :                                          * call the scanner after we return the
    1191             :                                          * YY_NULL, it'll still work - another
    1192             :                                          * YY_NULL will get returned.
    1193             :                                          */
    1194           0 :                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
    1195             : 
    1196           0 :                                         yy_act = YY_STATE_EOF(YY_START);
    1197           0 :                                         goto do_action;
    1198             :                                         }
    1199             : 
    1200             :                                 else
    1201             :                                         {
    1202           0 :                                         if ( ! (yy_did_buffer_switch_on_eof) )
    1203           0 :                                                 YY_NEW_FILE;
    1204             :                                         }
    1205           0 :                                 break;
    1206             :                                 }
    1207             : 
    1208           0 :                         case EOB_ACT_CONTINUE_SCAN:
    1209           0 :                                 (yy_c_buf_p) =
    1210           0 :                                         (yytext_ptr) + yy_amount_of_matched_text;
    1211             : 
    1212           0 :                                 yy_current_state = yy_get_previous_state(  );
    1213             : 
    1214           0 :                                 yy_cp = (yy_c_buf_p);
    1215           0 :                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1216           0 :                                 goto yy_match;
    1217             : 
    1218           0 :                         case EOB_ACT_LAST_MATCH:
    1219           0 :                                 (yy_c_buf_p) =
    1220           0 :                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
    1221             : 
    1222           0 :                                 yy_current_state = yy_get_previous_state(  );
    1223             : 
    1224           0 :                                 yy_cp = (yy_c_buf_p);
    1225           0 :                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1226           0 :                                 goto yy_find_action;
    1227             :                         }
    1228           0 :                 break;
    1229             :                 }
    1230             : 
    1231           0 :         default:
    1232           0 :                 YY_FATAL_ERROR(
    1233             :                         "fatal flex scanner internal error--no action found" );
    1234             :         } /* end of action switch */
    1235             :                 } /* end of scanning one token */
    1236             :         } /* end of user's declarations */
    1237             : } /* end of yylex */
    1238             : 
    1239             : /* yy_get_next_buffer - try to read in a new buffer
    1240             :  *
    1241             :  * Returns a code representing an action:
    1242             :  *      EOB_ACT_LAST_MATCH -
    1243             :  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    1244             :  *      EOB_ACT_END_OF_FILE - end of file
    1245             :  */
    1246           0 : static int yy_get_next_buffer (void)
    1247             : {
    1248           0 :         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    1249           0 :         char *source = (yytext_ptr);
    1250             :         int number_to_move, i;
    1251             :         int ret_val;
    1252             : 
    1253           0 :         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    1254           0 :                 YY_FATAL_ERROR(
    1255             :                 "fatal flex scanner internal error--end of buffer missed" );
    1256             : 
    1257           0 :         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    1258             :                 { /* Don't try to fill the buffer, so this is an EOF. */
    1259           0 :                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    1260             :                         {
    1261             :                         /* We matched a single character, the EOB, so
    1262             :                          * treat this as a final EOF.
    1263             :                          */
    1264           0 :                         return EOB_ACT_END_OF_FILE;
    1265             :                         }
    1266             : 
    1267             :                 else
    1268             :                         {
    1269             :                         /* We matched some text prior to the EOB, first
    1270             :                          * process it.
    1271             :                          */
    1272           0 :                         return EOB_ACT_LAST_MATCH;
    1273             :                         }
    1274             :                 }
    1275             : 
    1276             :         /* Try to read more data. */
    1277             : 
    1278             :         /* First move last chars to start of buffer. */
    1279           0 :         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
    1280             : 
    1281           0 :         for ( i = 0; i < number_to_move; ++i )
    1282           0 :                 *(dest++) = *(source++);
    1283             : 
    1284           0 :         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    1285             :                 /* don't do the read, it's not guaranteed to return an EOF,
    1286             :                  * just force an EOF
    1287             :                  */
    1288           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    1289             : 
    1290             :         else
    1291             :                 {
    1292           0 :                         int num_to_read =
    1293           0 :                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    1294             : 
    1295           0 :                 while ( num_to_read <= 0 )
    1296             :                         { /* Not enough room in the buffer - grow it. */
    1297             : 
    1298             :                         /* just a shorter name for the current buffer */
    1299           0 :                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
    1300             : 
    1301           0 :                         int yy_c_buf_p_offset =
    1302           0 :                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
    1303             : 
    1304           0 :                         if ( b->yy_is_our_buffer )
    1305             :                                 {
    1306           0 :                                 int new_size = b->yy_buf_size * 2;
    1307             : 
    1308           0 :                                 if ( new_size <= 0 )
    1309           0 :                                         b->yy_buf_size += b->yy_buf_size / 8;
    1310             :                                 else
    1311           0 :                                         b->yy_buf_size *= 2;
    1312             : 
    1313           0 :                                 b->yy_ch_buf = (char *)
    1314             :                                         /* Include room in for 2 EOB chars. */
    1315           0 :                                         yyrealloc( (void *) b->yy_ch_buf,
    1316           0 :                                                          (yy_size_t) (b->yy_buf_size + 2)  );
    1317             :                                 }
    1318             :                         else
    1319             :                                 /* Can't grow it, we don't own it. */
    1320           0 :                                 b->yy_ch_buf = NULL;
    1321             : 
    1322           0 :                         if ( ! b->yy_ch_buf )
    1323           0 :                                 YY_FATAL_ERROR(
    1324             :                                 "fatal error - scanner input buffer overflow" );
    1325             : 
    1326           0 :                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
    1327             : 
    1328           0 :                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    1329             :                                                 number_to_move - 1;
    1330             : 
    1331             :                         }
    1332             : 
    1333           0 :                 if ( num_to_read > YY_READ_BUF_SIZE )
    1334           0 :                         num_to_read = YY_READ_BUF_SIZE;
    1335             : 
    1336             :                 /* Read in more data. */
    1337           0 :                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    1338             :                         (yy_n_chars), num_to_read );
    1339             : 
    1340           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1341             :                 }
    1342             : 
    1343           0 :         if ( (yy_n_chars) == 0 )
    1344             :                 {
    1345           0 :                 if ( number_to_move == YY_MORE_ADJ )
    1346             :                         {
    1347           0 :                         ret_val = EOB_ACT_END_OF_FILE;
    1348           0 :                         yyrestart( yyin  );
    1349             :                         }
    1350             : 
    1351             :                 else
    1352             :                         {
    1353           0 :                         ret_val = EOB_ACT_LAST_MATCH;
    1354           0 :                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    1355             :                                 YY_BUFFER_EOF_PENDING;
    1356             :                         }
    1357             :                 }
    1358             : 
    1359             :         else
    1360           0 :                 ret_val = EOB_ACT_CONTINUE_SCAN;
    1361             : 
    1362           0 :         if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    1363             :                 /* Extend the array by 50%, plus the number we really need. */
    1364           0 :                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
    1365           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
    1366           0 :                         (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
    1367           0 :                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    1368           0 :                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    1369             :                 /* "- 2" to take care of EOB's */
    1370           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
    1371             :         }
    1372             : 
    1373           0 :         (yy_n_chars) += number_to_move;
    1374           0 :         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    1375           0 :         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
    1376             : 
    1377           0 :         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    1378             : 
    1379           0 :         return ret_val;
    1380             : }
    1381             : 
    1382             : /* yy_get_previous_state - get the state just before the EOB char was reached */
    1383             : 
    1384           0 :     static yy_state_type yy_get_previous_state (void)
    1385             : {
    1386             :         yy_state_type yy_current_state;
    1387             :         char *yy_cp;
    1388             :     
    1389           0 :         yy_current_state = (yy_start);
    1390             : 
    1391           0 :         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    1392             :                 {
    1393           0 :                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    1394           0 :                 if ( yy_accept[yy_current_state] )
    1395             :                         {
    1396           0 :                         (yy_last_accepting_state) = yy_current_state;
    1397           0 :                         (yy_last_accepting_cpos) = yy_cp;
    1398             :                         }
    1399           0 :                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1400             :                         {
    1401           0 :                         yy_current_state = (int) yy_def[yy_current_state];
    1402           0 :                         if ( yy_current_state >= 57 )
    1403           0 :                                 yy_c = yy_meta[yy_c];
    1404             :                         }
    1405           0 :                 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1406             :                 }
    1407             : 
    1408           0 :         return yy_current_state;
    1409             : }
    1410             : 
    1411             : /* yy_try_NUL_trans - try to make a transition on the NUL character
    1412             :  *
    1413             :  * synopsis
    1414             :  *      next_state = yy_try_NUL_trans( current_state );
    1415             :  */
    1416           0 :     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
    1417             : {
    1418             :         int yy_is_jam;
    1419           0 :         char *yy_cp = (yy_c_buf_p);
    1420             : 
    1421           0 :         YY_CHAR yy_c = 1;
    1422           0 :         if ( yy_accept[yy_current_state] )
    1423             :                 {
    1424           0 :                 (yy_last_accepting_state) = yy_current_state;
    1425           0 :                 (yy_last_accepting_cpos) = yy_cp;
    1426             :                 }
    1427           0 :         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1428             :                 {
    1429           0 :                 yy_current_state = (int) yy_def[yy_current_state];
    1430           0 :                 if ( yy_current_state >= 57 )
    1431           0 :                         yy_c = yy_meta[yy_c];
    1432             :                 }
    1433           0 :         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1434           0 :         yy_is_jam = (yy_current_state == 56);
    1435             : 
    1436           0 :                 return yy_is_jam ? 0 : yy_current_state;
    1437             : }
    1438             : 
    1439             : #ifndef YY_NO_UNPUT
    1440             : 
    1441             : #endif
    1442             : 
    1443             : #ifndef YY_NO_INPUT
    1444             : #ifdef __cplusplus
    1445             :     static int yyinput (void)
    1446             : #else
    1447             :     static int input  (void)
    1448             : #endif
    1449             : 
    1450             : {
    1451             :         int c;
    1452             :     
    1453             :         *(yy_c_buf_p) = (yy_hold_char);
    1454             : 
    1455             :         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    1456             :                 {
    1457             :                 /* yy_c_buf_p now points to the character we want to return.
    1458             :                  * If this occurs *before* the EOB characters, then it's a
    1459             :                  * valid NUL; if not, then we've hit the end of the buffer.
    1460             :                  */
    1461             :                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    1462             :                         /* This was really a NUL. */
    1463             :                         *(yy_c_buf_p) = '\0';
    1464             : 
    1465             :                 else
    1466             :                         { /* need more input */
    1467             :                         int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
    1468             :                         ++(yy_c_buf_p);
    1469             : 
    1470             :                         switch ( yy_get_next_buffer(  ) )
    1471             :                                 {
    1472             :                                 case EOB_ACT_LAST_MATCH:
    1473             :                                         /* This happens because yy_g_n_b()
    1474             :                                          * sees that we've accumulated a
    1475             :                                          * token and flags that we need to
    1476             :                                          * try matching the token before
    1477             :                                          * proceeding.  But for input(),
    1478             :                                          * there's no matching to consider.
    1479             :                                          * So convert the EOB_ACT_LAST_MATCH
    1480             :                                          * to EOB_ACT_END_OF_FILE.
    1481             :                                          */
    1482             : 
    1483             :                                         /* Reset buffer status. */
    1484             :                                         yyrestart( yyin );
    1485             : 
    1486             :                                         /*FALLTHROUGH*/
    1487             : 
    1488             :                                 case EOB_ACT_END_OF_FILE:
    1489             :                                         {
    1490             :                                         if ( yywrap(  ) )
    1491             :                                                 return 0;
    1492             : 
    1493             :                                         if ( ! (yy_did_buffer_switch_on_eof) )
    1494             :                                                 YY_NEW_FILE;
    1495             : #ifdef __cplusplus
    1496             :                                         return yyinput();
    1497             : #else
    1498             :                                         return input();
    1499             : #endif
    1500             :                                         }
    1501             : 
    1502             :                                 case EOB_ACT_CONTINUE_SCAN:
    1503             :                                         (yy_c_buf_p) = (yytext_ptr) + offset;
    1504             :                                         break;
    1505             :                                 }
    1506             :                         }
    1507             :                 }
    1508             : 
    1509             :         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
    1510             :         *(yy_c_buf_p) = '\0';   /* preserve yytext */
    1511             :         (yy_hold_char) = *++(yy_c_buf_p);
    1512             : 
    1513             :         return c;
    1514             : }
    1515             : #endif  /* ifndef YY_NO_INPUT */
    1516             : 
    1517             : /** Immediately switch to a different input stream.
    1518             :  * @param input_file A readable stream.
    1519             :  * 
    1520             :  * @note This function does not reset the start condition to @c INITIAL .
    1521             :  */
    1522           0 :     void yyrestart  (FILE * input_file )
    1523             : {
    1524             :     
    1525           0 :         if ( ! YY_CURRENT_BUFFER ){
    1526           0 :         yyensure_buffer_stack ();
    1527           0 :                 YY_CURRENT_BUFFER_LVALUE =
    1528           0 :             yy_create_buffer( yyin, YY_BUF_SIZE );
    1529             :         }
    1530             : 
    1531           0 :         yy_init_buffer( YY_CURRENT_BUFFER, input_file );
    1532           0 :         yy_load_buffer_state(  );
    1533           0 : }
    1534             : 
    1535             : /** Switch to a different input buffer.
    1536             :  * @param new_buffer The new input buffer.
    1537             :  * 
    1538             :  */
    1539           0 :     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
    1540             : {
    1541             :     
    1542             :         /* TODO. We should be able to replace this entire function body
    1543             :          * with
    1544             :          *              yypop_buffer_state();
    1545             :          *              yypush_buffer_state(new_buffer);
    1546             :      */
    1547           0 :         yyensure_buffer_stack ();
    1548           0 :         if ( YY_CURRENT_BUFFER == new_buffer )
    1549           0 :                 return;
    1550             : 
    1551           0 :         if ( YY_CURRENT_BUFFER )
    1552             :                 {
    1553             :                 /* Flush out information for old buffer. */
    1554           0 :                 *(yy_c_buf_p) = (yy_hold_char);
    1555           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    1556           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1557             :                 }
    1558             : 
    1559           0 :         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1560           0 :         yy_load_buffer_state(  );
    1561             : 
    1562             :         /* We don't actually know whether we did this switch during
    1563             :          * EOF (yywrap()) processing, but the only time this flag
    1564             :          * is looked at is after yywrap() is called, so it's safe
    1565             :          * to go ahead and always set it.
    1566             :          */
    1567           0 :         (yy_did_buffer_switch_on_eof) = 1;
    1568             : }
    1569             : 
    1570           0 : static void yy_load_buffer_state  (void)
    1571             : {
    1572           0 :         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1573           0 :         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    1574           0 :         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    1575           0 :         (yy_hold_char) = *(yy_c_buf_p);
    1576           0 : }
    1577             : 
    1578             : /** Allocate and initialize an input buffer state.
    1579             :  * @param file A readable stream.
    1580             :  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
    1581             :  * 
    1582             :  * @return the allocated buffer state.
    1583             :  */
    1584           0 :     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
    1585             : {
    1586             :         YY_BUFFER_STATE b;
    1587             :     
    1588           0 :         b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
    1589           0 :         if ( ! b )
    1590           0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    1591             : 
    1592           0 :         b->yy_buf_size = size;
    1593             : 
    1594             :         /* yy_ch_buf has to be 2 characters longer than the size given because
    1595             :          * we need to put in 2 end-of-buffer characters.
    1596             :          */
    1597           0 :         b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
    1598           0 :         if ( ! b->yy_ch_buf )
    1599           0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    1600             : 
    1601           0 :         b->yy_is_our_buffer = 1;
    1602             : 
    1603           0 :         yy_init_buffer( b, file );
    1604             : 
    1605           0 :         return b;
    1606             : }
    1607             : 
    1608             : /** Destroy the buffer.
    1609             :  * @param b a buffer created with yy_create_buffer()
    1610             :  * 
    1611             :  */
    1612           0 :     void yy_delete_buffer (YY_BUFFER_STATE  b )
    1613             : {
    1614             :     
    1615           0 :         if ( ! b )
    1616           0 :                 return;
    1617             : 
    1618           0 :         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    1619           0 :                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    1620             : 
    1621           0 :         if ( b->yy_is_our_buffer )
    1622           0 :                 yyfree( (void *) b->yy_ch_buf  );
    1623             : 
    1624           0 :         yyfree( (void *) b  );
    1625             : }
    1626             : 
    1627             : /* Initializes or reinitializes a buffer.
    1628             :  * This function is sometimes called more than once on the same buffer,
    1629             :  * such as during a yyrestart() or at EOF.
    1630             :  */
    1631           0 :     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
    1632             : 
    1633             : {
    1634           0 :         int oerrno = errno;
    1635             :     
    1636           0 :         yy_flush_buffer( b );
    1637             : 
    1638           0 :         b->yy_input_file = file;
    1639           0 :         b->yy_fill_buffer = 1;
    1640             : 
    1641             :     /* If b is the current buffer, then yy_init_buffer was _probably_
    1642             :      * called from yyrestart() or through yy_get_next_buffer.
    1643             :      * In that case, we don't want to reset the lineno or column.
    1644             :      */
    1645           0 :     if (b != YY_CURRENT_BUFFER){
    1646           0 :         b->yy_bs_lineno = 1;
    1647           0 :         b->yy_bs_column = 0;
    1648             :     }
    1649             : 
    1650           0 :         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    1651             :     
    1652           0 :         errno = oerrno;
    1653           0 : }
    1654             : 
    1655             : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
    1656             :  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
    1657             :  * 
    1658             :  */
    1659           0 :     void yy_flush_buffer (YY_BUFFER_STATE  b )
    1660             : {
    1661           0 :         if ( ! b )
    1662           0 :                 return;
    1663             : 
    1664           0 :         b->yy_n_chars = 0;
    1665             : 
    1666             :         /* We always need two end-of-buffer characters.  The first causes
    1667             :          * a transition to the end-of-buffer state.  The second causes
    1668             :          * a jam in that state.
    1669             :          */
    1670           0 :         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    1671           0 :         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    1672             : 
    1673           0 :         b->yy_buf_pos = &b->yy_ch_buf[0];
    1674             : 
    1675           0 :         b->yy_at_bol = 1;
    1676           0 :         b->yy_buffer_status = YY_BUFFER_NEW;
    1677             : 
    1678           0 :         if ( b == YY_CURRENT_BUFFER )
    1679           0 :                 yy_load_buffer_state(  );
    1680             : }
    1681             : 
    1682             : /** Pushes the new state onto the stack. The new state becomes
    1683             :  *  the current state. This function will allocate the stack
    1684             :  *  if necessary.
    1685             :  *  @param new_buffer The new state.
    1686             :  *  
    1687             :  */
    1688           0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
    1689             : {
    1690           0 :         if (new_buffer == NULL)
    1691           0 :                 return;
    1692             : 
    1693           0 :         yyensure_buffer_stack();
    1694             : 
    1695             :         /* This block is copied from yy_switch_to_buffer. */
    1696           0 :         if ( YY_CURRENT_BUFFER )
    1697             :                 {
    1698             :                 /* Flush out information for old buffer. */
    1699           0 :                 *(yy_c_buf_p) = (yy_hold_char);
    1700           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    1701           0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1702             :                 }
    1703             : 
    1704             :         /* Only push if top exists. Otherwise, replace top. */
    1705           0 :         if (YY_CURRENT_BUFFER)
    1706           0 :                 (yy_buffer_stack_top)++;
    1707           0 :         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1708             : 
    1709             :         /* copied from yy_switch_to_buffer. */
    1710           0 :         yy_load_buffer_state(  );
    1711           0 :         (yy_did_buffer_switch_on_eof) = 1;
    1712             : }
    1713             : 
    1714             : /** Removes and deletes the top of the stack, if present.
    1715             :  *  The next element becomes the new top.
    1716             :  *  
    1717             :  */
    1718           0 : void yypop_buffer_state (void)
    1719             : {
    1720           0 :         if (!YY_CURRENT_BUFFER)
    1721           0 :                 return;
    1722             : 
    1723           0 :         yy_delete_buffer(YY_CURRENT_BUFFER );
    1724           0 :         YY_CURRENT_BUFFER_LVALUE = NULL;
    1725           0 :         if ((yy_buffer_stack_top) > 0)
    1726           0 :                 --(yy_buffer_stack_top);
    1727             : 
    1728           0 :         if (YY_CURRENT_BUFFER) {
    1729           0 :                 yy_load_buffer_state(  );
    1730           0 :                 (yy_did_buffer_switch_on_eof) = 1;
    1731             :         }
    1732             : }
    1733             : 
    1734             : /* Allocates the stack if it does not exist.
    1735             :  *  Guarantees space for at least one push.
    1736             :  */
    1737           0 : static void yyensure_buffer_stack (void)
    1738             : {
    1739             :         yy_size_t num_to_alloc;
    1740             :     
    1741           0 :         if (!(yy_buffer_stack)) {
    1742             : 
    1743             :                 /* First allocation is just for 2 elements, since we don't know if this
    1744             :                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
    1745             :                  * immediate realloc on the next call.
    1746             :          */
    1747           0 :       num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
    1748           0 :                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
    1749             :                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
    1750             :                                                                 );
    1751           0 :                 if ( ! (yy_buffer_stack) )
    1752           0 :                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    1753             : 
    1754           0 :                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    1755             : 
    1756           0 :                 (yy_buffer_stack_max) = num_to_alloc;
    1757           0 :                 (yy_buffer_stack_top) = 0;
    1758           0 :                 return;
    1759             :         }
    1760             : 
    1761           0 :         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
    1762             : 
    1763             :                 /* Increase the buffer to prepare for a possible push. */
    1764           0 :                 yy_size_t grow_size = 8 /* arbitrary grow size */;
    1765             : 
    1766           0 :                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
    1767           0 :                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
    1768             :                                                                 ((yy_buffer_stack),
    1769             :                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
    1770             :                                                                 );
    1771           0 :                 if ( ! (yy_buffer_stack) )
    1772           0 :                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    1773             : 
    1774             :                 /* zero only the new slots.*/
    1775           0 :                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
    1776           0 :                 (yy_buffer_stack_max) = num_to_alloc;
    1777             :         }
    1778             : }
    1779             : 
    1780             : /** Setup the input buffer state to scan directly from a user-specified character buffer.
    1781             :  * @param base the character buffer
    1782             :  * @param size the size in bytes of the character buffer
    1783             :  * 
    1784             :  * @return the newly allocated buffer state object.
    1785             :  */
    1786           0 : YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
    1787             : {
    1788             :         YY_BUFFER_STATE b;
    1789             :     
    1790           0 :         if ( size < 2 ||
    1791           0 :              base[size-2] != YY_END_OF_BUFFER_CHAR ||
    1792           0 :              base[size-1] != YY_END_OF_BUFFER_CHAR )
    1793             :                 /* They forgot to leave room for the EOB's. */
    1794           0 :                 return NULL;
    1795             : 
    1796           0 :         b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
    1797           0 :         if ( ! b )
    1798           0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    1799             : 
    1800           0 :         b->yy_buf_size = (int) (size - 2);   /* "- 2" to take care of EOB's */
    1801           0 :         b->yy_buf_pos = b->yy_ch_buf = base;
    1802           0 :         b->yy_is_our_buffer = 0;
    1803           0 :         b->yy_input_file = NULL;
    1804           0 :         b->yy_n_chars = b->yy_buf_size;
    1805           0 :         b->yy_is_interactive = 0;
    1806           0 :         b->yy_at_bol = 1;
    1807           0 :         b->yy_fill_buffer = 0;
    1808           0 :         b->yy_buffer_status = YY_BUFFER_NEW;
    1809             : 
    1810           0 :         yy_switch_to_buffer( b  );
    1811             : 
    1812           0 :         return b;
    1813             : }
    1814             : 
    1815             : /** Setup the input buffer state to scan a string. The next call to yylex() will
    1816             :  * scan from a @e copy of @a str.
    1817             :  * @param yystr a NUL-terminated string to scan
    1818             :  * 
    1819             :  * @return the newly allocated buffer state object.
    1820             :  * @note If you want to scan bytes that may contain NUL values, then use
    1821             :  *       yy_scan_bytes() instead.
    1822             :  */
    1823           0 : YY_BUFFER_STATE yy_scan_string (const char * yystr )
    1824             : {
    1825             :     
    1826           0 :         return yy_scan_bytes( yystr, (int) strlen(yystr) );
    1827             : }
    1828             : 
    1829             : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
    1830             :  * scan from a @e copy of @a bytes.
    1831             :  * @param yybytes the byte buffer to scan
    1832             :  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
    1833             :  * 
    1834             :  * @return the newly allocated buffer state object.
    1835             :  */
    1836           0 : YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
    1837             : {
    1838             :         YY_BUFFER_STATE b;
    1839             :         char *buf;
    1840             :         yy_size_t n;
    1841             :         int i;
    1842             :     
    1843             :         /* Get memory for full buffer, including space for trailing EOB's. */
    1844           0 :         n = (yy_size_t) (_yybytes_len + 2);
    1845           0 :         buf = (char *) yyalloc( n  );
    1846           0 :         if ( ! buf )
    1847           0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    1848             : 
    1849           0 :         for ( i = 0; i < _yybytes_len; ++i )
    1850           0 :                 buf[i] = yybytes[i];
    1851             : 
    1852           0 :         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    1853             : 
    1854           0 :         b = yy_scan_buffer( buf, n );
    1855           0 :         if ( ! b )
    1856           0 :                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    1857             : 
    1858             :         /* It's okay to grow etc. this buffer, and we should throw it
    1859             :          * away when we're done.
    1860             :          */
    1861           0 :         b->yy_is_our_buffer = 1;
    1862             : 
    1863           0 :         return b;
    1864             : }
    1865             : 
    1866             : #ifndef YY_EXIT_FAILURE
    1867             : #define YY_EXIT_FAILURE 2
    1868             : #endif
    1869             : 
    1870           0 : static void yynoreturn yy_fatal_error (const char* msg )
    1871             : {
    1872           0 :                         fprintf( stderr, "%s\n", msg );
    1873           0 :         exit( YY_EXIT_FAILURE );
    1874             : }
    1875             : 
    1876             : /* Redefine yyless() so it works in section 3 code. */
    1877             : 
    1878             : #undef yyless
    1879             : #define yyless(n) \
    1880             :         do \
    1881             :                 { \
    1882             :                 /* Undo effects of setting up yytext. */ \
    1883             :         int yyless_macro_arg = (n); \
    1884             :         YY_LESS_LINENO(yyless_macro_arg);\
    1885             :                 yytext[yyleng] = (yy_hold_char); \
    1886             :                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
    1887             :                 (yy_hold_char) = *(yy_c_buf_p); \
    1888             :                 *(yy_c_buf_p) = '\0'; \
    1889             :                 yyleng = yyless_macro_arg; \
    1890             :                 } \
    1891             :         while ( 0 )
    1892             : 
    1893             : /* Accessor  methods (get/set functions) to struct members. */
    1894             : 
    1895             : /** Get the current line number.
    1896             :  * 
    1897             :  */
    1898           0 : int yyget_lineno  (void)
    1899             : {
    1900             :     
    1901           0 :     return yylineno;
    1902             : }
    1903             : 
    1904             : /** Get the input stream.
    1905             :  * 
    1906             :  */
    1907           0 : FILE *yyget_in  (void)
    1908             : {
    1909           0 :         return yyin;
    1910             : }
    1911             : 
    1912             : /** Get the output stream.
    1913             :  * 
    1914             :  */
    1915           0 : FILE *yyget_out  (void)
    1916             : {
    1917           0 :         return yyout;
    1918             : }
    1919             : 
    1920             : /** Get the length of the current token.
    1921             :  * 
    1922             :  */
    1923           0 : int yyget_leng  (void)
    1924             : {
    1925           0 :         return yyleng;
    1926             : }
    1927             : 
    1928             : /** Get the current token.
    1929             :  * 
    1930             :  */
    1931             : 
    1932           0 : char *yyget_text  (void)
    1933             : {
    1934           0 :         return yytext;
    1935             : }
    1936             : 
    1937             : /** Set the current line number.
    1938             :  * @param _line_number line number
    1939             :  * 
    1940             :  */
    1941           0 : void yyset_lineno (int  _line_number )
    1942             : {
    1943             :     
    1944           0 :     yylineno = _line_number;
    1945           0 : }
    1946             : 
    1947             : /** Set the input stream. This does not discard the current
    1948             :  * input buffer.
    1949             :  * @param _in_str A readable stream.
    1950             :  * 
    1951             :  * @see yy_switch_to_buffer
    1952             :  */
    1953           0 : void yyset_in (FILE *  _in_str )
    1954             : {
    1955           0 :         yyin = _in_str ;
    1956           0 : }
    1957             : 
    1958           0 : void yyset_out (FILE *  _out_str )
    1959             : {
    1960           0 :         yyout = _out_str ;
    1961           0 : }
    1962             : 
    1963           0 : int yyget_debug  (void)
    1964             : {
    1965           0 :         return yy_flex_debug;
    1966             : }
    1967             : 
    1968           0 : void yyset_debug (int  _bdebug )
    1969             : {
    1970           0 :         yy_flex_debug = _bdebug ;
    1971           0 : }
    1972             : 
    1973           0 : static int yy_init_globals (void)
    1974             : {
    1975             :         /* Initialization is the same as for the non-reentrant scanner.
    1976             :      * This function is called from yylex_destroy(), so don't allocate here.
    1977             :      */
    1978             : 
    1979           0 :     (yy_buffer_stack) = NULL;
    1980           0 :     (yy_buffer_stack_top) = 0;
    1981           0 :     (yy_buffer_stack_max) = 0;
    1982           0 :     (yy_c_buf_p) = NULL;
    1983           0 :     (yy_init) = 0;
    1984           0 :     (yy_start) = 0;
    1985             : 
    1986             : /* Defined in main.c */
    1987             : #ifdef YY_STDINIT
    1988             :     yyin = stdin;
    1989             :     yyout = stdout;
    1990             : #else
    1991           0 :     yyin = NULL;
    1992           0 :     yyout = NULL;
    1993             : #endif
    1994             : 
    1995             :     /* For future reference: Set errno on error, since we are called by
    1996             :      * yylex_init()
    1997             :      */
    1998           0 :     return 0;
    1999             : }
    2000             : 
    2001             : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
    2002           0 : int yylex_destroy  (void)
    2003             : {
    2004             :     
    2005             :     /* Pop the buffer stack, destroying each element. */
    2006           0 :         while(YY_CURRENT_BUFFER){
    2007           0 :                 yy_delete_buffer( YY_CURRENT_BUFFER  );
    2008           0 :                 YY_CURRENT_BUFFER_LVALUE = NULL;
    2009           0 :                 yypop_buffer_state();
    2010             :         }
    2011             : 
    2012             :         /* Destroy the stack itself. */
    2013           0 :         yyfree((yy_buffer_stack) );
    2014           0 :         (yy_buffer_stack) = NULL;
    2015             : 
    2016             :     /* Reset the globals. This is important in a non-reentrant scanner so the next time
    2017             :      * yylex() is called, initialization will occur. */
    2018           0 :     yy_init_globals( );
    2019             : 
    2020           0 :     return 0;
    2021             : }
    2022             : 
    2023             : /*
    2024             :  * Internal utility routines.
    2025             :  */
    2026             : 
    2027             : #ifndef yytext_ptr
    2028             : static void yy_flex_strncpy (char* s1, const char * s2, int n )
    2029             : {
    2030             :                 
    2031             :         int i;
    2032             :         for ( i = 0; i < n; ++i )
    2033             :                 s1[i] = s2[i];
    2034             : }
    2035             : #endif
    2036             : 
    2037             : #ifdef YY_NEED_STRLEN
    2038             : static int yy_flex_strlen (const char * s )
    2039             : {
    2040             :         int n;
    2041             :         for ( n = 0; s[n]; ++n )
    2042             :                 ;
    2043             : 
    2044             :         return n;
    2045             : }
    2046             : #endif
    2047             : 
    2048           0 : void yyfree (void * ptr )
    2049             : {
    2050           0 :                         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
    2051           0 : }
    2052             : 
    2053             : #define YYTABLES_NAME "yytables"
    2054             : 
    2055           0 : void *yyalloc(yy_size_t bytes)
    2056             : {
    2057           0 :     return SMB_MALLOC(bytes);
    2058             : }
    2059             : 
    2060           0 : void *yyrealloc(void *ptr, yy_size_t bytes)
    2061             : {
    2062           0 :     return SMB_REALLOC(ptr, bytes);
    2063             : }
    2064             : 

Generated by: LCOV version 1.13