Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages | Search for 
mysql-5.0.2-alpha / innobase / pars

lexyy.c File Reference

#include "univ.i"
#include <stdio.h>
#include "pars0pars.h"
#include "pars0grm.h"
#include "pars0sym.h"
#include "mem0mem.h"
#include "os0proc.h"

Include dependency graph for lexyy.c:

Include dependency graph

Classes

struct  yy_buffer_state

Defines

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION   2
#define YY_FLEX_MINOR_VERSION   5
#define yyconst
#define YY_PROTO(proto)   ()
#define YY_NULL   0
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define BEGIN   yy_start = 1 + 2 *
#define YY_START   ((yy_start - 1) / 2)
#define YYSTATE   YY_START
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define YY_NEW_FILE   yyrestart( yyin )
#define YY_END_OF_BUFFER_CHAR   0
#define YY_BUF_SIZE   16384
#define EOB_ACT_CONTINUE_SCAN   0
#define EOB_ACT_END_OF_FILE   1
#define EOB_ACT_LAST_MATCH   2
#define yyless(n)
#define unput(c)   yyunput( c, yytext_ptr )
#define YY_BUFFER_NEW   0
#define YY_BUFFER_NORMAL   1
#define YY_BUFFER_EOF_PENDING   2
#define YY_CURRENT_BUFFER   yy_current_buffer
#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )
#define yy_new_buffer   yy_create_buffer
#define yy_set_interactive(is_interactive)
#define yy_set_bol(at_bol)
#define YY_AT_BOL()   (yy_current_buffer->yy_at_bol)
#define yywrap()   1
#define YY_SKIP_YYWRAP
#define yytext_ptr   yytext
#define YY_DO_BEFORE_ACTION
#define YY_NUM_RULES   107
#define YY_END_OF_BUFFER   108
#define REJECT   reject_used_but_not_detected
#define yymore()   yymore_used_but_not_detected
#define YY_MORE_ADJ   0
#define YY_RESTORE_YY_MORE_OFFSET
#define INITIAL   0
#define YY_NEVER_INTERACTIVE   1
#define YY_NO_INPUT   1
#define YY_NO_UNPUT   1
#define YY_NO_SCAN_BUFFER   1
#define YY_NO_SCAN_BYTES   1
#define YY_NO_SCAN_STRING   1
#define YYSTYPE   que_node_t*
#define malloc(A)   ut_malloc(A)
#define free(A)   ut_free(A)
#define realloc(P, A)   ut_realloc(P, A)
#define exit(A)   ut_error
#define YY_INPUT(buf, result, max_size)   pars_get_lex_chars(buf, &result, max_size)
#define comment   1
#define quoted   2
#define YY_NO_PUSH_STATE   1
#define YY_NO_POP_STATE   1
#define YY_NO_TOP_STATE   1
#define YY_READ_BUF_SIZE   8192
#define ECHO   (void) fwrite( yytext, yyleng, 1, yyout )
#define yyterminate()   return YY_NULL
#define YY_START_STACK_INCR   25
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define YY_DECL   int yylex YY_PROTO(( void ))
#define YY_BREAK   break;
#define YY_RULE_SETUP   YY_USER_ACTION
#define YY_EXIT_FAILURE   2
#define yyless(n)

Typedefs

typedef yy_buffer_state * YY_BUFFER_STATE
typedef unsigned int yy_size_t
typedef unsigned char YY_CHAR
typedef int yy_state_type

Functions

void yyrestart ()
void yy_switch_to_buffer ()
void yy_load_buffer_state ()
YY_BUFFER_STATE yy_create_buffer ()
void yy_delete_buffer ()
void yy_init_buffer ()
void yy_flush_buffer ()
YY_BUFFER_STATE yy_scan_buffer ()
YY_BUFFER_STATE yy_scan_string ()
YY_BUFFER_STATE yy_scan_bytes ()
void * yy_flex_alloc ()
void * yy_flex_realloc ()
void yy_flex_free ()
yy_state_type yy_get_previous_state ()
yy_state_type yy_try_NUL_trans ()
int yy_get_next_buffer ()
void yy_fatal_error ()
void string_append (const char *str, ulint len)
int yylex ()
yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state)
int input ()
void yyrestart (FILE *input_file)
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
void yy_delete_buffer (YY_BUFFER_STATE b)
void yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
void yy_flush_buffer (YY_BUFFER_STATE b)
void yy_fatal_error (msg)
void * yy_flex_alloc (yy_size_t size)
void * yy_flex_realloc (void *ptr, yy_size_t size)
void yy_flex_free (void *ptr)

Variables

int yyleng
FILE * yyin = (FILE *) 0 *yyout = (FILE *) 0
FILE * yyout
YY_BUFFER_STATE yy_current_buffer = 0
char yy_hold_char
int yy_n_chars
char * yy_c_buf_p = (char *) 0
int yy_init = 1
int yy_start = 0
int yy_did_buffer_switch_on_eof
char * yytext
short int yy_accept [367]
int yy_ec [256]
int yy_meta [49]
short int yy_base [373]
short int yy_def [373]
short int yy_nxt [445]
short int yy_chk [445]
yy_state_type yy_last_accepting_state
char * yy_last_accepting_cpos
ulint stringbuf_len_alloc = 0
ulint stringbuf_len = 0
char * stringbuf

Define Documentation

#define BEGIN   yy_start = 1 + 2 *
 

#define comment   1
 

#define ECHO   (void) fwrite( yytext, yyleng, 1, yyout )
 

#define EOB_ACT_CONTINUE_SCAN   0
 

#define EOB_ACT_END_OF_FILE   1
 

#define EOB_ACT_LAST_MATCH   2
 

#define exit (  A   )     ut_error
 

#define FLEX_SCANNER
 

#define free (  A   )     ut_free(A)
 

#define INITIAL   0
 

#define malloc (  A   )     ut_malloc(A)
 

#define quoted   2
 

#define realloc (  P,
A   )     ut_realloc(P, A)
 

#define REJECT   reject_used_but_not_detected
 

#define unput (  c   )     yyunput( c, yytext_ptr )
 

 
#define YY_AT_BOL (   )     (yy_current_buffer->yy_at_bol)
 

#define YY_BREAK   break;
 

#define YY_BUF_SIZE   16384
 

#define YY_BUFFER_EOF_PENDING   2
 

#define YY_BUFFER_NEW   0
 

#define YY_BUFFER_NORMAL   1
 

#define YY_CURRENT_BUFFER   yy_current_buffer
 

#define YY_DECL   int yylex YY_PROTO(( void ))
 

#define YY_DO_BEFORE_ACTION
 

Value:

yytext_ptr = yy_bp; \
        yyleng = (int) (yy_cp - yy_bp); \
        yy_hold_char = *yy_cp; \
        *yy_cp = '\0'; \
        yy_c_buf_p = yy_cp;

#define YY_END_OF_BUFFER   108
 

#define YY_END_OF_BUFFER_CHAR   0
 

#define YY_EXIT_FAILURE   2
 

#define YY_FATAL_ERROR (  msg   )     yy_fatal_error( msg )
 

