Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
icalsslexer.c File Reference
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include "icalssyacc.h"
#include "icalgaugeimpl.h"
#include "assert.h"
#include <string.h>
#include <unistd.h>

Go to the source code of this file.

Classes

struct  yy_buffer_state
struct  yy_globals_t

Defines

#define YY_REENTRANT   1
#define YY_TEXT_IS_ARRAY
#define YY_REENTRANT_BISON_PURE   1
#define yy_create_buffer   ss_create_buffer
#define yy_delete_buffer   ss_delete_buffer
#define yy_scan_buffer   ss_scan_buffer
#define yy_scan_string   ss_scan_string
#define yy_scan_bytes   ss_scan_bytes
#define yy_flex_debug   ss_flex_debug
#define yy_init_buffer   ss_init_buffer
#define yy_flush_buffer   ss_flush_buffer
#define yy_load_buffer_state   ss_load_buffer_state
#define yy_switch_to_buffer   ss_switch_to_buffer
#define yylex   sslex
#define yyrestart   ssrestart
#define yylex_init   sslex_init
#define yylex_destroy   sslex_destroy
#define yyget_extra   ssget_extra
#define yyset_extra   ssset_extra
#define yyget_in   ssget_in
#define yyset_in   ssset_in
#define yyget_out   ssget_out
#define yyset_out   ssset_out
#define yyget_leng   ssget_leng
#define yyget_text   ssget_text
#define yyget_lineno   ssget_lineno
#define yyset_lineno   ssset_lineno
#define yyget_lval   ssget_lval
#define yyset_lval   ssset_lval
#define yywrap   sswrap
#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 YY_TYPEDEF_YY_SCANNER_T
#define YY_G(var)   (((struct yy_globals_t*)yy_globals)->var)
#define YY_LAST_ARG   , yy_globals
#define YY_ONLY_ARG   yy_globals
#define YY_DECL_LAST_ARG   yyscan_t yy_globals;
#define YY_CALL_LAST_ARG   , yy_globals
#define YY_CALL_ONLY_ARG   yy_globals
#define yyin   YY_G(yyin_r)
#define yyout   YY_G(yyout_r)
#define yyextra   YY_G(yyextra_r)
#define yyleng   YY_G(yyleng_r)
#define yytext   YY_G(yytext_r)
#define yylineno   YY_G(yylineno_r)
#define BEGIN   YY_G(yy_start) = 1 + 2 *
#define YY_START   ((YY_G(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 YY_CALL_LAST_ARG )
#define YY_END_OF_BUFFER_CHAR   0
#define YY_BUF_SIZE   16384
#define YY_TYPEDEF_YY_BUFFER_STATE
#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, YY_G(yytext_ptr) YY_CALL_LAST_ARG )
#define YY_TYPEDEF_YY_SIZE_T
#define YY_STRUCT_YY_BUFFER_STATE
#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_G(yy_current_buffer) YY_CALL_LAST_ARG)
#define yy_new_buffer   yy_create_buffer
#define yy_set_interactive(is_interactive)
#define yy_set_bol(at_bol)
#define YY_AT_BOL()   (YY_G(yy_current_buffer)->yy_at_bol)
#define YY_DO_BEFORE_ACTION
#define YY_NUM_RULES   23
#define YY_END_OF_BUFFER   24
#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 YYLMAX   8192
#define INITIAL   0
#define YYPURE
#define SS_FATAL_ERROR(msg)   sserror(msg)
#define sql   1
#define string_value   2
#define YY_EXTRA_TYPE   void *
#define yylval   YY_G(yylval_r)
#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 YY_INPUT(buf, result, max_size)
#define yyterminate()   return YY_NULL
#define YY_START_STACK_INCR   25
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define YY_LEX_ARGS
#define YY_DECL   int yylex YY_LEX_ARGS
#define YY_USER_ACTION
#define YY_BREAK   break;
#define YY_RULE_SETUP   YY_USER_ACTION
#define YY_EXIT_FAILURE   2
#define yyless(n)

Typedefs

typedef voidyyscan_t
typedef struct yy_buffer_stateYY_BUFFER_STATE
typedef unsigned int yy_size_t
typedef unsigned char YY_CHAR
typedef int yy_state_type

Functions

