Back to index

lightning-sunbird  0.9+nobinonly
icalsslexer.c
Go to the documentation of this file.
00001 #define YY_REENTRANT 1
00002 #define YY_TEXT_IS_ARRAY
00003 #define YY_REENTRANT_BISON_PURE 1
00004 #ifndef YY_REENTRANT
00005 #define yytext sstext
00006 #define yyleng ssleng
00007 #define yyin ssin
00008 #define yyout ssout
00009 #endif
00010 #define yy_create_buffer ss_create_buffer
00011 #define yy_delete_buffer ss_delete_buffer
00012 #define yy_scan_buffer ss_scan_buffer
00013 #define yy_scan_string ss_scan_string
00014 #define yy_scan_bytes ss_scan_bytes
00015 #define yy_flex_debug ss_flex_debug
00016 #define yy_init_buffer ss_init_buffer
00017 #define yy_flush_buffer ss_flush_buffer
00018 #define yy_load_buffer_state ss_load_buffer_state
00019 #define yy_switch_to_buffer ss_switch_to_buffer
00020 #define yylex sslex
00021 #define yyrestart ssrestart
00022 #define yylex_init sslex_init
00023 #define yylex_destroy sslex_destroy
00024 #define yyget_extra ssget_extra
00025 #define yyset_extra ssset_extra
00026 #define yyget_in ssget_in
00027 #define yyset_in ssset_in
00028 #define yyget_out ssget_out
00029 #define yyset_out ssset_out
00030 #define yyget_leng ssget_leng
00031 #define yyget_text ssget_text
00032 #define yyget_lineno ssget_lineno
00033 #define yyset_lineno ssset_lineno
00034 #ifdef YY_REENTRANT_BISON_PURE
00035 #define yyget_lval ssget_lval
00036 #define yyset_lval ssset_lval
00037 #ifdef YYLTYPE
00038 #define yyget_lloc ssget_lloc
00039 #define yyset_lloc ssset_lloc
00040 #endif
00041 #endif
00042 #define yywrap sswrap
00043 
00044 /* -*-C-*- */
00045 /* A lexical scanner generated by flex */
00046 
00047 #define FLEX_SCANNER
00048 #define YY_FLEX_MAJOR_VERSION 2
00049 #define YY_FLEX_MINOR_VERSION 5
00050 
00051 /* %- */
00052 /* begin standard C headers. */
00053 #include <stdio.h>
00054 #include <errno.h>
00055 #include <stdlib.h>
00056 /* end standard C headers. */
00057 /* %+ */
00058 /* %* */
00059 
00060 #ifdef __cplusplus
00061 
00062 /* %+ */
00063 /* %* */
00064 
00065 /* Use prototypes in function declarations. */
00066 #define YY_USE_PROTOS
00067 
00068 /* The "const" storage-class-modifier is valid. */
00069 #define YY_USE_CONST
00070 
00071 #else  /* ! __cplusplus */
00072 
00073 #if __STDC__
00074 
00075 #define YY_USE_PROTOS
00076 #define YY_USE_CONST
00077 
00078 #endif /* __STDC__ */
00079 #endif /* ! __cplusplus */
00080 
00081 #ifdef YY_USE_CONST
00082 #define yyconst const
00083 #else
00084 #define yyconst
00085 #endif
00086 
00087 
00088 #ifdef YY_USE_PROTOS
00089 #define YY_PROTO(proto) proto
00090 #else
00091 #define YY_PROTO(proto) ()
00092 #endif
00093 
00094 /* Returned upon end-of-file. */
00095 #define YY_NULL 0
00096 
00097 /* Promotes a possibly negative, possibly signed char to an unsigned
00098  * integer for use as an array index.  If the signed char is negative,
00099  * we want to instead treat it as an 8-bit unsigned char, hence the
00100  * double cast.
00101  */
00102 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00103 
00104 
00105 #ifdef YY_REENTRANT
00106 
00107 /* An opaque pointer. */
00108 #ifndef YY_TYPEDEF_YY_SCANNER_T
00109 #define YY_TYPEDEF_YY_SCANNER_T
00110 typedef void* yyscan_t;
00111 #endif
00112 
00113 /* For use wherever a Global is accessed or assigned. */
00114 #define YY_G(var) (((struct yy_globals_t*)yy_globals)->var)
00115 
00116 /* For use in function prototypes to append the additional argument. */
00117 #ifdef YY_USE_PROTOS
00118 #define YY_LAST_ARG , yyscan_t yy_globals
00119 #define YY_ONLY_ARG    yyscan_t yy_globals
00120 #else
00121 #define YY_LAST_ARG , yy_globals
00122 #define YY_ONLY_ARG    yy_globals
00123 #define YY_DECL_LAST_ARG yyscan_t yy_globals;
00124 #endif
00125 
00126 /* For use in function calls to pass the additional argument. */
00127 #define YY_CALL_LAST_ARG  , yy_globals
00128 #define YY_CALL_ONLY_ARG   yy_globals
00129 
00130 /* For convenience, these vars (plus the bison vars far below)
00131    are macros in the reentrant scanner. */
00132 #define yyin YY_G(yyin_r)
00133 #define yyout YY_G(yyout_r)
00134 #define yyextra YY_G(yyextra_r)
00135 #define yyleng YY_G(yyleng_r)
00136 #define yytext YY_G(yytext_r)
00137 #define yylineno YY_G(yylineno_r)
00138 
00139 int yylex_init YY_PROTO((yyscan_t* scanner));
00140 int yylex_destroy YY_PROTO((yyscan_t scanner));
00141 
00142 #else /* not YY_REENTRANT */
00143 
00144   /* Define these macros to be no-ops. */
00145 #define YY_G(var) (var)
00146 #define YY_LAST_ARG
00147 #define YY_ONLY_ARG  void
00148 #define YY_CALL_LAST_ARG
00149 #define YY_CALL_ONLY_ARG
00150 #define YY_DECL_LAST_ARG
00151 #endif
00152 
00153 /* Enter a start condition.  This macro really ought to take a parameter,
00154  * but we do it the disgusting crufty way forced on us by the ()-less
00155  * definition of BEGIN.
00156  */
00157 #define BEGIN YY_G(yy_start) = 1 + 2 *
00158 
00159 /* Translate the current start state into a value that can be later handed
00160  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00161  * compatibility.
00162  */
00163 #define YY_START ((YY_G(yy_start) - 1) / 2)
00164 #define YYSTATE YY_START
00165 
00166 /* Action number for EOF rule of a given start state. */
00167 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00168 
00169 /* Special action meaning "start processing a new file". */
00170 #define YY_NEW_FILE yyrestart( yyin YY_CALL_LAST_ARG )
00171 
00172 #define YY_END_OF_BUFFER_CHAR 0
00173 
00174 /* Size of default input buffer. */
00175 #define YY_BUF_SIZE 16384
00176 
00177 
00178 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
00179 #define YY_TYPEDEF_YY_BUFFER_STATE
00180 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00181 #endif
00182 
00183 #ifndef YY_REENTRANT
00184 extern size_t yyleng;
00185 #endif
00186 
00187 /* %- */
00188 #ifndef YY_REENTRANT
00189 extern FILE *yyin, *yyout;
00190 #endif
00191 /* %* */
00192 
00193 #define EOB_ACT_CONTINUE_SCAN 0
00194 #define EOB_ACT_END_OF_FILE 1
00195 #define EOB_ACT_LAST_MATCH 2
00196 
00197 /* The funky do-while in the following #define is used to turn the definition
00198  * int a single C statement (which needs a semi-colon terminator).  This
00199  * avoids problems with code like:
00200  *
00201  *     if ( condition_holds )
00202  *            yyless( 5 );
00203  *     else
00204  *            do_something_else();
00205  *
00206  * Prior to using the do-while the compiler would get upset at the
00207  * "else" because it interpreted the "if" statement as being all
00208  * done when it reached the ';' after the yyless() call.
00209  */
00210 
00211 /* Return all but the first 'n' matched characters back to the input stream. */
00212 
00213 #define yyless(n) \
00214        do \
00215               { \
00216               /* Undo effects of setting up yytext. */ \
00217               *yy_cp = YY_G(yy_hold_char); \
00218               YY_RESTORE_YY_MORE_OFFSET \
00219               YY_G(yy_c_buf_p) = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00220               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00221               } \
00222        while ( 0 )
00223 
00224 #define unput(c) yyunput( c, YY_G(yytext_ptr) YY_CALL_LAST_ARG )
00225 
00226 /* The following is because we cannot portably get our hands on size_t
00227  * (without autoconf's help, which isn't available because we want
00228  * flex-generated scanners to compile on their own).
00229  */
00230 
00231 #ifndef YY_TYPEDEF_YY_SIZE_T
00232 #define YY_TYPEDEF_YY_SIZE_T
00233 typedef unsigned int yy_size_t;
00234 #endif
00235 
00236 #ifndef YY_STRUCT_YY_BUFFER_STATE
00237 #define YY_STRUCT_YY_BUFFER_STATE
00238 struct yy_buffer_state
00239        {
00240 /* %- */
00241        FILE *yy_input_file;
00242 /* %+ */
00243 /* %* */
00244 
00245        char *yy_ch_buf;            /* input buffer */
00246        char *yy_buf_pos;           /* current position in input buffer */
00247 
00248        /* Size of input buffer in bytes, not including room for EOB
00249         * characters.
00250         */
00251        yy_size_t yy_buf_size;
00252 
00253        /* Number of characters read into yy_ch_buf, not including EOB
00254         * characters.
00255         */
00256        int yy_n_chars;
00257 
00258        /* Whether we "own" the buffer - i.e., we know we created it,
00259         * and can realloc() it to grow it, and should free() it to
00260         * delete it.
00261         */
00262        int yy_is_our_buffer;
00263 
00264        /* Whether this is an "interactive" input source; if so, and
00265         * if we're using stdio for input, then we want to use getc()
00266         * instead of fread(), to make sure we stop fetching input after
00267         * each newline.
00268         */
00269        int yy_is_interactive;
00270 
00271        /* Whether we're considered to be at the beginning of a line.
00272         * If so, '^' rules will be active on the next match, otherwise
00273         * not.
00274         */
00275        int yy_at_bol;
00276 
00277        /* Whether to try to fill the input buffer when we reach the
00278         * end of it.
00279         */
00280        int yy_fill_buffer;
00281 
00282        int yy_buffer_status;
00283 #define YY_BUFFER_NEW 0
00284 #define YY_BUFFER_NORMAL 1
00285        /* When an EOF's been seen but there's still some text to process
00286         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00287         * shouldn't try reading from the input source any more.  We might
00288         * still have a bunch of tokens to match, though, because of
00289         * possible backing-up.
00290         *
00291         * When we actually see the EOF, we change the status to "new"
00292         * (via yyrestart()), so that the user can continue scanning by
00293         * just pointing yyin at a new input file.
00294         */
00295 #define YY_BUFFER_EOF_PENDING 2
00296        };
00297 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
00298 
00299 /* %- Standard (non-C++) definition */
00300 /* %c */
00301 #ifndef ssIN_HEADER
00302 #ifndef YY_REENTRANT
00303 static YY_BUFFER_STATE yy_current_buffer = 0;
00304 #endif
00305 /* %e */
00306 #endif /* !ssIN_HEADER */
00307 /* %* */
00308 
00309 /* We provide macros for accessing buffer states in case in the
00310  * future we want to put the buffer states in a more general
00311  * "scanner state".
00312  */
00313 #define YY_CURRENT_BUFFER yy_current_buffer
00314 
00315 
00316 /* %- Standard (non-C++) definition */
00317 
00318 #ifndef YY_REENTRANT
00319 /* %c */
00320 #ifndef ssIN_HEADER
00321 /* yy_hold_char holds the character lost when yytext is formed. */
00322 static char yy_hold_char;
00323 
00324 static int yy_n_chars;             /* number of characters read into yy_ch_buf */
00325 
00326 
00327 size_t yyleng;
00328 
00329 /* Points to current character in buffer. */
00330 static char *yy_c_buf_p = (char *) 0;
00331 static int yy_init = 1;            /* whether we need to initialize */
00332 static int yy_start = 0;    /* start state number */
00333 
00334 /* Flag which is used to allow yywrap()'s to do buffer switches
00335  * instead of setting up a fresh yyin.  A bit of a hack ...
00336  */
00337 static int yy_did_buffer_switch_on_eof;
00338 /* %e */
00339 #endif /* !ssIN_HEADER */
00340 #endif /* end !YY_REENTRANT */
00341 
00342 void yyrestart YY_PROTO(( FILE *input_file YY_LAST_ARG ));
00343 
00344 
00345 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer YY_LAST_ARG ));
00346 void yy_load_buffer_state YY_PROTO(( YY_ONLY_ARG ));
00347 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size YY_LAST_ARG ));
00348 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b YY_LAST_ARG ));
00349 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file YY_LAST_ARG ));
00350 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b YY_LAST_ARG ));
00351 
00352 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_G(yy_current_buffer) YY_CALL_LAST_ARG)
00353 
00354 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size YY_LAST_ARG ));
00355 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str YY_LAST_ARG ));
00356 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len YY_LAST_ARG ));
00357 
00358 /* %* */
00359 
00360 /* %c */
00361 #ifndef ssIN_HEADER
00362 static void *yy_flex_alloc YY_PROTO(( yy_size_t YY_LAST_ARG ));
00363 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t YY_LAST_ARG ));
00364 static void yy_flex_free YY_PROTO(( void * YY_LAST_ARG ));
00365 /* %e */
00366 #endif /* !ssIN_HEADER */
00367 
00368 #define yy_new_buffer yy_create_buffer
00369 
00370 #define yy_set_interactive(is_interactive) \
00371        { \
00372        if ( ! YY_G(yy_current_buffer) ) \
00373               YY_G(yy_current_buffer) =    \
00374             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
00375        YY_G(yy_current_buffer)->yy_is_interactive = is_interactive; \
00376        }
00377 
00378 #define yy_set_bol(at_bol) \
00379        { \
00380        if ( ! YY_G(yy_current_buffer) ) \
00381               YY_G(yy_current_buffer) =    \
00382             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
00383        YY_G(yy_current_buffer)->yy_at_bol = at_bol; \
00384        }
00385 
00386 #define YY_AT_BOL() (YY_G(yy_current_buffer)->yy_at_bol)
00387 
00388 /* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
00389 /* Begin user sect3 */
00390 #ifndef ssIN_HEADER
00391 typedef unsigned char YY_CHAR;
00392 #endif /* !ssIN_HEADER */
00393 #ifndef ssIN_HEADER
00394 #ifndef YY_REENTRANT
00395 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00396 #endif
00397 #endif /* !ssIN_HEADER */
00398 #ifndef ssIN_HEADER
00399 typedef int yy_state_type;
00400 #endif /* !ssIN_HEADER */
00401 
00402 /* %- Standard (non-C++) definition */
00403 /* %c */
00404 #ifndef ssIN_HEADER
00405 static yy_state_type yy_get_previous_state YY_PROTO(( YY_ONLY_ARG ));
00406 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state  YY_LAST_ARG));
00407 static int yy_get_next_buffer YY_PROTO(( YY_ONLY_ARG ));
00408 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
00409 /* %e */
00410 #endif /* !ssIN_HEADER */
00411 /* %* */
00412 
00413 /* Done after the current pattern has been matched and before the
00414  * corresponding action - sets up yytext.
00415  */
00416 #define YY_DO_BEFORE_ACTION \
00417        YY_G(yytext_ptr) = yy_bp; \
00418 /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
00419        yyleng = (size_t) (yy_cp - yy_bp); \
00420        YY_G(yy_hold_char) = *yy_cp; \
00421        *yy_cp = '\0'; \
00422 /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
00423        if ( yyleng >= YYLMAX ) \
00424               YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
00425        yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 YY_CALL_LAST_ARG); \
00426        YY_G(yy_c_buf_p) = yy_cp;
00427 
00428 /* %* */
00429 
00430 /* %c */
00431 #ifndef ssIN_HEADER
00432 /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
00433 #define YY_NUM_RULES 23
00434 #define YY_END_OF_BUFFER 24
00435 static yyconst short int yy_accept[56] =
00436     {   0,
00437         0,    0,    0,    0,    0,    0,   24,   22,   18,   18,
00438        22,   17,   21,    4,   19,    8,    5,    9,   21,   21,
00439        21,   21,   21,   21,   21,   18,    7,    0,   21,   10,
00440         6,   11,   21,   21,   14,   21,   21,   13,   21,   21,
00441        20,   12,   21,   15,   21,   21,   21,    2,   16,   21,
00442        21,   21,    3,    1,    0
00443     } ;
00444 
00445 static yyconst int yy_ec[256] =
00446     {   0,
00447         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00448         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
00449         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00450         1,    4,    5,    1,    1,    1,    1,    1,    6,    1,
00451         1,    7,    1,    8,    7,    7,    1,    7,    7,    7,
00452         7,    7,    7,    7,    7,    7,    7,    9,   10,   11,
00453        12,   13,    1,    7,   14,    7,   15,   16,   17,   18,
00454         7,   19,   20,    7,    7,   21,   22,   23,   24,    7,
00455         7,   25,   26,   27,   28,    7,   29,    7,    7,    7,
00456         1,    1,    1,    1,    1,    1,   14,    7,   15,   16,
00457 
00458        17,   18,    7,   19,   20,    7,    7,   21,   22,   23,
00459        24,    7,    7,   25,   26,   27,   28,    7,   29,    7,
00460         7,    7,    1,    1,    1,    1,    1,    1,    1,    1,
00461         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00462         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00463         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00464         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00465         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00466         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00467         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00468 
00469         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00470         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00471         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00472         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00473         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00474         1,    1,    1,    1,    1
00475     } ;
00476 
00477 static yyconst int yy_meta[30] =
00478     {   0,
00479         1,    1,    1,    2,    1,    1,    3,    1,    2,    1,
00480         1,    1,    1,    3,    3,    3,    3,    3,    3,    3,
00481         3,    3,    3,    3,    3,    3,    3,    3,    3
00482     } ;
00483 
00484 static yyconst short int yy_base[58] =
00485     {   0,
00486         0,    0,    0,    0,    0,    0,   68,   69,   28,   31,
00487        55,    0,    0,   69,   69,   54,   53,   52,   40,   37,
00488        35,   12,   35,   42,   39,   35,   69,   51,    0,   69,
00489        69,   69,   40,   31,    0,   27,   32,    0,   31,   34,
00490        69,    0,   28,    0,   28,   31,   22,    0,    0,   31,
00491        28,   17,    0,    0,   69,   39,   40
00492     } ;
00493 
00494 static yyconst short int yy_def[58] =
00495     {   0,
00496        55,    1,    1,    1,    1,    1,   55,   55,   55,   55,
00497        55,   56,   57,   55,   55,   55,   55,   55,   57,   57,
00498        57,   57,   57,   57,   57,   55,   55,   56,   57,   55,
00499        55,   55,   57,   57,   57,   57,   57,   57,   57,   57,
00500        55,   57,   57,   57,   57,   57,   57,   57,   57,   57,
00501        57,   57,   57,   57,    0,   55,   55
00502     } ;
00503 
00504 static yyconst short int yy_nxt[99] =
00505     {   0,
00506         8,    9,   10,    9,   11,   12,   13,   14,    8,   15,
00507        16,   17,   18,   19,   13,   13,   13,   20,   13,   21,
00508        13,   13,   22,   23,   13,   24,   13,   13,   25,   26,
00509        26,   26,   26,   26,   26,   36,   26,   26,   26,   37,
00510        28,   28,   29,   54,   53,   52,   51,   50,   49,   48,
00511        47,   46,   45,   44,   43,   42,   41,   40,   39,   38,
00512        35,   34,   33,   32,   31,   30,   27,   55,    7,   55,
00513        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
00514        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
00515        55,   55,   55,   55,   55,   55,   55,   55
00516 
00517     } ;
00518 
00519 static yyconst short int yy_chk[99] =
00520     {   0,
00521         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00522         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00523         1,    1,    1,    1,    1,    1,    1,    1,    1,    9,
00524         9,    9,   10,   10,   10,   22,   26,   26,   26,   22,
00525        56,   56,   57,   52,   51,   50,   47,   46,   45,   43,
00526        40,   39,   37,   36,   34,   33,   28,   25,   24,   23,
00527        21,   20,   19,   18,   17,   16,   11,    7,   55,   55,
00528        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
00529        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
00530        55,   55,   55,   55,   55,   55,   55,   55
00531 
00532     } ;
00533 
00534 /* The intent behind this definition is that it'll catch
00535  * any uses of REJECT which flex missed.
00536  */
00537 #define REJECT reject_used_but_not_detected
00538 #define yymore() yymore_used_but_not_detected
00539 #define YY_MORE_ADJ 0
00540 #define YY_RESTORE_YY_MORE_OFFSET
00541 #ifndef YYLMAX
00542 #define YYLMAX 8192
00543 #endif
00544 
00545 #ifndef YY_REENTRANT
00546 char yytext[YYLMAX];
00547 char *yytext_ptr;
00548 #endif
00549 #line 1 "icalsslexer.l"
00550 #define INITIAL 0
00551 #line 2 "icalsslexer.l"
00552 /* -*- Mode: C -*-
00553   ======================================================================
00554   FILE: icalsslexer.l
00555   CREATOR: eric 8 Aug 2000
00556   
00557   DESCRIPTION:
00558   
00559   $Id: icalsslexer.c,v 1.10 2002/07/21 17:18:15 lindner Exp $
00560   $Locker:  $
00561 
00562 (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00563 
00564  This program is free software; you can redistribute it and/or modify
00565  it under the terms of either: 
00566 
00567     The LGPL as published by the Free Software Foundation, version
00568     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00569 
00570   Or:
00571 
00572     The Mozilla Public License Version 1.0. You may obtain a copy of
00573     the License at http://www.mozilla.org/MPL/
00574 
00575  The Original Code is eric. The Initial Developer of the Original
00576  Code is Eric Busboom
00577 
00578   ======================================================================*/
00579 
00580 #include "icalssyacc.h"
00581 #include "icalgaugeimpl.h"
00582 #include "assert.h"
00583 
00584 #include <string.h> /* For strdup() */
00585 
00586 #undef YYPURE
00587 #define YYPURE
00588 
00589 #undef SS_FATAL_ERROR
00590 #define SS_FATAL_ERROR(msg) sserror(msg)
00591 
00592 #define sql 1
00593 #define string_value 2
00594 
00595 #line 596 "lex.ss.c"
00596 /* %e */
00597 #endif /* !ssIN_HEADER */
00598 
00599 /* Special case for "unistd.h", since it is non-ANSI. We include it way
00600  * down here because we want the user's section 1 to have been scanned first.
00601  * The user has a chance to override it with an option.
00602  */
00603 #ifndef YY_NO_UNISTD_H
00604 /* %- */
00605 #include <unistd.h>
00606 /* %+ */
00607 /* %* */
00608 #endif /* !YY_NO_UNISTD_H */
00609 
00610 
00611 #ifndef YY_EXTRA_TYPE
00612 #define YY_EXTRA_TYPE void *
00613 #endif
00614 
00615 /* %- Reentrant structure and macros (non-C++). */
00616 #ifdef YY_REENTRANT
00617 
00618 /* %c */
00619 #ifndef ssIN_HEADER
00620 struct yy_globals_t
00621     {
00622 
00623     /* User-defined. Not touched by flex. */
00624     YY_EXTRA_TYPE yyextra_r;
00625 
00626     /* The rest are the same as the globals declared in the non-reentrant scanner. */
00627     FILE *yyin_r, *yyout_r;
00628     YY_BUFFER_STATE yy_current_buffer;
00629     char yy_hold_char;
00630     int yy_n_chars;
00631     int yyleng_r;
00632     char *yy_c_buf_p;
00633     int yy_init;
00634     int yy_start;
00635     int yy_did_buffer_switch_on_eof;
00636     int yy_start_stack_ptr;
00637     int yy_start_stack_depth;
00638     int *yy_start_stack;
00639     yy_state_type yy_last_accepting_state;
00640     char* yy_last_accepting_cpos;
00641 
00642     int yylineno_r;
00643 
00644 #ifdef YY_TEXT_IS_ARRAY
00645     char yytext_r[YYLMAX];
00646     char *yytext_ptr;
00647     int yy_more_offset;
00648     int yy_prev_more_offset;
00649 #else
00650     char *yytext_r;
00651     int yy_more_flag;
00652     int yy_more_len;
00653 #endif
00654 
00655 #ifdef YY_REENTRANT_BISON_PURE
00656     YYSTYPE * yylval_r;
00657 #ifdef YYLTYPE
00658     YYLTYPE * yylloc_r;
00659 #endif
00660 #endif
00661 
00662     };
00663 /* %e */
00664 #endif /* !ssIN_HEADER */
00665 
00666 /* %c */
00667 #ifndef ssIN_HEADER
00668 static int yy_init_globals YY_PROTO(( yyscan_t ));
00669 /* %e */
00670 #endif /* !ssIN_HEADER */
00671 
00672 /* This must go here because YYSTYPE and YYLSTYPE are included
00673  * from bison output in section 1.*/
00674 #ifdef YY_REENTRANT_BISON_PURE
00675 #    define yylval YY_G(yylval_r)
00676 #  ifdef YYLTYPE
00677 #    define yylloc YY_G(yylloc_r)
00678 #  endif
00679 #endif /* YY_REENTRANT_BISON_PURE */
00680 
00681 #endif /* end if YY_REENTRANT */
00682 
00683 /* Accessor methods to globals.
00684    These are made visible to non-reentrant scanners for convenience. */
00685 #ifndef YY_NO_GET_EXTRA
00686 YY_EXTRA_TYPE yyget_extra YY_PROTO(( YY_ONLY_ARG ));
00687 #endif
00688 
00689 #ifndef YY_NO_SET_EXTRA
00690 void yyset_extra YY_PROTO(( YY_EXTRA_TYPE user_defined YY_LAST_ARG ));
00691 #endif
00692 
00693 #ifndef YY_NO_GET_IN
00694 FILE *yyget_in YY_PROTO(( YY_ONLY_ARG ));
00695 #endif
00696 
00697 #ifndef YY_NO_SET_IN
00698 void yyset_in  YY_PROTO(( FILE * in_str YY_LAST_ARG ));
00699 #endif
00700 
00701 #ifndef YY_NO_GET_OUT
00702 FILE *yyget_out YY_PROTO(( YY_ONLY_ARG ));
00703 #endif
00704 
00705 #ifndef YY_NO_SET_OUT
00706 void yyset_out  YY_PROTO(( FILE * out_str YY_LAST_ARG ));
00707 #endif
00708 
00709 #ifndef YY_NO_GET_LENG
00710 int yyget_leng YY_PROTO(( YY_ONLY_ARG ));
00711 #endif
00712 
00713 #ifndef YY_NO_GET_TEXT
00714 char *yyget_text YY_PROTO(( YY_ONLY_ARG ));
00715 #endif
00716 
00717 #ifndef YY_NO_GET_LINENO
00718 int yyget_lineno YY_PROTO(( YY_ONLY_ARG ));
00719 #endif
00720 
00721 #ifndef YY_NO_SET_LINENO
00722 void yyset_lineno YY_PROTO(( int line_number YY_LAST_ARG ));
00723 #endif
00724 
00725 #ifdef YY_REENTRANT_BISON_PURE
00726 #ifndef YY_NO_GET_LVAL
00727 YYSTYPE * yyget_lval YY_PROTO(( YY_ONLY_ARG ));
00728 #endif
00729 void yyset_lval YY_PROTO(( YYSTYPE * yylvalp YY_LAST_ARG ));
00730 #ifdef YYLTYPE
00731 #ifndef YY_NO_GET_LLOC
00732    YYLTYPE *yyget_lloc YY_PROTO(( YY_ONLY_ARG ));
00733 #endif
00734 #ifndef YY_NO_SET_LLOC
00735     void yyset_lloc YY_PROTO(( YYLTYPE * yyllocp YY_LAST_ARG ));
00736 #endif
00737 #endif /* YYLTYPE */
00738 #endif /* YY_REENTRANT_BISON_PURE */
00739 
00740 /* Macros after this point can all be overridden by user definitions in
00741  * section 1.
00742  */
00743 
00744 #ifndef YY_SKIP_YYWRAP
00745 #ifdef __cplusplus
00746 extern "C" int yywrap YY_PROTO(( YY_ONLY_ARG ));
00747 #else
00748 extern int yywrap YY_PROTO(( YY_ONLY_ARG ));
00749 #endif
00750 #endif
00751 
00752 /* %- */
00753 /* %c */
00754 #ifndef ssIN_HEADER
00755 #ifndef YY_NO_UNPUT
00756 static void yyunput YY_PROTO(( int c, char *buf_ptr  YY_LAST_ARG));
00757 #endif
00758 /* %e */
00759 #endif /* !ssIN_HEADER */
00760 /* %* */
00761 
00762 #ifndef yytext_ptr
00763 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int YY_LAST_ARG));
00764 #endif
00765 
00766 #ifdef YY_NEED_STRLEN
00767 static int yy_flex_strlen YY_PROTO(( yyconst char * YY_LAST_ARG));
00768 #endif
00769 
00770 #ifndef YY_NO_INPUT
00771 /* %- Standard (non-C++) definition */
00772 /* %c */
00773 #ifndef ssIN_HEADER
00774 #ifdef __cplusplus
00775 static int yyinput YY_PROTO(( YY_ONLY_ARG ));
00776 #else
00777 static int input YY_PROTO(( YY_ONLY_ARG ));
00778 #endif
00779 /* %e */
00780 #endif /* !ssIN_HEADER */
00781 /* %* */
00782 #endif
00783 
00784 #if YY_STACK_USED
00785 #ifndef YY_REENTRANT
00786 /* %c */
00787 #ifndef ssIN_HEADER
00788 static int yy_start_stack_ptr = 0;
00789 static int yy_start_stack_depth = 0;
00790 static int *yy_start_stack = 0;
00791 /* %e */
00792 #endif /* !ssIN_HEADER */
00793 #endif
00794 #ifndef YY_NO_PUSH_STATE
00795 static void yy_push_state YY_PROTO(( int new_state YY_LAST_ARG));
00796 #endif
00797 #ifndef YY_NO_POP_STATE
00798 static void yy_pop_state YY_PROTO(( YY_ONLY_ARG ));
00799 #endif
00800 #ifndef YY_NO_TOP_STATE
00801 static int yy_top_state YY_PROTO(( YY_ONLY_ARG ));
00802 #endif
00803 
00804 #else
00805 #define YY_NO_PUSH_STATE 1
00806 #define YY_NO_POP_STATE 1
00807 #define YY_NO_TOP_STATE 1
00808 #endif
00809 
00810 /* Amount of stuff to slurp up with each read. */
00811 #ifndef YY_READ_BUF_SIZE
00812 #define YY_READ_BUF_SIZE 8192
00813 #endif
00814 
00815 /* Copy whatever the last rule matched to the standard output. */
00816 
00817 #ifndef ECHO
00818 /* %- Standard (non-C++) definition */
00819 /* This used to be an fputs(), but since the string might contain NUL's,
00820  * we now use fwrite().
00821  */
00822 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00823 /* %+ C++ definition */
00824 /* %* */
00825 #endif
00826 
00827 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00828  * is returned in "result".
00829  */
00830 #ifndef YY_INPUT
00831 #define YY_INPUT(buf,result,max_size) \
00832 /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
00833        if ( YY_G(yy_current_buffer)->yy_is_interactive ) \
00834               { \
00835               int c = '*'; \
00836               size_t n; \
00837               for ( n = 0; n < max_size && \
00838                           (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00839                      buf[n] = (char) c; \
00840               if ( c == '\n' ) \
00841                      buf[n++] = (char) c; \
00842               if ( c == EOF && ferror( yyin ) ) \
00843                      YY_FATAL_ERROR( "input in flex scanner failed" ); \
00844               result = n; \
00845               } \
00846        else \
00847               { \
00848               errno=0; \
00849               while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00850                      { \
00851                      if( errno != EINTR) \
00852                             { \
00853                             YY_FATAL_ERROR( "input in flex scanner failed" ); \
00854                             break; \
00855                             } \
00856                      errno=0; \
00857                      clearerr(yyin); \
00858                      } \
00859               }
00860 /* %+ C++ definition \ */\
00861 /* %* */
00862 #endif
00863 
00864 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00865  * we don't want an extra ';' after the "return" because that will cause
00866  * some compilers to complain about unreachable statements.
00867  */
00868 #ifndef yyterminate
00869 #define yyterminate() return YY_NULL
00870 #endif
00871 
00872 /* Number of entries by which start-condition stack grows. */
00873 #ifndef YY_START_STACK_INCR
00874 #define YY_START_STACK_INCR 25
00875 #endif
00876 
00877 /* Report a fatal error. */
00878 #ifndef YY_FATAL_ERROR
00879 /* %- */
00880 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00881 /* %+ */
00882 /* %* */
00883 #endif
00884 
00885 /* Default declaration of generated scanner - a define so the user can
00886  * easily add parameters.
00887  */
00888 #ifndef YY_DECL
00889 /* %- Standard (non-C++) definition */
00890 
00891 /* If the bison pure parser is used, then bison will provide
00892    one or two additional arguments. */
00893 
00894 #ifdef YY_REENTRANT_BISON_PURE
00895 #  ifdef YYLTYPE 
00896 #    ifdef YY_USE_PROTOS
00897 #        define YY_LEX_ARGS (YYSTYPE * yylvalp, YYLTYPE * yyllocp YY_LAST_ARG)
00898 #    else
00899 #        define YY_LEX_ARGS (yylvalp, yyllocp YY_LAST_ARG) \
00900                              YYSTYPE * yylvalp; YYLTYPE * yyllocp; YY_DECL_LAST_ARG
00901 #    endif
00902 #  else
00903 #    ifdef YY_USE_PROTOS
00904 #        define YY_LEX_ARGS (YYSTYPE * yylvalp YY_LAST_ARG)
00905 #    else
00906 #        define YY_LEX_ARGS (yylvalp YY_LAST_ARG) \
00907                              YYSTYPE * yylvalp; YY_DECL_LAST_ARG
00908 #    endif
00909 #  endif
00910 #else
00911 #  ifdef YY_USE_PROTOS
00912 #      define YY_LEX_ARGS (YY_ONLY_ARG)
00913 #  else
00914 #      define YY_LEX_ARGS (YY_ONLY_ARG) YY_DECL_LAST_ARG
00915 #  endif
00916 #endif
00917 
00918 
00919 extern int yylex YY_PROTO( YY_LEX_ARGS );
00920 
00921 #define YY_DECL int yylex YY_LEX_ARGS
00922 /* %+ C++ definition */
00923 /* %* */
00924 #endif
00925 
00926 /* Code executed at the beginning of each rule, after yytext and yyleng
00927  * have been set up.
00928  */
00929 #ifndef YY_USER_ACTION
00930 #define YY_USER_ACTION
00931 #endif
00932 
00933 /* Code executed at the end of each rule. */
00934 #ifndef YY_BREAK
00935 #define YY_BREAK break;
00936 #endif
00937 
00938 /* %% [6.0] YY_RULE_SETUP definition goes here */
00939 #define YY_RULE_SETUP \
00940        YY_USER_ACTION
00941 
00942 /* %c */
00943 #ifndef ssIN_HEADER
00944 YY_DECL
00945        {
00946        register yy_state_type yy_current_state;
00947        register char *yy_cp, *yy_bp;
00948        register int yy_act;
00949 
00950 /* %% [7.0] user's declarations go here */
00951 #line 66 "icalsslexer.l"
00952 
00953 
00954 
00955 
00956 
00957 
00958 #line 959 "lex.ss.c"
00959 
00960 #ifdef YY_REENTRANT_BISON_PURE
00961     yylval = yylvalp;
00962 #ifdef YYLTYPE
00963     yylloc = yyllocp;
00964 #endif
00965 #endif
00966 
00967        if ( YY_G(yy_init) )
00968               {
00969               YY_G(yy_init) = 0;
00970 
00971 #ifdef YY_USER_INIT
00972               YY_USER_INIT;
00973 #endif
00974 
00975               if ( ! YY_G(yy_start) )
00976                      YY_G(yy_start) = 1;  /* first start state */
00977 
00978               if ( ! yyin )
00979 /* %- */
00980                      yyin = stdin;
00981 /* %+ */
00982 /* %* */
00983 
00984               if ( ! yyout )
00985 /* %- */
00986                      yyout = stdout;
00987 /* %+ */
00988 /* %* */
00989 
00990               if ( ! YY_G(yy_current_buffer) )
00991                      YY_G(yy_current_buffer) =
00992                             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
00993 
00994               yy_load_buffer_state( YY_CALL_ONLY_ARG );
00995               }
00996 
00997        while ( 1 )          /* loops until end-of-file is reached */
00998               {
00999 /* %% [8.0] yymore()-related code goes here */
01000               yy_cp = YY_G(yy_c_buf_p);
01001 
01002               /* Support of yytext. */
01003               *yy_cp = YY_G(yy_hold_char);
01004 
01005               /* yy_bp points to the position in yy_ch_buf of the start of
01006                * the current run.
01007                */
01008               yy_bp = yy_cp;
01009 
01010 /* %% [9.0] code to set up and find next match goes here */
01011               yy_current_state = YY_G(yy_start);
01012 yy_match:
01013               do
01014                      {
01015                      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
01016                      if ( yy_accept[yy_current_state] )
01017                             {
01018                             YY_G(yy_last_accepting_state) = yy_current_state;
01019                             YY_G(yy_last_accepting_cpos) = yy_cp;
01020                             }
01021                      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01022                             {
01023                             yy_current_state = (int) yy_def[yy_current_state];
01024                             if ( yy_current_state >= 56 )
01025                                    yy_c = yy_meta[(unsigned int) yy_c];
01026                             }
01027                      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01028                      ++yy_cp;
01029                      }
01030               while ( yy_base[yy_current_state] != 69 );
01031 
01032 yy_find_action:
01033 /* %% [10.0] code to find the action number goes here */
01034               yy_act = yy_accept[yy_current_state];
01035               if ( yy_act == 0 )
01036                      { /* have to back up */
01037                      yy_cp = YY_G(yy_last_accepting_cpos);
01038                      yy_current_state = YY_G(yy_last_accepting_state);
01039                      yy_act = yy_accept[yy_current_state];
01040                      }
01041 
01042               YY_DO_BEFORE_ACTION;
01043 
01044 /* %% [11.0] code for yylineno update goes here */
01045 
01046 do_action:    /* This label is used only to access EOF actions. */
01047 
01048 /* %% [12.0] debug code goes here */
01049 
01050               switch ( yy_act )
01051        { /* beginning of action switch */
01052 /* %% [13.0] actions go here */
01053                      case 0: /* must back up */
01054                      /* undo the effects of YY_DO_BEFORE_ACTION */
01055                      *yy_cp = YY_G(yy_hold_char);
01056                      yy_cp = YY_G(yy_last_accepting_cpos);
01057                      yy_current_state = YY_G(yy_last_accepting_state);
01058                      goto yy_find_action;
01059 
01060 case 1:
01061 YY_RULE_SETUP
01062 #line 72 "icalsslexer.l"
01063 { return SELECT; }
01064        YY_BREAK
01065 case 2:
01066 YY_RULE_SETUP
01067 #line 73 "icalsslexer.l"
01068 { return FROM; }
01069        YY_BREAK
01070 case 3:
01071 YY_RULE_SETUP
01072 #line 74 "icalsslexer.l"
01073 { return WHERE; }
01074        YY_BREAK
01075 case 4:
01076 YY_RULE_SETUP
01077 #line 75 "icalsslexer.l"
01078 { return COMMA; }
01079        YY_BREAK
01080 case 5:
01081 YY_RULE_SETUP
01082 #line 76 "icalsslexer.l"
01083 { return EQUALS; }
01084        YY_BREAK
01085 case 6:
01086 YY_RULE_SETUP
01087 #line 77 "icalsslexer.l"
01088 { return EQUALS; }
01089        YY_BREAK
01090 case 7:
01091 YY_RULE_SETUP
01092 #line 78 "icalsslexer.l"
01093 { return NOTEQUALS; }
01094        YY_BREAK
01095 case 8:
01096 YY_RULE_SETUP
01097 #line 79 "icalsslexer.l"
01098 { return LESS; }
01099        YY_BREAK
01100 case 9:
01101 YY_RULE_SETUP
01102 #line 80 "icalsslexer.l"
01103 { return GREATER; }
01104        YY_BREAK
01105 case 10:
01106 YY_RULE_SETUP
01107 #line 81 "icalsslexer.l"
01108 { return LESSEQUALS; }
01109        YY_BREAK
01110 case 11:
01111 YY_RULE_SETUP
01112 #line 82 "icalsslexer.l"
01113 { return GREATEREQUALS; }
01114        YY_BREAK
01115 case 12:
01116 YY_RULE_SETUP
01117 #line 83 "icalsslexer.l"
01118 { return AND; }
01119        YY_BREAK
01120 case 13:
01121 YY_RULE_SETUP
01122 #line 84 "icalsslexer.l"
01123 { return OR; }
01124        YY_BREAK
01125 case 14:
01126 YY_RULE_SETUP
01127 #line 85 "icalsslexer.l"
01128 { return IS; }
01129        YY_BREAK
01130 case 15:
01131 YY_RULE_SETUP
01132 #line 86 "icalsslexer.l"
01133 { return NOT; }
01134        YY_BREAK
01135 case 16:
01136 YY_RULE_SETUP
01137 #line 87 "icalsslexer.l"
01138 { return SQLNULL; }
01139        YY_BREAK
01140 case 17:
01141 YY_RULE_SETUP
01142 #line 88 "icalsslexer.l"
01143 { return QUOTE; }
01144        YY_BREAK
01145 case 18:
01146 YY_RULE_SETUP
01147 #line 89 "icalsslexer.l"
01148 ;                    
01149        YY_BREAK
01150 case 19:
01151 YY_RULE_SETUP
01152 #line 90 "icalsslexer.l"
01153 { return EOL; }
01154        YY_BREAK
01155 case 20:
01156 YY_RULE_SETUP
01157 #line 92 "icalsslexer.l"
01158 {
01159        int c = input(yy_globals);
01160        unput(c);
01161        if(c!='\''){
01162               yylvalp->v_string= icalmemory_tmp_copy(yytext);
01163               return STRING;
01164        } else {
01165               /*ssmore();*/
01166        }
01167 }
01168        YY_BREAK
01169 case 21:
01170 YY_RULE_SETUP
01171 #line 103 "icalsslexer.l"
01172 {
01173         yylval->v_string= icalmemory_tmp_copy(yytext);
01174        return STRING; 
01175 }
01176        YY_BREAK
01177 case 22:
01178 YY_RULE_SETUP
01179 #line 109 "icalsslexer.l"
01180 { return yytext[0]; }
01181        YY_BREAK
01182 case 23:
01183 YY_RULE_SETUP
01184 #line 111 "icalsslexer.l"
01185 ECHO;
01186        YY_BREAK
01187 #line 1188 "lex.ss.c"
01188 case YY_STATE_EOF(INITIAL):
01189 case YY_STATE_EOF(sql):
01190 case YY_STATE_EOF(string_value):
01191        yyterminate();
01192 
01193        case YY_END_OF_BUFFER:
01194               {
01195               /* Amount of text matched not including the EOB char. */
01196               int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;
01197 
01198               /* Undo the effects of YY_DO_BEFORE_ACTION. */
01199               *yy_cp = YY_G(yy_hold_char);
01200               YY_RESTORE_YY_MORE_OFFSET
01201 
01202               if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_NEW )
01203                      {
01204                      /* We're scanning a new file or input source.  It's
01205                       * possible that this happened because the user
01206                       * just pointed yyin at a new source and called
01207                       * yylex().  If so, then we have to assure
01208                       * consistency between yy_current_buffer and our
01209                       * globals.  Here is the right place to do so, because
01210                       * this is the first action (other than possibly a
01211                       * back-up) that will match for the new input source.
01212                       */
01213                      YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_n_chars;
01214                      YY_G(yy_current_buffer)->yy_input_file = yyin;
01215                      YY_G(yy_current_buffer)->yy_buffer_status = YY_BUFFER_NORMAL;
01216                      }
01217 
01218               /* Note that here we test for yy_c_buf_p "<=" to the position
01219                * of the first EOB in the buffer, since yy_c_buf_p will
01220                * already have been incremented past the NUL character
01221                * (since all states make transitions on EOB to the
01222                * end-of-buffer state).  Contrast this with the test
01223                * in input().
01224                */
01225               if ( YY_G(yy_c_buf_p) <= &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] )
01226                      { /* This was really a NUL. */
01227                      yy_state_type yy_next_state;
01228 
01229                      YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;
01230 
01231                      yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
01232 
01233                      /* Okay, we're now positioned to make the NUL
01234                       * transition.  We couldn't have
01235                       * yy_get_previous_state() go ahead and do it
01236                       * for us because it doesn't know how to deal
01237                       * with the possibility of jamming (and we don't
01238                       * want to build jamming into it because then it
01239                       * will run more slowly).
01240                       */
01241 
01242                      yy_next_state = yy_try_NUL_trans( yy_current_state YY_CALL_LAST_ARG);
01243 
01244                      yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
01245 
01246                      if ( yy_next_state )
01247                             {
01248                             /* Consume the NUL. */
01249                             yy_cp = ++YY_G(yy_c_buf_p);
01250                             yy_current_state = yy_next_state;
01251                             goto yy_match;
01252                             }
01253 
01254                      else
01255                             {
01256 /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
01257                             yy_cp = YY_G(yy_c_buf_p);
01258                             goto yy_find_action;
01259                             }
01260                      }
01261 
01262               else switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) )
01263                      {
01264                      case EOB_ACT_END_OF_FILE:
01265                             {
01266                             YY_G(yy_did_buffer_switch_on_eof) = 0;
01267 
01268                             if ( yywrap( YY_CALL_ONLY_ARG ) )
01269                                    {
01270                                    /* Note: because we've taken care in
01271                                     * yy_get_next_buffer() to have set up
01272                                     * yytext, we can now set up
01273                                     * yy_c_buf_p so that if some total
01274                                     * hoser (like flex itself) wants to
01275                                     * call the scanner after we return the
01276                                     * YY_NULL, it'll still work - another
01277                                     * YY_NULL will get returned.
01278                                     */
01279                                    YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;
01280 
01281                                    yy_act = YY_STATE_EOF(YY_START);
01282                                    goto do_action;
01283                                    }
01284 
01285                             else
01286                                    {
01287                                    if ( ! YY_G(yy_did_buffer_switch_on_eof) )
01288                                           YY_NEW_FILE;
01289                                    }
01290                             break;
01291                             }
01292 
01293                      case EOB_ACT_CONTINUE_SCAN:
01294                             YY_G(yy_c_buf_p) =
01295                                    YY_G(yytext_ptr) + yy_amount_of_matched_text;
01296 
01297                             yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
01298 
01299                             yy_cp = YY_G(yy_c_buf_p);
01300                             yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
01301                             goto yy_match;
01302 
01303                      case EOB_ACT_LAST_MATCH:
01304                             YY_G(yy_c_buf_p) =
01305                             &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)];
01306 
01307                             yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
01308 
01309                             yy_cp = YY_G(yy_c_buf_p);
01310                             yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
01311                             goto yy_find_action;
01312                      }
01313               break;
01314               }
01315 
01316        default:
01317               YY_FATAL_ERROR(
01318                      "fatal flex scanner internal error--no action found" );
01319        } /* end of action switch */
01320               } /* end of scanning one token */
01321        } /* end of yylex */
01322 /* %e */
01323 #endif /* !ssIN_HEADER */
01324 /* %+ */
01325 /* %c */
01326 #ifndef ssIN_HEADER
01327 /* %e */
01328 #endif /* !ssIN_HEADER */
01329 /* %* */
01330 
01331 /* yy_get_next_buffer - try to read in a new buffer
01332  *
01333  * Returns a code representing an action:
01334  *     EOB_ACT_LAST_MATCH -
01335  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01336  *     EOB_ACT_END_OF_FILE - end of file
01337  */
01338 
01339 /* %- */
01340 /* %c */
01341 #ifndef ssIN_HEADER
01342 #ifdef YY_USE_PROTOS
01343 static int yy_get_next_buffer(YY_ONLY_ARG)
01344 #else
01345 static int yy_get_next_buffer(YY_ONLY_ARG)
01346 YY_DECL_LAST_ARG
01347 #endif
01348 /* %+ */
01349 /* %* */
01350        {
01351        register char *dest = YY_G(yy_current_buffer)->yy_ch_buf;
01352        register char *source = YY_G(yytext_ptr);
01353        register int number_to_move, i;
01354        int ret_val;
01355 
01356        if ( YY_G(yy_c_buf_p) > &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] )
01357               YY_FATAL_ERROR(
01358               "fatal flex scanner internal error--end of buffer missed" );
01359 
01360        if ( YY_G(yy_current_buffer)->yy_fill_buffer == 0 )
01361               { /* Don't try to fill the buffer, so this is an EOF. */
01362               if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
01363                      {
01364                      /* We matched a single character, the EOB, so
01365                       * treat this as a final EOF.
01366                       */
01367                      return EOB_ACT_END_OF_FILE;
01368                      }
01369 
01370               else
01371                      {
01372                      /* We matched some text prior to the EOB, first
01373                       * process it.
01374                       */
01375                      return EOB_ACT_LAST_MATCH;
01376                      }
01377               }
01378 
01379        /* Try to read more data. */
01380 
01381        /* First move last chars to start of buffer. */
01382        number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;
01383 
01384        for ( i = 0; i < number_to_move; ++i )
01385               *(dest++) = *(source++);
01386 
01387        if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01388               /* don't do the read, it's not guaranteed to return an EOF,
01389                * just force an EOF
01390                */
01391               YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars) = 0;
01392 
01393        else
01394               {
01395                      size_t num_to_read =
01396                      YY_G(yy_current_buffer)->yy_buf_size - number_to_move - 1;
01397 
01398               while ( num_to_read <= 0 )
01399                      { /* Not enough room in the buffer - grow it. */
01400 #ifdef YY_USES_REJECT
01401                      YY_FATAL_ERROR(
01402 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01403 #else
01404 
01405                      /* just a shorter name for the current buffer */
01406                      YY_BUFFER_STATE b = YY_G(yy_current_buffer);
01407 
01408                      int yy_c_buf_p_offset =
01409                             (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
01410 
01411                      if ( b->yy_is_our_buffer )
01412                             {
01413                             int new_size = b->yy_buf_size * 2;
01414 
01415                             if ( new_size <= 0 )
01416                                    b->yy_buf_size += b->yy_buf_size / 8;
01417                             else
01418                                    b->yy_buf_size *= 2;
01419 
01420                             b->yy_ch_buf = (char *)
01421                                    /* Include room in for 2 EOB chars. */
01422                                    yy_flex_realloc( (void *) b->yy_ch_buf,
01423                                                   b->yy_buf_size + 2 YY_CALL_LAST_ARG );
01424                             }
01425                      else
01426                             /* Can't grow it, we don't own it. */
01427                             b->yy_ch_buf = 0;
01428 
01429                      if ( ! b->yy_ch_buf )
01430                             YY_FATAL_ERROR(
01431                             "fatal error - scanner input buffer overflow" );
01432 
01433                      YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
01434 
01435                      num_to_read = YY_G(yy_current_buffer)->yy_buf_size -
01436                                           number_to_move - 1;
01437 #endif
01438                      }
01439 
01440               if ( num_to_read > YY_READ_BUF_SIZE )
01441                      num_to_read = YY_READ_BUF_SIZE;
01442 
01443               /* Read in more data. */
01444               YY_INPUT( (&YY_G(yy_current_buffer)->yy_ch_buf[number_to_move]),
01445                      YY_G(yy_n_chars), num_to_read );
01446 
01447               YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars);
01448               }
01449 
01450        if ( YY_G(yy_n_chars) == 0 )
01451               {
01452               if ( number_to_move == YY_MORE_ADJ )
01453                      {
01454                      ret_val = EOB_ACT_END_OF_FILE;
01455                      yyrestart( yyin  YY_CALL_LAST_ARG);
01456                      }
01457 
01458               else
01459                      {
01460                      ret_val = EOB_ACT_LAST_MATCH;
01461                      YY_G(yy_current_buffer)->yy_buffer_status =
01462                             YY_BUFFER_EOF_PENDING;
01463                      }
01464               }
01465 
01466        else
01467               ret_val = EOB_ACT_CONTINUE_SCAN;
01468 
01469        YY_G(yy_n_chars) += number_to_move;
01470        YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
01471        YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
01472 
01473        YY_G(yytext_ptr) = &YY_G(yy_current_buffer)->yy_ch_buf[0];
01474 
01475        return ret_val;
01476        }
01477 /* %e */
01478 #endif /* !ssIN_HEADER */
01479 
01480 /* yy_get_previous_state - get the state just before the EOB char was reached */
01481 
01482 /* %- */
01483 /* %c */
01484 #ifndef ssIN_HEADER
01485 #ifdef YY_USE_PROTOS
01486 static yy_state_type yy_get_previous_state(YY_ONLY_ARG)
01487 #else
01488 static yy_state_type yy_get_previous_state(YY_ONLY_ARG)
01489 YY_DECL_LAST_ARG
01490 #endif
01491 /* %+ */
01492 /* %* */
01493        {
01494        register yy_state_type yy_current_state;
01495        register char *yy_cp;
01496 
01497 /* %% [15.0] code to get the start state into yy_current_state goes here */
01498        yy_current_state = YY_G(yy_start);
01499 
01500        for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
01501               {
01502 /* %% [16.0] code to find the next state goes here */
01503               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01504               if ( yy_accept[yy_current_state] )
01505                      {
01506                      YY_G(yy_last_accepting_state) = yy_current_state;
01507                      YY_G(yy_last_accepting_cpos) = yy_cp;
01508                      }
01509               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01510                      {
01511                      yy_current_state = (int) yy_def[yy_current_state];
01512                      if ( yy_current_state >= 56 )
01513                             yy_c = yy_meta[(unsigned int) yy_c];
01514                      }
01515               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01516               }
01517 
01518        return yy_current_state;
01519        }
01520 
01521 
01522 /* yy_try_NUL_trans - try to make a transition on the NUL character
01523  *
01524  * synopsis
01525  *     next_state = yy_try_NUL_trans( current_state );
01526  */
01527 
01528 /* %- */
01529 #ifdef YY_USE_PROTOS
01530 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state YY_LAST_ARG )
01531 #else
01532 static yy_state_type yy_try_NUL_trans( yy_current_state YY_LAST_ARG )
01533 yy_state_type yy_current_state;
01534 YY_DECL_LAST_ARG
01535 #endif
01536 /* %+ */
01537 /* %* */
01538        {
01539        register int yy_is_jam;
01540 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
01541        register char *yy_cp = YY_G(yy_c_buf_p);
01542 
01543        register YY_CHAR yy_c = 1;
01544        if ( yy_accept[yy_current_state] )
01545               {
01546               YY_G(yy_last_accepting_state) = yy_current_state;
01547               YY_G(yy_last_accepting_cpos) = yy_cp;
01548               }
01549        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01550               {
01551               yy_current_state = (int) yy_def[yy_current_state];
01552               if ( yy_current_state >= 56 )
01553                      yy_c = yy_meta[(unsigned int) yy_c];
01554               }
01555        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01556        yy_is_jam = (yy_current_state == 55);
01557 
01558        return yy_is_jam ? 0 : yy_current_state;
01559        }
01560 
01561 
01562 /* %- */
01563 #ifndef YY_NO_UNPUT
01564 #ifdef YY_USE_PROTOS
01565 static void yyunput( int c, register char *yy_bp YY_LAST_ARG )
01566 #else
01567 static void yyunput( c, yy_bp YY_LAST_ARG)
01568 int c;
01569 register char *yy_bp;
01570 YY_DECL_LAST_ARG
01571 #endif
01572 /* %+ */
01573 /* %* */
01574        {
01575        register char *yy_cp = YY_G(yy_c_buf_p);
01576 
01577        /* undo effects of setting up yytext */
01578        *yy_cp = YY_G(yy_hold_char);
01579 
01580        if ( yy_cp < YY_G(yy_current_buffer)->yy_ch_buf + 2 )
01581               { /* need to shift things up to make room */
01582               /* +2 for EOB chars. */
01583               register int number_to_move = YY_G(yy_n_chars) + 2;
01584               register char *dest = &YY_G(yy_current_buffer)->yy_ch_buf[
01585                                    YY_G(yy_current_buffer)->yy_buf_size + 2];
01586               register char *source =
01587                             &YY_G(yy_current_buffer)->yy_ch_buf[number_to_move];
01588 
01589               while ( source > YY_G(yy_current_buffer)->yy_ch_buf )
01590                      *--dest = *--source;
01591 
01592               yy_cp += (int) (dest - source);
01593               yy_bp += (int) (dest - source);
01594               YY_G(yy_current_buffer)->yy_n_chars =
01595                      YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_buf_size;
01596 
01597               if ( yy_cp < YY_G(yy_current_buffer)->yy_ch_buf + 2 )
01598                      YY_FATAL_ERROR( "flex scanner push-back overflow" );
01599               }
01600 
01601        *--yy_cp = (char) c;
01602 
01603 /* %% [18.0] update yylineno here */
01604 
01605        YY_G(yytext_ptr) = yy_bp;
01606        YY_G(yy_hold_char) = *yy_cp;
01607        YY_G(yy_c_buf_p) = yy_cp;
01608        }
01609 /* %- */
01610 #endif /* ifndef YY_NO_UNPUT */
01611 /* %* */
01612 
01613 
01614 /* %- */
01615 #ifndef YY_NO_INPUT
01616 #ifdef __cplusplus
01617 static int yyinput(YY_ONLY_ARG)
01618 #else
01619 #ifdef YY_USE_PROTOS
01620 static int input(YY_ONLY_ARG)
01621 #else
01622 static int input(YY_ONLY_ARG)
01623     YY_DECL_LAST_ARG
01624 #endif
01625 #endif
01626 /* %+ */
01627 /* %* */
01628        {
01629        int c;
01630 
01631        *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
01632 
01633        if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
01634               {
01635               /* yy_c_buf_p now points to the character we want to return.
01636                * If this occurs *before* the EOB characters, then it's a
01637                * valid NUL; if not, then we've hit the end of the buffer.
01638                */
01639               if ( YY_G(yy_c_buf_p) < &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] )
01640                      /* This was really a NUL. */
01641                      *YY_G(yy_c_buf_p) = '\0';
01642 
01643               else
01644                      { /* need more input */
01645                      int offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
01646                      ++YY_G(yy_c_buf_p);
01647 
01648                      switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) )
01649                             {
01650                             case EOB_ACT_LAST_MATCH:
01651                                    /* This happens because yy_g_n_b()
01652                                     * sees that we've accumulated a
01653                                     * token and flags that we need to
01654                                     * try matching the token before
01655                                     * proceeding.  But for input(),
01656                                     * there's no matching to consider.
01657                                     * So convert the EOB_ACT_LAST_MATCH
01658                                     * to EOB_ACT_END_OF_FILE.
01659                                     */
01660 
01661                                    /* Reset buffer status. */
01662                                    yyrestart( yyin YY_CALL_LAST_ARG);
01663 
01664                                    /* fall through */
01665 
01666                             case EOB_ACT_END_OF_FILE:
01667                                    {
01668                                    if ( yywrap( YY_CALL_ONLY_ARG ) )
01669                                           return EOF;
01670 
01671                                    if ( ! YY_G(yy_did_buffer_switch_on_eof) )
01672                                           YY_NEW_FILE;
01673 #ifdef __cplusplus
01674                                    return yyinput(YY_CALL_ONLY_ARG);
01675 #else
01676                                    return input(YY_CALL_ONLY_ARG);
01677 #endif
01678                                    }
01679 
01680                             case EOB_ACT_CONTINUE_SCAN:
01681                                    YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
01682                                    break;
01683                             }
01684                      }
01685               }
01686 
01687        c = *(unsigned char *) YY_G(yy_c_buf_p);  /* cast for 8-bit char's */
01688        *YY_G(yy_c_buf_p) = '\0';   /* preserve yytext */
01689        YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);
01690 
01691 /* %% [19.0] update BOL and yylineno */
01692 
01693        return c;
01694        }
01695 /* %- */
01696 #endif /* ifndef YY_NO_INPUT */
01697 /* %* */
01698 
01699 /* %- */
01700 #ifdef YY_USE_PROTOS
01701 void yyrestart( FILE *input_file YY_LAST_ARG)
01702 #else
01703 void yyrestart( input_file YY_LAST_ARG)
01704 FILE *input_file;
01705 YY_DECL_LAST_ARG
01706 #endif
01707 /* %+ */
01708 /* %* */
01709        {
01710        if ( ! YY_G(yy_current_buffer) )
01711               YY_G(yy_current_buffer) =
01712             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
01713 
01714        yy_init_buffer( YY_G(yy_current_buffer), input_file YY_CALL_LAST_ARG);
01715        yy_load_buffer_state( YY_CALL_ONLY_ARG );
01716        }
01717 
01718 
01719 /* %- */
01720 #ifdef YY_USE_PROTOS
01721 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer YY_LAST_ARG )
01722 #else
01723 void yy_switch_to_buffer( new_buffer YY_LAST_ARG )
01724 YY_BUFFER_STATE new_buffer;
01725 YY_DECL_LAST_ARG
01726 #endif
01727 /* %+ */
01728 /* %* */
01729        {
01730        if ( YY_G(yy_current_buffer) == new_buffer )
01731               return;
01732 
01733        if ( YY_G(yy_current_buffer) )
01734               {
01735               /* Flush out information for old buffer. */
01736               *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
01737               YY_G(yy_current_buffer)->yy_buf_pos = YY_G(yy_c_buf_p);
01738               YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars);
01739               }
01740 
01741        YY_G(yy_current_buffer) = new_buffer;
01742        yy_load_buffer_state( YY_CALL_ONLY_ARG );
01743 
01744        /* We don't actually know whether we did this switch during
01745         * EOF (yywrap()) processing, but the only time this flag
01746         * is looked at is after yywrap() is called, so it's safe
01747         * to go ahead and always set it.
01748         */
01749        YY_G(yy_did_buffer_switch_on_eof) = 1;
01750        }
01751 
01752 
01753 /* %- */
01754 #ifdef YY_USE_PROTOS
01755 void yy_load_buffer_state( YY_ONLY_ARG )
01756 #else
01757 void yy_load_buffer_state(YY_ONLY_ARG )
01758 YY_DECL_LAST_ARG
01759 #endif
01760 /* %+ */
01761 /* %* */
01762        {
01763        YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_n_chars;
01764        YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_G(yy_current_buffer)->yy_buf_pos;
01765        yyin = YY_G(yy_current_buffer)->yy_input_file;
01766        YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
01767        }
01768 
01769 
01770 /* %- */
01771 #ifdef YY_USE_PROTOS
01772 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size YY_LAST_ARG)
01773 #else
01774 YY_BUFFER_STATE yy_create_buffer( file, size YY_LAST_ARG)
01775 FILE *file;
01776 int size;
01777 YY_DECL_LAST_ARG
01778 #endif
01779 /* %+ */
01780 /* %* */
01781        {
01782        YY_BUFFER_STATE b;
01783 
01784        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG );
01785        if ( ! b )
01786               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01787 
01788        b->yy_buf_size = size;
01789 
01790        /* yy_ch_buf has to be 2 characters longer than the size given because
01791         * we need to put in 2 end-of-buffer characters.
01792         */
01793        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 YY_CALL_LAST_ARG );
01794        if ( ! b->yy_ch_buf )
01795               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01796 
01797        b->yy_is_our_buffer = 1;
01798 
01799        yy_init_buffer( b, file YY_CALL_LAST_ARG);
01800 
01801        return b;
01802        }
01803 
01804 
01805 /* %- */
01806 #ifdef YY_USE_PROTOS
01807 void yy_delete_buffer( YY_BUFFER_STATE b YY_LAST_ARG)
01808 #else
01809 void yy_delete_buffer( b YY_LAST_ARG)
01810 YY_BUFFER_STATE b;
01811 YY_DECL_LAST_ARG
01812 #endif
01813 /* %+ */
01814 /* %* */
01815        {
01816        if ( ! b )
01817               return;
01818 
01819        if ( b == YY_G(yy_current_buffer) )
01820               YY_G(yy_current_buffer) = (YY_BUFFER_STATE) 0;
01821 
01822        if ( b->yy_is_our_buffer )
01823               yy_flex_free( (void *) b->yy_ch_buf YY_CALL_LAST_ARG );
01824 
01825        yy_flex_free( (void *) b YY_CALL_LAST_ARG );
01826        }
01827 
01828 
01829 /* %- */
01830 #ifndef YY_ALWAYS_INTERACTIVE
01831 #ifndef YY_NEVER_INTERACTIVE
01832 #ifdef __cplusplus
01833 extern "C" int isatty YY_PROTO(( int ));
01834 #else
01835 extern int isatty YY_PROTO(( int ));
01836 #endif /* __cplusplus */
01837 #endif /* !YY_NEVER_INTERACTIVE */
01838 #endif /* !YY_ALWAYS_INTERACTIVE */
01839 
01840 #ifdef YY_USE_PROTOS
01841 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file YY_LAST_ARG)
01842 #else
01843 void yy_init_buffer( b, file YY_LAST_ARG)
01844 YY_BUFFER_STATE b;
01845 FILE *file;
01846 YY_DECL_LAST_ARG
01847 #endif
01848 
01849 /* %+ */
01850 /* %* */
01851 
01852        {
01853        int oerrno = errno;
01854 
01855        yy_flush_buffer( b YY_CALL_LAST_ARG);
01856 
01857        b->yy_input_file = file;
01858        b->yy_fill_buffer = 1;
01859 
01860 /* %- */
01861 #if YY_ALWAYS_INTERACTIVE
01862        b->yy_is_interactive = 1;
01863 #else
01864 #if YY_NEVER_INTERACTIVE
01865        b->yy_is_interactive = 0;
01866 #else
01867        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01868 #endif
01869 #endif
01870 /* %+ */
01871 /* %* */
01872        errno = oerrno;
01873        }
01874 
01875 
01876 /* %- */
01877 #ifdef YY_USE_PROTOS
01878 void yy_flush_buffer( YY_BUFFER_STATE b YY_LAST_ARG )
01879 #else
01880 void yy_flush_buffer( b YY_LAST_ARG )
01881 YY_BUFFER_STATE b;
01882 YY_DECL_LAST_ARG
01883 #endif
01884 
01885 /* %+ */
01886 /* %* */
01887        {
01888        if ( ! b )
01889               return;
01890 
01891        b->yy_n_chars = 0;
01892 
01893        /* We always need two end-of-buffer characters.  The first causes
01894         * a transition to the end-of-buffer state.  The second causes
01895         * a jam in that state.
01896         */
01897        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01898        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01899 
01900        b->yy_buf_pos = &b->yy_ch_buf[0];
01901 
01902        b->yy_at_bol = 1;
01903        b->yy_buffer_status = YY_BUFFER_NEW;
01904 
01905        if ( b == YY_G(yy_current_buffer) )
01906               yy_load_buffer_state( YY_CALL_ONLY_ARG );
01907        }
01908 /* %* */
01909 
01910 
01911 #ifndef YY_NO_SCAN_BUFFER
01912 /* %- */
01913 #ifdef YY_USE_PROTOS
01914 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size YY_LAST_ARG )
01915 #else
01916 YY_BUFFER_STATE yy_scan_buffer( base, size YY_LAST_ARG )
01917 char *base;
01918 yy_size_t size;
01919 YY_DECL_LAST_ARG
01920 #endif
01921        {
01922        YY_BUFFER_STATE b;
01923 
01924        if ( size < 2 ||
01925             base[size-2] != YY_END_OF_BUFFER_CHAR ||
01926             base[size-1] != YY_END_OF_BUFFER_CHAR )
01927               /* They forgot to leave room for the EOB's. */
01928               return 0;
01929 
01930        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG );
01931        if ( ! b )
01932               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01933 
01934        b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
01935        b->yy_buf_pos = b->yy_ch_buf = base;
01936        b->yy_is_our_buffer = 0;
01937        b->yy_input_file = 0;
01938        b->yy_n_chars = b->yy_buf_size;
01939        b->yy_is_interactive = 0;
01940        b->yy_at_bol = 1;
01941        b->yy_fill_buffer = 0;
01942        b->yy_buffer_status = YY_BUFFER_NEW;
01943 
01944        yy_switch_to_buffer( b YY_CALL_LAST_ARG );
01945 
01946        return b;
01947        }
01948 /* %* */
01949 #endif
01950 
01951 
01952 #ifndef YY_NO_SCAN_STRING
01953 /* %- */
01954 #ifdef YY_USE_PROTOS
01955 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str YY_LAST_ARG )
01956 #else
01957 YY_BUFFER_STATE yy_scan_string( yy_str YY_LAST_ARG)
01958 yyconst char *yy_str;
01959 YY_DECL_LAST_ARG
01960 #endif
01961        {
01962        int len;
01963        for ( len = 0; yy_str[len]; ++len )
01964               ;
01965 
01966        return yy_scan_bytes( yy_str, len YY_CALL_LAST_ARG);
01967        }
01968 /* %* */
01969 #endif
01970 
01971 
01972 #ifndef YY_NO_SCAN_BYTES
01973 /* %- */
01974 #ifdef YY_USE_PROTOS
01975 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len YY_LAST_ARG)
01976 #else
01977 YY_BUFFER_STATE yy_scan_bytes( bytes, len YY_LAST_ARG)
01978 yyconst char *bytes;
01979 YY_DECL_LAST_ARG
01980 int len;
01981 #endif
01982        {
01983        YY_BUFFER_STATE b;
01984        char *buf;
01985        yy_size_t n;
01986        int i;
01987 
01988        /* Get memory for full buffer, including space for trailing EOB's. */
01989        n = len + 2;
01990        buf = (char *) yy_flex_alloc( n YY_CALL_LAST_ARG );
01991        if ( ! buf )
01992               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01993 
01994        for ( i = 0; i < len; ++i )
01995               buf[i] = bytes[i];
01996 
01997        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
01998 
01999        b = yy_scan_buffer( buf, n YY_CALL_LAST_ARG);
02000        if ( ! b )
02001               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
02002 
02003        /* It's okay to grow etc. this buffer, and we should throw it
02004         * away when we're done.
02005         */
02006        b->yy_is_our_buffer = 1;
02007 
02008        return b;
02009        }
02010 /* %* */
02011 #endif
02012 
02013 
02014 #ifndef YY_NO_PUSH_STATE
02015 /* %- */
02016 #ifdef YY_USE_PROTOS
02017 static void yy_push_state( int new_state YY_LAST_ARG)
02018 #else
02019 static void yy_push_state( new_state YY_LAST_ARG)
02020 int new_state;
02021 YY_DECL_LAST_ARG
02022 #endif
02023 /* %+ */
02024 /* %* */
02025        {
02026        if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) )
02027               {
02028               yy_size_t new_size;
02029 
02030               YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
02031               new_size = YY_G(yy_start_stack_depth) * sizeof( int );
02032 
02033               if ( ! YY_G(yy_start_stack) )
02034                      YY_G(yy_start_stack) = (int *) yy_flex_alloc( new_size YY_CALL_LAST_ARG );
02035 
02036               else
02037                      YY_G(yy_start_stack) = (int *) yy_flex_realloc(
02038                                    (void *) YY_G(yy_start_stack), new_size YY_CALL_LAST_ARG );
02039 
02040               if ( ! YY_G(yy_start_stack) )
02041                      YY_FATAL_ERROR(
02042                      "out of memory expanding start-condition stack" );
02043               }
02044 
02045        YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START;
02046 
02047        BEGIN(new_state);
02048        }
02049 #endif
02050 
02051 
02052 #ifndef YY_NO_POP_STATE
02053 /* %- */
02054 #ifdef YY_USE_PROTOS
02055 static void yy_pop_state( YY_ONLY_ARG )
02056 #else
02057 static void yy_pop_state( YY_ONLY_ARG )
02058 YY_DECL_LAST_ARG
02059 #endif
02060 /* %+ */
02061 /* %* */
02062        {
02063        if ( --YY_G(yy_start_stack_ptr) < 0 )
02064               YY_FATAL_ERROR( "start-condition stack underflow" );
02065 
02066        BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
02067        }
02068 #endif
02069 
02070 
02071 #ifndef YY_NO_TOP_STATE
02072 /* %- */
02073 #ifdef YY_USE_PROTOS
02074 static int yy_top_state( YY_ONLY_ARG )
02075 #else
02076 static int yy_top_state( YY_ONLY_ARG )
02077 YY_DECL_LAST_ARG
02078 #endif
02079 /* %+ */
02080 /* %* */
02081        {
02082        return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1];
02083        }
02084 #endif
02085 
02086 #ifndef YY_EXIT_FAILURE
02087 #define YY_EXIT_FAILURE 2
02088 #endif
02089 
02090 /* %- */
02091 static void yy_fatal_error( yyconst char msg[] )
02092        {
02093        (void) fprintf( stderr, "%s\n", msg );
02094        exit( YY_EXIT_FAILURE );
02095        }
02096 
02097 /* %+ */
02098 /* %* */
02099 
02100 
02101 /* Redefine yyless() so it works in section 3 code. */
02102 
02103 #undef yyless
02104 #define yyless(n) \
02105        do \
02106               { \
02107               /* Undo effects of setting up yytext. */ \
02108               yytext[yyleng] = YY_G(yy_hold_char); \
02109               YY_G(yy_c_buf_p) = yytext + n; \
02110               YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
02111               *YY_G(yy_c_buf_p) = '\0'; \
02112               yyleng = n; \
02113               } \
02114        while ( 0 )
02115 
02116 
02117 
02118 #ifdef YY_REENTRANT
02119 
02120 /* Accessor  methods (get/set functions) to struct members. */
02121 
02122 #ifndef YY_NO_GET_EXTRA
02123 #ifdef YY_USE_PROTOS
02124 YY_EXTRA_TYPE yyget_extra( YY_ONLY_ARG )
02125 #else
02126 YY_EXTRA_TYPE yyget_extra( YY_ONLY_ARG )
02127     YY_DECL_LAST_ARG
02128 #endif
02129 {
02130     return yyextra;
02131 }
02132 #endif /* !YY_NO_GET_EXTRA */
02133 
02134 #ifndef YY_NO_GET_LINENO
02135 #  ifdef YY_USE_PROTOS
02136 int yyget_lineno( YY_ONLY_ARG )
02137 #  else
02138 int yyget_lineno( YY_ONLY_ARG )
02139     YY_DECL_LAST_ARG
02140 #  endif
02141 {
02142     return yylineno;
02143 }
02144 #endif /* !YY_NO_GET_LINENO */
02145 
02146 #ifndef YY_NO_GET_IN
02147 #ifdef YY_USE_PROTOS
02148 FILE *yyget_in( YY_ONLY_ARG )
02149 #else
02150 FILE *yyget_in( YY_ONLY_ARG )
02151     YY_DECL_LAST_ARG
02152 #endif
02153 {
02154     return yyin;
02155 }
02156 #endif /* !YY_NO_GET_IN */
02157 
02158 #ifndef YY_NO_GET_OUT
02159 #ifdef YY_USE_PROTOS
02160 FILE *yyget_out( YY_ONLY_ARG )
02161 #else
02162 FILE *yyget_out( YY_ONLY_ARG )
02163     YY_DECL_LAST_ARG
02164 #endif
02165 {
02166     return yyout;
02167 }
02168 #endif /* !YY_NO_GET_OUT */
02169 
02170 #ifndef YY_NO_GET_LENG
02171 #ifdef YY_USE_PROTOS
02172 int yyget_leng( YY_ONLY_ARG )
02173 #else
02174 int yyget_leng( YY_ONLY_ARG )
02175     YY_DECL_LAST_ARG
02176 #endif
02177 {
02178     return yyleng;
02179 }
02180 #endif /* !YY_NO_GET_LENG */
02181 
02182 #ifndef YY_NO_GET_TEXT
02183 #ifdef YY_USE_PROTOS
02184 char *yyget_text( YY_ONLY_ARG )
02185 #else
02186 char *yyget_text( YY_ONLY_ARG )
02187     YY_DECL_LAST_ARG
02188 #endif
02189 {
02190     return yytext;
02191 }
02192 #endif /* !YY_NO_GET_TEXT */
02193 
02194 #ifndef YY_NO_SET_EXTRA
02195 #ifdef YY_USE_PROTOS
02196 void yyset_extra( YY_EXTRA_TYPE user_defined YY_LAST_ARG )
02197 #else
02198 void yyset_extra( user_defined YY_LAST_ARG )
02199     YY_EXTRA_TYPE user_defined;
02200     YY_DECL_LAST_ARG
02201 #endif
02202 {
02203     yyextra = user_defined ;
02204 }
02205 #endif /* !YY_NO_SET_EXTRA */
02206 
02207 #ifndef YY_NO_SET_LINENO
02208 #  ifdef YY_USE_PROTOS
02209 void yyset_lineno( int line_number YY_LAST_ARG )
02210 #  else
02211 void yyset_lineno( line_number YY_LAST_ARG )
02212     int line_number;
02213     YY_DECL_LAST_ARG
02214 #  endif
02215 {
02216     yylineno = line_number;
02217 }
02218 #endif /* !YY_NO_SET_LINENO */
02219 
02220 
02221 #ifndef YY_NO_SET_IN
02222 #ifdef YY_USE_PROTOS
02223 void yyset_in( FILE * in_str YY_LAST_ARG )
02224 #else
02225 void yyset_in( in_str YY_LAST_ARG )
02226     FILE * in_str;
02227     YY_DECL_LAST_ARG
02228 #endif
02229 {
02230     yyin = in_str ;
02231 }
02232 #endif /* !YY_NO_SET_IN */
02233 
02234 #ifndef YY_NO_SET_OUT
02235 #ifdef YY_USE_PROTOS
02236 void yyset_out( FILE * out_str YY_LAST_ARG )
02237 #else
02238 void yyset_out( out_str YY_LAST_ARG )
02239     FILE * out_str;
02240     YY_DECL_LAST_ARG
02241 #endif
02242 {
02243     yyout = out_str ;
02244 }
02245 #endif /* !YY_NO_SET_OUT */
02246 
02247 /* Accessor methods for yylval and yylloc */
02248 
02249 #ifdef YY_REENTRANT_BISON_PURE
02250 #ifndef YY_NO_GET_LVAL
02251 #ifdef YY_USE_PROTOS
02252 YYSTYPE * yyget_lval( YY_ONLY_ARG )
02253 #else
02254 YYSTYPE * yyget_lval( YY_ONLY_ARG )
02255     YY_DECL_LAST_ARG
02256 #endif
02257 {
02258     return yylval;
02259 }
02260 #endif /* !YY_NO_GET_LVAL */
02261 
02262 #ifndef YY_NO_SET_LVAL
02263 #ifdef YY_USE_PROTOS
02264 void yyset_lval( YYSTYPE * yylvalp YY_LAST_ARG )
02265 #else
02266 void yyset_lval( yylvalp YY_LAST_ARG )
02267     YYSTYPE * yylvalp;
02268     YY_DECL_LAST_ARG
02269 #endif
02270 {
02271     yylval = yylvalp;
02272 }
02273 #endif /* !YY_NO_SET_LVAL */
02274 
02275 #ifdef YYLTYPE
02276 #ifndef YY_NO_GET_LLOC
02277 #ifdef YY_USE_PROTOS
02278 YYLTYPE *yyget_lloc( YY_ONLY_ARG )
02279 #else
02280 YYLTYPE *yyget_lloc( YY_ONLY_ARG )
02281     YY_DECL_LAST_ARG
02282 #endif
02283 {
02284     return yylloc;
02285 }
02286 #endif /* !YY_NO_GET_LLOC */
02287 
02288 #ifndef YY_NO_SET_LLOC
02289 #ifdef YY_USE_PROTOS
02290 void yyset_lloc( YYLTYPE * yyllocp YY_LAST_ARG )
02291 #else
02292 void yyset_lloc( yyllocp YY_LAST_ARG )
02293     YYLTYPE * yyllocp;
02294     YY_DECL_LAST_ARG
02295 #endif
02296 {
02297     yylloc = yyllocp;
02298 }
02299 #endif /* !YY_NO_SET_LLOC */
02300 
02301 #endif /* YYLTYPE */
02302 #endif /* YY_REENTRANT_BISON_PURE */
02303 
02304 
02305 #ifdef YY_USE_PROTOS
02306 static int yy_init_globals( yyscan_t yy_globals)
02307 #else
02308 static int yy_init_globals( yy_globals )
02309     yyscan_t yy_globals;
02310 #endif
02311     {
02312     /* Initialization is the same as for the non-reentrant scanner.
02313        This function is called once per scanner lifetime. */
02314 
02315   /* We do not touch yylineno unless the option is enabled. */
02316 #ifdef YY_USE_LINENO
02317     yylineno =  1;
02318 #endif
02319     YY_G(yy_current_buffer) = 0;
02320     YY_G(yy_c_buf_p) = (char *) 0;
02321     YY_G(yy_init) = 1;
02322     YY_G(yy_start) = 0;
02323     YY_G(yy_start_stack_ptr) = 0;
02324     YY_G(yy_start_stack_depth) = 0;
02325     YY_G(yy_start_stack) = (int *) 0;
02326 
02327 /* Defined in main.c */
02328 #ifdef YY_STDINIT
02329     yyin = stdin;
02330     yyout = stdout;
02331 #else
02332     yyin = (FILE *) 0;
02333     yyout = (FILE *) 0;
02334 #endif
02335     return 0;
02336     }
02337 
02338 /* User-visible API */
02339 #ifdef YY_USE_PROTOS
02340 int yylex_init( yyscan_t* ptr_yy_globals)
02341 #else
02342 int yylex_init( ptr_yy_globals )
02343     yyscan_t* ptr_yy_globals;
02344 #endif
02345     {
02346     *ptr_yy_globals = (yyscan_t) yy_flex_alloc ( sizeof( struct yy_globals_t ), NULL );
02347     yy_init_globals ( *ptr_yy_globals );
02348     return 0;
02349     }
02350 
02351 #ifdef YY_USE_PROTOS
02352 int yylex_destroy( yyscan_t yy_globals )
02353 #else
02354 int yylex_destroy( yy_globals )
02355     yyscan_t yy_globals;
02356 #endif
02357     {
02358     if( yy_globals )
02359         {
02360 
02361             /* Destroy the current (main) buffer. */
02362             yy_delete_buffer( YY_G(yy_current_buffer) YY_CALL_LAST_ARG );
02363             YY_G(yy_current_buffer) = NULL;
02364 
02365             /* Destroy the start condition stack. */
02366             if( YY_G(yy_start_stack) ) {
02367                 yy_flex_free( YY_G(yy_start_stack) YY_CALL_LAST_ARG );
02368                 YY_G(yy_start_stack) = NULL;
02369             }
02370 
02371             /* Destroy the main struct. */
02372             yy_flex_free ( yy_globals YY_CALL_LAST_ARG );
02373         }
02374     return 0;
02375     }
02376 
02377 #endif /* End YY_REENTRANT */
02378 
02379 /* Internal utility routines. */
02380 
02381 #ifndef yytext_ptr
02382 #ifdef YY_USE_PROTOS
02383 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n YY_LAST_ARG)
02384 #else
02385 static void yy_flex_strncpy( s1, s2, n YY_LAST_ARG)
02386 char *s1;
02387 yyconst char *s2;
02388 int n;
02389 YY_DECL_LAST_ARG
02390 #endif
02391        {
02392        register int i;
02393        for ( i = 0; i < n; ++i )
02394               s1[i] = s2[i];
02395        }
02396 #endif
02397 
02398 #ifdef YY_NEED_STRLEN
02399 #ifdef YY_USE_PROTOS
02400 static int yy_flex_strlen( yyconst char *s YY_LAST_ARG)
02401 #else
02402 static int yy_flex_strlen( s YY_LAST_ARG)
02403 yyconst char *s;
02404 YY_DECL_LAST_ARG
02405 #endif
02406        {
02407        register int n;
02408        for ( n = 0; s[n]; ++n )
02409               ;
02410 
02411        return n;
02412        }
02413 #endif
02414 
02415 
02416 #ifdef YY_USE_PROTOS
02417 static void *yy_flex_alloc( yy_size_t size YY_LAST_ARG )
02418 #else
02419 static void *yy_flex_alloc( size YY_LAST_ARG )
02420 yy_size_t size;
02421 YY_DECL_LAST_ARG
02422 #endif
02423        {
02424        return (void *) malloc( size );
02425        }
02426 
02427 #ifdef YY_USE_PROTOS
02428 static void *yy_flex_realloc( void *ptr, yy_size_t size YY_LAST_ARG )
02429 #else
02430 static void *yy_flex_realloc( ptr, size YY_LAST_ARG )
02431 void *ptr;
02432 yy_size_t size;
02433 YY_DECL_LAST_ARG
02434 #endif
02435        {
02436        /* The cast to (char *) in the following accommodates both
02437         * implementations that use char* generic pointers, and those
02438         * that use void* generic pointers.  It works with the latter
02439         * because both ANSI C and C++ allow castless assignment from
02440         * any pointer type to void*, and deal with argument conversions
02441         * as though doing an assignment.
02442         */
02443        return (void *) realloc( (char *) ptr, size );
02444        }
02445 
02446 #ifdef YY_USE_PROTOS
02447 static void yy_flex_free( void *ptr YY_LAST_ARG )
02448 #else
02449 static void yy_flex_free( ptr YY_LAST_ARG )
02450 void *ptr;
02451 YY_DECL_LAST_ARG
02452 #endif
02453        {
02454        free( (char *) ptr );       /* see yy_flex_realloc() for (char *) cast */
02455        }
02456 
02457 #if YY_MAIN
02458 int main()
02459        {
02460 
02461 #ifdef YY_REENTRANT
02462     yyscan_t lexer;
02463     yylex_init(&lexer);
02464     yylex( lexer );
02465     yylex_destroy( lexer);
02466 
02467 #else
02468        yylex();
02469 #endif
02470 
02471        return 0;
02472        }
02473 #endif
02474 /* %e */
02475 #endif /* !ssIN_HEADER */
02476 #line 111 "icalsslexer.l"
02477 #ifndef ssIN_HEADER
02478 
02479 
02480 int yywrap(yyscan_t yy_globals)
02481 {
02482      return 1;
02483 }
02484 
02485 #endif /* !ssIN_HEADER */