#define YY_FLEX_MAJOR_VERSION   2
 

#define YY_FLEX_MINOR_VERSION   5
 

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )
 

#define YY_INPUT (  buf,
result,
max_size   )     pars_get_lex_chars(buf, &result, max_size)
 

#define YY_MORE_ADJ   0
 

#define YY_NEVER_INTERACTIVE   1
 

#define yy_new_buffer   yy_create_buffer
 

#define YY_NEW_FILE   yyrestart( yyin )
 

#define YY_NO_INPUT   1
 

#define YY_NO_POP_STATE   1
 

#define YY_NO_PUSH_STATE   1
 

#define YY_NO_SCAN_BUFFER   1
 

#define YY_NO_SCAN_BYTES   1
 

#define YY_NO_SCAN_STRING   1
 

#define YY_NO_TOP_STATE   1
 

#define YY_NO_UNPUT   1
 

#define YY_NULL   0
 

#define YY_NUM_RULES   107
 

#define YY_PROTO (  proto   )     ()
 

#define YY_READ_BUF_SIZE   8192
 

#define YY_RESTORE_YY_MORE_OFFSET
 

#define YY_RULE_SETUP   YY_USER_ACTION
 

#define YY_SC_TO_UI (  c   )     ((unsigned int) (unsigned char) c)
 

#define yy_set_bol (  at_bol   ) 
 

Value:

{ \
        if ( ! yy_current_buffer ) \
                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
        yy_current_buffer->yy_at_bol = at_bol; \
        }

#define yy_set_interactive (  is_interactive   ) 
 

Value:

{ \
        if ( ! yy_current_buffer ) \
                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
        yy_current_buffer->yy_is_interactive = is_interactive; \
        }

#define YY_SKIP_YYWRAP
 

#define YY_START   ((yy_start - 1) / 2)
 

#define YY_START_STACK_INCR   25
 

#define YY_STATE_EOF (  state   )     (YY_END_OF_BUFFER + state + 1)
 

#define yyconst
 

#define yyless (  n   ) 
 

Value:

do \
                { \
                /* Undo effects of setting up yytext. */ \
                yytext[yyleng] = yy_hold_char; \
                yy_c_buf_p = yytext + n; \
                yy_hold_char = *yy_c_buf_p; \
                *yy_c_buf_p = '\0'; \
                yyleng = n; \
                } \
        while ( 0 )

#define yyless (  n   ) 
 

Value:

do \
                { \
                /* Undo effects of setting up yytext. */ \
                *yy_cp = yy_hold_char; \
                YY_RESTORE_YY_MORE_OFFSET \
                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )

 
#define yymore (   )     yymore_used_but_not_detected
 

#define YYSTATE   YY_START
 

#define YYSTYPE   que_node_t*
 

 
#define yyterminate (   )     return YY_NULL
 

#define yytext_ptr   yytext
 

 
#define yywrap (   )     1
 

Typedef Documentation

typedef struct yy_buffer_state* YY_BUFFER_STATE
 

typedef unsigned char YY_CHAR
 

typedef unsigned int yy_size_t
 

typedef int yy_state_type
 

Function Documentation

int input (   )  [static]
  

02100         {
02101         int c;
02102 
02103         *yy_c_buf_p = yy_hold_char;
02104 
02105         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
02106                 {
02107                 /* yy_c_buf_p now points to the character we want to return.
02108                  * If this occurs *before* the EOB characters, then it's a
02109                  * valid NUL; if not, then we've hit the end of the buffer.
02110                  */
02111                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
02112                         /* This was really a NUL. */
02113                         *yy_c_buf_p = '\0';
02114 
02115                 else
02116                         { /* need more input */
02117                         int offset = yy_c_buf_p - yytext_ptr;
02118                         ++yy_c_buf_p;
02119 
02120                         switch ( yy_get_next_buffer() )
02121                                 {
02122                                 case EOB_ACT_LAST_MATCH:
02123                                         /* This happens because yy_g_n_b()
02124                                          * sees that we've accumulated a
02125                                          * token and flags that we need to
02126                                          * try matching the token before
02127                                          * proceeding.  But for input(),
02128                                          * there's no matching to consider.
02129                                          * So convert the EOB_ACT_LAST_MATCH
02130                                          * to EOB_ACT_END_OF_FILE.
02131                                          */
02132 
02133                                         /* Reset buffer status. */
02134                                         yyrestart( yyin );
02135 
02136                                         /* fall through */
02137 
02138                                 case EOB_ACT_END_OF_FILE:
02139                                         {
02140                                         if ( yywrap() )
02141                                                 return EOF;
02142 
02143                                         if ( ! yy_did_buffer_switch_on_eof )
02144                                                 YY_NEW_FILE;
02145 #ifdef __cplusplus
02146                                         return yyinput();
02147 #else
02148                                         return input();
02149 #endif
02150                                         }
02151 
02152                                 case EOB_ACT_CONTINUE_SCAN:
02153                                         yy_c_buf_p = yytext_ptr + offset;
02154                                         break;
02155                                 }
02156                         }
02157                 }
02158 
02159         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
02160         *yy_c_buf_p = '\0';     /* preserve yytext */
02161         yy_hold_char = *++yy_c_buf_p;
02162 
02163 
02164         return c;
02165         }

void string_append (  const char *  str,
ulint  len
)  [static]
  

00654                                      : string to be appended */
00655         ulint           len)    /* in: length of the string */
00656 {
00657         if (stringbuf == NULL) {
00658                 stringbuf = malloc(1);
00659                 stringbuf_len_alloc = 1;
00660         }
00661 
00662         if (stringbuf_len + len > stringbuf_len_alloc) {
00663                 while (stringbuf_len + len > stringbuf_len_alloc) {
00664                         stringbuf_len_alloc <<= 1;
00665                 }
00666                 stringbuf = realloc(stringbuf, stringbuf_len_alloc);
00667         }
00668 
00669         memcpy(stringbuf + stringbuf_len, str, len);
00670         stringbuf_len += len;
00671 }

YY_BUFFER_STATE yy_create_buffer (  FILE *  file,
int  size
) 
  

02233         {
02234         YY_BUFFER_STATE b;
02235 
02236         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
02237         if ( ! b )
02238                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02239 
02240         b->yy_buf_size = size;
02241 
02242         /* yy_ch_buf has to be 2 characters longer than the size given because
02243          * we need to put in 2 end-of-buffer characters.
02244          */
02245         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
02246         if ( ! b->yy_ch_buf )
02247                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02248 
02249         b->yy_is_our_buffer = 1;
02250 
02251         yy_init_buffer( b, file );
02252 
02253         return b;
02254         }

YY_BUFFER_STATE yy_create_buffer (   ) 
 

void yy_delete_buffer (  YY_BUFFER_STATE  b  ) 
  

02263         {
02264         if ( ! b )
02265                 return;
02266 
02267         if ( b == yy_current_buffer )
02268                 yy_current_buffer = (YY_BUFFER_STATE) 0;
02269 
02270         if ( b->yy_is_our_buffer )
02271                 yy_flex_free( (void *) b->yy_ch_buf );
02272 
02273         yy_flex_free( (void *) b );
02274         }