int yylex_init YY_PROTO ((yyscan_t *scanner))
int yylex_destroy YY_PROTO ((yyscan_t scanner))
void yyrestart YY_PROTO ((FILE *input_file YY_LAST_ARG))
void yy_switch_to_buffer YY_PROTO ((YY_BUFFER_STATE new_buffer YY_LAST_ARG))
void yy_load_buffer_state YY_PROTO ((YY_ONLY_ARG))
YY_BUFFER_STATE yy_create_buffer YY_PROTO ((FILE *file, int size YY_LAST_ARG))
void yy_delete_buffer YY_PROTO ((YY_BUFFER_STATE b YY_LAST_ARG))
void yy_init_buffer YY_PROTO ((YY_BUFFER_STATE b, FILE *file YY_LAST_ARG))
YY_BUFFER_STATE yy_scan_buffer YY_PROTO ((char *base, yy_size_t size YY_LAST_ARG))
YY_BUFFER_STATE yy_scan_string YY_PROTO ((yyconst char *yy_str YY_LAST_ARG))
YY_BUFFER_STATE yy_scan_bytes YY_PROTO ((yyconst char *bytes, int len YY_LAST_ARG))
static void *yy_flex_alloc YY_PROTO ((yy_size_t YY_LAST_ARG))
static void *yy_flex_realloc YY_PROTO ((void *, yy_size_t YY_LAST_ARG))
static void yy_flex_free YY_PROTO ((void *YY_LAST_ARG))
static yy_state_type
yy_try_NUL_trans 
YY_PROTO ((yy_state_type current_stateYY_LAST_ARG))
static void yy_fatal_error YY_PROTO ((yyconst char msg[]))
static int yy_init_globals YY_PROTO ((yyscan_t))
void yyset_extra YY_PROTO ((YY_EXTRA_TYPE user_defined YY_LAST_ARG))
void yyset_in YY_PROTO ((FILE *in_str YY_LAST_ARG))
void yyset_out YY_PROTO ((FILE *out_str YY_LAST_ARG))
void yyset_lineno YY_PROTO ((int line_number YY_LAST_ARG))
void yyset_lval YY_PROTO ((YYSTYPE *yylvalp YY_LAST_ARG))
static void yyunput YY_PROTO ((int c, char *buf_ptrYY_LAST_ARG))
static void yy_flex_strncpy YY_PROTO ((char *, yyconst char *, int YY_LAST_ARG))
int yylex YY_PROTO (YY_LEX_ARGS)
 if (YY_G(yy_init))
 while (1)
static int yy_get_next_buffer (YY_ONLY_ARG)
static yy_state_type yy_get_previous_state (YY_ONLY_ARG)
static yy_state_type yy_try_NUL_trans (yy_current_state YY_LAST_ARG) yy_state_type yy_current_state
void yy_init_buffer (b, file YY_LAST_ARG) YY_BUFFER_STATE b

Variables

static yyconst short int yy_accept [56]
static yyconst int yy_ec [256]
static yyconst int yy_meta [30]
static yyconst short int yy_base [58]
static yyconst short int yy_def [58]
static yyconst short int yy_nxt [99]
static yyconst short int yy_chk [99]
YY_DECL register yy_state_type yy_current_state
register char * yy_cp
register char * yy_bp
register int yy_act
 yylval = yylvalp
int size
FILEfile
YY_DECL_LAST_ARG int len
yyconst char * s2
int n

Class Documentation

struct yy_buffer_state

Definition at line 238 of file icalsslexer.c.

Collaboration diagram for yy_buffer_state:
Class Members
int yy_at_bol
char * yy_buf_pos
yy_size_t yy_buf_size
int yy_buffer_status
char * yy_ch_buf
int yy_fill_buffer
FILE * yy_input_file
int yy_is_interactive
int yy_is_our_buffer
int yy_n_chars
struct yy_globals_t

Definition at line 620 of file icalsslexer.c.

Collaboration diagram for yy_globals_t:
Class Members
char * yy_c_buf_p
YY_BUFFER_STATE yy_current_buffer
int yy_did_buffer_switch_on_eof
char yy_hold_char
int yy_init
char * yy_last_accepting_cpos
yy_state_type yy_last_accepting_state
int yy_more_offset
int yy_n_chars
int yy_prev_more_offset
int yy_start
int * yy_start_stack
int yy_start_stack_depth
int yy_start_stack_ptr
YY_EXTRA_TYPE yyextra_r
FILE * yyin_r
int yyleng_r
int yylineno_r
YYSTYPE * yylval_r
FILE * yyout_r
char * yytext_ptr
char yytext_r

Define Documentation

#define BEGIN   YY_G(yy_start) = 1 + 2 *

Definition at line 157 of file icalsslexer.c.

Definition at line 822 of file icalsslexer.c.

Definition at line 193 of file icalsslexer.c.

Definition at line 194 of file icalsslexer.c.

Definition at line 195 of file icalsslexer.c.

Definition at line 47 of file icalsslexer.c.

#define INITIAL   0

Definition at line 550 of file icalsslexer.c.

#define REJECT   reject_used_but_not_detected

Definition at line 537 of file icalsslexer.c.

#define sql   1

Definition at line 592 of file icalsslexer.c.

Definition at line 590 of file icalsslexer.c.

Definition at line 593 of file icalsslexer.c.

Definition at line 224 of file icalsslexer.c.

#define YY_AT_BOL ( )    (YY_G(yy_current_buffer)->yy_at_bol)

