LCOV - code coverage report
Current view: top level - gst/parse - lex._gst_parse_yy.c (source / functions) Hit Total Coverage
Test: GStreamer 0.10.32.1 Lines: 190 436 43.6 %
Date: 2011-03-25 Functions: 16 41 39.0 %
Branches: 72 223 32.3 %

           Branch data     Line data    Source code
       1                 :            : #ifdef HAVE_CONFIG_H
       2                 :            : #include <config.h>
       3                 :            : #endif
       4                 :            : 
       5                 :            : #line 3 "lex._gst_parse_yy.c"
       6                 :            : 
       7                 :            : #define  YY_INT_ALIGNED short int
       8                 :            : 
       9                 :            : /* A lexical scanner generated by flex */
      10                 :            : 
      11                 :            : #define FLEX_SCANNER
      12                 :            : #define YY_FLEX_MAJOR_VERSION 2
      13                 :            : #define YY_FLEX_MINOR_VERSION 5
      14                 :            : #define YY_FLEX_SUBMINOR_VERSION 35
      15                 :            : #if YY_FLEX_SUBMINOR_VERSION > 0
      16                 :            : #define FLEX_BETA
      17                 :            : #endif
      18                 :            : 
      19                 :            : /* First, we deal with  platform-specific or compiler-specific issues. */
      20                 :            : 
      21                 :            : /* begin standard C headers. */
      22                 :            : #include <stdio.h>
      23                 :            : #include <string.h>
      24                 :            : #include <errno.h>
      25                 :            : #include <stdlib.h>
      26                 :            : 
      27                 :            : /* end standard C headers. */
      28                 :            : 
      29                 :            : /* flex integer type definitions */
      30                 :            : 
      31                 :            : #ifndef FLEXINT_H
      32                 :            : #define FLEXINT_H
      33                 :            : 
      34                 :            : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
      35                 :            : 
      36                 :            : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
      37                 :            : 
      38                 :            : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
      39                 :            :  * if you want the limit (max/min) macros for int types. 
      40                 :            :  */
      41                 :            : #ifndef __STDC_LIMIT_MACROS
      42                 :            : #define __STDC_LIMIT_MACROS 1
      43                 :            : #endif
      44                 :            : 
      45                 :            : #include <inttypes.h>
      46                 :            : typedef int8_t flex_int8_t;
      47                 :            : typedef uint8_t flex_uint8_t;
      48                 :            : typedef int16_t flex_int16_t;
      49                 :            : typedef uint16_t flex_uint16_t;
      50                 :            : typedef int32_t flex_int32_t;
      51                 :            : typedef uint32_t flex_uint32_t;
      52                 :            : #else
      53                 :            : typedef signed char flex_int8_t;
      54                 :            : typedef short int flex_int16_t;
      55                 :            : typedef int flex_int32_t;
      56                 :            : typedef unsigned char flex_uint8_t; 
      57                 :            : typedef unsigned short int flex_uint16_t;
      58                 :            : typedef unsigned int flex_uint32_t;
      59                 :            : 
      60                 :            : /* Limits of integral types. */
      61                 :            : #ifndef INT8_MIN
      62                 :            : #define INT8_MIN               (-128)
      63                 :            : #endif
      64                 :            : #ifndef INT16_MIN
      65                 :            : #define INT16_MIN              (-32767-1)
      66                 :            : #endif
      67                 :            : #ifndef INT32_MIN
      68                 :            : #define INT32_MIN              (-2147483647-1)
      69                 :            : #endif
      70                 :            : #ifndef INT8_MAX
      71                 :            : #define INT8_MAX               (127)
      72                 :            : #endif
      73                 :            : #ifndef INT16_MAX
      74                 :            : #define INT16_MAX              (32767)
      75                 :            : #endif
      76                 :            : #ifndef INT32_MAX
      77                 :            : #define INT32_MAX              (2147483647)
      78                 :            : #endif
      79                 :            : #ifndef UINT8_MAX
      80                 :            : #define UINT8_MAX              (255U)
      81                 :            : #endif
      82                 :            : #ifndef UINT16_MAX
      83                 :            : #define UINT16_MAX             (65535U)
      84                 :            : #endif
      85                 :            : #ifndef UINT32_MAX
      86                 :            : #define UINT32_MAX             (4294967295U)
      87                 :            : #endif
      88                 :            : 
      89                 :            : #endif /* ! C99 */
      90                 :            : 
      91                 :            : #endif /* ! FLEXINT_H */
      92                 :            : 
      93                 :            : #ifdef __cplusplus
      94                 :            : 
      95                 :            : /* The "const" storage-class-modifier is valid. */
      96                 :            : #define YY_USE_CONST
      97                 :            : 
      98                 :            : #else /* ! __cplusplus */
      99                 :            : 
     100                 :            : /* C99 requires __STDC__ to be defined as 1. */
     101                 :            : #if defined (__STDC__)
     102                 :            : 
     103                 :            : #define YY_USE_CONST
     104                 :            : 
     105                 :            : #endif  /* defined (__STDC__) */
     106                 :            : #endif  /* ! __cplusplus */
     107                 :            : 
     108                 :            : #ifdef YY_USE_CONST
     109                 :            : #define yyconst const
     110                 :            : #else
     111                 :            : #define yyconst
     112                 :            : #endif
     113                 :            : 
     114                 :            : /* Returned upon end-of-file. */
     115                 :            : #define YY_NULL 0
     116                 :            : 
     117                 :            : /* Promotes a possibly negative, possibly signed char to an unsigned
     118                 :            :  * integer for use as an array index.  If the signed char is negative,
     119                 :            :  * we want to instead treat it as an 8-bit unsigned char, hence the
     120                 :            :  * double cast.
     121                 :            :  */
     122                 :            : #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
     123                 :            : 
     124                 :            : /* An opaque pointer. */
     125                 :            : #ifndef YY_TYPEDEF_YY_SCANNER_T
     126                 :            : #define YY_TYPEDEF_YY_SCANNER_T
     127                 :            : typedef void* yyscan_t;
     128                 :            : #endif
     129                 :            : 
     130                 :            : /* For convenience, these vars (plus the bison vars far below)
     131                 :            :    are macros in the reentrant scanner. */
     132                 :            : #define yyin yyg->yyin_r
     133                 :            : #define yyout yyg->yyout_r
     134                 :            : #define yyextra yyg->yyextra_r
     135                 :            : #define yyleng yyg->yyleng_r
     136                 :            : #define yytext yyg->yytext_r
     137                 :            : #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
     138                 :            : #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
     139                 :            : #define yy_flex_debug yyg->yy_flex_debug_r
     140                 :            : 
     141                 :            : /* Enter a start condition.  This macro really ought to take a parameter,
     142                 :            :  * but we do it the disgusting crufty way forced on us by the ()-less
     143                 :            :  * definition of BEGIN.
     144                 :            :  */
     145                 :            : #define BEGIN yyg->yy_start = 1 + 2 *
     146                 :            : 
     147                 :            : /* Translate the current start state into a value that can be later handed
     148                 :            :  * to BEGIN to return to the state.  The YYSTATE alias is for lex
     149                 :            :  * compatibility.
     150                 :            :  */
     151                 :            : #define YY_START ((yyg->yy_start - 1) / 2)
     152                 :            : #define YYSTATE YY_START
     153                 :            : 
     154                 :            : /* Action number for EOF rule of a given start state. */
     155                 :            : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
     156                 :            : 
     157                 :            : /* Special action meaning "start processing a new file". */
     158                 :            : #define YY_NEW_FILE _gst_parse_yyrestart(yyin ,yyscanner )
     159                 :            : 
     160                 :            : #define YY_END_OF_BUFFER_CHAR 0
     161                 :            : 
     162                 :            : /* Size of default input buffer. */
     163                 :            : #ifndef YY_BUF_SIZE
     164                 :            : #ifdef __ia64__
     165                 :            : /* On IA-64, the buffer size is 16k, not 8k.
     166                 :            :  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
     167                 :            :  * Ditto for the __ia64__ case accordingly.
     168                 :            :  */
     169                 :            : #define YY_BUF_SIZE 32768
     170                 :            : #else
     171                 :            : #define YY_BUF_SIZE 16384
     172                 :            : #endif /* __ia64__ */
     173                 :            : #endif
     174                 :            : 
     175                 :            : /* The state buf must be large enough to hold one state per character in the main buffer.
     176                 :            :  */
     177                 :            : #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
     178                 :            : 
     179                 :            : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
     180                 :            : #define YY_TYPEDEF_YY_BUFFER_STATE
     181                 :            : typedef struct yy_buffer_state *YY_BUFFER_STATE;
     182                 :            : #endif
     183                 :            : 
     184                 :            : #define EOB_ACT_CONTINUE_SCAN 0
     185                 :            : #define EOB_ACT_END_OF_FILE 1
     186                 :            : #define EOB_ACT_LAST_MATCH 2
     187                 :            : 
     188                 :            :     #define YY_LESS_LINENO(n)
     189                 :            :     
     190                 :            : /* Return all but the first "n" matched characters back to the input stream. */
     191                 :            : #define yyless(n) \
     192                 :            :   do \
     193                 :            :     { \
     194                 :            :     /* Undo effects of setting up yytext. */ \
     195                 :            :         int yyless_macro_arg = (n); \
     196                 :            :         YY_LESS_LINENO(yyless_macro_arg);\
     197                 :            :     *yy_cp = yyg->yy_hold_char; \
     198                 :            :     YY_RESTORE_YY_MORE_OFFSET \
     199                 :            :     yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
     200                 :            :     YY_DO_BEFORE_ACTION; /* set up yytext again */ \
     201                 :            :     } \
     202                 :            :   while ( 0 )
     203                 :            : 
     204                 :            : #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
     205                 :            : 
     206                 :            : #ifndef YY_TYPEDEF_YY_SIZE_T
     207                 :            : #define YY_TYPEDEF_YY_SIZE_T
     208                 :            : typedef size_t yy_size_t;
     209                 :            : #endif
     210                 :            : 
     211                 :            : #ifndef YY_STRUCT_YY_BUFFER_STATE
     212                 :            : #define YY_STRUCT_YY_BUFFER_STATE
     213                 :            : struct yy_buffer_state
     214                 :            :   {
     215                 :            :   FILE *yy_input_file;
     216                 :            : 
     217                 :            :   char *yy_ch_buf;    /* input buffer */
     218                 :            :   char *yy_buf_pos;   /* current position in input buffer */
     219                 :            : 
     220                 :            :   /* Size of input buffer in bytes, not including room for EOB
     221                 :            :    * characters.
     222                 :            :    */
     223                 :            :   yy_size_t yy_buf_size;
     224                 :            : 
     225                 :            :   /* Number of characters read into yy_ch_buf, not including EOB
     226                 :            :    * characters.
     227                 :            :    */
     228                 :            :   int yy_n_chars;
     229                 :            : 
     230                 :            :   /* Whether we "own" the buffer - i.e., we know we created it,
     231                 :            :    * and can realloc() it to grow it, and should free() it to
     232                 :            :    * delete it.
     233                 :            :    */
     234                 :            :   int yy_is_our_buffer;
     235                 :            : 
     236                 :            :   /* Whether this is an "interactive" input source; if so, and
     237                 :            :    * if we're using stdio for input, then we want to use getc()
     238                 :            :    * instead of fread(), to make sure we stop fetching input after
     239                 :            :    * each newline.
     240                 :            :    */
     241                 :            :   int yy_is_interactive;
     242                 :            : 
     243                 :            :   /* Whether we're considered to be at the beginning of a line.
     244                 :            :    * If so, '^' rules will be active on the next match, otherwise
     245                 :            :    * not.
     246                 :            :    */
     247                 :            :   int yy_at_bol;
     248                 :            : 
     249                 :            :     int yy_bs_lineno; /**< The line count. */
     250                 :            :     int yy_bs_column; /**< The column count. */
     251                 :            :     
     252                 :            :   /* Whether to try to fill the input buffer when we reach the
     253                 :            :    * end of it.
     254                 :            :    */
     255                 :            :   int yy_fill_buffer;
     256                 :            : 
     257                 :            :   int yy_buffer_status;
     258                 :            : 
     259                 :            : #define YY_BUFFER_NEW 0
     260                 :            : #define YY_BUFFER_NORMAL 1
     261                 :            :   /* When an EOF's been seen but there's still some text to process
     262                 :            :    * then we mark the buffer as YY_EOF_PENDING, to indicate that we
     263                 :            :    * shouldn't try reading from the input source any more.  We might
     264                 :            :    * still have a bunch of tokens to match, though, because of
     265                 :            :    * possible backing-up.
     266                 :            :    *
     267                 :            :    * When we actually see the EOF, we change the status to "new"
     268                 :            :    * (via _gst_parse_yyrestart()), so that the user can continue scanning by
     269                 :            :    * just pointing yyin at a new input file.
     270                 :            :    */
     271                 :            : #define YY_BUFFER_EOF_PENDING 2
     272                 :            : 
     273                 :            :   };
     274                 :            : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
     275                 :            : 
     276                 :            : /* We provide macros for accessing buffer states in case in the
     277                 :            :  * future we want to put the buffer states in a more general
     278                 :            :  * "scanner state".
     279                 :            :  *
     280                 :            :  * Returns the top of the stack, or NULL.
     281                 :            :  */
     282                 :            : #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
     283                 :            :                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
     284                 :            :                           : NULL)
     285                 :            : 
     286                 :            : /* Same as previous macro, but useful when we know that the buffer stack is not
     287                 :            :  * NULL or when we need an lvalue. For internal use only.
     288                 :            :  */
     289                 :            : #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
     290                 :            : 
     291                 :            : void _gst_parse_yyrestart (FILE *input_file ,yyscan_t yyscanner );
     292                 :            : void _gst_parse_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
     293                 :            : YY_BUFFER_STATE _gst_parse_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
     294                 :            : void _gst_parse_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
     295                 :            : void _gst_parse_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
     296                 :            : void _gst_parse_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
     297                 :            : void _gst_parse_yypop_buffer_state (yyscan_t yyscanner );
     298                 :            : 
     299                 :            : static void _gst_parse_yyensure_buffer_stack (yyscan_t yyscanner );
     300                 :            : static void _gst_parse_yy_load_buffer_state (yyscan_t yyscanner );
     301                 :            : static void _gst_parse_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
     302                 :            : 
     303                 :            : #define YY_FLUSH_BUFFER _gst_parse_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
     304                 :            : 
     305                 :            : YY_BUFFER_STATE _gst_parse_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
     306                 :            : YY_BUFFER_STATE _gst_parse_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
     307                 :            : YY_BUFFER_STATE _gst_parse_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
     308                 :            : 
     309                 :            : void *_gst_parse_yyalloc (yy_size_t ,yyscan_t yyscanner );
     310                 :            : void *_gst_parse_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
     311                 :            : void _gst_parse_yyfree (void * ,yyscan_t yyscanner );
     312                 :            : 
     313                 :            : #define yy_new_buffer _gst_parse_yy_create_buffer
     314                 :            : 
     315                 :            : #define yy_set_interactive(is_interactive) \
     316                 :            :   { \
     317                 :            :   if ( ! YY_CURRENT_BUFFER ){ \
     318                 :            :         _gst_parse_yyensure_buffer_stack (yyscanner); \
     319                 :            :     YY_CURRENT_BUFFER_LVALUE =    \
     320                 :            :             _gst_parse_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
     321                 :            :   } \
     322                 :            :   YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
     323                 :            :   }
     324                 :            : 
     325                 :            : #define yy_set_bol(at_bol) \
     326                 :            :   { \
     327                 :            :   if ( ! YY_CURRENT_BUFFER ){\
     328                 :            :         _gst_parse_yyensure_buffer_stack (yyscanner); \
     329                 :            :     YY_CURRENT_BUFFER_LVALUE =    \
     330                 :            :             _gst_parse_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
     331                 :            :   } \
     332                 :            :   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
     333                 :            :   }
     334                 :            : 
     335                 :            : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
     336                 :            : 
     337                 :            : /* Begin user sect3 */
     338                 :            : 
     339                 :            : #define _gst_parse_yywrap(n) 1
     340                 :            : #define YY_SKIP_YYWRAP
     341                 :            : 
     342                 :            : typedef unsigned char YY_CHAR;
     343                 :            : 
     344                 :            : typedef int yy_state_type;
     345                 :            : 
     346                 :            : #define yytext_ptr yytext_r
     347                 :            : 
     348                 :            : static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
     349                 :            : static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
     350                 :            : static int yy_get_next_buffer (yyscan_t yyscanner );
     351                 :            : static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
     352                 :            : 
     353                 :            : /* Done after the current pattern has been matched and before the
     354                 :            :  * corresponding action - sets up yytext.
     355                 :            :  */
     356                 :            : #define YY_DO_BEFORE_ACTION \
     357                 :            :   yyg->yytext_ptr = yy_bp; \
     358                 :            :   yyleng = (size_t) (yy_cp - yy_bp); \
     359                 :            :   yyg->yy_hold_char = *yy_cp; \
     360                 :            :   *yy_cp = '\0'; \
     361                 :            :   yyg->yy_c_buf_p = yy_cp;
     362                 :            : 
     363                 :            : #define YY_NUM_RULES 11
     364                 :            : #define YY_END_OF_BUFFER 12
     365                 :            : /* This struct is not used in this scanner,
     366                 :            :    but its presence is necessary. */
     367                 :            : struct yy_trans_info
     368                 :            :   {
     369                 :            :   flex_int32_t yy_verify;
     370                 :            :   flex_int32_t yy_nxt;
     371                 :            :   };
     372                 :            : static yyconst flex_int16_t yy_accept[177] =
     373                 :            :     {   0,
     374                 :            :         0,    0,    0,    0,   12,   10,    9,    9,    6,   10,
     375                 :            :         8,    8,   10,    5,    5,    8,   11,    9,    0,    0,
     376                 :            :         0,    2,    7,    7,    7,    7,    0,    5,    0,    5,
     377                 :            :         3,    5,    0,    0,    2,    7,    0,    7,    7,    7,
     378                 :            :         0,    7,    7,    7,    0,    3,    0,    0,    4,    3,
     379                 :            :         0,    1,    0,    1,    1,    1,    0,    7,    0,    7,
     380                 :            :         7,    7,    0,    7,    7,    7,    3,    3,    3,    3,
     381                 :            :         7,    1,    0,    1,    1,    0,    1,    1,    1,    0,
     382                 :            :         0,    6,    0,    0,    0,    0,    7,    7,    7,    7,
     383                 :            :         7,    7,    1,    0,    1,    1,    0,    1,    1,    0,
     384                 :            : 
     385                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    6,    0,
     386                 :            :         0,    0,    7,    0,    7,    7,    0,    7,    7,    7,
     387                 :            :         1,    1,    0,    0,    0,    7,    0,    7,    7,    0,
     388                 :            :         7,    7,    0,    0,    7,    7,    0,    0,    0,    0,
     389                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     390                 :            :         0,    0,    0,    0,    6,    0,    0,    0,    0,    0,
     391                 :            :         0,    0,    0,    0,    0,    6,    0,    0,    0,    0,
     392                 :            :         0,    0,    0,    0,    0,    0
     393                 :            :     } ;
     394                 :            : 
     395                 :            : static yyconst flex_int32_t yy_ec[256] =
     396                 :            :     {   0,
     397                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
     398                 :            :         2,    2,    2,    1,    1,    1,    1,    1,    1,    1,
     399                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     400                 :            :         1,    2,    4,    5,    1,    1,    6,    1,    7,    8,
     401                 :            :         9,    1,   10,   11,   12,   13,   14,   12,   12,   12,
     402                 :            :        12,   12,   12,   12,   12,   12,   12,   15,   16,    1,
     403                 :            :        17,    1,    1,    1,   18,   18,   18,   18,   18,   18,
     404                 :            :        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
     405                 :            :        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
     406                 :            :         1,   19,    1,    1,   20,    1,   18,   18,   18,   21,
     407                 :            : 
     408                 :            :        21,   21,   18,   18,   21,   18,   18,   18,   18,   21,
     409                 :            :        18,   18,   18,   21,   18,   21,   18,   18,   18,   18,
     410                 :            :        18,   18,   22,    1,   22,    1,    1,    1,    1,    1,
     411                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     412                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     413                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     414                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     415                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     416                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     417                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     418                 :            : 
     419                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     420                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     421                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     422                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     423                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     424                 :            :         1,    1,    1,    1,    1
     425                 :            :     } ;
     426                 :            : 
     427                 :            : static yyconst flex_int32_t yy_meta[23] =
     428                 :            :     {   0,
     429                 :            :         1,    2,    3,    1,    1,    4,    1,    1,    1,    5,
     430                 :            :         5,    6,    7,    8,    9,    1,   10,    6,    1,    4,
     431                 :            :         6,    1
     432                 :            :     } ;
     433                 :            : 
     434                 :            : static yyconst flex_int16_t yy_base[216] =
     435                 :            :     {   0,
     436                 :            :         0,    0,    0,    0,  203, 1331,   21,   23,   25,  180,
     437                 :            :      1331,   15,   25,   43,  167,  152, 1331,   32,   35,  149,
     438                 :            :        43,    0,  126,   63,   81,   38,   99,  115,  125,    0,
     439                 :            :       131,  151,  167,   55,    0,  185,   66,  105,  203,  221,
     440                 :            :        24,  239,   95,   40,   67,  257,   89,   78, 1331,  273,
     441                 :            :        81,   75,  293,  311,  329,   70,  348, 1331,   74,  369,
     442                 :            :       387,  405,   32,  423,  441,  459,    0,    0,    0,   60,
     443                 :            :        85,  477,   86,   94,  495,   80,  104,  106,   96,  108,
     444                 :            :       109, 1331,  513,    0,  108,  531,  117,  112,   33,  549,
     445                 :            :       567,  136, 1331,  132,  585,  154,  128,  603,  156,  159,
     446                 :            : 
     447                 :            :       164,  621,  639,  659,  158,   33,  171,  179,  181,    0,
     448                 :            :         0,    0,  677,  143,  176,  695,  177,  207,   22,  148,
     449                 :            :       193,  194,    0,  213,  199, 1331,  202,  713,  216,  218,
     450                 :            :       731,  228,  227,  750,  224,  225,  772,  243,  245,  793,
     451                 :            :         0,  811,  250,  255,  829,    0,  847,  269,  285,  865,
     452                 :            :       883,  903,  287,  289,  297,    0,    0,    0,  299,  307,
     453                 :            :       921,  939,  959,  317,  321,  322,    0,    0,    0,    0,
     454                 :            :       373,    0,  377,    0,    0, 1331,  978,  987,  993,  998,
     455                 :            :      1003, 1012, 1022, 1032, 1041, 1047, 1056, 1066, 1076, 1086,
     456                 :            :      1096, 1106, 1116, 1126, 1133, 1142, 1152, 1162, 1172, 1182,
     457                 :            : 
     458                 :            :      1192, 1201, 1207, 1217, 1227, 1237, 1242, 1250, 1260, 1270,
     459                 :            :      1280, 1290, 1300, 1310, 1320
     460                 :            :     } ;
     461                 :            : 
     462                 :            : static yyconst flex_int16_t yy_def[216] =
     463                 :            :     {   0,
     464                 :            :       176,    1,  177,  177,  176,  176,  176,  176,  178,  176,
     465                 :            :       176,  176,  179,  176,   14,  176,  176,  176,  178,  180,
     466                 :            :       179,  181,  179,  182,  183,  184,  176,  185,  186,   14,
     467                 :            :       176,  185,  187,  176,  181,  182,  188,  179,  189,  183,
     468                 :            :       190,  191,  179,  184,  176,  176,  176,  176,  176,  176,
     469                 :            :       176,  187,  187,  192,  193,  194,  176,  176,  188,  182,
     470                 :            :       182,  189,  190,  183,  183,  191,  195,  195,   50,  195,
     471                 :            :       196,  192,  197,  198,  193,  199,  200,  187,  194,   57,
     472                 :            :        57,  176,  201,   57,  202,  203,  188,  190,  196,  204,
     473                 :            :       205,  206,  176,  197,  192,  198,  199,  193,  200,   57,
     474                 :            : 
     475                 :            :        57,  201,   57,  203,  202,  207,   57,   57,   57,  102,
     476                 :            :       103,  104,  204,  208,  209,  205,  210,  211,  196,  206,
     477                 :            :       197,  199,  103,  103,  176,  176,  208,  204,  209,  210,
     478                 :            :       205,  211,   57,  176,  208,  210,  176,  134,  134,  212,
     479                 :            :       134,  213,  137,  137,  214,  137,  215,  134,  134,  212,
     480                 :            :       134,  213,  134,  134,  134,  150,  151,  152,  137,  137,
     481                 :            :       214,  137,  215,  137,  137,  137,  161,  162,  163,  151,
     482                 :            :       151,  162,  162,  134,  137,    0,  176,  176,  176,  176,
     483                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     484                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     485                 :            : 
     486                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     487                 :            :       176,  176,  176,  176,  176
     488                 :            :     } ;
     489                 :            : 
     490                 :            : static yyconst flex_int16_t yy_nxt[1354] =
     491                 :            :     {   0,
     492                 :            :         6,    7,    8,    9,   10,    6,    6,   11,   11,    6,
     493                 :            :        11,    6,   12,   13,    6,   11,   11,   14,    6,   10,
     494                 :            :        15,   16,   18,   18,   18,   18,   19,   19,   21,   24,
     495                 :            :        58,   25,   22,   18,   18,   22,   19,   19,   88,   23,
     496                 :            :        92,   23,   63,   26,   27,   27,  125,   24,   28,   25,
     497                 :            :        63,   92,   29,   29,   30,   31,   44,   32,   44,   33,
     498                 :            :        30,   26,   28,   30,   37,   37,   57,   38,   48,   48,
     499                 :            :        58,   52,   57,   51,   49,   57,  176,  176,   87,   48,
     500                 :            :        48,   39,   41,   41,   59,   49,   93,   38,   79,   90,
     501                 :            :        93,   91,   59,   56,   71,   72,   73,   52,   97,   42,
     502                 :            : 
     503                 :            :        27,   27,   51,   92,   94,   75,   76,  176,  176,  105,
     504                 :            :       105,   45,   96,   26,   79,   33,   27,   27,   58,   80,
     505                 :            :        80,   58,   99,   26,   56,   80,   80,   46,   80,   80,
     506                 :            :        63,   33,   48,   48,  122,   59,  121,   89,   49,   47,
     507                 :            :        29,   29,   29,   29,   26,   47,   97,  126,   50,   89,
     508                 :            :        94,   50,   27,   27,  120,   72,   73,   75,   76,  105,
     509                 :            :       105,  127,   34,   46,   51,   21,  120,   33,   53,   53,
     510                 :            :        80,   54,   96,   55,   99,   80,   80,  113,  114,   80,
     511                 :            :        21,   80,   80,  126,   80,   56,   37,   37,   80,   38,
     512                 :            :        80,   80,   80,   21,  129,  130,   80,   93,   80,   80,
     513                 :            : 
     514                 :            :        93,   80,  176,   39,   36,   37,  135,   61,  116,  117,
     515                 :            :       134,   94,   97,  176,   81,   81,  134,  113,  114,  134,
     516                 :            :       127,   62,   41,   41,  136,  132,  133,   38,  126,  116,
     517                 :            :       117,  126,  176,  176,  129,  176,  130,  176,  137,   42,
     518                 :            :        40,   41,  127,  130,  137,   65,  132,  137,  176,  176,
     519                 :            :       176,  176,  176,  176,  138,  176,  138,   66,   48,   48,
     520                 :            :       138,  143,  138,  138,   49,  138,  143,  143,  176,  176,
     521                 :            :       143,  176,  143,  176,   67,  143,  176,   67,   68,  176,
     522                 :            :       138,  176,   29,   29,   69,   29,  138,   70,  176,  138,
     523                 :            :        69,  176,   68,   69,   53,   53,  138,   54,  138,   55,
     524                 :            : 
     525                 :            :       138,  176,  138,  176,  138,  138,  138,  138,  138,  138,
     526                 :            :       143,   56,   73,   73,  138,   52,  143,  138,  143,  143,
     527                 :            :       176,  176,  176,  176,  143,  176,  176,  143,  143,   74,
     528                 :            :        76,   76,  143,  143,  143,   52,  176,  143,  143,  143,
     529                 :            :       176,  143,  143,  176,  176,  176,  176,   77,   80,   81,
     530                 :            :        81,   82,   80,   80,   80,   80,   80,   80,   83,   84,
     531                 :            :        80,   80,   80,   85,   80,   84,   86,   80,   84,   80,
     532                 :            :        37,   37,  176,   38,  139,  139,  176,  176,  144,  144,
     533                 :            :       176,  176,  176,  176,  176,  176,  174,   39,   37,   37,
     534                 :            :       175,   38,  176,  176,  176,  176,  176,  176,  176,  176,
     535                 :            : 
     536                 :            :       176,  176,  176,  176,  176,   39,   36,   37,  176,   61,
     537                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     538                 :            :       176,  176,  176,   62,   41,   41,  176,  176,  176,   38,
     539                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     540                 :            :       176,   42,   41,   41,  176,  176,  176,   38,  176,  176,
     541                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,   42,
     542                 :            :        40,   41,  176,  176,  176,   65,  176,  176,  176,  176,
     543                 :            :       176,  176,  176,  176,  176,  176,  176,   66,   73,   73,
     544                 :            :       176,   52,  176,  176,  176,  176,  176,  176,  176,  176,
     545                 :            :       176,  176,  176,  176,  176,   74,   76,   76,  176,  176,
     546                 :            : 
     547                 :            :       176,   52,  176,  176,  176,  176,  176,  176,  176,  176,
     548                 :            :       176,  176,  176,   77,  101,  101,   82,  176,  176,  176,
     549                 :            :       176,  176,  176,  102,  176,  176,  176,  176,  103,  176,
     550                 :            :       176,  104,  108,   81,  109,  176,  176,  176,  176,  176,
     551                 :            :       176,  110,  176,  176,  176,  176,  111,  176,  176,  112,
     552                 :            :       114,  114,  176,   89,  176,  176,  176,  176,  176,  176,
     553                 :            :       176,  176,  176,  176,  176,  176,  176,  115,  117,  117,
     554                 :            :       176,  176,  176,   89,  176,  176,  176,  176,  176,  176,
     555                 :            :       176,  176,  176,  176,  176,  118,   73,   73,  176,   52,
     556                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     557                 :            : 
     558                 :            :       176,  176,  176,   74,   76,   76,  176,  176,  176,   52,
     559                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     560                 :            :       176,   77,  101,  101,   82,  176,  176,  176,  176,  176,
     561                 :            :       176,  102,  176,  176,  176,  176,  103,  176,  176,  104,
     562                 :            :       123,  123,  176,  176,  176,  176,  176,  176,  176,  176,
     563                 :            :       124,  176,  176,  176,  176,  176,  124,  176,  176,  124,
     564                 :            :       108,   81,  109,  176,  176,  176,  176,  176,  176,  110,
     565                 :            :       176,  176,  176,  176,  111,  176,  176,  112,  114,  114,
     566                 :            :       176,   89,  176,  176,  176,  176,  176,  176,  176,  176,
     567                 :            :       176,  176,  176,  176,  176,  115,  117,  117,  176,  176,
     568                 :            : 
     569                 :            :       176,   89,  176,  176,  176,  176,  176,  176,  176,  176,
     570                 :            :       176,  176,  176,  118,  114,  114,  176,   89,  176,  176,
     571                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     572                 :            :       176,  115,  117,  117,  176,  176,  176,   89,  176,  176,
     573                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  118,
     574                 :            :       138,  139,  139,   82,  138,  138,  138,  138,  138,  138,
     575                 :            :       140,  141,  138,  138,  138,   85,  138,  141,  142,  138,
     576                 :            :       141,  138,  143,  144,  144,   82,  143,  143,  143,  143,
     577                 :            :       143,  143,  145,  146,  143,  143,  143,   85,  143,  146,
     578                 :            :       147,  143,  146,  143,  149,  149,   82,  176,  176,  176,
     579                 :            : 
     580                 :            :       176,  176,  176,  150,  176,  176,  176,  176,  151,  176,
     581                 :            :       176,  152,  154,  139,  155,  176,  176,  176,  176,  176,
     582                 :            :       176,  156,  176,  176,  176,  176,  157,  176,  176,  158,
     583                 :            :       160,  160,   82,  176,  176,  176,  176,  176,  176,  161,
     584                 :            :       176,  176,  176,  176,  162,  176,  176,  163,  165,  144,
     585                 :            :       166,  176,  176,  176,  176,  176,  176,  167,  176,  176,
     586                 :            :       176,  176,  168,  176,  176,  169,  149,  149,   82,  176,
     587                 :            :       176,  176,  176,  176,  176,  150,  176,  176,  176,  176,
     588                 :            :       151,  176,  176,  152,  170,  170,  176,  176,  176,  176,
     589                 :            :       176,  176,  176,  176,  171,  176,  176,  176,  176,  176,
     590                 :            : 
     591                 :            :       171,  176,  176,  171,  154,  139,  155,  176,  176,  176,
     592                 :            :       176,  176,  176,  156,  176,  176,  176,  176,  157,  176,
     593                 :            :       176,  158,  160,  160,   82,  176,  176,  176,  176,  176,
     594                 :            :       176,  161,  176,  176,  176,  176,  162,  176,  176,  163,
     595                 :            :       172,  172,  176,  176,  176,  176,  176,  176,  176,  176,
     596                 :            :       173,  176,  176,  176,  176,  176,  173,  176,  176,  173,
     597                 :            :       165,  144,  166,  176,  176,  176,  176,  176,  176,  167,
     598                 :            :       176,  176,  176,  176,  168,  176,  176,  169,   17,   17,
     599                 :            :        17,   17,   17,   17,   17,   17,   17,   17,   20,   20,
     600                 :            :       176,  176,   20,   23,  176,  176,   23,   23,   23,   23,
     601                 :            : 
     602                 :            :        23,   23,   23,   20,  176,   20,   35,  176,   35,  176,
     603                 :            :       176,   35,   36,   36,   36,   36,   36,   36,   36,   36,
     604                 :            :        36,   36,   40,   40,   40,   40,   40,   40,   40,   40,
     605                 :            :        40,   40,   43,   43,  176,   43,   43,   43,   43,   43,
     606                 :            :        43,   43,   28,   28,   28,  176,   28,   28,  176,   28,
     607                 :            :        28,   29,   29,   29,  176,   29,   52,   52,   52,   52,
     608                 :            :        52,   52,   52,   52,   52,   52,   37,   37,   37,   37,
     609                 :            :        37,   37,   37,   37,   37,   37,   60,   60,   60,   60,
     610                 :            :        60,   60,   60,   60,   60,   60,   41,   41,   41,   41,
     611                 :            :        41,   41,   41,   41,   41,   41,   64,   64,   64,   64,
     612                 :            : 
     613                 :            :        64,   64,   64,   64,   64,   64,   72,   72,   72,   72,
     614                 :            :        72,   72,   72,   72,   72,   72,   75,   75,   75,   75,
     615                 :            :        75,   75,   75,   75,   75,   75,   78,   78,  176,   78,
     616                 :            :        78,   78,   78,   78,   78,   78,   68,  176,   68,  176,
     617                 :            :       176,   68,   89,  176,  176,   89,   89,   89,   89,   89,
     618                 :            :        89,   89,   73,   73,   73,   73,   73,   73,   73,   73,
     619                 :            :        73,   73,   95,   95,   95,   95,   95,   95,   95,   95,
     620                 :            :        95,   95,   76,   76,   76,   76,   76,   76,   76,   76,
     621                 :            :        76,   76,   98,   98,   98,   98,   98,   98,   98,   98,
     622                 :            :        98,   98,  100,  100,  100,  100,  100,  100,  100,  100,
     623                 :            : 
     624                 :            :       100,  100,  106,  106,  176,  176,  106,  107,  107,  107,
     625                 :            :       107,  107,  107,  107,  107,  107,  107,  113,  113,  113,
     626                 :            :       113,  113,  113,  113,  113,  113,  113,  116,  116,  116,
     627                 :            :       116,  116,  116,  116,  116,  116,  116,  119,  119,  176,
     628                 :            :       119,  119,  119,  119,  119,  119,  119,  106,  176,  106,
     629                 :            :       114,  114,  114,  114,  114,  114,  114,  114,  114,  114,
     630                 :            :       128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
     631                 :            :       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
     632                 :            :       131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
     633                 :            :       148,  148,  148,  148,  148,  148,  148,  148,  148,  148,
     634                 :            : 
     635                 :            :       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
     636                 :            :       159,  159,  159,  159,  159,  159,  159,  159,  159,  159,
     637                 :            :       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
     638                 :            :         5,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     639                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     640                 :            :       176,  176,  176
     641                 :            :     } ;
     642                 :            : 
     643                 :            : static yyconst flex_int16_t yy_chk[1354] =
     644                 :            :     {   0,
     645                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     646                 :            :         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     647                 :            :         1,    1,    7,    7,    8,    8,    9,    9,   12,   13,
     648                 :            :        41,   13,   12,   18,   18,   12,   19,   19,   63,   26,
     649                 :            :       119,   44,   41,   13,   14,   14,  106,   21,   14,   21,
     650                 :            :        63,   89,   14,   14,   14,   14,   26,   14,   44,   14,
     651                 :            :        14,   21,   14,   14,   24,   24,   34,   24,   45,   45,
     652                 :            :        37,   56,   34,   70,   45,   34,   52,   52,   59,   48,
     653                 :            :        48,   24,   25,   25,   37,   48,   76,   25,   56,   71,
     654                 :            :        73,   71,   59,   52,   51,   74,   74,   79,   76,   25,
     655                 :            : 
     656                 :            :        27,   27,   47,   71,   73,   77,   77,   78,   78,   85,
     657                 :            :        85,   27,   74,   43,   79,   27,   28,   28,   88,   80,
     658                 :            :        81,   87,   77,   38,   78,   80,   81,   28,   80,   81,
     659                 :            :        88,   28,   31,   31,   97,   87,   94,   92,   31,   29,
     660                 :            :        31,   31,   31,   31,   23,   31,   97,  114,   31,  120,
     661                 :            :        94,   31,   32,   32,   92,   96,   96,   99,   99,  105,
     662                 :            :       105,  114,   20,   32,   32,   16,  120,   32,   33,   33,
     663                 :            :       100,   33,   96,   33,   99,  101,  100,  115,  115,  100,
     664                 :            :        15,  101,  107,  117,  101,   33,   36,   36,  107,   36,
     665                 :            :       108,  107,  109,   10,  115,  117,  108,  121,  109,  108,
     666                 :            : 
     667                 :            :       122,  109,    5,   36,   39,   39,  127,   39,  118,  118,
     668                 :            :       125,  121,  122,    0,  124,  124,  125,  129,  129,  125,
     669                 :            :       127,   39,   40,   40,  130,  118,  124,   40,  135,  132,
     670                 :            :       132,  136,    0,    0,  129,    0,  130,    0,  133,   40,
     671                 :            :        42,   42,  135,  136,  133,   42,  132,  133,    0,    0,
     672                 :            :         0,    0,    0,    0,  138,    0,  139,   42,   46,   46,
     673                 :            :       138,  143,  139,  138,   46,  139,  144,  143,    0,    0,
     674                 :            :       143,    0,  144,    0,   46,  144,    0,   46,   50,    0,
     675                 :            :       148,    0,   50,   50,   50,   50,  148,   50,    0,  148,
     676                 :            :        50,    0,   50,   50,   53,   53,  149,   53,  153,   53,
     677                 :            : 
     678                 :            :       154,    0,  149,    0,  153,  149,  154,  153,  155,  154,
     679                 :            :       159,   53,   54,   54,  155,   54,  159,  155,  160,  159,
     680                 :            :         0,    0,    0,    0,  160,    0,    0,  160,  164,   54,
     681                 :            :        55,   55,  165,  166,  164,   55,    0,  164,  165,  166,
     682                 :            :         0,  165,  166,    0,    0,    0,    0,   55,   57,   57,
     683                 :            :        57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
     684                 :            :        57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
     685                 :            :        60,   60,    0,   60,  171,  171,    0,    0,  173,  173,
     686                 :            :         0,    0,    0,    0,    0,    0,  171,   60,   61,   61,
     687                 :            :       173,   61,    0,    0,    0,    0,    0,    0,    0,    0,
     688                 :            : 
     689                 :            :         0,    0,    0,    0,    0,   61,   62,   62,    0,   62,
     690                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     691                 :            :         0,    0,    0,   62,   64,   64,    0,    0,    0,   64,
     692                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     693                 :            :         0,   64,   65,   65,    0,    0,    0,   65,    0,    0,
     694                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,   65,
     695                 :            :        66,   66,    0,    0,    0,   66,    0,    0,    0,    0,
     696                 :            :         0,    0,    0,    0,    0,    0,    0,   66,   72,   72,
     697                 :            :         0,   72,    0,    0,    0,    0,    0,    0,    0,    0,
     698                 :            :         0,    0,    0,    0,    0,   72,   75,   75,    0,    0,
     699                 :            : 
     700                 :            :         0,   75,    0,    0,    0,    0,    0,    0,    0,    0,
     701                 :            :         0,    0,    0,   75,   83,   83,   83,    0,    0,    0,
     702                 :            :         0,    0,    0,   83,    0,    0,    0,    0,   83,    0,
     703                 :            :         0,   83,   86,   86,   86,    0,    0,    0,    0,    0,
     704                 :            :         0,   86,    0,    0,    0,    0,   86,    0,    0,   86,
     705                 :            :        90,   90,    0,   90,    0,    0,    0,    0,    0,    0,
     706                 :            :         0,    0,    0,    0,    0,    0,    0,   90,   91,   91,
     707                 :            :         0,    0,    0,   91,    0,    0,    0,    0,    0,    0,
     708                 :            :         0,    0,    0,    0,    0,   91,   95,   95,    0,   95,
     709                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     710                 :            : 
     711                 :            :         0,    0,    0,   95,   98,   98,    0,    0,    0,   98,
     712                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     713                 :            :         0,   98,  102,  102,  102,    0,    0,    0,    0,    0,
     714                 :            :         0,  102,    0,    0,    0,    0,  102,    0,    0,  102,
     715                 :            :       103,  103,    0,    0,    0,    0,    0,    0,    0,    0,
     716                 :            :       103,    0,    0,    0,    0,    0,  103,    0,    0,  103,
     717                 :            :       104,  104,  104,    0,    0,    0,    0,    0,    0,  104,
     718                 :            :         0,    0,    0,    0,  104,    0,    0,  104,  113,  113,
     719                 :            :         0,  113,    0,    0,    0,    0,    0,    0,    0,    0,
     720                 :            :         0,    0,    0,    0,    0,  113,  116,  116,    0,    0,
     721                 :            : 
     722                 :            :         0,  116,    0,    0,    0,    0,    0,    0,    0,    0,
     723                 :            :         0,    0,    0,  116,  128,  128,    0,  128,    0,    0,
     724                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     725                 :            :         0,  128,  131,  131,    0,    0,    0,  131,    0,    0,
     726                 :            :         0,    0,    0,    0,    0,    0,    0,    0,    0,  131,
     727                 :            :       134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
     728                 :            :       134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
     729                 :            :       134,  134,  137,  137,  137,  137,  137,  137,  137,  137,
     730                 :            :       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
     731                 :            :       137,  137,  137,  137,  140,  140,  140,    0,    0,    0,
     732                 :            : 
     733                 :            :         0,    0,    0,  140,    0,    0,    0,    0,  140,    0,
     734                 :            :         0,  140,  142,  142,  142,    0,    0,    0,    0,    0,
     735                 :            :         0,  142,    0,    0,    0,    0,  142,    0,    0,  142,
     736                 :            :       145,  145,  145,    0,    0,    0,    0,    0,    0,  145,
     737                 :            :         0,    0,    0,    0,  145,    0,    0,  145,  147,  147,
     738                 :            :       147,    0,    0,    0,    0,    0,    0,  147,    0,    0,
     739                 :            :         0,    0,  147,    0,    0,  147,  150,  150,  150,    0,
     740                 :            :         0,    0,    0,    0,    0,  150,    0,    0,    0,    0,
     741                 :            :       150,    0,    0,  150,  151,  151,    0,    0,    0,    0,
     742                 :            :         0,    0,    0,    0,  151,    0,    0,    0,    0,    0,
     743                 :            : 
     744                 :            :       151,    0,    0,  151,  152,  152,  152,    0,    0,    0,
     745                 :            :         0,    0,    0,  152,    0,    0,    0,    0,  152,    0,
     746                 :            :         0,  152,  161,  161,  161,    0,    0,    0,    0,    0,
     747                 :            :         0,  161,    0,    0,    0,    0,  161,    0,    0,  161,
     748                 :            :       162,  162,    0,    0,    0,    0,    0,    0,    0,    0,
     749                 :            :       162,    0,    0,    0,    0,    0,  162,    0,    0,  162,
     750                 :            :       163,  163,  163,    0,    0,    0,    0,    0,    0,  163,
     751                 :            :         0,    0,    0,    0,  163,    0,    0,  163,  177,  177,
     752                 :            :       177,  177,  177,  177,  177,  177,  177,  177,  178,  178,
     753                 :            :         0,    0,  178,  179,    0,    0,  179,  179,  179,  179,
     754                 :            : 
     755                 :            :       179,  179,  179,  180,    0,  180,  181,    0,  181,    0,
     756                 :            :         0,  181,  182,  182,  182,  182,  182,  182,  182,  182,
     757                 :            :       182,  182,  183,  183,  183,  183,  183,  183,  183,  183,
     758                 :            :       183,  183,  184,  184,    0,  184,  184,  184,  184,  184,
     759                 :            :       184,  184,  185,  185,  185,    0,  185,  185,    0,  185,
     760                 :            :       185,  186,  186,  186,    0,  186,  187,  187,  187,  187,
     761                 :            :       187,  187,  187,  187,  187,  187,  188,  188,  188,  188,
     762                 :            :       188,  188,  188,  188,  188,  188,  189,  189,  189,  189,
     763                 :            :       189,  189,  189,  189,  189,  189,  190,  190,  190,  190,
     764                 :            :       190,  190,  190,  190,  190,  190,  191,  191,  191,  191,
     765                 :            : 
     766                 :            :       191,  191,  191,  191,  191,  191,  192,  192,  192,  192,
     767                 :            :       192,  192,  192,  192,  192,  192,  193,  193,  193,  193,
     768                 :            :       193,  193,  193,  193,  193,  193,  194,  194,    0,  194,
     769                 :            :       194,  194,  194,  194,  194,  194,  195,    0,  195,    0,
     770                 :            :         0,  195,  196,    0,    0,  196,  196,  196,  196,  196,
     771                 :            :       196,  196,  197,  197,  197,  197,  197,  197,  197,  197,
     772                 :            :       197,  197,  198,  198,  198,  198,  198,  198,  198,  198,
     773                 :            :       198,  198,  199,  199,  199,  199,  199,  199,  199,  199,
     774                 :            :       199,  199,  200,  200,  200,  200,  200,  200,  200,  200,
     775                 :            :       200,  200,  201,  201,  201,  201,  201,  201,  201,  201,
     776                 :            : 
     777                 :            :       201,  201,  202,  202,    0,    0,  202,  203,  203,  203,
     778                 :            :       203,  203,  203,  203,  203,  203,  203,  204,  204,  204,
     779                 :            :       204,  204,  204,  204,  204,  204,  204,  205,  205,  205,
     780                 :            :       205,  205,  205,  205,  205,  205,  205,  206,  206,    0,
     781                 :            :       206,  206,  206,  206,  206,  206,  206,  207,    0,  207,
     782                 :            :       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
     783                 :            :       209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
     784                 :            :       210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
     785                 :            :       211,  211,  211,  211,  211,  211,  211,  211,  211,  211,
     786                 :            :       212,  212,  212,  212,  212,  212,  212,  212,  212,  212,
     787                 :            : 
     788                 :            :       213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
     789                 :            :       214,  214,  214,  214,  214,  214,  214,  214,  214,  214,
     790                 :            :       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
     791                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     792                 :            :       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
     793                 :            :       176,  176,  176
     794                 :            :     } ;
     795                 :            : 
     796                 :            : /* The intent behind this definition is that it'll catch
     797                 :            :  * any uses of REJECT which flex missed.
     798                 :            :  */
     799                 :            : #define REJECT reject_used_but_not_detected
     800                 :            : #define yymore() yymore_used_but_not_detected
     801                 :            : #define YY_MORE_ADJ 0
     802                 :            : #define YY_RESTORE_YY_MORE_OFFSET
     803                 :            : #line 1 "parse.l"
     804                 :            : #line 2 "parse.l"
     805                 :            : #include "../gst_private.h"
     806                 :            : 
     807                 :            : #include <math.h>
     808                 :            : #include <string.h>
     809                 :            : 
     810                 :            : #include <glib/gprintf.h>
     811                 :            : 
     812                 :            : #include "types.h"
     813                 :            : #include "../gstinfo.h"
     814                 :            : #include "../gsturi.h"
     815                 :            : #include "grammar.tab.h"
     816                 :            : 
     817                 :            : /* Override the default ECHO so as to avoid fortify warnings. Ignore the
     818                 :            :    embedded-NUL case for now. We know yytext is NUL-terminated. */
     819                 :            : #define ECHO g_fprintf(yyout, "%s", yytext)
     820                 :            : 
     821                 :            : #ifdef G_HAVE_ISO_VARARGS
     822                 :            : #define PRINT(...) GST_CAT_DEBUG (GST_CAT_PIPELINE, "flex: " __VA_ARGS__)
     823                 :            : #elif defined(G_HAVE_GNUC_VARARGS)
     824                 :            : #define PRINT(args...) GST_CAT_DEBUG (GST_CAT_PIPELINE, "flex: " args)
     825                 :            : #else
     826                 :            : static inline void
     827                 :            : PRINT (const char *format, ...)
     828                 :            : {
     829                 :            :   va_list varargs;
     830                 :            : 
     831                 :            :   va_start (varargs, format);
     832                 :            :   GST_CAT_LEVEL_LOG_valist (GST_CAT_PIPELINE, GST_LEVEL_DEBUG, NULL,
     833                 :            :     format, varargs);
     834                 :            :   va_end (varargs);
     835                 :            : }
     836                 :            : #endif
     837                 :            : 
     838                 :            : /* we must do this here, because nearly everything matches a {_string} */ 
     839                 :            : /* get pad/element references and stuff with dots right */
     840                 :            : /* links */
     841                 :            : 
     842                 :            : #define YY_NO_INPUT 1
     843                 :            : #line 841 "lex._gst_parse_yy.c"
     844                 :            : 
     845                 :            : #define INITIAL 0
     846                 :            : #define value 1
     847                 :            : 
     848                 :            : #ifndef YY_NO_UNISTD_H
     849                 :            : /* Special case for "unistd.h", since it is non-ANSI. We include it way
     850                 :            :  * down here because we want the user's section 1 to have been scanned first.
     851                 :            :  * The user has a chance to override it with an option.
     852                 :            :  */
     853                 :            : #include <unistd.h>
     854                 :            : #endif
     855                 :            : 
     856                 :            : #ifndef YY_EXTRA_TYPE
     857                 :            : #define YY_EXTRA_TYPE void *
     858                 :            : #endif
     859                 :            : 
     860                 :            : /* Holds the entire state of the reentrant scanner. */
     861                 :            : struct yyguts_t
     862                 :            :     {
     863                 :            : 
     864                 :            :     /* User-defined. Not touched by flex. */
     865                 :            :     YY_EXTRA_TYPE yyextra_r;
     866                 :            : 
     867                 :            :     /* The rest are the same as the globals declared in the non-reentrant scanner. */
     868                 :            :     FILE *yyin_r, *yyout_r;
     869                 :            :     size_t yy_buffer_stack_top; /**< index of top of stack. */
     870                 :            :     size_t yy_buffer_stack_max; /**< capacity of stack. */
     871                 :            :     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     872                 :            :     char yy_hold_char;
     873                 :            :     int yy_n_chars;
     874                 :            :     int yyleng_r;
     875                 :            :     char *yy_c_buf_p;
     876                 :            :     int yy_init;
     877                 :            :     int yy_start;
     878                 :            :     int yy_did_buffer_switch_on_eof;
     879                 :            :     int yy_start_stack_ptr;
     880                 :            :     int yy_start_stack_depth;
     881                 :            :     int *yy_start_stack;
     882                 :            :     yy_state_type yy_last_accepting_state;
     883                 :            :     char* yy_last_accepting_cpos;
     884                 :            : 
     885                 :            :     int yylineno_r;
     886                 :            :     int yy_flex_debug_r;
     887                 :            : 
     888                 :            :     char *yytext_r;
     889                 :            :     int yy_more_flag;
     890                 :            :     int yy_more_len;
     891                 :            : 
     892                 :            :     YYSTYPE * yylval_r;
     893                 :            : 
     894                 :            :     }; /* end struct yyguts_t */
     895                 :            : 
     896                 :            : static int yy_init_globals (yyscan_t yyscanner );
     897                 :            : 
     898                 :            :     /* This must go here because YYSTYPE and YYLTYPE are included
     899                 :            :      * from bison output in section 1.*/
     900                 :            :     #    define yylval yyg->yylval_r
     901                 :            :     
     902                 :            : int _gst_parse_yylex_init (yyscan_t* scanner);
     903                 :            : 
     904                 :            : int _gst_parse_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
     905                 :            : 
     906                 :            : /* Accessor methods to globals.
     907                 :            :    These are made visible to non-reentrant scanners for convenience. */
     908                 :            : 
     909                 :            : int _gst_parse_yylex_destroy (yyscan_t yyscanner );
     910                 :            : 
     911                 :            : int _gst_parse_yyget_debug (yyscan_t yyscanner );
     912                 :            : 
     913                 :            : void _gst_parse_yyset_debug (int debug_flag ,yyscan_t yyscanner );
     914                 :            : 
     915                 :            : YY_EXTRA_TYPE _gst_parse_yyget_extra (yyscan_t yyscanner );
     916                 :            : 
     917                 :            : void _gst_parse_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
     918                 :            : 
     919                 :            : FILE *_gst_parse_yyget_in (yyscan_t yyscanner );
     920                 :            : 
     921                 :            : void _gst_parse_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
     922                 :            : 
     923                 :            : FILE *_gst_parse_yyget_out (yyscan_t yyscanner );
     924                 :            : 
     925                 :            : void _gst_parse_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
     926                 :            : 
     927                 :            : int _gst_parse_yyget_leng (yyscan_t yyscanner );
     928                 :            : 
     929                 :            : char *_gst_parse_yyget_text (yyscan_t yyscanner );
     930                 :            : 
     931                 :            : int _gst_parse_yyget_lineno (yyscan_t yyscanner );
     932                 :            : 
     933                 :            : void _gst_parse_yyset_lineno (int line_number ,yyscan_t yyscanner );
     934                 :            : 
     935                 :            : YYSTYPE * _gst_parse_yyget_lval (yyscan_t yyscanner );
     936                 :            : 
     937                 :            : void _gst_parse_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
     938                 :            : 
     939                 :            : /* Macros after this point can all be overridden by user definitions in
     940                 :            :  * section 1.
     941                 :            :  */
     942                 :            : 
     943                 :            : #ifndef YY_SKIP_YYWRAP
     944                 :            : #ifdef __cplusplus
     945                 :            : extern "C" int _gst_parse_yywrap (yyscan_t yyscanner );
     946                 :            : #else
     947                 :            : extern int _gst_parse_yywrap (yyscan_t yyscanner );
     948                 :            : #endif
     949                 :            : #endif
     950                 :            : 
     951                 :            : #ifndef yytext_ptr
     952                 :            : static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
     953                 :            : #endif
     954                 :            : 
     955                 :            : #ifdef YY_NEED_STRLEN
     956                 :            : static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
     957                 :            : #endif
     958                 :            : 
     959                 :            : #ifndef YY_NO_INPUT
     960                 :            : 
     961                 :            : #ifdef __cplusplus
     962                 :            : static int yyinput (yyscan_t yyscanner );
     963                 :            : #else
     964                 :            : static int input (yyscan_t yyscanner );
     965                 :            : #endif
     966                 :            : 
     967                 :            : #endif
     968                 :            : 
     969                 :            : /* Amount of stuff to slurp up with each read. */
     970                 :            : #ifndef YY_READ_BUF_SIZE
     971                 :            : #ifdef __ia64__
     972                 :            : /* On IA-64, the buffer size is 16k, not 8k */
     973                 :            : #define YY_READ_BUF_SIZE 16384
     974                 :            : #else
     975                 :            : #define YY_READ_BUF_SIZE 8192
     976                 :            : #endif /* __ia64__ */
     977                 :            : #endif
     978                 :            : 
     979                 :            : /* Copy whatever the last rule matched to the standard output. */
     980                 :            : #ifndef ECHO
     981                 :            : /* This used to be an fputs(), but since the string might contain NUL's,
     982                 :            :  * we now use fwrite().
     983                 :            :  */
     984                 :            : #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
     985                 :            : #endif
     986                 :            : 
     987                 :            : /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
     988                 :            :  * is returned in "result".
     989                 :            :  */
     990                 :            : #ifndef YY_INPUT
     991                 :            : #define YY_INPUT(buf,result,max_size) \
     992                 :            :   if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
     993                 :            :     { \
     994                 :            :     int c = '*'; \
     995                 :            :     size_t n; \
     996                 :            :     for ( n = 0; n < max_size && \
     997                 :            :            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
     998                 :            :       buf[n] = (char) c; \
     999                 :            :     if ( c == '\n' ) \
    1000                 :            :       buf[n++] = (char) c; \
    1001                 :            :     if ( c == EOF && ferror( yyin ) ) \
    1002                 :            :       YY_FATAL_ERROR( "input in flex scanner failed" ); \
    1003                 :            :     result = n; \
    1004                 :            :     } \
    1005                 :            :   else \
    1006                 :            :     { \
    1007                 :            :     errno=0; \
    1008                 :            :     while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
    1009                 :            :       { \
    1010                 :            :       if( errno != EINTR) \
    1011                 :            :         { \
    1012                 :            :         YY_FATAL_ERROR( "input in flex scanner failed" ); \
    1013                 :            :         break; \
    1014                 :            :         } \
    1015                 :            :       errno=0; \
    1016                 :            :       clearerr(yyin); \
    1017                 :            :       } \
    1018                 :            :     }\
    1019                 :            : \
    1020                 :            : 
    1021                 :            : #endif
    1022                 :            : 
    1023                 :            : /* No semi-colon after return; correct usage is to write "yyterminate();" -
    1024                 :            :  * we don't want an extra ';' after the "return" because that will cause
    1025                 :            :  * some compilers to complain about unreachable statements.
    1026                 :            :  */
    1027                 :            : #ifndef yyterminate
    1028                 :            : #define yyterminate() return YY_NULL
    1029                 :            : #endif
    1030                 :            : 
    1031                 :            : /* Number of entries by which start-condition stack grows. */
    1032                 :            : #ifndef YY_START_STACK_INCR
    1033                 :            : #define YY_START_STACK_INCR 25
    1034                 :            : #endif
    1035                 :            : 
    1036                 :            : /* Report a fatal error. */
    1037                 :            : #ifndef YY_FATAL_ERROR
    1038                 :            : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
    1039                 :            : #endif
    1040                 :            : 
    1041                 :            : /* end tables serialization structures and prototypes */
    1042                 :            : 
    1043                 :            : /* Default declaration of generated scanner - a define so the user can
    1044                 :            :  * easily add parameters.
    1045                 :            :  */
    1046                 :            : #ifndef YY_DECL
    1047                 :            : #define YY_DECL_IS_OURS 1
    1048                 :            : 
    1049                 :            : extern int _gst_parse_yylex \
    1050                 :            :                (YYSTYPE * yylval_param ,yyscan_t yyscanner);
    1051                 :            : 
    1052                 :            : #define YY_DECL int _gst_parse_yylex \
    1053                 :            :                (YYSTYPE * yylval_param , yyscan_t yyscanner)
    1054                 :            : #endif /* !YY_DECL */
    1055                 :            : 
    1056                 :            : /* Code executed at the beginning of each rule, after yytext and yyleng
    1057                 :            :  * have been set up.
    1058                 :            :  */
    1059                 :            : #ifndef YY_USER_ACTION
    1060                 :            : #define YY_USER_ACTION
    1061                 :            : #endif
    1062                 :            : 
    1063                 :            : /* Code executed at the end of each rule. */
    1064                 :            : #ifndef YY_BREAK
    1065                 :            : #define YY_BREAK break;
    1066                 :            : #endif
    1067                 :            : 
    1068                 :            : #define YY_RULE_SETUP \
    1069                 :            :   YY_USER_ACTION
    1070                 :        499 : 
    1071                 :            : /** The main scanner function which does all the work.
    1072                 :            :  */
    1073                 :            : YY_DECL
    1074                 :            : {
    1075                 :        499 :   register yy_state_type yy_current_state;
    1076                 :            :   register char *yy_cp, *yy_bp;
    1077                 :            :   register int yy_act;
    1078                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1079                 :            : 
    1080                 :            : #line 71 "parse.l"
    1081                 :            : 
    1082                 :        499 : 
    1083                 :            : #line 1081 "lex._gst_parse_yy.c"
    1084         [ +  + ]:        499 : 
    1085                 :            :     yylval = yylval_param;
    1086                 :         61 : 
    1087                 :            :   if ( !yyg->yy_init )
    1088                 :            :     {
    1089                 :            :     yyg->yy_init = 1;
    1090                 :            : 
    1091                 :            : #ifdef YY_USER_INIT
    1092         [ +  - ]:         61 :     YY_USER_INIT;
    1093                 :         61 : #endif
    1094                 :            : 
    1095         [ +  - ]:         61 :     if ( ! yyg->yy_start )
    1096                 :         61 :       yyg->yy_start = 1; /* first start state */
    1097                 :            : 
    1098         [ +  - ]:         61 :     if ( ! yyin )
    1099                 :         61 :       yyin = stdin;
    1100                 :            : 
    1101 [ +  - ][ -  + ]:         61 :     if ( ! yyout )
    1102                 :          0 :       yyout = stdout;
    1103                 :          0 : 
    1104                 :          0 :     if ( ! YY_CURRENT_BUFFER ) {
    1105                 :            :       _gst_parse_yyensure_buffer_stack (yyscanner);
    1106                 :            :       YY_CURRENT_BUFFER_LVALUE =
    1107                 :         61 :         _gst_parse_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    1108                 :            :     }
    1109                 :            : 
    1110                 :            :     _gst_parse_yy_load_buffer_state(yyscanner );
    1111                 :            :     }
    1112                 :        872 : 
    1113                 :            :   while ( 1 )   /* loops until end-of-file is reached */
    1114                 :            :     {
    1115                 :        872 :     yy_cp = yyg->yy_c_buf_p;
    1116                 :            : 
    1117                 :            :     /* Support of yytext. */
    1118                 :            :     *yy_cp = yyg->yy_hold_char;
    1119                 :            : 
    1120                 :        872 :     /* yy_bp points to the position in yy_ch_buf of the start of
    1121                 :            :      * the current run.
    1122                 :        872 :      */
    1123                 :            :     yy_bp = yy_cp;
    1124                 :            : 
    1125                 :            :     yy_current_state = yyg->yy_start;
    1126                 :       5694 : yy_match:
    1127         [ +  + ]:       5694 :     do
    1128                 :            :       {
    1129                 :       3570 :       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
    1130                 :       3570 :       if ( yy_accept[yy_current_state] )
    1131                 :            :         {
    1132         [ +  + ]:      10069 :         yyg->yy_last_accepting_state = yy_current_state;
    1133                 :            :         yyg->yy_last_accepting_cpos = yy_cp;
    1134                 :       4375 :         }
    1135         [ +  + ]:       4375 :       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1136                 :       1356 :         {
    1137                 :            :         yy_current_state = (int) yy_def[yy_current_state];
    1138                 :       5694 :         if ( yy_current_state >= 177 )
    1139                 :       5694 :           yy_c = yy_meta[(unsigned int) yy_c];
    1140                 :            :         }
    1141         [ +  + ]:       5694 :       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    1142                 :        872 :       ++yy_cp;
    1143                 :        872 :       }
    1144                 :            :     while ( yy_current_state != 176 );
    1145                 :            :     yy_cp = yyg->yy_last_accepting_cpos;
    1146                 :        948 :     yy_current_state = yyg->yy_last_accepting_state;
    1147                 :            : 
    1148                 :        948 : yy_find_action:
    1149                 :            :     yy_act = yy_accept[yy_current_state];
    1150                 :            : 
    1151                 :            :     YY_DO_BEFORE_ACTION;
    1152   [ +  +  +  +  :       1007 : 
          +  +  +  +  +  
          +  +  -  +  +  
                      - ]
    1153                 :            : do_action:  /* This label is used only to access EOF actions. */
    1154                 :            : 
    1155                 :            :     switch ( yy_act )
    1156                 :          8 :   { /* beginning of action switch */
    1157                 :          8 :       case 0: /* must back up */
    1158                 :          8 :       /* undo the effects of YY_DO_BEFORE_ACTION */
    1159                 :          8 :       *yy_cp = yyg->yy_hold_char;
    1160                 :            :       yy_cp = yyg->yy_last_accepting_cpos;
    1161                 :            :       yy_current_state = yyg->yy_last_accepting_state;
    1162                 :            :       goto yy_find_action;
    1163                 :            : 
    1164                 :            : case 1:
    1165                 :            : /* rule 1 can match eol */
    1166                 :            : YY_RULE_SETUP
    1167                 :            : #line 73 "parse.l"
    1168                 :            : {
    1169                 :            :     /* "=" */
    1170                 :            :     PRINT ("ASSIGNMENT: %s", yytext);
    1171                 :            :     yylval->s = gst_parse_strdup (yytext);
    1172                 :            :     BEGIN (INITIAL);
    1173                 :            :     return ASSIGNMENT;
    1174                 :            : }
    1175                 :            :   YY_BREAK
    1176                 :            : case 2:
    1177                 :            : YY_RULE_SETUP
    1178                 :            : #line 81 "parse.l"
    1179                 :            : {
    1180                 :            :     yytext++;
    1181                 :            :     PRINT ("PADREF: %s", yytext);
    1182                 :            :     yylval->s = gst_parse_strdup (yytext);
    1183                 :            :     BEGIN (INITIAL);
    1184                 :            :     return PADREF;
    1185                 :            : }
    1186                 :            :   YY_BREAK
    1187                 :            : case 3:
    1188                 :            : YY_RULE_SETUP
    1189                 :            : #line 89 "parse.l"
    1190                 :            : {
    1191                 :            :     PRINT ("REF: %s", yytext);
    1192                 :            :     yylval->s = gst_parse_strdup (yytext);
    1193                 :            :     BEGIN (INITIAL);
    1194                 :            :     return REF;
    1195                 :            : }
    1196                 :            :   YY_BREAK
    1197                 :            : case 4:
    1198                 :            : /* rule 4 can match eol */
    1199                 :            : YY_RULE_SETUP
    1200                 :            : #line 96 "parse.l"
    1201                 :            : {
    1202                 :            :     gchar *pos = yytext;
    1203                 :            :     while (!g_ascii_isspace (*pos) && (*pos != '.')) pos++;
    1204                 :            :     *pos = '\0';
    1205                 :            :     PRINT ("BINREF: %s", yytext);
    1206                 :            :     yylval->s = gst_parse_strdup (yytext);
    1207                 :            :     BEGIN (INITIAL);
    1208                 :            :     return BINREF;
    1209                 :            : }
    1210                 :            :   YY_BREAK
    1211                 :            : case 5:
    1212                 :            : YY_RULE_SETUP
    1213                 :            : #line 106 "parse.l"
    1214                 :            : {
    1215                 :            :     PRINT ("IDENTIFIER: %s", yytext);
    1216                 :            :     yylval->s = gst_parse_strdup (yytext);
    1217                 :            :     BEGIN (INITIAL);
    1218                 :            :     return IDENTIFIER;
    1219                 :            : }
    1220                 :            :   YY_BREAK
    1221                 :            : case 6:
    1222                 :            : /* rule 6 can match eol */
    1223                 :            : YY_RULE_SETUP
    1224                 :            : #line 113 "parse.l"
    1225                 :            : {
    1226                 :            :     gchar *c = yytext;
    1227                 :            :     PRINT ("LINK: %s", yytext);
    1228                 :            :     c++;
    1229                 :            :     if (*c) {
    1230                 :            :       while (g_ascii_isspace (*c)) c++;
    1231                 :            :       c = yylval->s = gst_parse_strdup (c);
    1232                 :            :       while (*c) c++;
    1233                 :            :       if (*--c != '!')
    1234                 :            :   g_assert_not_reached ();
    1235                 :            :       while (g_ascii_isspace (*--c));
    1236                 :            :       *++c = '\0';
    1237                 :            :     } else {
    1238                 :            :       yylval->s = NULL;
    1239                 :            :     }
    1240                 :            :     BEGIN (INITIAL);
    1241                 :            :     return LINK;
    1242                 :            : }
    1243                 :            :   YY_BREAK
    1244                 :            : case 7:
    1245                 :            : /* rule 7 can match eol */
    1246                 :            : YY_RULE_SETUP
    1247                 :            : #line 131 "parse.l"
    1248                 :            : {
    1249                 :            :   PRINT ("URL: %s", yytext);
    1250                 :            :   yylval->s = g_strdup (yytext);
    1251                 :            :   gst_parse_unescape (yylval->s);
    1252                 :            :   BEGIN (INITIAL);
    1253                 :            :   return PARSE_URL;
    1254                 :            : }
    1255                 :            :   YY_BREAK
    1256                 :            : case 8:
    1257                 :            : YY_RULE_SETUP
    1258                 :            : #line 139 "parse.l"
    1259                 :            : { PRINT ("OPERATOR: [%s]", yytext); return *yytext; }
    1260                 :            :   YY_BREAK
    1261                 :            : case 9:
    1262                 :            : /* rule 9 can match eol */
    1263                 :            : YY_RULE_SETUP
    1264                 :            : #line 141 "parse.l"
    1265                 :            : { PRINT ("SPACE: [%s]", yytext); }
    1266                 :            :   YY_BREAK
    1267                 :            : case 10:
    1268                 :            : YY_RULE_SETUP
    1269                 :            : #line 143 "parse.l"
    1270                 :            : {
    1271                 :            :     PRINT ("Invalid Lexer element: %s\n", yytext);
    1272                 :            :     return *yytext;
    1273                 :            : }
    1274                 :            :   YY_BREAK
    1275                 :            : case 11:
    1276                 :            : YY_RULE_SETUP
    1277                 :            : #line 148 "parse.l"
    1278                 :            : ECHO;
    1279                 :            :   YY_BREAK
    1280                 :         59 : #line 1278 "lex._gst_parse_yy.c"
    1281                 :            : case YY_STATE_EOF(INITIAL):
    1282                 :            : case YY_STATE_EOF(value):
    1283                 :            :   yyterminate();
    1284                 :            : 
    1285                 :        127 :   case YY_END_OF_BUFFER:
    1286                 :            :     {
    1287                 :            :     /* Amount of text matched not including the EOB char. */
    1288                 :        127 :     int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
    1289                 :            : 
    1290                 :            :     /* Undo the effects of YY_DO_BEFORE_ACTION. */
    1291         [ +  + ]:        127 :     *yy_cp = yyg->yy_hold_char;
    1292                 :            :     YY_RESTORE_YY_MORE_OFFSET
    1293                 :            : 
    1294                 :            :     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    1295                 :            :       {
    1296                 :            :       /* We're scanning a new file or input source.  It's
    1297                 :            :        * possible that this happened because the user
    1298                 :            :        * just pointed yyin at a new source and called
    1299                 :            :        * _gst_parse_yylex().  If so, then we have to assure
    1300                 :            :        * consistency between YY_CURRENT_BUFFER and our
    1301                 :            :        * globals.  Here is the right place to do so, because
    1302                 :         61 :        * this is the first action (other than possibly a
    1303                 :         61 :        * back-up) that will match for the new input source.
    1304                 :         61 :        */
    1305                 :            :       yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1306                 :            :       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
    1307                 :            :       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    1308                 :            :       }
    1309                 :            : 
    1310                 :            :     /* Note that here we test for yy_c_buf_p "<=" to the position
    1311                 :            :      * of the first EOB in the buffer, since yy_c_buf_p will
    1312                 :            :      * already have been incremented past the NUL character
    1313                 :            :      * (since all states make transitions on EOB to the
    1314         [ -  + ]:        127 :      * end-of-buffer state).  Contrast this with the test
    1315                 :            :      * in input().
    1316                 :            :      */
    1317                 :            :     if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
    1318                 :          0 :       { /* This was really a NUL. */
    1319                 :            :       yy_state_type yy_next_state;
    1320                 :          0 : 
    1321                 :            :       yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
    1322                 :            : 
    1323                 :            :       yy_current_state = yy_get_previous_state( yyscanner );
    1324                 :            : 
    1325                 :            :       /* Okay, we're now positioned to make the NUL
    1326                 :            :        * transition.  We couldn't have
    1327                 :            :        * yy_get_previous_state() go ahead and do it
    1328                 :            :        * for us because it doesn't know how to deal
    1329                 :            :        * with the possibility of jamming (and we don't
    1330                 :            :        * want to build jamming into it because then it
    1331                 :          0 :        * will run more slowly).
    1332                 :            :        */
    1333                 :          0 : 
    1334                 :            :       yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
    1335         [ #  # ]:          0 : 
    1336                 :            :       yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    1337                 :            : 
    1338                 :          0 :       if ( yy_next_state )
    1339                 :          0 :         {
    1340                 :          0 :         /* Consume the NUL. */
    1341                 :            :         yy_cp = ++yyg->yy_c_buf_p;
    1342                 :            :         yy_current_state = yy_next_state;
    1343                 :            :         goto yy_match;
    1344                 :            :         }
    1345                 :          0 : 
    1346                 :          0 :       else
    1347                 :          0 :         {
    1348                 :            :         yy_cp = yyg->yy_last_accepting_cpos;
    1349                 :            :         yy_current_state = yyg->yy_last_accepting_state;
    1350                 :            :         goto yy_find_action;
    1351   [ +  -  +  - ]:        127 :         }
    1352                 :            :       }
    1353                 :            : 
    1354                 :            :     else switch ( yy_get_next_buffer( yyscanner ) )
    1355                 :         59 :       {
    1356                 :            :       case EOB_ACT_END_OF_FILE:
    1357                 :            :         {
    1358                 :            :         yyg->yy_did_buffer_switch_on_eof = 0;
    1359                 :            : 
    1360                 :            :         if ( _gst_parse_yywrap(yyscanner ) )
    1361                 :            :           {
    1362                 :            :           /* Note: because we've taken care in
    1363                 :            :            * yy_get_next_buffer() to have set up
    1364                 :            :            * yytext, we can now set up
    1365                 :            :            * yy_c_buf_p so that if some total
    1366                 :            :            * hoser (like flex itself) wants to
    1367                 :            :            * call the scanner after we return the
    1368                 :         59 :            * YY_NULL, it'll still work - another
    1369                 :            :            * YY_NULL will get returned.
    1370                 :         59 :            */
    1371                 :         59 :           yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
    1372                 :            : 
    1373                 :            :           yy_act = YY_STATE_EOF(YY_START);
    1374                 :            :           goto do_action;
    1375                 :            :           }
    1376                 :            : 
    1377                 :            :         else
    1378                 :            :           {
    1379                 :            :           if ( ! yyg->yy_did_buffer_switch_on_eof )
    1380                 :            :             YY_NEW_FILE;
    1381                 :            :           }
    1382                 :            :         break;
    1383                 :          0 :         }
    1384                 :          0 : 
    1385                 :            :       case EOB_ACT_CONTINUE_SCAN:
    1386                 :          0 :         yyg->yy_c_buf_p =
    1387                 :            :           yyg->yytext_ptr + yy_amount_of_matched_text;
    1388                 :          0 : 
    1389                 :          0 :         yy_current_state = yy_get_previous_state( yyscanner );
    1390                 :          0 : 
    1391                 :            :         yy_cp = yyg->yy_c_buf_p;
    1392                 :            :         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    1393                 :         68 :         goto yy_match;
    1394                 :         68 : 
    1395                 :            :       case EOB_ACT_LAST_MATCH:
    1396                 :         68 :         yyg->yy_c_buf_p =
    1397                 :            :         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
    1398                 :         68 : 
    1399                 :         68 :         yy_current_state = yy_get_previous_state( yyscanner );
    1400                 :         68 : 
    1401                 :            :         yy_cp = yyg->yy_c_buf_p;
    1402                 :          0 :         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    1403                 :            :         goto yy_find_action;
    1404                 :            :       }
    1405                 :            :     break;
    1406                 :          0 :     }
    1407                 :            : 
    1408                 :            :   default:
    1409                 :        872 :     YY_FATAL_ERROR(
    1410                 :            :       "fatal flex scanner internal error--no action found" );
    1411                 :            :   } /* end of action switch */
    1412                 :            :     } /* end of scanning one token */
    1413                 :            : } /* end of _gst_parse_yylex */
    1414                 :            : 
    1415                 :            : /* yy_get_next_buffer - try to read in a new buffer
    1416                 :            :  *
    1417                 :            :  * Returns a code representing an action:
    1418                 :            :  *  EOB_ACT_LAST_MATCH -
    1419                 :        127 :  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    1420                 :            :  *  EOB_ACT_END_OF_FILE - end of file
    1421                 :        127 :  */
    1422                 :        127 : static int yy_get_next_buffer (yyscan_t yyscanner)
    1423                 :        127 : {
    1424                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1425                 :            :   register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    1426                 :            :   register char *source = yyg->yytext_ptr;
    1427         [ -  + ]:        127 :   register int number_to_move, i;
    1428                 :          0 :   int ret_val;
    1429                 :            : 
    1430                 :            :   if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
    1431         [ +  - ]:        127 :     YY_FATAL_ERROR(
    1432                 :            :     "fatal flex scanner internal error--end of buffer missed" );
    1433         [ +  + ]:        127 : 
    1434                 :            :   if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    1435                 :            :     { /* Don't try to fill the buffer, so this is an EOF. */
    1436                 :            :     if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
    1437                 :            :       {
    1438                 :         59 :       /* We matched a single character, the EOB, so
    1439                 :            :        * treat this as a final EOF.
    1440                 :            :        */
    1441                 :            :       return EOB_ACT_END_OF_FILE;
    1442                 :            :       }
    1443                 :            : 
    1444                 :            :     else
    1445                 :            :       {
    1446                 :         68 :       /* We matched some text prior to the EOB, first
    1447                 :            :        * process it.
    1448                 :            :        */
    1449                 :            :       return EOB_ACT_LAST_MATCH;
    1450                 :            :       }
    1451                 :            :     }
    1452                 :            : 
    1453                 :          0 :   /* Try to read more data. */
    1454                 :            : 
    1455         [ #  # ]:          0 :   /* First move last chars to start of buffer. */
    1456                 :          0 :   number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
    1457                 :            : 
    1458         [ #  # ]:          0 :   for ( i = 0; i < number_to_move; ++i )
    1459                 :            :     *(dest++) = *(source++);
    1460                 :            : 
    1461                 :            :   if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    1462                 :          0 :     /* don't do the read, it's not guaranteed to return an EOF,
    1463                 :            :      * just force an EOF
    1464                 :            :      */
    1465                 :            :     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
    1466                 :          0 : 
    1467                 :          0 :   else
    1468                 :            :     {
    1469         [ #  # ]:          0 :       int num_to_read =
    1470                 :            :       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    1471                 :            : 
    1472                 :            :     while ( num_to_read <= 0 )
    1473         [ #  # ]:          0 :       { /* Not enough room in the buffer - grow it. */
    1474                 :            : 
    1475                 :          0 :       /* just a shorter name for the current buffer */
    1476                 :          0 :       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    1477                 :            : 
    1478         [ #  # ]:          0 :       int yy_c_buf_p_offset =
    1479                 :            :         (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
    1480                 :          0 : 
    1481                 :            :       if ( b->yy_is_our_buffer )
    1482         [ #  # ]:          0 :         {
    1483                 :          0 :         int new_size = b->yy_buf_size * 2;
    1484                 :            : 
    1485                 :          0 :         if ( new_size <= 0 )
    1486                 :            :           b->yy_buf_size += b->yy_buf_size / 8;
    1487                 :          0 :         else
    1488                 :            :           b->yy_buf_size *= 2;
    1489                 :          0 : 
    1490                 :            :         b->yy_ch_buf = (char *)
    1491                 :            :           /* Include room in for 2 EOB chars. */
    1492                 :            :           _gst_parse_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
    1493                 :          0 :         }
    1494                 :            :       else
    1495         [ #  # ]:          0 :         /* Can't grow it, we don't own it. */
    1496                 :          0 :         b->yy_ch_buf = 0;
    1497                 :            : 
    1498                 :            :       if ( ! b->yy_ch_buf )
    1499                 :          0 :         YY_FATAL_ERROR(
    1500                 :            :         "fatal error - scanner input buffer overflow" );
    1501                 :          0 : 
    1502                 :            :       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    1503                 :            : 
    1504                 :            :       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    1505                 :            :             number_to_move - 1;
    1506         [ #  # ]:          0 : 
    1507                 :          0 :       }
    1508                 :            : 
    1509                 :            :     if ( num_to_read > YY_READ_BUF_SIZE )
    1510 [ #  # ][ #  # ]:          0 :       num_to_read = YY_READ_BUF_SIZE;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1511                 :            : 
    1512                 :            :     /* Read in more data. */
    1513                 :          0 :     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    1514                 :            :       yyg->yy_n_chars, (size_t) num_to_read );
    1515                 :            : 
    1516         [ #  # ]:          0 :     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    1517                 :            :     }
    1518         [ #  # ]:          0 : 
    1519                 :            :   if ( yyg->yy_n_chars == 0 )
    1520                 :          0 :     {
    1521                 :          0 :     if ( number_to_move == YY_MORE_ADJ )
    1522                 :            :       {
    1523                 :            :       ret_val = EOB_ACT_END_OF_FILE;
    1524                 :            :       _gst_parse_yyrestart(yyin  ,yyscanner);
    1525                 :            :       }
    1526                 :          0 : 
    1527                 :          0 :     else
    1528                 :            :       {
    1529                 :            :       ret_val = EOB_ACT_LAST_MATCH;
    1530                 :            :       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    1531                 :            :         YY_BUFFER_EOF_PENDING;
    1532                 :            :       }
    1533                 :          0 :     }
    1534                 :            : 
    1535         [ #  # ]:          0 :   else
    1536                 :            :     ret_val = EOB_ACT_CONTINUE_SCAN;
    1537                 :          0 : 
    1538                 :          0 :   if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    1539         [ #  # ]:          0 :     /* Extend the array by 50%, plus the number we really need. */
    1540                 :          0 :     yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
    1541                 :            :     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) _gst_parse_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
    1542                 :            :     if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    1543                 :          0 :       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    1544                 :          0 :   }
    1545                 :          0 : 
    1546                 :            :   yyg->yy_n_chars += number_to_move;
    1547                 :          0 :   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    1548                 :            :   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    1549                 :        127 : 
    1550                 :            :   yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    1551                 :            : 
    1552                 :            :   return ret_val;
    1553                 :            : }
    1554                 :         68 : 
    1555                 :            : /* yy_get_previous_state - get the state just before the EOB char was reached */
    1556                 :            : 
    1557                 :            :     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
    1558                 :         68 : {
    1559                 :            :   register yy_state_type yy_current_state;
    1560                 :         68 :   register char *yy_cp;
    1561                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1562         [ +  + ]:        739 : 
    1563                 :            :   yy_current_state = yyg->yy_start;
    1564         [ +  - ]:        671 : 
    1565         [ +  + ]:        671 :   for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
    1566                 :            :     {
    1567                 :        503 :     register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    1568                 :        503 :     if ( yy_accept[yy_current_state] )
    1569                 :            :       {
    1570         [ +  + ]:       1218 :       yyg->yy_last_accepting_state = yy_current_state;
    1571                 :            :       yyg->yy_last_accepting_cpos = yy_cp;
    1572                 :        547 :       }
    1573         [ +  + ]:        547 :     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1574                 :        228 :       {
    1575                 :            :       yy_current_state = (int) yy_def[yy_current_state];
    1576                 :        671 :       if ( yy_current_state >= 177 )
    1577                 :            :         yy_c = yy_meta[(unsigned int) yy_c];
    1578                 :            :       }
    1579                 :         68 :     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    1580                 :            :     }
    1581                 :            : 
    1582                 :            :   return yy_current_state;
    1583                 :            : }
    1584                 :            : 
    1585                 :            : /* yy_try_NUL_trans - try to make a transition on the NUL character
    1586                 :            :  *
    1587                 :          0 :  * synopsis
    1588                 :            :  *  next_state = yy_try_NUL_trans( current_state );
    1589                 :            :  */
    1590                 :          0 :     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
    1591                 :          0 : {
    1592                 :            :   register int yy_is_jam;
    1593                 :          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
    1594         [ #  # ]:          0 :   register char *yy_cp = yyg->yy_c_buf_p;
    1595                 :            : 
    1596                 :          0 :   register YY_CHAR yy_c = 1;
    1597                 :          0 :   if ( yy_accept[yy_current_state] )
    1598                 :            :     {
    1599         [ #  # ]:          0 :     yyg->yy_last_accepting_state = yy_current_state;
    1600                 :            :     yyg->yy_last_accepting_cpos = yy_cp;
    1601                 :          0 :     }
    1602         [ #  # ]:          0 :   while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1603                 :          0 :     {
    1604                 :            :     yy_current_state = (int) yy_def[yy_current_state];
    1605                 :          0 :     if ( yy_current_state >= 177 )
    1606                 :          0 :       yy_c = yy_meta[(unsigned int) yy_c];
    1607                 :            :     }
    1608         [ #  # ]:          0 :   yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    1609                 :            :   yy_is_jam = (yy_current_state == 176);
    1610                 :            : 
    1611                 :            :   return yy_is_jam ? 0 : yy_current_state;
    1612                 :            : }
    1613                 :            : 
    1614                 :            : #ifndef YY_NO_INPUT
    1615                 :            : #ifdef __cplusplus
    1616                 :            :     static int yyinput (yyscan_t yyscanner)
    1617                 :            : #else
    1618                 :            :     static int input  (yyscan_t yyscanner)
    1619                 :            : #endif
    1620                 :            : 
    1621                 :            : {
    1622                 :            :   int c;
    1623                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1624                 :            : 
    1625                 :            :   *yyg->yy_c_buf_p = yyg->yy_hold_char;
    1626                 :            : 
    1627                 :            :   if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
    1628                 :            :     {
    1629                 :            :     /* yy_c_buf_p now points to the character we want to return.
    1630                 :            :      * If this occurs *before* the EOB characters, then it's a
    1631                 :            :      * valid NUL; if not, then we've hit the end of the buffer.
    1632                 :            :      */
    1633                 :            :     if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
    1634                 :            :       /* This was really a NUL. */
    1635                 :            :       *yyg->yy_c_buf_p = '\0';
    1636                 :            : 
    1637                 :            :     else
    1638                 :            :       { /* need more input */
    1639                 :            :       int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
    1640                 :            :       ++yyg->yy_c_buf_p;
    1641                 :            : 
    1642                 :            :       switch ( yy_get_next_buffer( yyscanner ) )
    1643                 :            :         {
    1644                 :            :         case EOB_ACT_LAST_MATCH:
    1645                 :            :           /* This happens because yy_g_n_b()
    1646                 :            :            * sees that we've accumulated a
    1647                 :            :            * token and flags that we need to
    1648                 :            :            * try matching the token before
    1649                 :            :            * proceeding.  But for input(),
    1650                 :            :            * there's no matching to consider.
    1651                 :            :            * So convert the EOB_ACT_LAST_MATCH
    1652                 :            :            * to EOB_ACT_END_OF_FILE.
    1653                 :            :            */
    1654                 :            : 
    1655                 :            :           /* Reset buffer status. */
    1656                 :            :           _gst_parse_yyrestart(yyin ,yyscanner);
    1657                 :            : 
    1658                 :            :           /*FALLTHROUGH*/
    1659                 :            : 
    1660                 :            :         case EOB_ACT_END_OF_FILE:
    1661                 :            :           {
    1662                 :            :           if ( _gst_parse_yywrap(yyscanner ) )
    1663                 :            :             return EOF;
    1664                 :            : 
    1665                 :            :           if ( ! yyg->yy_did_buffer_switch_on_eof )
    1666                 :            :             YY_NEW_FILE;
    1667                 :            : #ifdef __cplusplus
    1668                 :            :           return yyinput(yyscanner);
    1669                 :            : #else
    1670                 :            :           return input(yyscanner);
    1671                 :            : #endif
    1672                 :            :           }
    1673                 :            : 
    1674                 :            :         case EOB_ACT_CONTINUE_SCAN:
    1675                 :            :           yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
    1676                 :            :           break;
    1677                 :            :         }
    1678                 :            :       }
    1679                 :            :     }
    1680                 :            : 
    1681                 :            :   c = *(unsigned char *) yyg->yy_c_buf_p;  /* cast for 8-bit char's */
    1682                 :            :   *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
    1683                 :            :   yyg->yy_hold_char = *++yyg->yy_c_buf_p;
    1684                 :            : 
    1685                 :            :   return c;
    1686                 :            : }
    1687                 :            : #endif  /* ifndef YY_NO_INPUT */
    1688                 :            : 
    1689                 :            : /** Immediately switch to a different input stream.
    1690                 :            :  * @param input_file A readable stream.
    1691                 :          0 :  * @param yyscanner The scanner object.
    1692                 :            :  * @note This function does not reset the start condition to @c INITIAL .
    1693                 :          0 :  */
    1694                 :            :     void _gst_parse_yyrestart  (FILE * input_file , yyscan_t yyscanner)
    1695 [ #  # ][ #  # ]:          0 : {
    1696                 :          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1697                 :          0 : 
    1698                 :          0 :   if ( ! YY_CURRENT_BUFFER ){
    1699                 :            :         _gst_parse_yyensure_buffer_stack (yyscanner);
    1700                 :            :     YY_CURRENT_BUFFER_LVALUE =
    1701         [ #  # ]:          0 :             _gst_parse_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    1702                 :          0 :   }
    1703                 :          0 : 
    1704                 :            :   _gst_parse_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
    1705                 :            :   _gst_parse_yy_load_buffer_state(yyscanner );
    1706                 :            : }
    1707                 :            : 
    1708                 :            : /** Switch to a different input buffer.
    1709                 :         61 :  * @param new_buffer The new input buffer.
    1710                 :            :  * @param yyscanner The scanner object.
    1711                 :         61 :  */
    1712                 :            :     void _gst_parse_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
    1713                 :            : {
    1714                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1715                 :            : 
    1716                 :            :   /* TODO. We should be able to replace this entire function body
    1717                 :            :    * with
    1718                 :         61 :    *    _gst_parse_yypop_buffer_state();
    1719 [ +  - ][ -  + ]:         61 :    *    _gst_parse_yypush_buffer_state(new_buffer);
    1720                 :         61 :      */
    1721                 :            :   _gst_parse_yyensure_buffer_stack (yyscanner);
    1722 [ +  - ][ -  + ]:         61 :   if ( YY_CURRENT_BUFFER == new_buffer )
    1723                 :            :     return;
    1724                 :            : 
    1725                 :          0 :   if ( YY_CURRENT_BUFFER )
    1726                 :          0 :     {
    1727                 :          0 :     /* Flush out information for old buffer. */
    1728                 :            :     *yyg->yy_c_buf_p = yyg->yy_hold_char;
    1729                 :            :     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
    1730                 :         61 :     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    1731                 :         61 :     }
    1732                 :            : 
    1733                 :            :   YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1734                 :            :   _gst_parse_yy_load_buffer_state(yyscanner );
    1735                 :            : 
    1736                 :            :   /* We don't actually know whether we did this switch during
    1737                 :            :    * EOF (_gst_parse_yywrap()) processing, but the only time this flag
    1738                 :         61 :    * is looked at is after _gst_parse_yywrap() is called, so it's safe
    1739                 :            :    * to go ahead and always set it.
    1740                 :            :    */
    1741                 :        122 :   yyg->yy_did_buffer_switch_on_eof = 1;
    1742                 :            : }
    1743                 :        122 : 
    1744                 :        122 : static void _gst_parse_yy_load_buffer_state  (yyscan_t yyscanner)
    1745                 :        122 : {
    1746                 :        122 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1747                 :        122 :   yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1748                 :        122 :   yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    1749                 :            :   yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    1750                 :            :   yyg->yy_hold_char = *yyg->yy_c_buf_p;
    1751                 :            : }
    1752                 :            : 
    1753                 :            : /** Allocate and initialize an input buffer state.
    1754                 :            :  * @param file A readable stream.
    1755                 :            :  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
    1756                 :          0 :  * @param yyscanner The scanner object.
    1757                 :            :  * @return the allocated buffer state.
    1758                 :            :  */
    1759                 :            :     YY_BUFFER_STATE _gst_parse_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
    1760                 :          0 : {
    1761         [ #  # ]:          0 :   YY_BUFFER_STATE b;
    1762                 :          0 :     
    1763                 :            :   b = (YY_BUFFER_STATE) _gst_parse_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    1764                 :          0 :   if ( ! b )
    1765                 :            :     YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yy_create_buffer()" );
    1766                 :            : 
    1767                 :            :   b->yy_buf_size = size;
    1768                 :            : 
    1769                 :          0 :   /* yy_ch_buf has to be 2 characters longer than the size given because
    1770         [ #  # ]:          0 :    * we need to put in 2 end-of-buffer characters.
    1771                 :          0 :    */
    1772                 :            :   b->yy_ch_buf = (char *) _gst_parse_yyalloc(b->yy_buf_size + 2 ,yyscanner );
    1773                 :          0 :   if ( ! b->yy_ch_buf )
    1774                 :            :     YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yy_create_buffer()" );
    1775                 :          0 : 
    1776                 :            :   b->yy_is_our_buffer = 1;
    1777                 :          0 : 
    1778                 :            :   _gst_parse_yy_init_buffer(b,file ,yyscanner);
    1779                 :            : 
    1780                 :            :   return b;
    1781                 :            : }
    1782                 :            : 
    1783                 :            : /** Destroy the buffer.
    1784                 :         61 :  * @param b a buffer created with _gst_parse_yy_create_buffer()
    1785                 :            :  * @param yyscanner The scanner object.
    1786                 :         61 :  */
    1787                 :            :     void _gst_parse_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
    1788         [ -  + ]:         61 : {
    1789                 :         61 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1790                 :            : 
    1791 [ +  - ][ +  - ]:         61 :   if ( ! b )
    1792                 :         61 :     return;
    1793                 :            : 
    1794         [ +  - ]:         61 :   if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    1795                 :         61 :     YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    1796                 :            : 
    1797                 :         61 :   if ( b->yy_is_our_buffer )
    1798                 :            :     _gst_parse_yyfree((void *) b->yy_ch_buf ,yyscanner );
    1799                 :            : 
    1800                 :            :   _gst_parse_yyfree((void *) b ,yyscanner );
    1801                 :            : }
    1802                 :            : 
    1803                 :            : /* Initializes or reinitializes a buffer.
    1804                 :          0 :  * This function is sometimes called more than once on the same buffer,
    1805                 :            :  * such as during a _gst_parse_yyrestart() or at EOF.
    1806                 :            :  */
    1807                 :          0 :     static void _gst_parse_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
    1808                 :          0 : 
    1809                 :            : {
    1810                 :          0 :   int oerrno = errno;
    1811                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1812                 :          0 : 
    1813                 :          0 :   _gst_parse_yy_flush_buffer(b ,yyscanner);
    1814                 :            : 
    1815                 :            :   b->yy_input_file = file;
    1816                 :            :   b->yy_fill_buffer = 1;
    1817                 :            : 
    1818                 :            :     /* If b is the current buffer, then _gst_parse_yy_init_buffer was _probably_
    1819 [ #  # ][ #  # ]:          0 :      * called from _gst_parse_yyrestart() or through yy_get_next_buffer.
    1820                 :          0 :      * In that case, we don't want to reset the lineno or column.
    1821                 :          0 :      */
    1822                 :            :     if (b != YY_CURRENT_BUFFER){
    1823                 :            :         b->yy_bs_lineno = 1;
    1824                 :          0 :         b->yy_bs_column = 0;
    1825                 :            :     }
    1826                 :          0 : 
    1827                 :          0 :         b->yy_is_interactive = 0;
    1828                 :            :     
    1829                 :            :   errno = oerrno;
    1830                 :            : }
    1831                 :            : 
    1832                 :            : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
    1833                 :          0 :  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
    1834                 :            :  * @param yyscanner The scanner object.
    1835                 :          0 :  */
    1836         [ #  # ]:          0 :     void _gst_parse_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
    1837                 :          0 : {
    1838                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1839                 :          0 :   if ( ! b )
    1840                 :            :     return;
    1841                 :            : 
    1842                 :            :   b->yy_n_chars = 0;
    1843                 :            : 
    1844                 :            :   /* We always need two end-of-buffer characters.  The first causes
    1845                 :          0 :    * a transition to the end-of-buffer state.  The second causes
    1846                 :          0 :    * a jam in that state.
    1847                 :            :    */
    1848                 :          0 :   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    1849                 :            :   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    1850                 :          0 : 
    1851                 :          0 :   b->yy_buf_pos = &b->yy_ch_buf[0];
    1852                 :            : 
    1853 [ #  # ][ #  # ]:          0 :   b->yy_at_bol = 1;
    1854                 :          0 :   b->yy_buffer_status = YY_BUFFER_NEW;
    1855                 :            : 
    1856                 :            :   if ( b == YY_CURRENT_BUFFER )
    1857                 :            :     _gst_parse_yy_load_buffer_state(yyscanner );
    1858                 :            : }
    1859                 :            : 
    1860                 :            : /** Pushes the new state onto the stack. The new state becomes
    1861                 :            :  *  the current state. This function will allocate the stack
    1862                 :            :  *  if necessary.
    1863                 :          0 :  *  @param new_buffer The new state.
    1864                 :            :  *  @param yyscanner The scanner object.
    1865                 :          0 :  */
    1866         [ #  # ]:          0 : void _gst_parse_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
    1867                 :          0 : {
    1868                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1869                 :          0 :   if (new_buffer == NULL)
    1870                 :            :     return;
    1871                 :            : 
    1872 [ #  # ][ #  # ]:          0 :   _gst_parse_yyensure_buffer_stack(yyscanner);
    1873                 :            : 
    1874                 :            :   /* This block is copied from _gst_parse_yy_switch_to_buffer. */
    1875                 :          0 :   if ( YY_CURRENT_BUFFER )
    1876                 :          0 :     {
    1877                 :          0 :     /* Flush out information for old buffer. */
    1878                 :            :     *yyg->yy_c_buf_p = yyg->yy_hold_char;
    1879                 :            :     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
    1880                 :            :     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    1881 [ #  # ][ #  # ]:          0 :     }
    1882                 :          0 : 
    1883                 :          0 :   /* Only push if top exists. Otherwise, replace top. */
    1884                 :            :   if (YY_CURRENT_BUFFER)
    1885                 :            :     yyg->yy_buffer_stack_top++;
    1886                 :          0 :   YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1887                 :          0 : 
    1888                 :            :   /* copied from _gst_parse_yy_switch_to_buffer. */
    1889                 :            :   _gst_parse_yy_load_buffer_state(yyscanner );
    1890                 :            :   yyg->yy_did_buffer_switch_on_eof = 1;
    1891                 :            : }
    1892                 :            : 
    1893                 :            : /** Removes and deletes the top of the stack, if present.
    1894                 :         61 :  *  The next element becomes the new top.
    1895                 :            :  *  @param yyscanner The scanner object.
    1896                 :         61 :  */
    1897 [ +  - ][ +  - ]:         61 : void _gst_parse_yypop_buffer_state (yyscan_t yyscanner)
    1898                 :         61 : {
    1899                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1900         [ #  # ]:          0 :   if (!YY_CURRENT_BUFFER)
    1901                 :          0 :     return;
    1902         [ #  # ]:          0 : 
    1903                 :          0 :   _gst_parse_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
    1904                 :            :   YY_CURRENT_BUFFER_LVALUE = NULL;
    1905 [ #  # ][ #  # ]:          0 :   if (yyg->yy_buffer_stack_top > 0)
    1906                 :          0 :     --yyg->yy_buffer_stack_top;
    1907                 :          0 : 
    1908                 :            :   if (YY_CURRENT_BUFFER) {
    1909                 :            :     _gst_parse_yy_load_buffer_state(yyscanner );
    1910                 :            :     yyg->yy_did_buffer_switch_on_eof = 1;
    1911                 :            :   }
    1912                 :            : }
    1913                 :            : 
    1914                 :         61 : /* Allocates the stack if it does not exist.
    1915                 :            :  *  Guarantees space for at least one push.
    1916                 :            :  */
    1917                 :         61 : static void _gst_parse_yyensure_buffer_stack (yyscan_t yyscanner)
    1918                 :            : {
    1919         [ +  - ]:         61 :   int num_to_alloc;
    1920                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    1921                 :            : 
    1922                 :            :   if (!yyg->yy_buffer_stack) {
    1923                 :            : 
    1924                 :            :     /* First allocation is just for 2 elements, since we don't know if this
    1925                 :         61 :      * scanner will even need a stack. We use 2 instead of 1 to avoid an
    1926                 :         61 :      * immediate realloc on the next call.
    1927                 :         61 :          */
    1928                 :            :     num_to_alloc = 1;
    1929         [ -  + ]:         61 :     yyg->yy_buffer_stack = (struct yy_buffer_state**)_gst_parse_yyalloc
    1930                 :          0 :                 (num_to_alloc * sizeof(struct yy_buffer_state*)
    1931                 :            :                 , yyscanner);
    1932                 :         61 :     if ( ! yyg->yy_buffer_stack )
    1933                 :            :       YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yyensure_buffer_stack()" );
    1934                 :         61 :                   
    1935                 :         61 :     memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    1936                 :         61 :         
    1937                 :            :     yyg->yy_buffer_stack_max = num_to_alloc;
    1938                 :            :     yyg->yy_buffer_stack_top = 0;
    1939         [ #  # ]:          0 :     return;
    1940                 :            :   }
    1941                 :            : 
    1942                 :          0 :   if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
    1943                 :            : 
    1944                 :          0 :     /* Increase the buffer to prepare for a possible push. */
    1945                 :          0 :     int grow_size = 8 /* arbitrary grow size */;
    1946                 :          0 : 
    1947                 :            :     num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
    1948                 :            :     yyg->yy_buffer_stack = (struct yy_buffer_state**)_gst_parse_yyrealloc
    1949         [ #  # ]:          0 :                 (yyg->yy_buffer_stack,
    1950                 :          0 :                 num_to_alloc * sizeof(struct yy_buffer_state*)
    1951                 :            :                 , yyscanner);
    1952                 :            :     if ( ! yyg->yy_buffer_stack )
    1953                 :          0 :       YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yyensure_buffer_stack()" );
    1954                 :          0 : 
    1955                 :            :     /* zero only the new slots.*/
    1956                 :            :     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
    1957                 :            :     yyg->yy_buffer_stack_max = num_to_alloc;
    1958                 :            :   }
    1959                 :            : }
    1960                 :            : 
    1961                 :            : /** Setup the input buffer state to scan directly from a user-specified character buffer.
    1962                 :            :  * @param base the character buffer
    1963                 :            :  * @param size the size in bytes of the character buffer
    1964                 :         61 :  * @param yyscanner The scanner object.
    1965                 :            :  * @return the newly allocated buffer state object. 
    1966                 :            :  */
    1967                 :            : YY_BUFFER_STATE _gst_parse_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
    1968 [ +  - ][ +  - ]:         61 : {
    1969         [ -  + ]:         61 :   YY_BUFFER_STATE b;
    1970                 :         61 :     
    1971                 :            :   if ( size < 2 ||
    1972                 :          0 :        base[size-2] != YY_END_OF_BUFFER_CHAR ||
    1973                 :            :        base[size-1] != YY_END_OF_BUFFER_CHAR )
    1974                 :         61 :     /* They forgot to leave room for the EOB's. */
    1975         [ -  + ]:         61 :     return 0;
    1976                 :          0 : 
    1977                 :            :   b = (YY_BUFFER_STATE) _gst_parse_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    1978                 :         61 :   if ( ! b )
    1979                 :         61 :     YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yy_scan_buffer()" );
    1980                 :         61 : 
    1981                 :         61 :   b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
    1982                 :         61 :   b->yy_buf_pos = b->yy_ch_buf = base;
    1983                 :         61 :   b->yy_is_our_buffer = 0;
    1984                 :         61 :   b->yy_input_file = 0;
    1985                 :         61 :   b->yy_n_chars = b->yy_buf_size;
    1986                 :         61 :   b->yy_is_interactive = 0;
    1987                 :            :   b->yy_at_bol = 1;
    1988                 :         61 :   b->yy_fill_buffer = 0;
    1989                 :            :   b->yy_buffer_status = YY_BUFFER_NEW;
    1990                 :         61 : 
    1991                 :            :   _gst_parse_yy_switch_to_buffer(b ,yyscanner );
    1992                 :            : 
    1993                 :            :   return b;
    1994                 :            : }
    1995                 :            : 
    1996                 :            : /** Setup the input buffer state to scan a string. The next call to _gst_parse_yylex() will
    1997                 :            :  * scan from a @e copy of @a str.
    1998                 :            :  * @param yystr a NUL-terminated string to scan
    1999                 :            :  * @param yyscanner The scanner object.
    2000                 :            :  * @return the newly allocated buffer state object.
    2001                 :         61 :  * @note If you want to scan bytes that may contain NUL values, then use
    2002                 :            :  *       _gst_parse_yy_scan_bytes() instead.
    2003                 :            :  */
    2004                 :         61 : YY_BUFFER_STATE _gst_parse_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
    2005                 :            : {
    2006                 :            :     
    2007                 :            :   return _gst_parse_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
    2008                 :            : }
    2009                 :            : 
    2010                 :            : /** Setup the input buffer state to scan the given bytes. The next call to _gst_parse_yylex() will
    2011                 :            :  * scan from a @e copy of @a bytes.
    2012                 :            :  * @param yybytes the byte buffer to scan
    2013                 :            :  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
    2014                 :         61 :  * @param yyscanner The scanner object.
    2015                 :            :  * @return the newly allocated buffer state object.
    2016                 :            :  */
    2017                 :            : YY_BUFFER_STATE _gst_parse_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
    2018                 :            : {
    2019                 :            :   YY_BUFFER_STATE b;
    2020                 :            :   char *buf;
    2021                 :            :   yy_size_t n;
    2022                 :         61 :   int i;
    2023                 :         61 :     
    2024         [ -  + ]:         61 :   /* Get memory for full buffer, including space for trailing EOB's. */
    2025                 :          0 :   n = _yybytes_len + 2;
    2026                 :            :   buf = (char *) _gst_parse_yyalloc(n ,yyscanner );
    2027         [ +  + ]:       3965 :   if ( ! buf )
    2028                 :       3904 :     YY_FATAL_ERROR( "out of dynamic memory in _gst_parse_yy_scan_bytes()" );
    2029                 :            : 
    2030                 :         61 :   for ( i = 0; i < _yybytes_len; ++i )
    2031                 :            :     buf[i] = yybytes[i];
    2032                 :         61 : 
    2033         [ -  + ]:         61 :   buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    2034                 :          0 : 
    2035                 :            :   b = _gst_parse_yy_scan_buffer(buf,n ,yyscanner);
    2036                 :            :   if ( ! b )
    2037                 :            :     YY_FATAL_ERROR( "bad buffer in _gst_parse_yy_scan_bytes()" );
    2038                 :            : 
    2039                 :         61 :   /* It's okay to grow etc. this buffer, and we should throw it
    2040                 :            :    * away when we're done.
    2041                 :         61 :    */
    2042                 :            :   b->yy_is_our_buffer = 1;
    2043                 :            : 
    2044                 :            :   return b;
    2045                 :            : }
    2046                 :            : 
    2047                 :            : #ifndef YY_EXIT_FAILURE
    2048                 :          0 : #define YY_EXIT_FAILURE 2
    2049                 :            : #endif
    2050                 :          0 : 
    2051                 :          0 : static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
    2052                 :            : {
    2053                 :            :       (void) fprintf( stderr, "%s\n", msg );
    2054                 :            :   exit( YY_EXIT_FAILURE );
    2055                 :            : }
    2056                 :            : 
    2057                 :            : /* Redefine yyless() so it works in section 3 code. */
    2058                 :            : 
    2059                 :            : #undef yyless
    2060                 :            : #define yyless(n) \
    2061                 :            :   do \
    2062                 :            :     { \
    2063                 :            :     /* Undo effects of setting up yytext. */ \
    2064                 :            :         int yyless_macro_arg = (n); \
    2065                 :            :         YY_LESS_LINENO(yyless_macro_arg);\
    2066                 :            :     yytext[yyleng] = yyg->yy_hold_char; \
    2067                 :            :     yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
    2068                 :            :     yyg->yy_hold_char = *yyg->yy_c_buf_p; \
    2069                 :            :     *yyg->yy_c_buf_p = '\0'; \
    2070                 :            :     yyleng = yyless_macro_arg; \
    2071                 :            :     } \
    2072                 :            :   while ( 0 )
    2073                 :            : 
    2074                 :            : /* Accessor  methods (get/set functions) to struct members. */
    2075                 :            : 
    2076                 :          0 : /** Get the user-defined data for this scanner.
    2077                 :            :  * @param yyscanner The scanner object.
    2078                 :          0 :  */
    2079                 :          0 : YY_EXTRA_TYPE _gst_parse_yyget_extra  (yyscan_t yyscanner)
    2080                 :            : {
    2081                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2082                 :            :     return yyextra;
    2083                 :            : }
    2084                 :            : 
    2085                 :          0 : /** Get the current line number.
    2086                 :            :  * @param yyscanner The scanner object.
    2087                 :          0 :  */
    2088                 :            : int _gst_parse_yyget_lineno  (yyscan_t yyscanner)
    2089 [ #  # ][ #  # ]:          0 : {
    2090                 :          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2091                 :            :     
    2092                 :          0 :         if (! YY_CURRENT_BUFFER)
    2093                 :            :             return 0;
    2094                 :            :     
    2095                 :            :     return yylineno;
    2096                 :            : }
    2097                 :            : 
    2098                 :          0 : /** Get the current column number.
    2099                 :            :  * @param yyscanner The scanner object.
    2100                 :          0 :  */
    2101                 :            : int _gst_parse_yyget_column  (yyscan_t yyscanner)
    2102 [ #  # ][ #  # ]:          0 : {
    2103                 :          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2104                 :            :     
    2105                 :          0 :         if (! YY_CURRENT_BUFFER)
    2106                 :            :             return 0;
    2107                 :            :     
    2108                 :            :     return yycolumn;
    2109                 :            : }
    2110                 :            : 
    2111                 :          0 : /** Get the input stream.
    2112                 :            :  * @param yyscanner The scanner object.
    2113                 :          0 :  */
    2114                 :          0 : FILE *_gst_parse_yyget_in  (yyscan_t yyscanner)
    2115                 :            : {
    2116                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2117                 :            :     return yyin;
    2118                 :            : }
    2119                 :            : 
    2120                 :          0 : /** Get the output stream.
    2121                 :            :  * @param yyscanner The scanner object.
    2122                 :          0 :  */
    2123                 :          0 : FILE *_gst_parse_yyget_out  (yyscan_t yyscanner)
    2124                 :            : {
    2125                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2126                 :            :     return yyout;
    2127                 :            : }
    2128                 :            : 
    2129                 :          0 : /** Get the length of the current token.
    2130                 :            :  * @param yyscanner The scanner object.
    2131                 :          0 :  */
    2132                 :          0 : int _gst_parse_yyget_leng  (yyscan_t yyscanner)
    2133                 :            : {
    2134                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2135                 :            :     return yyleng;
    2136                 :            : }
    2137                 :            : 
    2138                 :            : /** Get the current token.
    2139                 :          0 :  * @param yyscanner The scanner object.
    2140                 :            :  */
    2141                 :          0 : 
    2142                 :          0 : char *_gst_parse_yyget_text  (yyscan_t yyscanner)
    2143                 :            : {
    2144                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2145                 :            :     return yytext;
    2146                 :            : }
    2147                 :            : 
    2148                 :            : /** Set the user-defined data. This data is never touched by the scanner.
    2149                 :          0 :  * @param user_defined The data to be associated with this scanner.
    2150                 :            :  * @param yyscanner The scanner object.
    2151                 :          0 :  */
    2152                 :          0 : void _gst_parse_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
    2153                 :          0 : {
    2154                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2155                 :            :     yyextra = user_defined ;
    2156                 :            : }
    2157                 :            : 
    2158                 :            : /** Set the current line number.
    2159                 :          0 :  * @param line_number
    2160                 :            :  * @param yyscanner The scanner object.
    2161                 :          0 :  */
    2162                 :            : void _gst_parse_yyset_lineno (int  line_number , yyscan_t yyscanner)
    2163                 :            : {
    2164 [ #  # ][ #  # ]:          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2165                 :          0 : 
    2166                 :            :         /* lineno is only valid if an input buffer exists. */
    2167                 :          0 :         if (! YY_CURRENT_BUFFER )
    2168                 :          0 :            yy_fatal_error( "_gst_parse_yyset_lineno called with no buffer" , yyscanner); 
    2169                 :            :     
    2170                 :            :     yylineno = line_number;
    2171                 :            : }
    2172                 :            : 
    2173                 :            : /** Set the current column.
    2174                 :          0 :  * @param line_number
    2175                 :            :  * @param yyscanner The scanner object.
    2176                 :          0 :  */
    2177                 :            : void _gst_parse_yyset_column (int  column_no , yyscan_t yyscanner)
    2178                 :            : {
    2179 [ #  # ][ #  # ]:          0 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2180                 :          0 : 
    2181                 :            :         /* column is only valid if an input buffer exists. */
    2182                 :          0 :         if (! YY_CURRENT_BUFFER )
    2183                 :          0 :            yy_fatal_error( "_gst_parse_yyset_column called with no buffer" , yyscanner); 
    2184                 :            :     
    2185                 :            :     yycolumn = column_no;
    2186                 :            : }
    2187                 :            : 
    2188                 :            : /** Set the input stream. This does not discard the current
    2189                 :            :  * input buffer.
    2190                 :            :  * @param in_str A readable stream.
    2191                 :          0 :  * @param yyscanner The scanner object.
    2192                 :            :  * @see _gst_parse_yy_switch_to_buffer
    2193                 :          0 :  */
    2194                 :          0 : void _gst_parse_yyset_in (FILE *  in_str , yyscan_t yyscanner)
    2195                 :          0 : {
    2196                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2197                 :          0 :     yyin = in_str ;
    2198                 :            : }
    2199                 :          0 : 
    2200                 :          0 : void _gst_parse_yyset_out (FILE *  out_str , yyscan_t yyscanner)
    2201                 :          0 : {
    2202                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2203                 :          0 :     yyout = out_str ;
    2204                 :            : }
    2205                 :          0 : 
    2206                 :          0 : int _gst_parse_yyget_debug  (yyscan_t yyscanner)
    2207                 :            : {
    2208                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2209                 :          0 :     return yy_flex_debug;
    2210                 :            : }
    2211                 :          0 : 
    2212                 :          0 : void _gst_parse_yyset_debug (int  bdebug , yyscan_t yyscanner)
    2213                 :          0 : {
    2214                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2215                 :            :     yy_flex_debug = bdebug ;
    2216                 :            : }
    2217                 :          0 : 
    2218                 :            : /* Accessor methods for yylval and yylloc */
    2219                 :          0 : 
    2220                 :          0 : YYSTYPE * _gst_parse_yyget_lval  (yyscan_t yyscanner)
    2221                 :            : {
    2222                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2223                 :          0 :     return yylval;
    2224                 :            : }
    2225                 :          0 : 
    2226                 :          0 : void _gst_parse_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
    2227                 :          0 : {
    2228                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2229                 :            :     yylval = yylval_param;
    2230                 :            : }
    2231                 :            : 
    2232                 :            : /* User-visible API */
    2233                 :            : 
    2234                 :            : /* _gst_parse_yylex_init is special because it creates the scanner itself, so it is
    2235                 :            :  * the ONLY reentrant function that doesn't take the scanner as the last argument.
    2236                 :         61 :  * That's why we explicitly handle the declaration, instead of using our macros.
    2237                 :            :  */
    2238                 :            : 
    2239         [ -  + ]:         61 : int _gst_parse_yylex_init(yyscan_t* ptr_yy_globals)
    2240                 :          0 : 
    2241                 :          0 : {
    2242                 :            :     if (ptr_yy_globals == NULL){
    2243                 :            :         errno = EINVAL;
    2244                 :         61 :         return 1;
    2245                 :            :     }
    2246         [ -  + ]:         61 : 
    2247                 :          0 :     *ptr_yy_globals = (yyscan_t) _gst_parse_yyalloc ( sizeof( struct yyguts_t ), NULL );
    2248                 :          0 : 
    2249                 :            :     if (*ptr_yy_globals == NULL){
    2250                 :            :         errno = ENOMEM;
    2251                 :            :         return 1;
    2252                 :         61 :     }
    2253                 :            : 
    2254                 :         61 :     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    2255                 :            :     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
    2256                 :            : 
    2257                 :            :     return yy_init_globals ( *ptr_yy_globals );
    2258                 :            : }
    2259                 :            : 
    2260                 :            : /* _gst_parse_yylex_init_extra has the same functionality as _gst_parse_yylex_init, but follows the
    2261                 :            :  * convention of taking the scanner as the last argument. Note however, that
    2262                 :            :  * this is a *pointer* to a scanner, as it will be allocated by this call (and
    2263                 :            :  * is the reason, too, why this function also must handle its own declaration).
    2264                 :            :  * The user defined value in the first argument will be available to _gst_parse_yyalloc in
    2265                 :          0 :  * the yyextra field.
    2266                 :            :  */
    2267                 :            : 
    2268                 :            : int _gst_parse_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
    2269                 :            : 
    2270                 :          0 : {
    2271                 :            :     struct yyguts_t dummy_yyguts;
    2272         [ #  # ]:          0 : 
    2273                 :          0 :     _gst_parse_yyset_extra (yy_user_defined, &dummy_yyguts);
    2274                 :          0 : 
    2275                 :            :     if (ptr_yy_globals == NULL){
    2276                 :            :         errno = EINVAL;
    2277                 :          0 :         return 1;
    2278                 :            :     }
    2279         [ #  # ]:          0 :   
    2280                 :          0 :     *ptr_yy_globals = (yyscan_t) _gst_parse_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
    2281                 :          0 :   
    2282                 :            :     if (*ptr_yy_globals == NULL){
    2283                 :            :         errno = ENOMEM;
    2284                 :            :         return 1;
    2285                 :            :     }
    2286                 :          0 :     
    2287                 :            :     /* By setting to 0xAA, we expose bugs in
    2288                 :          0 :     yy_init_globals. Leave at 0x00 for releases. */
    2289                 :            :     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
    2290                 :          0 :     
    2291                 :            :     _gst_parse_yyset_extra (yy_user_defined, *ptr_yy_globals);
    2292                 :            :     
    2293                 :        122 :     return yy_init_globals ( *ptr_yy_globals );
    2294                 :            : }
    2295                 :        122 : 
    2296                 :            : static int yy_init_globals (yyscan_t yyscanner)
    2297                 :            : {
    2298                 :            :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2299                 :            :     /* Initialization is the same as for the non-reentrant scanner.
    2300                 :        122 :      * This function is called from _gst_parse_yylex_destroy(), so don't allocate here.
    2301                 :        122 :      */
    2302                 :        122 : 
    2303                 :        122 :     yyg->yy_buffer_stack = 0;
    2304                 :        122 :     yyg->yy_buffer_stack_top = 0;
    2305                 :        122 :     yyg->yy_buffer_stack_max = 0;
    2306                 :            :     yyg->yy_c_buf_p = (char *) 0;
    2307                 :        122 :     yyg->yy_init = 0;
    2308                 :        122 :     yyg->yy_start = 0;
    2309                 :        122 : 
    2310                 :            :     yyg->yy_start_stack_ptr = 0;
    2311                 :            :     yyg->yy_start_stack_depth = 0;
    2312                 :            :     yyg->yy_start_stack =  NULL;
    2313                 :            : 
    2314                 :            : /* Defined in main.c */
    2315                 :            : #ifdef YY_STDINIT
    2316                 :        122 :     yyin = stdin;
    2317                 :        122 :     yyout = stdout;
    2318                 :            : #else
    2319                 :            :     yyin = (FILE *) 0;
    2320                 :            :     yyout = (FILE *) 0;
    2321                 :            : #endif
    2322                 :            : 
    2323                 :        122 :     /* For future reference: Set errno on error, since we are called by
    2324                 :            :      * _gst_parse_yylex_init()
    2325                 :            :      */
    2326                 :            :     return 0;
    2327                 :         61 : }
    2328                 :            : 
    2329                 :         61 : /* _gst_parse_yylex_destroy is for both reentrant and non-reentrant scanners. */
    2330                 :            : int _gst_parse_yylex_destroy  (yyscan_t yyscanner)
    2331                 :            : {
    2332 [ +  - ][ +  + ]:        122 :     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    2333         [ +  - ]:         61 : 
    2334                 :         61 :     /* Pop the buffer stack, destroying each element. */
    2335                 :         61 :   while(YY_CURRENT_BUFFER){
    2336                 :            :     _gst_parse_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
    2337                 :            :     YY_CURRENT_BUFFER_LVALUE = NULL;
    2338                 :            :     _gst_parse_yypop_buffer_state(yyscanner);
    2339                 :         61 :   }
    2340                 :         61 : 
    2341                 :            :   /* Destroy the stack itself. */
    2342                 :            :   _gst_parse_yyfree(yyg->yy_buffer_stack ,yyscanner);
    2343                 :         61 :   yyg->yy_buffer_stack = NULL;
    2344                 :         61 : 
    2345                 :            :     /* Destroy the start condition stack. */
    2346                 :            :         _gst_parse_yyfree(yyg->yy_start_stack ,yyscanner );
    2347                 :            :         yyg->yy_start_stack = NULL;
    2348                 :         61 : 
    2349                 :            :     /* Reset the globals. This is important in a non-reentrant scanner so the next time
    2350                 :            :      * _gst_parse_yylex() is called, initialization will occur. */
    2351                 :         61 :     yy_init_globals( yyscanner);
    2352                 :         61 : 
    2353                 :         61 :     /* Destroy the main struct (reentrant only). */
    2354                 :            :     _gst_parse_yyfree ( yyscanner , yyscanner );
    2355                 :            :     yyscanner = NULL;
    2356                 :            :     return 0;
    2357                 :            : }
    2358                 :            : 
    2359                 :            : /*
    2360                 :            :  * Internal utility routines.
    2361                 :            :  */
    2362                 :            : 
    2363                 :            : #ifndef yytext_ptr
    2364                 :            : static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
    2365                 :            : {
    2366                 :            :   register int i;
    2367                 :            :   for ( i = 0; i < n; ++i )
    2368                 :            :     s1[i] = s2[i];
    2369                 :            : }
    2370                 :            : #endif
    2371                 :            : 
    2372                 :            : #ifdef YY_NEED_STRLEN
    2373                 :            : static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
    2374                 :            : {
    2375                 :            :   register int n;
    2376                 :            :   for ( n = 0; s[n]; ++n )
    2377                 :            :     ;
    2378                 :            : 
    2379                 :            :   return n;
    2380                 :        244 : }
    2381                 :            : #endif
    2382                 :        244 : 
    2383                 :            : void *_gst_parse_yyalloc (yy_size_t  size , yyscan_t yyscanner)
    2384                 :            : {
    2385                 :          0 :   return (void *) malloc( size );
    2386                 :            : }
    2387                 :            : 
    2388                 :            : void *_gst_parse_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
    2389                 :            : {
    2390                 :            :   /* The cast to (char *) in the following accommodates both
    2391                 :            :    * implementations that use char* generic pointers, and those
    2392                 :            :    * that use void* generic pointers.  It works with the latter
    2393                 :            :    * because both ANSI C and C++ allow castless assignment from
    2394                 :          0 :    * any pointer type to void*, and deal with argument conversions
    2395                 :            :    * as though doing an assignment.
    2396                 :            :    */
    2397                 :        305 :   return (void *) realloc( (char *) ptr, size );
    2398                 :            : }
    2399                 :        305 : 
    2400                 :        305 : void _gst_parse_yyfree (void * ptr , yyscan_t yyscanner)
    2401                 :            : {
    2402                 :            :   free( (char *) ptr ); /* see _gst_parse_yyrealloc() for (char *) cast */
    2403                 :            : }
    2404                 :            : 
    2405                 :            : #define YYTABLES_NAME "yytables"
    2406                 :            : 
    2407                 :            : #line 148 "parse.l"
    2408                 :            : 
    2409                 :            : 
    2410                 :            : 
    2411                 :            : /* A Bison parser, made by GNU Bison 2.4.1.  */
    2412                 :            : 
    2413                 :            : /* Skeleton interface for Bison's Yacc-like parsers in C
    2414                 :            :    
    2415                 :            :       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    2416                 :            :    Free Software Foundation, Inc.
    2417                 :            :    
    2418                 :            :    This program is free software: you can redistribute it and/or modify
    2419                 :            :    it under the terms of the GNU General Public License as published by
    2420                 :            :    the Free Software Foundation, either version 3 of the License, or
    2421                 :            :    (at your option) any later version.
    2422                 :            :    
    2423                 :            :    This program is distributed in the hope that it will be useful,
    2424                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
    2425                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    2426                 :            :    GNU General Public License for more details.
    2427                 :            :    
    2428                 :            :    You should have received a copy of the GNU General Public License
    2429                 :            :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
    2430                 :            : 
    2431                 :            : /* As a special exception, you may create a larger work that contains
    2432                 :            :    part or all of the Bison parser skeleton and distribute that work
    2433                 :            :    under terms of your choice, so long as that work isn't itself a
    2434                 :            :    parser generator using the skeleton or a modified version thereof
    2435                 :            :    as a parser skeleton.  Alternatively, if you modify or redistribute
    2436                 :            :    the parser skeleton itself, you may (at your option) remove this
    2437                 :            :    special exception, which will cause the skeleton and the resulting
    2438                 :            :    Bison output files to be licensed under the GNU General Public
    2439                 :            :    License without this special exception.
    2440                 :            :    
    2441                 :            :    This special exception was added by the Free Software Foundation in
    2442                 :            :    version 2.2 of Bison.  */
    2443                 :            : 
    2444                 :            : 
    2445                 :            : /* Tokens.  */
    2446                 :            : #ifndef YYTOKENTYPE
    2447                 :            : # define YYTOKENTYPE
    2448                 :            :    /* Put the tokens into the symbol table, so that GDB and other debuggers
    2449                 :            :       know about them.  */
    2450                 :            :    enum yytokentype {
    2451                 :            :      PARSE_URL = 258,
    2452                 :            :      IDENTIFIER = 259,
    2453                 :            :      BINREF = 260,
    2454                 :            :      PADREF = 261,
    2455                 :            :      REF = 262,
    2456                 :            :      ASSIGNMENT = 263,
    2457                 :            :      LINK = 264
    2458                 :            :    };
    2459                 :            : #endif
    2460                 :            : 
    2461                 :            : 
    2462                 :            : 
    2463                 :            : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
    2464                 :            : typedef union YYSTYPE
    2465                 :            : {
    2466                 :            : 
    2467                 :            : /* Line 1676 of yacc.c  */
    2468                 :            : #line 623 "./grammar.y"
    2469                 :            : 
    2470                 :            :     gchar *s;
    2471                 :            :     chain_t *c;
    2472                 :            :     link_t *l;
    2473                 :            :     GstElement *e;
    2474                 :            :     GSList *p;
    2475                 :            :     graph_t *g;
    2476                 :            : 
    2477                 :            : 
    2478                 :            : 
    2479                 :            : /* Line 1676 of yacc.c  */
    2480                 :            : #line 72 "grammar.tab.h"
    2481                 :            : } YYSTYPE;
    2482                 :            : # define YYSTYPE_IS_TRIVIAL 1
    2483                 :            : # define yystype YYSTYPE /* obsolescent; will be withdrawn */
    2484                 :            : # define YYSTYPE_IS_DECLARED 1
    2485                 :            : #endif
    2486                 :            : 
    2487                 :            : 
    2488                 :            : 
    2489                 :            : 
    2490                 :            : 

Generated by: LCOV version 1.9