void yy_delete_buffer (   ) 
 

void yy_fatal_error (  msg   )  [static]
  

02496         {
02497         (void) fprintf( stderr, "%s\n", msg );
02498         exit( YY_EXIT_FAILURE );
02499         }

void yy_fatal_error (   )  [static]
 

void* yy_flex_alloc (  yy_size_t  size  )  [static]
  

02560         {
02561         return (void *) malloc( size );
02562         }

void* yy_flex_alloc (   )  [static]
 

void yy_flex_free (  void *  ptr  )  [static]
  

02588         {
02589         free( ptr );
02590         }

void yy_flex_free (   )  [static]
 

void* yy_flex_realloc (  void *  ptr,
yy_size_t  size
)  [static]
  

02571         {
02572         /* The cast to (char *) in the following accommodates both
02573          * implementations that use char* generic pointers, and those
02574          * that use void* generic pointers.  It works with the latter
02575          * because both ANSI C and C++ allow castless assignment from
02576          * any pointer type to void*, and deal with argument conversions
02577          * as though doing an assignment.
02578          */
02579         return (void *) realloc( (char *) ptr, size );
02580         }

void* yy_flex_realloc (   )  [static]
 

void yy_flush_buffer (  YY_BUFFER_STATE  b  ) 
  

02317         {
02318         if ( ! b )
02319                 return;
02320 
02321         b->yy_n_chars = 0;
02322 
02323         /* We always need two end-of-buffer characters.  The first causes
02324          * a transition to the end-of-buffer state.  The second causes
02325          * a jam in that state.
02326          */
02327         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
02328         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
02329 
02330         b->yy_buf_pos = &b->yy_ch_buf[0];
02331 
02332         b->yy_at_bol = 1;
02333         b->yy_buffer_status = YY_BUFFER_NEW;
02334 
02335         if ( b == yy_current_buffer )
02336                 yy_load_buffer_state();
02337         }

void yy_flush_buffer (   ) 
 

int yy_get_next_buffer (   )  [static]
  

01856         {
01857         register char *dest = yy_current_buffer->yy_ch_buf;
01858         register char *source = yytext_ptr;
01859         register int number_to_move, i;
01860         int ret_val;
01861 
01862         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01863                 YY_FATAL_ERROR(
01864                 "fatal flex scanner internal error--end of buffer missed" );
01865 
01866         if ( yy_current_buffer->yy_fill_buffer == 0 )
01867                 { /* Don't try to fill the buffer, so this is an EOF. */
01868                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01869                         {
01870                         /* We matched a single character, the EOB, so
01871                          * treat this as a final EOF.
01872                          */
01873                         return EOB_ACT_END_OF_FILE;
01874                         }
01875 
01876                 else
01877                         {
01878                         /* We matched some text prior to the EOB, first
01879                          * process it.
01880                          */
01881                         return EOB_ACT_LAST_MATCH;
01882                         }
01883                 }
01884 
01885         /* Try to read more data. */
01886 
01887         /* First move last chars to start of buffer. */
01888         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01889 
01890         for ( i = 0; i < number_to_move; ++i )
01891                 *(dest++) = *(source++);
01892 
01893         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01894                 /* don't do the read, it's not guaranteed to return an EOF,
01895                  * just force an EOF
01896                  */
01897                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01898 
01899         else
01900                 {
01901                 int num_to_read =
01902                         yy_current_buffer->yy_buf_size - number_to_move - 1;
01903 
01904                 while ( num_to_read <= 0 )
01905                         { /* Not enough room in the buffer - grow it. */
01906 #ifdef YY_USES_REJECT
01907                         YY_FATAL_ERROR(
01908 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01909 #else
01910 
01911                         /* just a shorter name for the current buffer */
01912                         YY_BUFFER_STATE b = yy_current_buffer;
01913 
01914                         int yy_c_buf_p_offset =
01915                                 (int) (yy_c_buf_p - b->yy_ch_buf);
01916 
01917                         if ( b->yy_is_our_buffer )
01918                                 {
01919                                 int new_size = b->yy_buf_size * 2;
01920 
01921                                 if ( new_size <= 0 )
01922                                         b->yy_buf_size += b->yy_buf_size / 8;
01923                                 else
01924                                         b->yy_buf_size *= 2;
01925 
01926                                 b->yy_ch_buf = (char *)
01927                                         /* Include room in for 2 EOB chars. */
01928                                         yy_flex_realloc( (void *) b->yy_ch_buf,
01929                                                          b->yy_buf_size + 2 );
01930                                 }
01931                         else
01932                                 /* Can't grow it, we don't own it. */
01933                                 b->yy_ch_buf = 0;
01934 
01935                         if ( ! b->yy_ch_buf )
01936                                 YY_FATAL_ERROR(
01937                                 "fatal error - scanner input buffer overflow" );
01938 
01939                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01940 
01941                         num_to_read = yy_current_buffer->yy_buf_size -
01942                                                 number_to_move - 1;
01943 #endif
01944                         }
01945 
01946                 if ( num_to_read > YY_READ_BUF_SIZE )
01947                         num_to_read = YY_READ_BUF_SIZE;
01948 
01949                 /* Read in more data. */
01950                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01951                         yy_n_chars, num_to_read );
01952 
01953                 yy_current_buffer->yy_n_chars = yy_n_chars;
01954                 }
01955 
01956         if ( yy_n_chars == 0 )
01957                 {
01958                 if ( number_to_move == YY_MORE_ADJ )
01959                         {
01960                         ret_val = EOB_ACT_END_OF_FILE;
01961                         yyrestart( yyin );
01962                         }
01963 
01964                 else
01965                         {
01966                         ret_val = EOB_ACT_LAST_MATCH;
01967                         yy_current_buffer->yy_buffer_status =
01968                                 YY_BUFFER_EOF_PENDING;
01969                         }
01970                 }
01971 
01972         else
01973                 ret_val = EOB_ACT_CONTINUE_SCAN;
01974 
01975         yy_n_chars += number_to_move;
01976         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01977         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01978 
01979         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01980 
01981         return ret_val;
01982         }

yy_state_type yy_get_previous_state (   )  [static]
  

01988         {
01989         register yy_state_type yy_current_state;
01990         register char *yy_cp;
01991 
01992         yy_current_state = yy_start;
01993 
01994         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01995                 {
01996                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01997                 if ( yy_accept[yy_current_state] )
01998                         {
01999                         yy_last_accepting_state = yy_current_state;
02000                         yy_last_accepting_cpos = yy_cp;
02001                         }
02002                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02003                         {
02004                         yy_current_state = (int) yy_def[yy_current_state];
02005                         if ( yy_current_state >= 367 )
02006                                 yy_c = yy_meta[(unsigned int) yy_c];
02007                         }
02008                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02009                 }
02010 
02011         return yy_current_state;
02012         }

void yy_init_buffer (  YY_BUFFER_STATE  b,
FILE *  file
) 
  