Definition at line 386 of file icalsslexer.c.

Definition at line 935 of file icalsslexer.c.

#define YY_BUF_SIZE   16384

Definition at line 175 of file icalsslexer.c.

Definition at line 295 of file icalsslexer.c.

Definition at line 283 of file icalsslexer.c.

Definition at line 284 of file icalsslexer.c.

#define YY_CALL_LAST_ARG   , yy_globals

Definition at line 127 of file icalsslexer.c.

#define YY_CALL_ONLY_ARG   yy_globals

Definition at line 128 of file icalsslexer.c.

#define yy_create_buffer   ss_create_buffer

Definition at line 10 of file icalsslexer.c.

Definition at line 313 of file icalsslexer.c.

Definition at line 921 of file icalsslexer.c.

#define YY_DECL_LAST_ARG   yyscan_t yy_globals;

Definition at line 123 of file icalsslexer.c.

#define yy_delete_buffer   ss_delete_buffer

Definition at line 11 of file icalsslexer.c.

Value:
YY_G(yytext_ptr) = yy_bp; \
/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
       yyleng = (size_t) (yy_cp - yy_bp); \
       YY_G(yy_hold_char) = *yy_cp; \
       *yy_cp = '\0'; \
/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
       if ( yyleng >= YYLMAX ) \
              YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
       yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 YY_CALL_LAST_ARG); \
       YY_G(yy_c_buf_p) = yy_cp;

Definition at line 416 of file icalsslexer.c.

Definition at line 434 of file icalsslexer.c.

Definition at line 172 of file icalsslexer.c.

Definition at line 612 of file icalsslexer.c.

Definition at line 880 of file icalsslexer.c.

#define yy_flex_debug   ss_flex_debug

Definition at line 15 of file icalsslexer.c.

Definition at line 48 of file icalsslexer.c.

Definition at line 49 of file icalsslexer.c.

#define yy_flush_buffer   ss_flush_buffer

Definition at line 17 of file icalsslexer.c.

Definition at line 352 of file icalsslexer.c.

#define YY_G (   var)    (((struct yy_globals_t*)yy_globals)->var)

Definition at line 114 of file icalsslexer.c.

#define yy_init_buffer   ss_init_buffer

Definition at line 16 of file icalsslexer.c.