02292         {
02293         yy_flush_buffer( b );
02294 
02295         b->yy_input_file = file;
02296         b->yy_fill_buffer = 1;
02297 
02298 #if YY_ALWAYS_INTERACTIVE
02299         b->yy_is_interactive = 1;
02300 #else
02301 #if YY_NEVER_INTERACTIVE
02302         b->yy_is_interactive = 0;
02303 #else
02304         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
02305 #endif
02306 #endif
02307         }

void yy_init_buffer (   ) 
 

void yy_load_buffer_state (   ) 
  

02218         {
02219         yy_n_chars = yy_current_buffer->yy_n_chars;
02220         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
02221         yyin = yy_current_buffer->yy_input_file;
02222         yy_hold_char = *yy_c_buf_p;
02223         }

YY_BUFFER_STATE yy_scan_buffer (   ) 
 

YY_BUFFER_STATE yy_scan_bytes (   ) 
 

YY_BUFFER_STATE yy_scan_string (   ) 
 

void yy_switch_to_buffer (  YY_BUFFER_STATE  new_buffer  ) 
  

02189         {
02190         if ( yy_current_buffer == new_buffer )
02191                 return;
02192 
02193         if ( yy_current_buffer )
02194                 {
02195                 /* Flush out information for old buffer. */
02196                 *yy_c_buf_p = yy_hold_char;
02197                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
02198                 yy_current_buffer->yy_n_chars = yy_n_chars;
02199                 }
02200 
02201         yy_current_buffer = new_buffer;
02202         yy_load_buffer_state();
02203 
02204         /* We don't actually know whether we did this switch during
02205          * EOF (yywrap()) processing, but the only time this flag
02206          * is looked at is after yywrap() is called, so it's safe
02207          * to go ahead and always set it.
02208          */
02209         yy_did_buffer_switch_on_eof = 1;
02210         }

void yy_switch_to_buffer (   ) 
 

yy_state_type yy_try_NUL_trans (  yy_state_type  yy_current_state  )  [static]
  

02027         {
02028         register int yy_is_jam;
02029         register char *yy_cp = yy_c_buf_p;
02030 
02031         register YY_CHAR yy_c = 1;
02032         if ( yy_accept[yy_current_state] )
02033                 {
02034                 yy_last_accepting_state = yy_current_state;
02035                 yy_last_accepting_cpos = yy_cp;
02036                 }
02037         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02038                 {
02039                 yy_current_state = (int) yy_def[yy_current_state];
02040                 if ( yy_current_state >= 367 )
02041                         yy_c = yy_meta[(unsigned int) yy_c];
02042                 }
02043         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02044         yy_is_jam = (yy_current_state == 366);
02045 
02046         return yy_is_jam ? 0 : yy_current_state;
02047         }

yy_state_type yy_try_NUL_trans (   )  [static]
 

int yylex (  void   ) 
  