#define YY_INPUT (   buf,
  result,
  max_size 
)
Value:
/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
       if ( YY_G(yy_current_buffer)->yy_is_interactive ) \
              { \
		int c = '*'; \
              size_t n; \
              for ( n = 0; n < max_size && \
                          (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
                     buf[n] = (char) c; \
              if ( c == '\n' ) \
                     buf[n++] = (char) c; \
              if ( c == EOF && ferror( yyin ) ) \
                     YY_FATAL_ERROR( "input in flex scanner failed" ); \
              result = n; \
              } \
       else \
              { \
              errno=0; \
              while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
                     { \
                     if( errno != EINTR) \
                            { \
                            YY_FATAL_ERROR( "input in flex scanner failed" ); \
                            break; \
                            } \
                     errno=0; \
                     clearerr(yyin); \
                     } \
              }

Definition at line 831 of file icalsslexer.c.

#define YY_LAST_ARG   , yy_globals

Definition at line 121 of file icalsslexer.c.

Value:
(yylvalp YY_LAST_ARG) \
                             YYSTYPE * yylvalp; YY_DECL_LAST_ARG

Definition at line 906 of file icalsslexer.c.

#define yy_load_buffer_state   ss_load_buffer_state

Definition at line 18 of file icalsslexer.c.

Definition at line 539 of file icalsslexer.c.

Definition at line 368 of file icalsslexer.c.

Definition at line 170 of file icalsslexer.c.

Definition at line 806 of file icalsslexer.c.

Definition at line 805 of file icalsslexer.c.

Definition at line 807 of file icalsslexer.c.

#define YY_NULL   0

Definition at line 95 of file icalsslexer.c.

#define YY_NUM_RULES   23

Definition at line 433 of file icalsslexer.c.

#define YY_ONLY_ARG   yy_globals

Definition at line 122 of file icalsslexer.c.

#define YY_PROTO (   proto)    ()

Definition at line 91 of file icalsslexer.c.

Definition at line 812 of file icalsslexer.c.

Definition at line 1 of file icalsslexer.c.

Definition at line 3 of file icalsslexer.c.

Definition at line 540 of file icalsslexer.c.

Definition at line 939 of file icalsslexer.c.

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

Definition at line 102 of file icalsslexer.c.

#define yy_scan_buffer   ss_scan_buffer

Definition at line 12 of file icalsslexer.c.

#define yy_scan_bytes   ss_scan_bytes

Definition at line 14 of file icalsslexer.c.

#define yy_scan_string   ss_scan_string

Definition at line 13 of file icalsslexer.c.

#define yy_set_bol (   at_bol)
Value:
{ \
       if ( ! YY_G(yy_current_buffer) ) \
              YY_G(yy_current_buffer) =    \
            yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
       YY_G(yy_current_buffer)->yy_at_bol = at_bol; \
       }

Definition at line 378 of file icalsslexer.c.

#define yy_set_interactive (   is_interactive)
Value:
{ \
       if ( ! YY_G(yy_current_buffer) ) \
              YY_G(yy_current_buffer) =    \
            yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
       YY_G(yy_current_buffer)->yy_is_interactive = is_interactive; \
       }

Definition at line 370 of file icalsslexer.c.

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

Definition at line 163 of file icalsslexer.c.

Definition at line 874 of file icalsslexer.c.

Definition at line 167 of file icalsslexer.c.

Definition at line 237 of file icalsslexer.c.

#define yy_switch_to_buffer   ss_switch_to_buffer

Definition at line 19 of file icalsslexer.c.

Definition at line 2 of file icalsslexer.c.

Definition at line 179 of file icalsslexer.c.

Definition at line 109 of file icalsslexer.c.

Definition at line 232 of file icalsslexer.c.

Definition at line 930 of file icalsslexer.c.

Definition at line 84 of file icalsslexer.c.

#define yyextra   YY_G(yyextra_r)

Definition at line 134 of file icalsslexer.c.

#define yyget_extra   ssget_extra

Definition at line 24 of file icalsslexer.c.

#define yyget_in   ssget_in

Definition at line 26 of file icalsslexer.c.

#define yyget_leng   ssget_leng

Definition at line 30 of file icalsslexer.c.

#define yyget_lineno   ssget_lineno

Definition at line 32 of file icalsslexer.c.

#define yyget_lval   ssget_lval

Definition at line 35 of file icalsslexer.c.

#define yyget_out   ssget_out

Definition at line 28 of file icalsslexer.c.

#define yyget_text   ssget_text

Definition at line 31 of file icalsslexer.c.

FILE * yyin   YY_G(yyin_r)

Definition at line 132 of file icalsslexer.c.

int yyleng   YY_G(yyleng_r)

Definition at line 135 of file icalsslexer.c.

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

Definition at line 213 of file icalsslexer.c.

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

Definition at line 213 of file icalsslexer.c.

#define yylex   sslex

Definition at line 20 of file icalsslexer.c.

#define yylex_destroy   sslex_destroy

Definition at line 23 of file icalsslexer.c.

#define yylex_init   sslex_init

Definition at line 22 of file icalsslexer.c.

#define yylineno   YY_G(yylineno_r)

Definition at line 137 of file icalsslexer.c.

#define YYLMAX   8192

Definition at line 542 of file icalsslexer.c.

#define yylval   YY_G(yylval_r)

Definition at line 675 of file icalsslexer.c.

#define yymore ( )    yymore_used_but_not_detected

Definition at line 538 of file icalsslexer.c.

FILE * yyout   YY_G(yyout_r)

Definition at line 133 of file icalsslexer.c.

Definition at line 587 of file icalsslexer.c.

#define yyrestart   ssrestart

Definition at line 21 of file icalsslexer.c.

#define yyset_extra   ssset_extra

Definition at line 25 of file icalsslexer.c.

#define yyset_in   ssset_in

Definition at line 27 of file icalsslexer.c.

#define yyset_lineno   ssset_lineno

Definition at line 33 of file icalsslexer.c.

#define yyset_lval   ssset_lval

Definition at line 36 of file icalsslexer.c.

#define yyset_out   ssset_out

Definition at line 29 of file icalsslexer.c.

Definition at line 164 of file icalsslexer.c.

Definition at line 869 of file icalsslexer.c.

char * yytext   YY_G(yytext_r)

Definition at line 136 of file icalsslexer.c.

#define yywrap   sswrap

Definition at line 42 of file icalsslexer.c.


Typedef Documentation

Definition at line 180 of file icalsslexer.c.

typedef unsigned char YY_CHAR

Definition at line 391 of file icalsslexer.c.

typedef unsigned int yy_size_t

Definition at line 233 of file icalsslexer.c.

typedef int yy_state_type

Definition at line 399 of file icalsslexer.c.

typedef void* yyscan_t

Definition at line 110 of file icalsslexer.c.


Function Documentation

if ( YY_G(yy_init )

Definition at line 967 of file icalsslexer.c.

              {
              YY_G(yy_init) = 0;

#ifdef YY_USER_INIT
              YY_USER_INIT;
#endif

              if ( ! YY_G(yy_start) )
                     YY_G(yy_start) = 1;  /* first start state */

              if ( ! yyin )
/* %- */
                     yyin = stdin;
/* %+ */
/* %* */

              if ( ! yyout )
/* %- */
                     yyout = stdout;
/* %+ */
/* %* */

              if ( ! YY_G(yy_current_buffer) )
                     YY_G(yy_current_buffer) =
                            yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);

              yy_load_buffer_state( YY_CALL_ONLY_ARG );
              }
while ( )

Definition at line 997 of file icalsslexer.c.

              {
/* %% [8.0] yymore()-related code goes here */
              yy_cp = YY_G(yy_c_buf_p);

              /* Support of yytext. */
              *yy_cp = YY_G(yy_hold_char);

              /* yy_bp points to the position in yy_ch_buf of the start of
               * the current run.
               */
              yy_bp = yy_cp;

/* %% [9.0] code to set up and find next match goes here */
              yy_current_state = YY_G(yy_start);
yy_match:
              do
                     {
                     register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                     if ( yy_accept[yy_current_state] )
                            {
                            YY_G(yy_last_accepting_state) = yy_current_state;
                            YY_G(yy_last_accepting_cpos) = yy_cp;
                            }
                     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                            {
                            yy_current_state = (int) yy_def[yy_current_state];
                            if ( yy_current_state >= 56 )
                                   yy_c = yy_meta[(unsigned int) yy_c];
                            }
                     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                     ++yy_cp;
                     }
              while ( yy_base[yy_current_state] != 69 );

yy_find_action:
/* %% [10.0] code to find the action number goes here */
              yy_act = yy_accept[yy_current_state];
              if ( yy_act == 0 )
                     { /* have to back up */
                     yy_cp = YY_G(yy_last_accepting_cpos);
                     yy_current_state = YY_G(yy_last_accepting_state);
                     yy_act = yy_accept[yy_current_state];
                     }

              YY_DO_BEFORE_ACTION;

/* %% [11.0] code for yylineno update goes here */

do_action:    /* This label is used only to access EOF actions. */

/* %% [12.0] debug code goes here */

              switch ( yy_act )
       { /* beginning of action switch */
/* %% [13.0] actions go here */
                     case 0: /* must back up */
                     /* undo the effects of YY_DO_BEFORE_ACTION */
                     *yy_cp = YY_G(yy_hold_char);
                     yy_cp = YY_G(yy_last_accepting_cpos);
                     yy_current_state = YY_G(yy_last_accepting_state);
                     goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 72 "icalsslexer.l"
{ return SELECT; }
       YY_BREAK
case 2:
YY_RULE_SETUP
#line 73 "icalsslexer.l"
{ return FROM; }
       YY_BREAK
case 3:
YY_RULE_SETUP
#line 74 "icalsslexer.l"
{ return WHERE; }
       YY_BREAK
case 4:
YY_RULE_SETUP
#line 75 "icalsslexer.l"
{ return COMMA; }
       YY_BREAK
case 5:
YY_RULE_SETUP
#line 76 "icalsslexer.l"
{ return EQUALS; }
       YY_BREAK
case 6:
YY_RULE_SETUP
#line 77 "icalsslexer.l"
{ return EQUALS; }
       YY_BREAK
case 7:
YY_RULE_SETUP
#line 78 "icalsslexer.l"
{ return NOTEQUALS; }
       YY_BREAK
case 8:
YY_RULE_SETUP
#line 79 "icalsslexer.l"
{ return LESS; }
       YY_BREAK
case 9:
YY_RULE_SETUP
#line 80 "icalsslexer.l"
{ return GREATER; }
       YY_BREAK
case 10:
YY_RULE_SETUP
#line 81 "icalsslexer.l"
{ return LESSEQUALS; }
       YY_BREAK
case 11:
YY_RULE_SETUP
#line 82 "icalsslexer.l"
{ return GREATEREQUALS; }
       YY_BREAK
case 12:
YY_RULE_SETUP
#line 83 "icalsslexer.l"
{ return AND; }
       YY_BREAK
case 13:
YY_RULE_SETUP
#line 84 "icalsslexer.l"
{ return OR; }
       YY_BREAK
case 14:
YY_RULE_SETUP
#line 85 "icalsslexer.l"
{ return IS; }
       YY_BREAK
case 15:
YY_RULE_SETUP
#line 86 "icalsslexer.l"
{ return NOT; }
       YY_BREAK
case 16:
YY_RULE_SETUP
#line 87 "icalsslexer.l"
{ return SQLNULL; }
       YY_BREAK
case 17:
YY_RULE_SETUP
#line 88 "icalsslexer.l"
{ return QUOTE; }
       YY_BREAK
case 18:
YY_RULE_SETUP
#line 89 "icalsslexer.l"
;                    
       YY_BREAK
case 19:
YY_RULE_SETUP
#line 90 "icalsslexer.l"
{ return EOL; }
       YY_BREAK
case 20:
YY_RULE_SETUP
#line 92 "icalsslexer.l"
{
       int c = input(yy_globals);
       unput(c);
       if(c!='\''){
              yylvalp->v_string= icalmemory_tmp_copy(yytext);
              return STRING;
       } else {
              /*ssmore();*/
       }
}
       YY_BREAK
case 21:
YY_RULE_SETUP
#line 103 "icalsslexer.l"
{
        yylval->v_string= icalmemory_tmp_copy(yytext);
       return STRING; 
}
       YY_BREAK
case 22:
YY_RULE_SETUP
#line 109 "icalsslexer.l"
{ return yytext[0]; }
       YY_BREAK
case 23:
YY_RULE_SETUP
#line 111 "icalsslexer.l"
ECHO;
       YY_BREAK
#line 1188 "lex.ss.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(sql):
case YY_STATE_EOF(string_value):
       yyterminate();

       case YY_END_OF_BUFFER:
              {
              /* Amount of text matched not including the EOB char. */
              int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;

              /* Undo the effects of YY_DO_BEFORE_ACTION. */
              *yy_cp = YY_G(yy_hold_char);
              YY_RESTORE_YY_MORE_OFFSET

              if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_NEW )
                     {
                     /* We're scanning a new file or input source.  It's
                      * possible that this happened because the user
                      * just pointed yyin at a new source and called
                      * yylex().  If so, then we have to assure
                      * consistency between yy_current_buffer and our
                      * globals.  Here is the right place to do so, because
                      * this is the first action (other than possibly a
                      * back-up) that will match for the new input source.
                      */
                     YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_n_chars;
                     YY_G(yy_current_buffer)->yy_input_file = yyin;
                     YY_G(yy_current_buffer)->yy_buffer_status = YY_BUFFER_NORMAL;
                     }

              /* Note that here we test for yy_c_buf_p "<=" to the position
               * of the first EOB in the buffer, since yy_c_buf_p will
               * already have been incremented past the NUL character
               * (since all states make transitions on EOB to the
               * end-of-buffer state).  Contrast this with the test
               * in input().
               */
              if ( YY_G(yy_c_buf_p) <= &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] )
                     { /* This was really a NUL. */
                     yy_state_type yy_next_state;

                     YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;

                     yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );

                     /* Okay, we're now positioned to make the NUL
                      * transition.  We couldn't have
                      * yy_get_previous_state() go ahead and do it
                      * for us because it doesn't know how to deal
                      * with the possibility of jamming (and we don't
                      * want to build jamming into it because then it
                      * will run more slowly).
                      */

                     yy_next_state = yy_try_NUL_trans( yy_current_state YY_CALL_LAST_ARG);

                     yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;

                     if ( yy_next_state )
                            {
                            /* Consume the NUL. */
                            yy_cp = ++YY_G(yy_c_buf_p);
                            yy_current_state = yy_next_state;
                            goto yy_match;
                            }

                     else
                            {
/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
                            yy_cp = YY_G(yy_c_buf_p);
                            goto yy_find_action;
                            }
                     }

              else switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) )
                     {
                     case EOB_ACT_END_OF_FILE:
                            {
                            YY_G(yy_did_buffer_switch_on_eof) = 0;

                            if ( yywrap( YY_CALL_ONLY_ARG ) )
                                   {
                                   /* Note: because we've taken care in
                                    * yy_get_next_buffer() to have set up
                                    * yytext, we can now set up
                                    * yy_c_buf_p so that if some total
                                    * hoser (like flex itself) wants to
                                    * call the scanner after we return the
                                    * YY_NULL, it'll still work - another
                                    * YY_NULL will get returned.
                                    */
                                   YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;

                                   yy_act = YY_STATE_EOF(YY_START);
                                   goto do_action;
                                   }

                            else
                                   {
                                   if ( ! YY_G(yy_did_buffer_switch_on_eof) )
                                          YY_NEW_FILE;
                                   }
                            break;
                            }

                     case EOB_ACT_CONTINUE_SCAN:
                            YY_G(yy_c_buf_p) =
                                   YY_G(yytext_ptr) + yy_amount_of_matched_text;

                            yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );

                            yy_cp = YY_G(yy_c_buf_p);
                            yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
                            goto yy_match;

                     case EOB_ACT_LAST_MATCH:
                            YY_G(yy_c_buf_p) =
                            &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)];

                            yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );

                            yy_cp = YY_G(yy_c_buf_p);
                            yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
                            goto yy_find_action;
                     }
              break;
              }

       default:
              YY_FATAL_ERROR(
                     "fatal flex scanner internal error--no action found" );
       } /* end of action switch */
              } /* end of scanning one token */

Here is the call graph for this function:

Here is the caller graph for this function:

static int yy_get_next_buffer ( YY_ONLY_ARG  ) [static]

Definition at line 1345 of file icalsslexer.c.

       {
       register char *dest = YY_G(yy_current_buffer)->yy_ch_buf;
       register char *source = YY_G(yytext_ptr);
       register int number_to_move, i;
       int ret_val;

       if ( YY_G(yy_c_buf_p) > &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] )
              YY_FATAL_ERROR(
              "fatal flex scanner internal error--end of buffer missed" );

       if ( YY_G(yy_current_buffer)->yy_fill_buffer == 0 )
              { /* Don't try to fill the buffer, so this is an EOF. */
              if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
                     {
                     /* We matched a single character, the EOB, so
                      * treat this as a final EOF.
                      */
                     return EOB_ACT_END_OF_FILE;
                     }

              else
                     {
                     /* We matched some text prior to the EOB, first
                      * process it.
                      */
                     return EOB_ACT_LAST_MATCH;
                     }
              }

       /* Try to read more data. */

       /* First move last chars to start of buffer. */
       number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;

       for ( i = 0; i < number_to_move; ++i )
              *(dest++) = *(source++);

       if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_EOF_PENDING )
              /* don't do the read, it's not guaranteed to return an EOF,
               * just force an EOF
               */
              YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars) = 0;

       else
              {
                     size_t num_to_read =
                     YY_G(yy_current_buffer)->yy_buf_size - number_to_move - 1;

              while ( num_to_read <= 0 )
                     { /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
                     YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else

                     /* just a shorter name for the current buffer */
                     YY_BUFFER_STATE b = YY_G(yy_current_buffer);

                     int yy_c_buf_p_offset =
                            (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);

                     if ( b->yy_is_our_buffer )
                            {
                            int new_size = b->yy_buf_size * 2;

                            if ( new_size <= 0 )
                                   b->yy_buf_size += b->yy_buf_size / 8;
                            else
                                   b->yy_buf_size *= 2;

                            b->yy_ch_buf = (char *)
                                   /* Include room in for 2 EOB chars. */
                                   yy_flex_realloc( (void *) b->yy_ch_buf,
                                                  b->yy_buf_size + 2 YY_CALL_LAST_ARG );
                            }
                     else
                            /* Can't grow it, we don't own it. */
                            b->yy_ch_buf = 0;

                     if ( ! b->yy_ch_buf )
                            YY_FATAL_ERROR(
                            "fatal error - scanner input buffer overflow" );

                     YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

                     num_to_read = YY_G(yy_current_buffer)->yy_buf_size -
                                          number_to_move - 1;
#endif
                     }

              if ( num_to_read > YY_READ_BUF_SIZE )
                     num_to_read = YY_READ_BUF_SIZE;

              /* Read in more data. */
              YY_INPUT( (&YY_G(yy_current_buffer)->yy_ch_buf[number_to_move]),
                     YY_G(yy_n_chars), num_to_read );

              YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars);
              }

       if ( YY_G(yy_n_chars) == 0 )
              {
              if ( number_to_move == YY_MORE_ADJ )
                     {
                     ret_val = EOB_ACT_END_OF_FILE;
                     yyrestart( yyin  YY_CALL_LAST_ARG);
                     }

              else
                     {
                     ret_val = EOB_ACT_LAST_MATCH;
                     YY_G(yy_current_buffer)->yy_buffer_status =
                            YY_BUFFER_EOF_PENDING;
                     }
              }

       else
              ret_val = EOB_ACT_CONTINUE_SCAN;

       YY_G(yy_n_chars) += number_to_move;
       YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
       YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

       YY_G(yytext_ptr) = &YY_G(yy_current_buffer)->yy_ch_buf[0];

       return ret_val;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1488 of file icalsslexer.c.

       {
       register yy_state_type yy_current_state;
       register char *yy_cp;

/* %% [15.0] code to get the start state into yy_current_state goes here */
       yy_current_state = YY_G(yy_start);

       for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
              {
/* %% [16.0] code to find the next state goes here */
              register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
              if ( yy_accept[yy_current_state] )
                     {
                     YY_G(yy_last_accepting_state) = yy_current_state;
                     YY_G(yy_last_accepting_cpos) = yy_cp;
                     }
              while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                     {
                     yy_current_state = (int) yy_def[yy_current_state];
                     if ( yy_current_state >= 56 )
                            yy_c = yy_meta[(unsigned int) yy_c];
                     }
              yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
              }

       return yy_current_state;
       }