00823         {
00824         register yy_state_type yy_current_state;
00825         register char *yy_cp, *yy_bp;
00826         register int yy_act;
00827 
00828 #line 102 "pars0lex.l"
00829 
00830 
00831 #line 830 "lex.yy.c"
00832 
00833         if ( yy_init )
00834                 {
00835                 yy_init = 0;
00836 
00837 #ifdef YY_USER_INIT
00838                 YY_USER_INIT;
00839 #endif
00840 
00841                 if ( ! yy_start )
00842                         yy_start = 1;   /* first start state */
00843 
00844                 if ( ! yyin )
00845                         yyin = stdin;
00846 
00847                 if ( ! yyout )
00848                         yyout = stdout;
00849 
00850                 if ( ! yy_current_buffer )
00851                         yy_current_buffer =
00852                                 yy_create_buffer( yyin, YY_BUF_SIZE );
00853 
00854                 yy_load_buffer_state();
00855                 }
00856 
00857         while ( 1 )             /* loops until end-of-file is reached */
00858                 {
00859                 yy_cp = yy_c_buf_p;
00860 
00861                 /* Support of yytext. */
00862                 *yy_cp = yy_hold_char;
00863 
00864                 /* yy_bp points to the position in yy_ch_buf of the start of
00865                  * the current run.
00866                  */
00867                 yy_bp = yy_cp;
00868 
00869                 yy_current_state = yy_start;
00870 yy_match:
00871                 do
00872                         {
00873                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00874                         if ( yy_accept[yy_current_state] )
00875                                 {
00876                                 yy_last_accepting_state = yy_current_state;
00877                                 yy_last_accepting_cpos = yy_cp;
00878                                 }
00879                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00880                                 {
00881                                 yy_current_state = (int) yy_def[yy_current_state];
00882                                 if ( yy_current_state >= 367 )
00883                                         yy_c = yy_meta[(unsigned int) yy_c];
00884                                 }
00885                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00886                         ++yy_cp;
00887                         }
00888                 while ( yy_base[yy_current_state] != 396 );
00889 
00890 yy_find_action:
00891                 yy_act = yy_accept[yy_current_state];
00892                 if ( yy_act == 0 )
00893                         { /* have to back up */
00894                         yy_cp = yy_last_accepting_cpos;
00895                         yy_current_state = yy_last_accepting_state;
00896                         yy_act = yy_accept[yy_current_state];
00897                         }
00898 
00899                 YY_DO_BEFORE_ACTION;
00900 
00901 
00902 do_action:      /* This label is used only to access EOF actions. */
00903 
00904 
00905                 switch ( yy_act )
00906         { /* beginning of action switch */
00907                         case 0: /* must back up */
00908                         /* undo the effects of YY_DO_BEFORE_ACTION */
00909                         *yy_cp = yy_hold_char;
00910                         yy_cp = yy_last_accepting_cpos;
00911                         yy_current_state = yy_last_accepting_state;
00912                         goto yy_find_action;
00913 
00914 case 1:
00915 YY_RULE_SETUP
00916 #line 104 "pars0lex.l"
00917 {
00918                         yylval = sym_tab_add_int_lit(pars_sym_tab_global,
00919                                                                 atoi(yytext));
00920                         return(PARS_INT_LIT);
00921 }
00922         YY_BREAK
00923 case 2:
00924 YY_RULE_SETUP
00925 #line 110 "pars0lex.l"
00926 {
00927                         ut_error;       /* not implemented */
00928 
00929                         return(PARS_FLOAT_LIT);
00930 }
00931         YY_BREAK
00932 case 3:
00933 YY_RULE_SETUP
00934 #line 116 "pars0lex.l"
00935 {
00936 /* Quoted character string literals are handled in an explicit
00937 start state 'quoted'.  This state is entered and the buffer for
00938 the scanned string is emptied upon encountering a starting quote.
00939 
00940 In the state 'quoted', only two actions are possible (defined below). */
00941                         BEGIN(quoted);
00942                         stringbuf_len = 0;
00943 }
00944         YY_BREAK
00945 case 4:
00946 YY_RULE_SETUP
00947 #line 125 "pars0lex.l"
00948 {
00949                         /* Got a sequence of characters other than "'":
00950                         append to string buffer */
00951                         string_append(yytext, yyleng);
00952 }
00953         YY_BREAK
00954 case 5:
00955 YY_RULE_SETUP
00956 #line 130 "pars0lex.l"
00957 {
00958                         /* Got a sequence of "'" characters:
00959                         append half of them to string buffer,
00960                         as "''" represents a single "'".
00961                         We apply truncating division,
00962                         so that "'''" will result in "'". */
00963 
00964                         string_append(yytext, yyleng / 2);
00965 
00966                         /* If we got an odd number of quotes, then the
00967                         last quote we got is the terminating quote.
00968                         At the end of the string, we return to the
00969                         initial start state and report the scanned
00970                         string literal. */
00971 
00972                         if (yyleng % 2) {
00973                                 BEGIN(INITIAL);
00974                                 yylval = sym_tab_add_str_lit(
00975                                         pars_sym_tab_global,
00976                                         (byte*) stringbuf, stringbuf_len);
00977                                 return(PARS_STR_LIT);
00978                         }
00979 }
00980         YY_BREAK
00981 case 6:
00982 YY_RULE_SETUP
00983 #line 154 "pars0lex.l"
00984 {
00985                         yylval = sym_tab_add_null_lit(pars_sym_tab_global);
00986 
00987                         return(PARS_NULL_LIT);
00988 }
00989         YY_BREAK
00990 case 7:
00991 YY_RULE_SETUP
00992 #line 160 "pars0lex.l"
00993 {
00994                         /* Implicit cursor name */
00995                         yylval = sym_tab_add_str_lit(pars_sym_tab_global,
00996                                                         (byte*) yytext, yyleng);
00997                         return(PARS_SQL_TOKEN);
00998 }
00999         YY_BREAK
01000 case 8:
01001 YY_RULE_SETUP
01002 #line 167 "pars0lex.l"
01003 {
01004                         return(PARS_AND_TOKEN);
01005 }
01006         YY_BREAK
01007 case 9:
01008 YY_RULE_SETUP
01009 #line 171 "pars0lex.l"
01010 {
01011                         return(PARS_OR_TOKEN);
01012 }
01013         YY_BREAK
01014 case 10:
01015 YY_RULE_SETUP
01016 #line 175 "pars0lex.l"
01017 {
01018                         return(PARS_NOT_TOKEN);
01019 }
01020         YY_BREAK
01021 case 11:
01022 YY_RULE_SETUP
01023 #line 179 "pars0lex.l"
01024 {
01025                         return(PARS_PROCEDURE_TOKEN);
01026 }
01027         YY_BREAK
01028 case 12:
01029 YY_RULE_SETUP
01030 #line 183 "pars0lex.l"
01031 {
01032                         return(PARS_IN_TOKEN);
01033 }
01034         YY_BREAK
01035 case 13:
01036 YY_RULE_SETUP
01037 #line 187 "pars0lex.l"
01038 {
01039                         return(PARS_OUT_TOKEN);
01040 }
01041         YY_BREAK
01042 case 14:
01043 YY_RULE_SETUP
01044 #line 191 "pars0lex.l"
01045 {
01046                         return(PARS_INT_TOKEN);
01047 }
01048         YY_BREAK
01049 case 15:
01050 YY_RULE_SETUP
01051 #line 195 "pars0lex.l"
01052 {
01053                         return(PARS_INT_TOKEN);
01054 }
01055         YY_BREAK
01056 case 16:
01057 YY_RULE_SETUP
01058 #line 199 "pars0lex.l"
01059 {
01060                         return(PARS_FLOAT_TOKEN);
01061 }
01062         YY_BREAK
01063 case 17:
01064 YY_RULE_SETUP
01065 #line 203 "pars0lex.l"
01066 {
01067                         return(PARS_CHAR_TOKEN);
01068 }
01069         YY_BREAK
01070 case 18:
01071 YY_RULE_SETUP
01072 #line 207 "pars0lex.l"
01073 {
01074                         return(PARS_IS_TOKEN);
01075 }
01076         YY_BREAK
01077 case 19:
01078 YY_RULE_SETUP
01079 #line 211 "pars0lex.l"
01080 {
01081                         return(PARS_BEGIN_TOKEN);
01082 }
01083         YY_BREAK
01084 case 20:
01085 YY_RULE_SETUP
01086 #line 215 "pars0lex.l"
01087 {
01088                         return(PARS_END_TOKEN);
01089 }
01090         YY_BREAK
01091 case 21:
01092 YY_RULE_SETUP
01093 #line 219 "pars0lex.l"
01094 {
01095                         return(PARS_IF_TOKEN);
01096 }
01097         YY_BREAK
01098 case 22:
01099 YY_RULE_SETUP
01100 #line 223 "pars0lex.l"
01101 {
01102                         return(PARS_THEN_TOKEN);
01103 }
01104         YY_BREAK
01105 case 23:
01106 YY_RULE_SETUP
01107 #line 227 "pars0lex.l"
01108 {
01109                         return(PARS_ELSE_TOKEN);
01110 }
01111         YY_BREAK
01112 case 24:
01113 YY_RULE_SETUP
01114 #line 231 "pars0lex.l"
01115 {
01116                         return(PARS_ELSIF_TOKEN);
01117 }
01118         YY_BREAK
01119 case 25:
01120 YY_RULE_SETUP
01121 #line 235 "pars0lex.l"
01122 {
01123                         return(PARS_LOOP_TOKEN);
01124 }
01125         YY_BREAK
01126 case 26:
01127 YY_RULE_SETUP
01128 #line 239 "pars0lex.l"
01129 {
01130                         return(PARS_WHILE_TOKEN);
01131 }
01132         YY_BREAK
01133 case 27:
01134 YY_RULE_SETUP
01135 #line 243 "pars0lex.l"
01136 {
01137                         return(PARS_RETURN_TOKEN);
01138 }
01139         YY_BREAK
01140 case 28:
01141 YY_RULE_SETUP
01142 #line 247 "pars0lex.l"
01143 {
01144                         return(PARS_SELECT_TOKEN);
01145 }
01146         YY_BREAK
01147 case 29:
01148 YY_RULE_SETUP
01149 #line 251 "pars0lex.l"
01150 {
01151                         return(PARS_SUM_TOKEN);
01152 }
01153         YY_BREAK
01154 case 30:
01155 YY_RULE_SETUP
01156 #line 255 "pars0lex.l"
01157 {
01158                         return(PARS_COUNT_TOKEN);
01159 }
01160         YY_BREAK
01161 case 31:
01162 YY_RULE_SETUP
01163 #line 259 "pars0lex.l"
01164 {
01165                         return(PARS_DISTINCT_TOKEN);
01166 }
01167         YY_BREAK
01168 case 32:
01169 YY_RULE_SETUP
01170 #line 263 "pars0lex.l"
01171 {
01172                         return(PARS_FROM_TOKEN);
01173 }
01174         YY_BREAK
01175 case 33:
01176 YY_RULE_SETUP
01177 #line 267 "pars0lex.l"
01178 {
01179                         return(PARS_WHERE_TOKEN);
01180 }
01181         YY_BREAK
01182 case 34:
01183 YY_RULE_SETUP
01184 #line 271 "pars0lex.l"
01185 {
01186                         return(PARS_FOR_TOKEN);
01187 }
01188         YY_BREAK
01189 case 35:
01190 YY_RULE_SETUP
01191 #line 275 "pars0lex.l"
01192 {
01193                         return(PARS_CONSISTENT_TOKEN);
01194 }
01195         YY_BREAK
01196 case 36:
01197 YY_RULE_SETUP
01198 #line 279 "pars0lex.l"
01199 {
01200                         return(PARS_READ_TOKEN);
01201 }
01202         YY_BREAK
01203 case 37:
01204 YY_RULE_SETUP
01205 #line 283 "pars0lex.l"
01206 {
01207                         return(PARS_ORDER_TOKEN);
01208 }
01209         YY_BREAK
01210 case 38:
01211 YY_RULE_SETUP
01212 #line 287 "pars0lex.l"
01213 {
01214                         return(PARS_BY_TOKEN);
01215 }
01216         YY_BREAK
01217 case 39:
01218 YY_RULE_SETUP
01219 #line 291 "pars0lex.l"
01220 {
01221                         return(PARS_ASC_TOKEN);
01222 }
01223         YY_BREAK
01224 case 40:
01225 YY_RULE_SETUP
01226 #line 295 "pars0lex.l"
01227 {
01228                         return(PARS_DESC_TOKEN);
01229 }
01230         YY_BREAK
01231 case 41:
01232 YY_RULE_SETUP
01233 #line 299 "pars0lex.l"
01234 {
01235                         return(PARS_INSERT_TOKEN);
01236 }
01237         YY_BREAK
01238 case 42:
01239 YY_RULE_SETUP
01240 #line 303 "pars0lex.l"
01241 {
01242                         return(PARS_INTO_TOKEN);
01243 }
01244         YY_BREAK
01245 case 43:
01246 YY_RULE_SETUP
01247 #line 307 "pars0lex.l"
01248 {
01249                         return(PARS_VALUES_TOKEN);
01250 }
01251         YY_BREAK
01252 case 44:
01253 YY_RULE_SETUP
01254 #line 311 "pars0lex.l"
01255 {
01256                         return(PARS_UPDATE_TOKEN);
01257 }
01258         YY_BREAK
01259 case 45:
01260 YY_RULE_SETUP
01261 #line 315 "pars0lex.l"
01262 {
01263                         return(PARS_SET_TOKEN);
01264 }
01265         YY_BREAK
01266 case 46:
01267 YY_RULE_SETUP
01268 #line 319 "pars0lex.l"
01269 {
01270                         return(PARS_DELETE_TOKEN);
01271 }
01272         YY_BREAK
01273 case 47:
01274 YY_RULE_SETUP
01275 #line 323 "pars0lex.l"
01276 {
01277                         return(PARS_CURRENT_TOKEN);
01278 }
01279         YY_BREAK
01280 case 48:
01281 YY_RULE_SETUP
01282 #line 327 "pars0lex.l"
01283 {
01284                         return(PARS_OF_TOKEN);
01285 }
01286         YY_BREAK
01287 case 49:
01288 YY_RULE_SETUP
01289 #line 331 "pars0lex.l"
01290 {
01291                         return(PARS_CREATE_TOKEN);
01292 }
01293         YY_BREAK
01294 case 50:
01295 YY_RULE_SETUP
01296 #line 335 "pars0lex.l"
01297 {
01298                         return(PARS_TABLE_TOKEN);
01299 }
01300         YY_BREAK
01301 case 51:
01302 YY_RULE_SETUP
01303 #line 339 "pars0lex.l"
01304 {
01305                         return(PARS_INDEX_TOKEN);
01306 }
01307         YY_BREAK
01308 case 52:
01309 YY_RULE_SETUP
01310 #line 343 "pars0lex.l"
01311 {
01312                         return(PARS_UNIQUE_TOKEN);
01313 }
01314         YY_BREAK
01315 case 53:
01316 YY_RULE_SETUP
01317 #line 347 "pars0lex.l"
01318 {
01319                         return(PARS_CLUSTERED_TOKEN);
01320 }
01321         YY_BREAK
01322 case 54:
01323 YY_RULE_SETUP
01324 #line 351 "pars0lex.l"
01325 {
01326                         return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN);
01327 }
01328         YY_BREAK
01329 case 55:
01330 YY_RULE_SETUP
01331 #line 355 "pars0lex.l"
01332 {
01333                         return(PARS_ON_TOKEN);
01334 }
01335         YY_BREAK
01336 case 56:
01337 YY_RULE_SETUP
01338 #line 359 "pars0lex.l"
01339 {
01340                         return(PARS_DECLARE_TOKEN);
01341 }
01342         YY_BREAK
01343 case 57:
01344 YY_RULE_SETUP
01345 #line 363 "pars0lex.l"
01346 {
01347                         return(PARS_CURSOR_TOKEN);
01348 }
01349         YY_BREAK
01350 case 58:
01351 YY_RULE_SETUP
01352 #line 367 "pars0lex.l"
01353 {
01354                         return(PARS_OPEN_TOKEN);
01355 }
01356         YY_BREAK
01357 case 59:
01358 YY_RULE_SETUP
01359 #line 371 "pars0lex.l"
01360 {
01361                         return(PARS_FETCH_TOKEN);
01362 }
01363         YY_BREAK
01364 case 60:
01365 YY_RULE_SETUP
01366 #line 375 "pars0lex.l"
01367 {
01368                         return(PARS_CLOSE_TOKEN);
01369 }
01370         YY_BREAK
01371 case 61:
01372 YY_RULE_SETUP
01373 #line 379 "pars0lex.l"
01374 {
01375                         return(PARS_NOTFOUND_TOKEN);
01376 }
01377         YY_BREAK
01378 case 62:
01379 YY_RULE_SETUP
01380 #line 383 "pars0lex.l"
01381 {
01382                         return(PARS_TO_CHAR_TOKEN);
01383 }
01384         YY_BREAK
01385 case 63:
01386 YY_RULE_SETUP
01387 #line 387 "pars0lex.l"
01388 {
01389                         return(PARS_TO_NUMBER_TOKEN);
01390 }
01391         YY_BREAK
01392 case 64:
01393 YY_RULE_SETUP
01394 #line 391 "pars0lex.l"
01395 {
01396                         return(PARS_TO_BINARY_TOKEN);
01397 }
01398         YY_BREAK
01399 case 65:
01400 YY_RULE_SETUP
01401 #line 395 "pars0lex.l"
01402 {
01403                         return(PARS_BINARY_TO_NUMBER_TOKEN);
01404 }
01405         YY_BREAK
01406 case 66:
01407 YY_RULE_SETUP
01408 #line 399 "pars0lex.l"
01409 {
01410                         return(PARS_SUBSTR_TOKEN);
01411 }
01412         YY_BREAK
01413 case 67:
01414 YY_RULE_SETUP
01415 #line 403 "pars0lex.l"
01416 {
01417                         return(PARS_REPLSTR_TOKEN);
01418 }
01419         YY_BREAK
01420 case 68:
01421 YY_RULE_SETUP
01422 #line 407 "pars0lex.l"
01423 {
01424                         return(PARS_CONCAT_TOKEN);
01425 }
01426         YY_BREAK
01427 case 69:
01428 YY_RULE_SETUP
01429 #line 411 "pars0lex.l"
01430 {
01431                         return(PARS_INSTR_TOKEN);
01432 }
01433         YY_BREAK
01434 case 70:
01435 YY_RULE_SETUP
01436 #line 415 "pars0lex.l"
01437 {
01438                         return(PARS_LENGTH_TOKEN);
01439 }
01440         YY_BREAK
01441 case 71:
01442 YY_RULE_SETUP
01443 #line 419 "pars0lex.l"
01444 {
01445                         return(PARS_SYSDATE_TOKEN);
01446 }
01447         YY_BREAK
01448 case 72:
01449 YY_RULE_SETUP
01450 #line 423 "pars0lex.l"
01451 {
01452                         return(PARS_PRINTF_TOKEN);
01453 }
01454         YY_BREAK
01455 case 73:
01456 YY_RULE_SETUP
01457 #line 427 "pars0lex.l"
01458 {
01459                         return(PARS_ASSERT_TOKEN);
01460 }
01461         YY_BREAK
01462 case 74:
01463 YY_RULE_SETUP
01464 #line 431 "pars0lex.l"
01465 {
01466                         return(PARS_RND_TOKEN);
01467 }
01468         YY_BREAK
01469 case 75:
01470 YY_RULE_SETUP
01471 #line 435 "pars0lex.l"
01472 {
01473                         return(PARS_RND_STR_TOKEN);
01474 }
01475         YY_BREAK
01476 case 76:
01477 YY_RULE_SETUP
01478 #line 439 "pars0lex.l"
01479 {
01480                         return(PARS_ROW_PRINTF_TOKEN);
01481 }
01482         YY_BREAK
01483 case 77:
01484 YY_RULE_SETUP
01485 #line 443 "pars0lex.l"
01486 {
01487                         return(PARS_COMMIT_TOKEN);
01488 }
01489         YY_BREAK
01490 case 78:
01491 YY_RULE_SETUP
01492 #line 447 "pars0lex.l"
01493 {
01494                         return(PARS_ROLLBACK_TOKEN);
01495 }
01496         YY_BREAK
01497 case 79:
01498 YY_RULE_SETUP
01499 #line 451 "pars0lex.l"
01500 {
01501                         return(PARS_WORK_TOKEN);
01502 }
01503         YY_BREAK
01504 case 80:
01505 YY_RULE_SETUP
01506 #line 455 "pars0lex.l"
01507 {
01508                         yylval = sym_tab_add_id(pars_sym_tab_global,
01509                                                         (byte*)yytext,
01510                                                         ut_strlen(yytext));
01511                         return(PARS_ID_TOKEN);
01512 }
01513         YY_BREAK
01514 case 81:
01515 YY_RULE_SETUP
01516 #line 462 "pars0lex.l"
01517 {
01518                         return(PARS_DDOT_TOKEN);
01519 }
01520         YY_BREAK
01521 case 82:
01522 YY_RULE_SETUP
01523 #line 466 "pars0lex.l"
01524 {
01525                         return(PARS_ASSIGN_TOKEN);
01526 }
01527         YY_BREAK
01528 case 83:
01529 YY_RULE_SETUP
01530 #line 470 "pars0lex.l"
01531 {
01532                         return(PARS_LE_TOKEN);
01533 }
01534         YY_BREAK
01535 case 84:
01536 YY_RULE_SETUP
01537 #line 474 "pars0lex.l"
01538 {
01539                         return(PARS_GE_TOKEN);
01540 }
01541         YY_BREAK
01542 case 85:
01543 YY_RULE_SETUP
01544 #line 478 "pars0lex.l"
01545 {
01546                         return(PARS_NE_TOKEN);
01547 }
01548         YY_BREAK
01549 case 86:
01550 YY_RULE_SETUP
01551 #line 482 "pars0lex.l"
01552 {
01553 
01554                         return((int)(*yytext));
01555 }
01556         YY_BREAK
01557 case 87:
01558 YY_RULE_SETUP
01559 #line 487 "pars0lex.l"
01560 {
01561 
01562                         return((int)(*yytext));
01563 }
01564         YY_BREAK
01565 case 88:
01566 YY_RULE_SETUP
01567 #line 492 "pars0lex.l"
01568 {
01569 
01570                         return((int)(*yytext));
01571 }
01572         YY_BREAK
01573 case 89:
01574 YY_RULE_SETUP
01575 #line 497 "pars0lex.l"
01576 {
01577 
01578                         return((int)(*yytext));
01579 }
01580         YY_BREAK
01581 case 90:
01582 YY_RULE_SETUP
01583 #line 502 "pars0lex.l"
01584 {
01585 
01586                         return((int)(*yytext));
01587 }
01588         YY_BREAK
01589 case 91:
01590 YY_RULE_SETUP
01591 #line 507 "pars0lex.l"
01592 {
01593 
01594                         return((int)(*yytext));
01595 }
01596         YY_BREAK
01597 case 92:
01598 YY_RULE_SETUP
01599 #line 512 "pars0lex.l"
01600 {
01601 
01602                         return((int)(*yytext));
01603 }
01604         YY_BREAK
01605 case 93:
01606 YY_RULE_SETUP
01607 #line 517 "pars0lex.l"
01608 {
01609 
01610                         return((int)(*yytext));
01611 }
01612         YY_BREAK
01613 case 94:
01614 YY_RULE_SETUP
01615 #line 522 "pars0lex.l"
01616 {
01617 
01618                         return((int)(*yytext));
01619 }
01620         YY_BREAK
01621 case 95:
01622 YY_RULE_SETUP
01623 #line 527 "pars0lex.l"
01624 {
01625 
01626                         return((int)(*yytext));
01627 }
01628         YY_BREAK
01629 case 96:
01630 YY_RULE_SETUP
01631 #line 532 "pars0lex.l"
01632 {
01633 
01634                         return((int)(*yytext));
01635 }
01636         YY_BREAK
01637 case 97:
01638 YY_RULE_SETUP
01639 #line 537 "pars0lex.l"
01640 {
01641 
01642                         return((int)(*yytext));
01643 }
01644         YY_BREAK
01645 case 98:
01646 YY_RULE_SETUP
01647 #line 542 "pars0lex.l"
01648 {
01649 
01650                         return((int)(*yytext));
01651 }
01652         YY_BREAK
01653 case 99:
01654 YY_RULE_SETUP
01655 #line 547 "pars0lex.l"
01656 {
01657 
01658                         return((int)(*yytext));
01659 }
01660         YY_BREAK
01661 case 100:
01662 YY_RULE_SETUP
01663 #line 552 "pars0lex.l"
01664 {
01665 
01666                         return((int)(*yytext));
01667 }
01668         YY_BREAK
01669 case 101:
01670 YY_RULE_SETUP
01671 #line 557 "pars0lex.l"
01672 BEGIN(comment); /* eat up comment */
01673         YY_BREAK
01674 case 102:
01675 YY_RULE_SETUP
01676 #line 559 "pars0lex.l"
01677 
01678         YY_BREAK
01679 case 103:
01680 YY_RULE_SETUP
01681 #line 560 "pars0lex.l"
01682 
01683         YY_BREAK
01684 case 104:
01685 YY_RULE_SETUP
01686 #line 561 "pars0lex.l"
01687 BEGIN(INITIAL);
01688         YY_BREAK
01689 case 105:
01690 YY_RULE_SETUP
01691 #line 563 "pars0lex.l"
01692 /* eat up whitespace */
01693         YY_BREAK
01694 case 106:
01695 YY_RULE_SETUP
01696 #line 566 "pars0lex.l"
01697 {
01698                         fprintf(stderr,"Unrecognized character: %02x\n",
01699                                 *yytext);
01700 
01701                         ut_error;
01702 
01703                         return(0);
01704 }
01705         YY_BREAK
01706 case 107:
01707 YY_RULE_SETUP
01708 #line 575 "pars0lex.l"
01709 YY_FATAL_ERROR( "flex scanner jammed" );
01710         YY_BREAK
01711 #line 1710 "lex.yy.c"
01712 case YY_STATE_EOF(INITIAL):
01713 case YY_STATE_EOF(comment):
01714 case YY_STATE_EOF(quoted):
01715         yyterminate();
01716 
01717         case YY_END_OF_BUFFER:
01718                 {
01719                 /* Amount of text matched not including the EOB char. */
01720                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01721 
01722                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01723                 *yy_cp = yy_hold_char;
01724                 YY_RESTORE_YY_MORE_OFFSET
01725 
01726                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
01727                         {
01728                         /* We're scanning a new file or input source.  It's
01729                          * possible that this happened because the user
01730                          * just pointed yyin at a new source and called
01731                          * yylex().  If so, then we have to assure
01732                          * consistency between yy_current_buffer and our
01733                          * globals.  Here is the right place to do so, because
01734                          * this is the first action (other than possibly a
01735                          * back-up) that will match for the new input source.
01736                          */
01737                         yy_n_chars = yy_current_buffer->yy_n_chars;
01738                         yy_current_buffer->yy_input_file = yyin;
01739                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
01740                         }
01741 
01742                 /* Note that here we test for yy_c_buf_p "<=" to the position
01743                  * of the first EOB in the buffer, since yy_c_buf_p will
01744                  * already have been incremented past the NUL character
01745                  * (since all states make transitions on EOB to the
01746                  * end-of-buffer state).  Contrast this with the test
01747                  * in input().
01748                  */
01749                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01750                         { /* This was really a NUL. */
01751                         yy_state_type yy_next_state;
01752 
01753                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
01754 
01755                         yy_current_state = yy_get_previous_state();
01756 
01757                         /* Okay, we're now positioned to make the NUL
01758                          * transition.  We couldn't have
01759                          * yy_get_previous_state() go ahead and do it
01760                          * for us because it doesn't know how to deal
01761                          * with the possibility of jamming (and we don't
01762                          * want to build jamming into it because then it
01763                          * will run more slowly).
01764                          */
01765 
01766                         yy_next_state = yy_try_NUL_trans( yy_current_state );
01767 
01768                         yy_bp = yytext_ptr + YY_MORE_ADJ;
01769 
01770                         if ( yy_next_state )
01771                                 {
01772                                 /* Consume the NUL. */
01773                                 yy_cp = ++yy_c_buf_p;
01774                                 yy_current_state = yy_next_state;
01775                                 goto yy_match;
01776                                 }
01777 
01778                         else
01779                                 {
01780                                 yy_cp = yy_c_buf_p;
01781                                 goto yy_find_action;
01782                                 }
01783                         }
01784 
01785                 else switch ( yy_get_next_buffer() )
01786                         {
01787                         case EOB_ACT_END_OF_FILE:
01788                                 {
01789                                 yy_did_buffer_switch_on_eof = 0;
01790 
01791                                 if ( yywrap() )
01792                                         {
01793                                         /* Note: because we've taken care in
01794                                          * yy_get_next_buffer() to have set up
01795                                          * yytext, we can now set up
01796                                          * yy_c_buf_p so that if some total
01797                                          * hoser (like flex itself) wants to
01798                                          * call the scanner after we return the
01799                                          * YY_NULL, it'll still work - another
01800                                          * YY_NULL will get returned.
01801                                          */
01802                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
01803 
01804                                         yy_act = YY_STATE_EOF(YY_START);
01805                                         goto do_action;
01806                                         }
01807 
01808                                 else
01809                                         {
01810                                         if ( ! yy_did_buffer_switch_on_eof )
01811                                                 YY_NEW_FILE;
01812                                         }
01813                                 break;
01814                                 }
01815 
01816                         case EOB_ACT_CONTINUE_SCAN:
01817                                 yy_c_buf_p =
01818                                         yytext_ptr + yy_amount_of_matched_text;
01819 
01820                                 yy_current_state = yy_get_previous_state();
01821 
01822                                 yy_cp = yy_c_buf_p;
01823                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01824                                 goto yy_match;
01825 
01826                         case EOB_ACT_LAST_MATCH:
01827                                 yy_c_buf_p =
01828                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
01829 
01830                                 yy_current_state = yy_get_previous_state();
01831 
01832                                 yy_cp = yy_c_buf_p;
01833                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01834                                 goto yy_find_action;
01835                         }
01836                 break;
01837                 }
01838 
01839         default:
01840                 YY_FATAL_ERROR(
01841                         "fatal flex scanner internal error--no action found" );
01842         } /* end of action switch */
01843                 } /* end of scanning one token */
01844         } /* end of yylex */

void yyrestart (  FILE *  input_file  ) 
  

02174         {
02175         if ( ! yy_current_buffer )
02176                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
02177 
02178         yy_init_buffer( yy_current_buffer, input_file );
02179         yy_load_buffer_state();
02180         }

void yyrestart (   ) 
 

Variable Documentation

char* stringbuf [static]
 

ulint stringbuf_len = 0 [static]
 

ulint stringbuf_len_alloc = 0 [static]
 

short int yy_accept[367] [static]
 

short int yy_base[373] [static]
 

char* yy_c_buf_p = (char *) 0 [static]
 

short int yy_chk[445] [static]
 

YY_BUFFER_STATE yy_current_buffer = 0 [static]
 

short int yy_def[373] [static]
 

int yy_did_buffer_switch_on_eof [static]
 

int yy_ec[256] [static]
 

char yy_hold_char [static]
 

int yy_init = 1 [static]
 

char* yy_last_accepting_cpos [static]
 

yy_state_type yy_last_accepting_state [static]
 

int yy_meta[49] [static]
 

Initial value:

    {   0,
        1,    1,    1,    1,    2,    1,    1,    3,    1,    1,
        1,    1,    1,    4,    1,    1,    1,    1,    1,    1,
        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
        4,    4,    4,    4,    4,    4,    1,    1
    }

int yy_n_chars [static]
 

short int yy_nxt[445] [static]
 

int yy_start = 0 [static]
 

FILE * yyin = (FILE *) 0 *yyout = (FILE *) 0
 

int yyleng
 

FILE * yyout
 

char * yytext
 

Generated on Thu Feb 24 10:41:14 2005 for MySQL by  doxygen 1.3.9.1