Here is the caller graph for this function:

void yy_init_buffer ( b  ,
file  YY_LAST_ARG 
)
int yylex_init YY_PROTO ( (yyscan_t *scanner)  )
void yyrestart YY_PROTO ( (FILE *input_file YY_LAST_ARG )
static int input YY_PROTO ( (YY_ONLY_ARG )
static void* yy_flex_alloc YY_PROTO ( (yy_size_t YY_LAST_ARG ) [static]
static void* yy_flex_realloc YY_PROTO ( (void *, yy_size_t YY_LAST_ARG ) [static]
static void yy_flex_free YY_PROTO ( (void *YY_LAST_ARG ) [static]
static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_stateYY_LAST_ARG)  ) [static]
static void yy_fatal_error YY_PROTO ( (yyconst char msg[])  ) [static]
static int yy_init_globals YY_PROTO ( (yyscan_t ) [static]
void yyset_lineno YY_PROTO ( (int line_number YY_LAST_ARG )
static void yyunput YY_PROTO ( (int c, char *buf_ptrYY_LAST_ARG)  ) [static]
static void yy_flex_strncpy YY_PROTO ( (char *, yyconst char *, int YY_LAST_ARG ) [static]
static yy_state_type yy_try_NUL_trans ( yy_current_state  YY_LAST_ARG) [static]

Here is the caller graph for this function:


Variable Documentation

Definition at line 1845 of file icalsslexer.c.

Definition at line 1958 of file icalsslexer.c.

print< RDF:Descriptionabout=\"urn:mozilla:plugin:{$guid}:{$version}\"> n

Definition at line 2388 of file icalsslexer.c.

yyconst char* s2

Definition at line 2199 of file icalsslexer.c.

Definition at line 1704 of file icalsslexer.c.

yyconst short int yy_accept[56] [static]
Initial value:
    {   0,
        0,    0,    0,    0,    0,    0,   24,   22,   18,   18,
       22,   17,   21,    4,   19,    8,    5,    9,   21,   21,
       21,   21,   21,   21,   21,   18,    7,    0,   21,   10,
        6,   11,   21,   21,   14,   21,   21,   13,   21,   21,
       20,   12,   21,   15,   21,   21,   21,    2,   16,   21,
       21,   21,    3,    1,    0
    }

Definition at line 435 of file icalsslexer.c.

register int yy_act

Definition at line 948 of file icalsslexer.c.

yyconst short int yy_base[58] [static]
Initial value:
    {   0,
        0,    0,    0,    0,    0,    0,   68,   69,   28,   31,
       55,    0,    0,   69,   69,   54,   53,   52,   40,   37,
       35,   12,   35,   42,   39,   35,   69,   51,    0,   69,
       69,   69,   40,   31,    0,   27,   32,    0,   31,   34,
       69,    0,   28,    0,   28,   31,   22,    0,    0,   31,
       28,   17,    0,    0,   69,   39,   40
    }

Definition at line 484 of file icalsslexer.c.

register char * yy_bp

Definition at line 947 of file icalsslexer.c.

yyconst short int yy_chk[99] [static]
Initial value:
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    9,
        9,    9,   10,   10,   10,   22,   26,   26,   26,   22,
       56,   56,   57,   52,   51,   50,   47,   46,   45,   43,
       40,   39,   37,   36,   34,   33,   28,   25,   24,   23,
       21,   20,   19,   18,   17,   16,   11,    7,   55,   55,
       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
       55,   55,   55,   55,   55,   55,   55,   55

    }

Definition at line 519 of file icalsslexer.c.

register char* yy_cp

Definition at line 947 of file icalsslexer.c.

Definition at line 946 of file icalsslexer.c.

yyconst short int yy_def[58] [static]
Initial value:
    {   0,
       55,    1,    1,    1,    1,    1,   55,   55,   55,   55,
       55,   56,   57,   55,   55,   55,   55,   55,   57,   57,
       57,   57,   57,   57,   57,   55,   55,   56,   57,   55,
       55,   55,   57,   57,   57,   57,   57,   57,   57,   57,
       55,   57,   57,   57,   57,   57,   57,   57,   57,   57,
       57,   57,   57,   57,    0,   55,   55
    }

Definition at line 494 of file icalsslexer.c.

yyconst int yy_ec[256] [static]

Definition at line 445 of file icalsslexer.c.

yyconst int yy_meta[30] [static]
Initial value:
    {   0,
        1,    1,    1,    2,    1,    1,    3,    1,    2,    1,
        1,    1,    1,    3,    3,    3,    3,    3,    3,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    3
    }

Definition at line 477 of file icalsslexer.c.

yyconst short int yy_nxt[99] [static]
Initial value:
    {   0,
        8,    9,   10,    9,   11,   12,   13,   14,    8,   15,
       16,   17,   18,   19,   13,   13,   13,   20,   13,   21,
       13,   13,   22,   23,   13,   24,   13,   13,   25,   26,
       26,   26,   26,   26,   26,   36,   26,   26,   26,   37,
       28,   28,   29,   54,   53,   52,   51,   50,   49,   48,
       47,   46,   45,   44,   43,   42,   41,   40,   39,   38,
       35,   34,   33,   32,   31,   30,   27,   55,    7,   55,
       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
       55,   55,   55,   55,   55,   55,   55,   55

    }

Definition at line 504 of file icalsslexer.c.

yylval = yylvalp

Definition at line 961 of file icalsslexer.c.