Main Page | File List

lex.yy.c

00001 /* A lexical scanner generated by flex */
00002 
00003 /* Scanner skeleton version:
00004  * $Header: /sources/pornfind/filterFlex/html/lex_8yy_8c-source.html,v 1.1.1.1 2006/05/09 07:59:50 npeyruss Exp $
00005  */
00006 
00007 #define FLEX_SCANNER
00008 #define YY_FLEX_MAJOR_VERSION 2
00009 #define YY_FLEX_MINOR_VERSION 5
00010 
00011 #include <stdio.h>
00012 #include <unistd.h>
00013 
00014 
00015 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
00016 #ifdef c_plusplus
00017 #ifndef __cplusplus
00018 #define __cplusplus
00019 #endif
00020 #endif
00021 
00022 
00023 #ifdef __cplusplus
00024 
00025 #include <stdlib.h>
00026 
00027 /* Use prototypes in function declarations. */
00028 #define YY_USE_PROTOS
00029 
00030 /* The "const" storage-class-modifier is valid. */
00031 #define YY_USE_CONST
00032 
00033 #else   /* ! __cplusplus */
00034 
00035 #if __STDC__
00036 
00037 #define YY_USE_PROTOS
00038 #define YY_USE_CONST
00039 
00040 #endif  /* __STDC__ */
00041 #endif  /* ! __cplusplus */
00042 
00043 #ifdef __TURBOC__
00044  #pragma warn -rch
00045  #pragma warn -use
00046 #include <io.h>
00047 #include <stdlib.h>
00048 #define YY_USE_CONST
00049 #define YY_USE_PROTOS
00050 #endif
00051 
00052 #ifdef YY_USE_CONST
00053 #define yyconst const
00054 #else
00055 #define yyconst
00056 #endif
00057 
00058 
00059 #ifdef YY_USE_PROTOS
00060 #define YY_PROTO(proto) proto
00061 #else
00062 #define YY_PROTO(proto) ()
00063 #endif
00064 
00065 /* Returned upon end-of-file. */
00066 #define YY_NULL 0
00067 
00068 /* Promotes a possibly negative, possibly signed char to an unsigned
00069  * integer for use as an array index.  If the signed char is negative,
00070  * we want to instead treat it as an 8-bit unsigned char, hence the
00071  * double cast.
00072  */
00073 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00074 
00075 /* Enter a start condition.  This macro really ought to take a parameter,
00076  * but we do it the disgusting crufty way forced on us by the ()-less
00077  * definition of BEGIN.
00078  */
00079 #define BEGIN yy_start = 1 + 2 *
00080 
00081 /* Translate the current start state into a value that can be later handed
00082  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00083  * compatibility.
00084  */
00085 #define YY_START ((yy_start - 1) / 2)
00086 #define YYSTATE YY_START
00087 
00088 /* Action number for EOF rule of a given start state. */
00089 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00090 
00091 /* Special action meaning "start processing a new file". */
00092 #define YY_NEW_FILE yyrestart( yyin )
00093 
00094 #define YY_END_OF_BUFFER_CHAR 0
00095 
00096 /* Size of default input buffer. */
00097 #define YY_BUF_SIZE 16384
00098 
00099 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00100 
00101 extern int yyleng;
00102 extern FILE *yyin, *yyout;
00103 
00104 #define EOB_ACT_CONTINUE_SCAN 0
00105 #define EOB_ACT_END_OF_FILE 1
00106 #define EOB_ACT_LAST_MATCH 2
00107 
00108 /* The funky do-while in the following #define is used to turn the definition
00109  * int a single C statement (which needs a semi-colon terminator).  This
00110  * avoids problems with code like:
00111  *
00112  *      if ( condition_holds )
00113  *              yyless( 5 );
00114  *      else
00115  *              do_something_else();
00116  *
00117  * Prior to using the do-while the compiler would get upset at the
00118  * "else" because it interpreted the "if" statement as being all
00119  * done when it reached the ';' after the yyless() call.
00120  */
00121 
00122 /* Return all but the first 'n' matched characters back to the input stream. */
00123 
00124 #define yyless(n) \
00125         do \
00126                 { \
00127                 /* Undo effects of setting up yytext. */ \
00128                 *yy_cp = yy_hold_char; \
00129                 YY_RESTORE_YY_MORE_OFFSET \
00130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00132                 } \
00133         while ( 0 )
00134 
00135 #define unput(c) yyunput( c, yytext_ptr )
00136 
00137 /* The following is because we cannot portably get our hands on size_t
00138  * (without autoconf's help, which isn't available because we want
00139  * flex-generated scanners to compile on their own).
00140  */
00141 typedef unsigned int yy_size_t;
00142 
00143 
00144 struct yy_buffer_state
00145         {
00146         FILE *yy_input_file;
00147 
00148         char *yy_ch_buf;                /* input buffer */
00149         char *yy_buf_pos;               /* current position in input buffer */
00150 
00151         /* Size of input buffer in bytes, not including room for EOB
00152          * characters.
00153          */
00154         yy_size_t yy_buf_size;
00155 
00156         /* Number of characters read into yy_ch_buf, not including EOB
00157          * characters.
00158          */
00159         int yy_n_chars;
00160 
00161         /* Whether we "own" the buffer - i.e., we know we created it,
00162          * and can realloc() it to grow it, and should free() it to
00163          * delete it.
00164          */
00165         int yy_is_our_buffer;
00166 
00167         /* Whether this is an "interactive" input source; if so, and
00168          * if we're using stdio for input, then we want to use getc()
00169          * instead of fread(), to make sure we stop fetching input after
00170          * each newline.
00171          */
00172         int yy_is_interactive;
00173 
00174         /* Whether we're considered to be at the beginning of a line.
00175          * If so, '^' rules will be active on the next match, otherwise
00176          * not.
00177          */
00178         int yy_at_bol;
00179 
00180         /* Whether to try to fill the input buffer when we reach the
00181          * end of it.
00182          */
00183         int yy_fill_buffer;
00184 
00185         int yy_buffer_status;
00186 #define YY_BUFFER_NEW 0
00187 #define YY_BUFFER_NORMAL 1
00188         /* When an EOF's been seen but there's still some text to process
00189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00190          * shouldn't try reading from the input source any more.  We might
00191          * still have a bunch of tokens to match, though, because of
00192          * possible backing-up.
00193          *
00194          * When we actually see the EOF, we change the status to "new"
00195          * (via yyrestart()), so that the user can continue scanning by
00196          * just pointing yyin at a new input file.
00197          */
00198 #define YY_BUFFER_EOF_PENDING 2
00199         };
00200 
00201 static YY_BUFFER_STATE yy_current_buffer = 0;
00202 
00203 /* We provide macros for accessing buffer states in case in the
00204  * future we want to put the buffer states in a more general
00205  * "scanner state".
00206  */
00207 #define YY_CURRENT_BUFFER yy_current_buffer
00208 
00209 
00210 /* yy_hold_char holds the character lost when yytext is formed. */
00211 static char yy_hold_char;
00212 
00213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
00214 
00215 
00216 int yyleng;
00217 
00218 /* Points to current character in buffer. */
00219 static char *yy_c_buf_p = (char *) 0;
00220 static int yy_init = 1;         /* whether we need to initialize */
00221 static int yy_start = 0;        /* start state number */
00222 
00223 /* Flag which is used to allow yywrap()'s to do buffer switches
00224  * instead of setting up a fresh yyin.  A bit of a hack ...
00225  */
00226 static int yy_did_buffer_switch_on_eof;
00227 
00228 void yyrestart YY_PROTO(( FILE *input_file ));
00229 
00230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
00231 void yy_load_buffer_state YY_PROTO(( void ));
00232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
00233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
00235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
00237 
00238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
00239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
00240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
00241 
00242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
00243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
00244 static void yy_flex_free YY_PROTO(( void * ));
00245 
00246 #define yy_new_buffer yy_create_buffer
00247 
00248 #define yy_set_interactive(is_interactive) \
00249         { \
00250         if ( ! yy_current_buffer ) \
00251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00252         yy_current_buffer->yy_is_interactive = is_interactive; \
00253         }
00254 
00255 #define yy_set_bol(at_bol) \
00256         { \
00257         if ( ! yy_current_buffer ) \
00258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00259         yy_current_buffer->yy_at_bol = at_bol; \
00260         }
00261 
00262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
00263 
00264 typedef unsigned char YY_CHAR;
00265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00266 typedef int yy_state_type;
00267 extern char *yytext;
00268 #define yytext_ptr yytext
00269 
00270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
00271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
00272 static int yy_get_next_buffer YY_PROTO(( void ));
00273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
00274 
00275 /* Done after the current pattern has been matched and before the
00276  * corresponding action - sets up yytext.
00277  */
00278 #define YY_DO_BEFORE_ACTION \
00279         yytext_ptr = yy_bp; \
00280         yytext_ptr -= yy_more_len; \
00281         yyleng = (int) (yy_cp - yytext_ptr); \
00282         yy_hold_char = *yy_cp; \
00283         *yy_cp = '\0'; \
00284         yy_c_buf_p = yy_cp;
00285 
00286 #define YY_NUM_RULES 29
00287 #define YY_END_OF_BUFFER 30
00288 static yyconst short int yy_accept[187] =
00289     {   0,
00290        18,   18,    0,    0,   26,   26,    0,    0,    0,    0,
00291        16,   16,    0,    0,   30,   28,   28,   18,   14,   28,
00292        25,   28,   26,    9,    8,    9,   13,   12,   13,   16,
00293        17,   28,   28,   15,    5,    4,    5,    3,   18,   18,
00294        18,   18,    0,    0,    0,    0,    0,    0,    0,    0,
00295         0,    0,    0,    0,    0,    0,   26,   26,    0,    0,
00296        16,    0,    0,    0,    0,    0,   18,    0,    0,    0,
00297         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00298         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00299         0,    0,   26,    0,   11,    0,   10,    1,    0,    0,
00300 
00301         0,    0,    0,    0,    0,    0,    0,    0,    0,   25,
00302         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00303         0,    0,    0,    0,   27,    0,    0,    0,    0,    0,
00304         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00305         0,    0,    0,    0,    0,    2,    0,    0,    0,    0,
00306         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00307         0,    0,    0,    0,    6,    0,   19,    0,    0,    0,
00308        20,    0,    0,   21,    0,    0,   22,    0,    0,   23,
00309         0,    0,    3,   24,    7,    0
00310     } ;
00311 
00312 static yyconst int yy_ec[256] =
00313     {   0,
00314         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
00315         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00316         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00317         1,    3,    4,    5,    6,    7,    7,    8,    9,    1,
00318         1,    1,   10,    1,   11,   12,   13,   14,   14,   14,
00319        14,   14,   14,   14,   14,   14,   14,    7,   15,   16,
00320         7,   17,    7,    7,   18,   19,   20,   21,   22,   14,
00321        23,   14,   24,   14,   14,   25,   14,   26,   27,   28,
00322        14,   29,   30,   31,   32,   33,   34,   14,   35,   14,
00323         1,    1,    1,    1,    1,    1,   18,   19,   20,   21,
00324 
00325        22,   14,   23,   14,   24,   14,   14,   25,   14,   26,
00326        27,   28,   14,   29,   30,   31,   32,   33,   34,   14,
00327        35,   14,    1,    1,    1,    1,    1,    1,    1,    1,
00328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00335 
00336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00341         1,    1,    1,    1,    1
00342     } ;
00343 
00344 static yyconst int yy_meta[36] =
00345     {   0,
00346         1,    2,    1,    3,    1,    1,    3,    4,    1,    3,
00347         5,    5,    3,    6,    4,    1,    7,    6,    6,    6,
00348         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
00349         6,    6,    6,    6,    6
00350     } ;
00351 
00352 static yyconst short int yy_base[203] =
00353     {   0,
00354         0,    0,  365,  364,   35,    0,   69,   70,   73,   74,
00355        72,   85,   78,   84,  376,  379,    0,   99,   75,  362,
00356       379,  109,  138,  379,  379,  344,  379,  379,  362,   87,
00357       379,  367,  362,  379,  379,  379,  340,  379,  148,  160,
00358       172,    0,  358,    0,   73,    0,  334,   98,  347,   99,
00359       335,  105,  334,  345,  120,  168,  188,  198,  343,  345,
00360       115,  356,  351,  354,  349,  326,    0,  345,  338,  325,
00361       318,   87,  342,  331,  326,  320,  326,  327,  322,  316,
00362       329,  323,  318,  312,  325,  309,  318,  313,  307,  315,
00363       310,  304,    0,  303,  379,  296,  379,  379,  306,  304,
00364 
00365         0,  313,  295,  297,  307,  303,  291,  293,  303,  379,
00366       288,  290,  300,  289,  284,  286,  296,  281,  283,  293,
00367       286,  284,  280,  285,    0,  275,  285,  271,  279,  271,
00368       281,  267,  268,  278,  264,  281,  264,  274,  260,  261,
00369       271,  253,  228,  230,  176,  379,  184,  189,  181,  172,
00370       174,  179,  171,  168,  174,  159,  156,  162,  152,  147,
00371       151,  143,  131,  140,  379,  139,  379,  138,  132,  131,
00372       379,  129,  124,  379,  122,  115,  379,  111,   98,  379,
00373        93,   83,  379,  379,  379,  379,  211,  218,  225,  232,
00374       239,   72,  244,  248,  254,  260,  267,  272,  278,   67,
00375 
00376       282,  284
00377     } ;
00378 
00379 static yyconst short int yy_def[203] =
00380     {   0,
00381       186,    1,  187,  187,  186,    5,  188,  188,  189,  189,
00382       190,  190,  191,  191,  186,  186,  192,  193,  186,  186,
00383       186,  186,  194,  186,  186,  186,  186,  186,  186,  195,
00384       186,  196,  197,  186,  186,  186,  186,  186,  193,  198,
00385       198,   39,  186,  199,  186,  200,  186,  186,  186,  186,
00386       186,  186,  186,  186,  186,  186,  201,  194,  186,  186,
00387       195,  196,  197,  196,  197,  186,   39,  186,  199,  186,
00388       186,  200,  186,  186,  186,  186,  186,  186,  186,  186,
00389       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00390       186,  186,   58,  186,  186,  186,  186,  186,  186,  186,
00391 
00392       202,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00393       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00394       186,  186,  186,  186,  202,  186,  186,  186,  186,  186,
00395       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00396       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00397       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00398       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00399       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00400       186,  186,  186,  186,  186,    0,  186,  186,  186,  186,
00401       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00402 
00403       186,  186
00404     } ;
00405 
00406 static yyconst short int yy_nxt[415] =
00407     {   0,
00408        16,   16,   16,   16,   16,   16,   16,   17,   16,   16,
00409        16,   16,   16,   18,   16,   19,   16,   18,   18,   18,
00410        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
00411        18,   18,   18,   18,   18,   16,   16,   21,   16,   16,
00412        16,   16,   22,   16,   16,   16,   16,   16,   23,   16,
00413        16,   16,   23,   23,   23,   23,   23,   23,   23,   23,
00414        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
00415        25,   25,   72,   31,   28,   28,   32,   39,   43,   36,
00416        33,   26,   26,   29,   29,   36,   31,   44,   34,   32,
00417        37,   62,   70,   33,   38,   63,   37,  101,  101,  185,
00418 
00419        38,   34,   40,   71,   45,   40,   41,  180,   40,   40,
00420        40,   40,  180,   40,   47,   74,   78,   75,   79,   62,
00421        76,   80,   82,   63,   83,  177,   48,   84,   49,  177,
00422        50,   51,   52,   53,   54,   55,  174,   87,  174,   88,
00423        56,   57,   89,  171,   57,  171,  184,   57,   57,   57,
00424        57,   40,  167,  167,   40,   41,  183,   40,   40,   40,
00425        40,  182,   40,   40,  181,  180,   40,   41,  179,   40,
00426        40,   40,   40,  178,   40,   40,  177,  176,   40,   41,
00427       175,   40,   40,   40,   40,   90,   40,   91,  174,  173,
00428        92,   57,  172,  171,   57,  170,  169,   57,   57,   57,
00429 
00430        57,   57,  168,  167,   57,  166,  165,   57,   57,   57,
00431        57,   16,   16,   16,   16,   16,   16,   16,   24,   24,
00432        24,   24,   24,   24,   24,   27,   27,   27,   27,   27,
00433        27,   27,   30,   30,   30,   30,   30,   30,   30,   35,
00434        35,   35,   35,   35,   35,   35,   42,   42,   42,   42,
00435        58,  164,   58,   58,   61,  163,   61,   61,   61,   61,
00436        64,   64,   64,   64,   64,   64,   64,   65,   65,   65,
00437        65,   65,   65,   65,   67,   67,   67,   67,   69,   69,
00438        69,   69,   69,   69,   93,  162,   93,   93,  125,  125,
00439       161,  160,  159,  158,  157,  110,  156,  155,  154,  153,
00440 
00441       152,  151,  150,  149,  148,  147,  146,  145,  144,  143,
00442       142,  141,  140,  139,  138,  137,  136,  135,  134,  133,
00443       132,  131,  130,  129,  128,  127,  126,  110,  124,  123,
00444       122,  121,  120,  119,  118,  117,  116,  115,  114,  110,
00445       113,  112,  111,  110,  109,  108,  107,  106,  105,  104,
00446       103,  102,  100,   99,   98,   97,   96,   61,   61,   61,
00447        61,   95,   94,   86,   85,   81,   77,   73,   68,   66,
00448        61,   61,   60,   59,   46,  186,   20,   20,   15,  186,
00449       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00450       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00451 
00452       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00453       186,  186,  186,  186
00454     } ;
00455 
00456 static yyconst short int yy_chk[415] =
00457     {   0,
00458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00459         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00460         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00461         1,    1,    1,    1,    1,    5,    5,    5,    5,    5,
00462         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00463         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00464         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00465         7,    8,  200,   11,    9,   10,   11,  192,   19,   13,
00466        11,    7,    8,    9,   10,   14,   12,   19,   11,   12,
00467        13,   30,   45,   12,   13,   30,   14,   72,   72,  182,
00468 
00469        14,   12,   18,   45,   19,   18,   18,  181,   18,   18,
00470        18,   18,  179,   18,   22,   48,   50,   48,   50,   61,
00471        48,   50,   52,   61,   52,  178,   22,   52,   22,  176,
00472        22,   22,   22,   22,   22,   22,  175,   55,  173,   55,
00473        22,   23,   55,  172,   23,  170,  169,   23,   23,   23,
00474        23,   39,  168,  166,   39,   39,  164,   39,   39,   39,
00475        39,  163,   39,   40,  162,  161,   40,   40,  160,   40,
00476        40,   40,   40,  159,   40,   41,  158,  157,   41,   41,
00477       156,   41,   41,   41,   41,   56,   41,   56,  155,  154,
00478        56,   57,  153,  152,   57,  151,  150,   57,   57,   57,
00479 
00480        57,   58,  149,  148,   58,  147,  145,   58,   58,   58,
00481        58,  187,  187,  187,  187,  187,  187,  187,  188,  188,
00482       188,  188,  188,  188,  188,  189,  189,  189,  189,  189,
00483       189,  189,  190,  190,  190,  190,  190,  190,  190,  191,
00484       191,  191,  191,  191,  191,  191,  193,  193,  193,  193,
00485       194,  144,  194,  194,  195,  143,  195,  195,  195,  195,
00486       196,  196,  196,  196,  196,  196,  196,  197,  197,  197,
00487       197,  197,  197,  197,  198,  198,  198,  198,  199,  199,
00488       199,  199,  199,  199,  201,  142,  201,  201,  202,  202,
00489       141,  140,  139,  138,  137,  136,  135,  134,  133,  132,
00490 
00491       131,  130,  129,  128,  127,  126,  124,  123,  122,  121,
00492       120,  119,  118,  117,  116,  115,  114,  113,  112,  111,
00493       109,  108,  107,  106,  105,  104,  103,  102,  100,   99,
00494        96,   94,   92,   91,   90,   89,   88,   87,   86,   85,
00495        84,   83,   82,   81,   80,   79,   78,   77,   76,   75,
00496        74,   73,   71,   70,   69,   68,   66,   65,   64,   63,
00497        62,   60,   59,   54,   53,   51,   49,   47,   43,   37,
00498        33,   32,   29,   26,   20,   15,    4,    3,  186,  186,
00499       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00500       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00501 
00502       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
00503       186,  186,  186,  186
00504     } ;
00505 
00506 static yy_state_type yy_last_accepting_state;
00507 static char *yy_last_accepting_cpos;
00508 
00509 /* The intent behind this definition is that it'll catch
00510  * any uses of REJECT which flex missed.
00511  */
00512 #define REJECT reject_used_but_not_detected
00513 static int yy_more_flag = 0;
00514 static int yy_more_len = 0;
00515 #define yymore() (yy_more_flag = 1)
00516 #define YY_MORE_ADJ yy_more_len
00517 #define YY_RESTORE_YY_MORE_OFFSET
00518 char *yytext;
00519 #line 1 "tokenize.l"
00520 #define INITIAL 0
00521 #line 2 "tokenize.l"
00522 #include <stdio.h>
00523 #include <stdlib.h>
00524 #include <string.h>
00525 #include "cut.h"
00526 #include "store.h"
00527 #include "score.h"
00528 
00529 YY_BUFFER_STATE all;
00530 YY_BUFFER_STATE buf_tag;
00531 YY_BUFFER_STATE buf_word;
00532 
00533 char *mot=NULL;
00534 unsigned int porn, scoring;
00535 #define YY_STACK_USED 1
00536 #define DOMAINST 1
00537 #define ACCENT 2
00538 
00539 #define SCRIPT 3
00540 #define COMMENT 4
00541 #define TAG 5
00542 #define STYLE 6
00543 
00544 #line 545 "lex.yy.c"
00545 
00546 /* Macros after this point can all be overridden by user definitions in
00547  * section 1.
00548  */
00549 
00550 #ifndef YY_SKIP_YYWRAP
00551 #ifdef __cplusplus
00552 extern "C" int yywrap YY_PROTO(( void ));
00553 #else
00554 extern int yywrap YY_PROTO(( void ));
00555 #endif
00556 #endif
00557 
00558 #ifndef YY_NO_UNPUT
00559 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
00560 #endif
00561 
00562 #ifndef yytext_ptr
00563 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00564 #endif
00565 
00566 #ifdef YY_NEED_STRLEN
00567 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00568 #endif
00569 
00570 #ifndef YY_NO_INPUT
00571 #ifdef __cplusplus
00572 static int yyinput YY_PROTO(( void ));
00573 #else
00574 static int input YY_PROTO(( void ));
00575 #endif
00576 #endif
00577 
00578 #if YY_STACK_USED
00579 static int yy_start_stack_ptr = 0;
00580 static int yy_start_stack_depth = 0;
00581 static int *yy_start_stack = 0;
00582 #ifndef YY_NO_PUSH_STATE
00583 static void yy_push_state YY_PROTO(( int new_state ));
00584 #endif
00585 #ifndef YY_NO_POP_STATE
00586 static void yy_pop_state YY_PROTO(( void ));
00587 #endif
00588 #ifndef YY_NO_TOP_STATE
00589 static int yy_top_state YY_PROTO(( void ));
00590 #endif
00591 
00592 #else
00593 #define YY_NO_PUSH_STATE 1
00594 #define YY_NO_POP_STATE 1
00595 #define YY_NO_TOP_STATE 1
00596 #endif
00597 
00598 #ifdef YY_MALLOC_DECL
00599 YY_MALLOC_DECL
00600 #else
00601 #if __STDC__
00602 #ifndef __cplusplus
00603 #include <stdlib.h>
00604 #endif
00605 #else
00606 /* Just try to get by without declaring the routines.  This will fail
00607  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00608  * or sizeof(void*) != sizeof(int).
00609  */
00610 #endif
00611 #endif
00612 
00613 /* Amount of stuff to slurp up with each read. */
00614 #ifndef YY_READ_BUF_SIZE
00615 #define YY_READ_BUF_SIZE 8192
00616 #endif
00617 
00618 /* Copy whatever the last rule matched to the standard output. */
00619 
00620 #ifndef ECHO
00621 /* This used to be an fputs(), but since the string might contain NUL's,
00622  * we now use fwrite().
00623  */
00624 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00625 #endif
00626 
00627 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00628  * is returned in "result".
00629  */
00630 #ifndef YY_INPUT
00631 #define YY_INPUT(buf,result,max_size) \
00632         if ( yy_current_buffer->yy_is_interactive ) \
00633                 { \
00634                 int c = '*', n; \
00635                 for ( n = 0; n < max_size && \
00636                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00637                         buf[n] = (char) c; \
00638                 if ( c == '\n' ) \
00639                         buf[n++] = (char) c; \
00640                 if ( c == EOF && ferror( yyin ) ) \
00641                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
00642                 result = n; \
00643                 } \
00644         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
00645                   && ferror( yyin ) ) \
00646                 YY_FATAL_ERROR( "input in flex scanner failed" );
00647 #endif
00648 
00649 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00650  * we don't want an extra ';' after the "return" because that will cause
00651  * some compilers to complain about unreachable statements.
00652  */
00653 #ifndef yyterminate
00654 #define yyterminate() return YY_NULL
00655 #endif
00656 
00657 /* Number of entries by which start-condition stack grows. */
00658 #ifndef YY_START_STACK_INCR
00659 #define YY_START_STACK_INCR 25
00660 #endif
00661 
00662 /* Report a fatal error. */
00663 #ifndef YY_FATAL_ERROR
00664 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00665 #endif
00666 
00667 /* Default declaration of generated scanner - a define so the user can
00668  * easily add parameters.
00669  */
00670 #ifndef YY_DECL
00671 #define YY_DECL int yylex YY_PROTO(( void ))
00672 #endif
00673 
00674 /* Code executed at the beginning of each rule, after yytext and yyleng
00675  * have been set up.
00676  */
00677 #ifndef YY_USER_ACTION
00678 #define YY_USER_ACTION
00679 #endif
00680 
00681 /* Code executed at the end of each rule. */
00682 #ifndef YY_BREAK
00683 #define YY_BREAK break;
00684 #endif
00685 
00686 #define YY_RULE_SETUP \
00687         YY_USER_ACTION
00688 
00689 YY_DECL
00690         {
00691         register yy_state_type yy_current_state;
00692         register char *yy_cp = NULL, *yy_bp = NULL;
00693         register int yy_act;
00694 
00695 #line 25 "tokenize.l"
00696 
00697 
00698 #line 699 "lex.yy.c"
00699 
00700         if ( yy_init )
00701                 {
00702                 yy_init = 0;
00703 
00704 #ifdef YY_USER_INIT
00705                 YY_USER_INIT;
00706 #endif
00707 
00708                 if ( ! yy_start )
00709                         yy_start = 1;   /* first start state */
00710 
00711                 if ( ! yyin )
00712                         yyin = stdin;
00713 
00714                 if ( ! yyout )
00715                         yyout = stdout;
00716 
00717                 if ( ! yy_current_buffer )
00718                         yy_current_buffer =
00719                                 yy_create_buffer( yyin, YY_BUF_SIZE );
00720 
00721                 yy_load_buffer_state();
00722                 }
00723 
00724         while ( 1 )             /* loops until end-of-file is reached */
00725                 {
00726                 yy_more_len = 0;
00727                 if ( yy_more_flag )
00728                         {
00729                         yy_more_len = yy_c_buf_p - yytext_ptr;
00730                         yy_more_flag = 0;
00731                         }
00732                 yy_cp = yy_c_buf_p;
00733 
00734                 /* Support of yytext. */
00735                 *yy_cp = yy_hold_char;
00736 
00737                 /* yy_bp points to the position in yy_ch_buf of the start of
00738                  * the current run.
00739                  */
00740                 yy_bp = yy_cp;
00741 
00742                 yy_current_state = yy_start;
00743 yy_match:
00744                 do
00745                         {
00746                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00747                         if ( yy_accept[yy_current_state] )
00748                                 {
00749                                 yy_last_accepting_state = yy_current_state;
00750                                 yy_last_accepting_cpos = yy_cp;
00751                                 }
00752                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00753                                 {
00754                                 yy_current_state = (int) yy_def[yy_current_state];
00755                                 if ( yy_current_state >= 187 )
00756                                         yy_c = yy_meta[(unsigned int) yy_c];
00757                                 }
00758                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00759                         ++yy_cp;
00760                         }
00761                 while ( yy_base[yy_current_state] != 379 );
00762 
00763 yy_find_action:
00764                 yy_act = yy_accept[yy_current_state];
00765                 if ( yy_act == 0 )
00766                         { /* have to back up */
00767                         yy_cp = yy_last_accepting_cpos;
00768                         yy_current_state = yy_last_accepting_state;
00769                         yy_act = yy_accept[yy_current_state];
00770                         }
00771 
00772                 YY_DO_BEFORE_ACTION;
00773 
00774 
00775 do_action:      /* This label is used only to access EOF actions. */
00776 
00777 
00778                 switch ( yy_act )
00779         { /* beginning of action switch */
00780                         case 0: /* must back up */
00781                         /* undo the effects of YY_DO_BEFORE_ACTION */
00782                         *yy_cp = yy_hold_char;
00783                         yy_cp = yy_last_accepting_cpos;
00784                         yy_current_state = yy_last_accepting_state;
00785                         goto yy_find_action;
00786 
00787 case 1:
00788 YY_RULE_SETUP
00789 #line 27 "tokenize.l"
00790 {}
00791         YY_BREAK
00792 case 2:
00793 YY_RULE_SETUP
00794 #line 29 "tokenize.l"
00795 {yy_push_state(STYLE);}
00796         YY_BREAK
00797 case 3:
00798 YY_RULE_SETUP
00799 #line 30 "tokenize.l"
00800 {yy_pop_state();}
00801         YY_BREAK
00802 case 4:
00803 YY_RULE_SETUP
00804 #line 31 "tokenize.l"
00805 {}
00806         YY_BREAK
00807 case 5:
00808 YY_RULE_SETUP
00809 #line 32 "tokenize.l"
00810 {}
00811         YY_BREAK
00812 case YY_STATE_EOF(STYLE):
00813 #line 33 "tokenize.l"
00814 {} 
00815         YY_BREAK
00816 case 6:
00817 YY_RULE_SETUP
00818 #line 35 "tokenize.l"
00819 {yy_push_state(SCRIPT);}
00820         YY_BREAK
00821 case 7:
00822 YY_RULE_SETUP
00823 #line 36 "tokenize.l"
00824 {yy_pop_state();}
00825         YY_BREAK
00826 case 8:
00827 YY_RULE_SETUP
00828 #line 37 "tokenize.l"
00829 {}
00830         YY_BREAK
00831 case 9:
00832 YY_RULE_SETUP
00833 #line 38 "tokenize.l"
00834 {} 
00835         YY_BREAK
00836 case YY_STATE_EOF(SCRIPT):
00837 #line 39 "tokenize.l"
00838 {yy_pop_state();}
00839         YY_BREAK
00840 case 10:
00841 YY_RULE_SETUP
00842 #line 41 "tokenize.l"
00843 {yy_push_state(COMMENT);}
00844         YY_BREAK
00845 case 11:
00846 YY_RULE_SETUP
00847 #line 42 "tokenize.l"
00848 {yy_pop_state();}
00849         YY_BREAK
00850 case 12:
00851 YY_RULE_SETUP
00852 #line 43 "tokenize.l"
00853 {}
00854         YY_BREAK
00855 case 13:
00856 YY_RULE_SETUP
00857 #line 44 "tokenize.l"
00858 {} 
00859         YY_BREAK
00860 case YY_STATE_EOF(COMMENT):
00861 #line 45 "tokenize.l"
00862 {yy_pop_state();}
00863         YY_BREAK
00864 case 14:
00865 YY_RULE_SETUP
00866 #line 47 "tokenize.l"
00867 {yy_push_state(TAG);yymore();}
00868         YY_BREAK
00869 case 15:
00870 YY_RULE_SETUP
00871 #line 48 "tokenize.l"
00872 {
00873   yy_pop_state();
00874   char *toCut = NULL;
00875   toCut = malloc(sizeof(char)*(strlen(yytext)+1));
00876   strcpy(toCut, yytext);
00877   cut_tags( toCut , porn, scoring);
00878   free(toCut);
00879   toCut = NULL;
00880   BEGIN DOMAINST;
00881   buf_tag = yy_scan_string( yytext );
00882   yy_switch_to_buffer(buf_tag);
00883 }
00884         YY_BREAK
00885 case 16:
00886 YY_RULE_SETUP
00887 #line 60 "tokenize.l"
00888 {
00889   yymore();
00890 }
00891         YY_BREAK
00892 case 17:
00893 YY_RULE_SETUP
00894 #line 63 "tokenize.l"
00895 {yymore();}
00896         YY_BREAK
00897 case 18:
00898 YY_RULE_SETUP
00899 #line 65 "tokenize.l"
00900 {
00901   mot = malloc(sizeof(char));
00902   strcpy(mot,"");
00903   BEGIN ACCENT;
00904   buf_word = yy_scan_string( yytext );
00905   yy_switch_to_buffer(buf_word);
00906 }
00907         YY_BREAK
00908 case 19:
00909 YY_RULE_SETUP
00910 #line 73 "tokenize.l"
00911 {
00912   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00913   strcat(mot, "a");
00914 }
00915         YY_BREAK
00916 case 20:
00917 YY_RULE_SETUP
00918 #line 77 "tokenize.l"
00919 {
00920   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00921   strcat(mot, "e");
00922 }
00923         YY_BREAK
00924 case 21:
00925 YY_RULE_SETUP
00926 #line 81 "tokenize.l"
00927 {
00928   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00929   strcat(mot, "i");
00930 }
00931         YY_BREAK
00932 case 22:
00933 YY_RULE_SETUP
00934 #line 85 "tokenize.l"
00935 {
00936   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00937   strcat(mot, "o");
00938 }
00939         YY_BREAK
00940 case 23:
00941 YY_RULE_SETUP
00942 #line 89 "tokenize.l"
00943 {
00944   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00945   strcat(mot, "u");
00946 }
00947         YY_BREAK
00948 case 24:
00949 YY_RULE_SETUP
00950 #line 93 "tokenize.l"
00951 {
00952   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00953   strcat(mot, "c");
00954 }
00955         YY_BREAK
00956 case 25:
00957 YY_RULE_SETUP
00958 #line 97 "tokenize.l"
00959 {
00960   mot = realloc(mot,sizeof(char)*(strlen(mot)+2));
00961   strcat(mot," ");
00962 }
00963         YY_BREAK
00964 case 26:
00965 YY_RULE_SETUP
00966 #line 101 "tokenize.l"
00967 {
00968   mot = realloc(mot,sizeof(char)*(strlen(mot)+strlen(yytext)+1));
00969   strcat(mot,yytext);
00970 }
00971         YY_BREAK
00972 case YY_STATE_EOF(ACCENT):
00973 #line 106 "tokenize.l"
00974 {
00975   cut_words(mot, porn, scoring);
00976   BEGIN DOMAINST;
00977   yy_delete_buffer(buf_word);  
00978   buf_tag = yy_scan_string( mot );
00979   yy_switch_to_buffer(buf_tag);
00980   free(mot);
00981   mot=NULL;
00982 }
00983         YY_BREAK
00984 case 27:
00985 YY_RULE_SETUP
00986 #line 116 "tokenize.l"
00987 {
00988   if(scoring) score_storeToken(yytext, DOMAINS);
00989   else store_storeTempToken(yytext, DOMAINS);
00990 }
00991         YY_BREAK
00992 case YY_STATE_EOF(DOMAINST):
00993 #line 121 "tokenize.l"
00994 {
00995   BEGIN INITIAL;
00996   yy_delete_buffer(buf_tag);
00997   yy_switch_to_buffer(all);
00998 }
00999         YY_BREAK
01000 case 28:
01001 YY_RULE_SETUP
01002 #line 127 "tokenize.l"
01003 {}
01004         YY_BREAK
01005 case 29:
01006 YY_RULE_SETUP
01007 #line 129 "tokenize.l"
01008 ECHO;
01009         YY_BREAK
01010 #line 1011 "lex.yy.c"
01011 case YY_STATE_EOF(INITIAL):
01012 case YY_STATE_EOF(TAG):
01013         yyterminate();
01014 
01015         case YY_END_OF_BUFFER:
01016                 {
01017                 /* Amount of text matched not including the EOB char. */
01018                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01019 
01020                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01021                 *yy_cp = yy_hold_char;
01022                 YY_RESTORE_YY_MORE_OFFSET
01023 
01024                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
01025                         {
01026                         /* We're scanning a new file or input source.  It's
01027                          * possible that this happened because the user
01028                          * just pointed yyin at a new source and called
01029                          * yylex().  If so, then we have to assure
01030                          * consistency between yy_current_buffer and our
01031                          * globals.  Here is the right place to do so, because
01032                          * this is the first action (other than possibly a
01033                          * back-up) that will match for the new input source.
01034                          */
01035                         yy_n_chars = yy_current_buffer->yy_n_chars;
01036                         yy_current_buffer->yy_input_file = yyin;
01037                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
01038                         }
01039 
01040                 /* Note that here we test for yy_c_buf_p "<=" to the position
01041                  * of the first EOB in the buffer, since yy_c_buf_p will
01042                  * already have been incremented past the NUL character
01043                  * (since all states make transitions on EOB to the
01044                  * end-of-buffer state).  Contrast this with the test
01045                  * in input().
01046                  */
01047                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01048                         { /* This was really a NUL. */
01049                         yy_state_type yy_next_state;
01050 
01051                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
01052 
01053                         yy_current_state = yy_get_previous_state();
01054 
01055                         /* Okay, we're now positioned to make the NUL
01056                          * transition.  We couldn't have
01057                          * yy_get_previous_state() go ahead and do it
01058                          * for us because it doesn't know how to deal
01059                          * with the possibility of jamming (and we don't
01060                          * want to build jamming into it because then it
01061                          * will run more slowly).
01062                          */
01063 
01064                         yy_next_state = yy_try_NUL_trans( yy_current_state );
01065 
01066                         yy_bp = yytext_ptr + YY_MORE_ADJ;
01067 
01068                         if ( yy_next_state )
01069                                 {
01070                                 /* Consume the NUL. */
01071                                 yy_cp = ++yy_c_buf_p;
01072                                 yy_current_state = yy_next_state;
01073                                 goto yy_match;
01074                                 }
01075 
01076                         else
01077                                 {
01078                                 yy_cp = yy_c_buf_p;
01079                                 goto yy_find_action;
01080                                 }
01081                         }
01082 
01083                 else switch ( yy_get_next_buffer() )
01084                         {
01085                         case EOB_ACT_END_OF_FILE:
01086                                 {
01087                                 yy_did_buffer_switch_on_eof = 0;
01088 
01089                                 if ( yywrap() )
01090                                         {
01091                                         /* Note: because we've taken care in
01092                                          * yy_get_next_buffer() to have set up
01093                                          * yytext, we can now set up
01094                                          * yy_c_buf_p so that if some total
01095                                          * hoser (like flex itself) wants to
01096                                          * call the scanner after we return the
01097                                          * YY_NULL, it'll still work - another
01098                                          * YY_NULL will get returned.
01099                                          */
01100                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
01101 
01102                                         yy_act = YY_STATE_EOF(YY_START);
01103                                         goto do_action;
01104                                         }
01105 
01106                                 else
01107                                         {
01108                                         if ( ! yy_did_buffer_switch_on_eof )
01109                                                 YY_NEW_FILE;
01110                                         }
01111                                 break;
01112                                 }
01113 
01114                         case EOB_ACT_CONTINUE_SCAN:
01115                                 yy_c_buf_p =
01116                                         yytext_ptr + yy_amount_of_matched_text;
01117 
01118                                 yy_current_state = yy_get_previous_state();
01119 
01120                                 yy_cp = yy_c_buf_p;
01121                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01122                                 goto yy_match;
01123 
01124                         case EOB_ACT_LAST_MATCH:
01125                                 yy_c_buf_p =
01126                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
01127 
01128                                 yy_current_state = yy_get_previous_state();
01129 
01130                                 yy_cp = yy_c_buf_p;
01131                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01132                                 goto yy_find_action;
01133                         }
01134                 break;
01135                 }
01136 
01137         default:
01138                 YY_FATAL_ERROR(
01139                         "fatal flex scanner internal error--no action found" );
01140         } /* end of action switch */
01141                 } /* end of scanning one token */
01142         } /* end of yylex */
01143 
01144 
01145 /* yy_get_next_buffer - try to read in a new buffer
01146  *
01147  * Returns a code representing an action:
01148  *      EOB_ACT_LAST_MATCH -
01149  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01150  *      EOB_ACT_END_OF_FILE - end of file
01151  */
01152 
01153 static int yy_get_next_buffer()
01154         {
01155         register char *dest = yy_current_buffer->yy_ch_buf;
01156         register char *source = yytext_ptr;
01157         register int number_to_move, i;
01158         int ret_val;
01159 
01160         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01161                 YY_FATAL_ERROR(
01162                 "fatal flex scanner internal error--end of buffer missed" );
01163 
01164         if ( yy_current_buffer->yy_fill_buffer == 0 )
01165                 { /* Don't try to fill the buffer, so this is an EOF. */
01166                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01167                         {
01168                         /* We matched a single character, the EOB, so
01169                          * treat this as a final EOF.
01170                          */
01171                         return EOB_ACT_END_OF_FILE;
01172                         }
01173 
01174                 else
01175                         {
01176                         /* We matched some text prior to the EOB, first
01177                          * process it.
01178                          */
01179                         return EOB_ACT_LAST_MATCH;
01180                         }
01181                 }
01182 
01183         /* Try to read more data. */
01184 
01185         /* First move last chars to start of buffer. */
01186         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01187 
01188         for ( i = 0; i < number_to_move; ++i )
01189                 *(dest++) = *(source++);
01190 
01191         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01192                 /* don't do the read, it's not guaranteed to return an EOF,
01193                  * just force an EOF
01194                  */
01195                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01196 
01197         else
01198                 {
01199                 int num_to_read =
01200                         yy_current_buffer->yy_buf_size - number_to_move - 1;
01201 
01202                 while ( num_to_read <= 0 )
01203                         { /* Not enough room in the buffer - grow it. */
01204 #ifdef YY_USES_REJECT
01205                         YY_FATAL_ERROR(
01206 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01207 #else
01208 
01209                         /* just a shorter name for the current buffer */
01210                         YY_BUFFER_STATE b = yy_current_buffer;
01211 
01212                         int yy_c_buf_p_offset =
01213                                 (int) (yy_c_buf_p - b->yy_ch_buf);
01214 
01215                         if ( b->yy_is_our_buffer )
01216                                 {
01217                                 int new_size = b->yy_buf_size * 2;
01218 
01219                                 if ( new_size <= 0 )
01220                                         b->yy_buf_size += b->yy_buf_size / 8;
01221                                 else
01222                                         b->yy_buf_size *= 2;
01223 
01224                                 b->yy_ch_buf = (char *)
01225                                         /* Include room in for 2 EOB chars. */
01226                                         yy_flex_realloc( (void *) b->yy_ch_buf,
01227                                                          b->yy_buf_size + 2 );
01228                                 }
01229                         else
01230                                 /* Can't grow it, we don't own it. */
01231                                 b->yy_ch_buf = 0;
01232 
01233                         if ( ! b->yy_ch_buf )
01234                                 YY_FATAL_ERROR(
01235                                 "fatal error - scanner input buffer overflow" );
01236 
01237                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01238 
01239                         num_to_read = yy_current_buffer->yy_buf_size -
01240                                                 number_to_move - 1;
01241 #endif
01242                         }
01243 
01244                 if ( num_to_read > YY_READ_BUF_SIZE )
01245                         num_to_read = YY_READ_BUF_SIZE;
01246 
01247                 /* Read in more data. */
01248                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01249                         yy_n_chars, num_to_read );
01250 
01251                 yy_current_buffer->yy_n_chars = yy_n_chars;
01252                 }
01253 
01254         if ( yy_n_chars == 0 )
01255                 {
01256                 if ( number_to_move == YY_MORE_ADJ )
01257                         {
01258                         ret_val = EOB_ACT_END_OF_FILE;
01259                         yyrestart( yyin );
01260                         }
01261 
01262                 else
01263                         {
01264                         ret_val = EOB_ACT_LAST_MATCH;
01265                         yy_current_buffer->yy_buffer_status =
01266                                 YY_BUFFER_EOF_PENDING;
01267                         }
01268                 }
01269 
01270         else
01271                 ret_val = EOB_ACT_CONTINUE_SCAN;
01272 
01273         yy_n_chars += number_to_move;
01274         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01275         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01276 
01277         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01278 
01279         return ret_val;
01280         }
01281 
01282 
01283 /* yy_get_previous_state - get the state just before the EOB char was reached */
01284 
01285 static yy_state_type yy_get_previous_state()
01286         {
01287         register yy_state_type yy_current_state;
01288         register char *yy_cp;
01289 
01290         yy_current_state = yy_start;
01291 
01292         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01293                 {
01294                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01295                 if ( yy_accept[yy_current_state] )
01296                         {
01297                         yy_last_accepting_state = yy_current_state;
01298                         yy_last_accepting_cpos = yy_cp;
01299                         }
01300                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01301                         {
01302                         yy_current_state = (int) yy_def[yy_current_state];
01303                         if ( yy_current_state >= 187 )
01304                                 yy_c = yy_meta[(unsigned int) yy_c];
01305                         }
01306                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01307                 }
01308 
01309         return yy_current_state;
01310         }
01311 
01312 
01313 /* yy_try_NUL_trans - try to make a transition on the NUL character
01314  *
01315  * synopsis
01316  *      next_state = yy_try_NUL_trans( current_state );
01317  */
01318 
01319 #ifdef YY_USE_PROTOS
01320 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
01321 #else
01322 static yy_state_type yy_try_NUL_trans( yy_current_state )
01323 yy_state_type yy_current_state;
01324 #endif
01325         {
01326         register int yy_is_jam;
01327         register char *yy_cp = yy_c_buf_p;
01328 
01329         register YY_CHAR yy_c = 1;
01330         if ( yy_accept[yy_current_state] )
01331                 {
01332                 yy_last_accepting_state = yy_current_state;
01333                 yy_last_accepting_cpos = yy_cp;
01334                 }
01335         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01336                 {
01337                 yy_current_state = (int) yy_def[yy_current_state];
01338                 if ( yy_current_state >= 187 )
01339                         yy_c = yy_meta[(unsigned int) yy_c];
01340                 }
01341         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01342         yy_is_jam = (yy_current_state == 186);
01343 
01344         return yy_is_jam ? 0 : yy_current_state;
01345         }
01346 
01347 
01348 #ifndef YY_NO_UNPUT
01349 #ifdef YY_USE_PROTOS
01350 static void yyunput( int c, register char *yy_bp )
01351 #else
01352 static void yyunput( c, yy_bp )
01353 int c;
01354 register char *yy_bp;
01355 #endif
01356         {
01357         register char *yy_cp = yy_c_buf_p;
01358 
01359         /* undo effects of setting up yytext */
01360         *yy_cp = yy_hold_char;
01361 
01362         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01363                 { /* need to shift things up to make room */
01364                 /* +2 for EOB chars. */
01365                 register int number_to_move = yy_n_chars + 2;
01366                 register char *dest = &yy_current_buffer->yy_ch_buf[
01367                                         yy_current_buffer->yy_buf_size + 2];
01368                 register char *source =
01369                                 &yy_current_buffer->yy_ch_buf[number_to_move];
01370 
01371                 while ( source > yy_current_buffer->yy_ch_buf )
01372                         *--dest = *--source;
01373 
01374                 yy_cp += (int) (dest - source);
01375                 yy_bp += (int) (dest - source);
01376                 yy_current_buffer->yy_n_chars =
01377                         yy_n_chars = yy_current_buffer->yy_buf_size;
01378 
01379                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01380                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
01381                 }
01382 
01383         *--yy_cp = (char) c;
01384 
01385 
01386         yytext_ptr = yy_bp;
01387         yy_hold_char = *yy_cp;
01388         yy_c_buf_p = yy_cp;
01389         }
01390 #endif  /* ifndef YY_NO_UNPUT */
01391 
01392 
01393 #ifndef YY_NO_INPUT
01394 #ifdef __cplusplus
01395 static int yyinput()
01396 #else
01397 static int input()
01398 #endif
01399         {
01400         int c;
01401 
01402         *yy_c_buf_p = yy_hold_char;
01403 
01404         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01405                 {
01406                 /* yy_c_buf_p now points to the character we want to return.
01407                  * If this occurs *before* the EOB characters, then it's a
01408                  * valid NUL; if not, then we've hit the end of the buffer.
01409                  */
01410                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01411                         /* This was really a NUL. */
01412                         *yy_c_buf_p = '\0';
01413 
01414                 else
01415                         { /* need more input */
01416                         int offset = yy_c_buf_p - yytext_ptr;
01417                         ++yy_c_buf_p;
01418 
01419                         switch ( yy_get_next_buffer() )
01420                                 {
01421                                 case EOB_ACT_LAST_MATCH:
01422                                         /* This happens because yy_g_n_b()
01423                                          * sees that we've accumulated a
01424                                          * token and flags that we need to
01425                                          * try matching the token before
01426                                          * proceeding.  But for input(),
01427                                          * there's no matching to consider.
01428                                          * So convert the EOB_ACT_LAST_MATCH
01429                                          * to EOB_ACT_END_OF_FILE.
01430                                          */
01431 
01432                                         /* Reset buffer status. */
01433                                         yyrestart( yyin );
01434 
01435                                         /* fall through */
01436 
01437                                 case EOB_ACT_END_OF_FILE:
01438                                         {
01439                                         if ( yywrap() )
01440                                                 return EOF;
01441 
01442                                         if ( ! yy_did_buffer_switch_on_eof )
01443                                                 YY_NEW_FILE;
01444 #ifdef __cplusplus
01445                                         return yyinput();
01446 #else
01447                                         return input();
01448 #endif
01449                                         }
01450 
01451                                 case EOB_ACT_CONTINUE_SCAN:
01452                                         yy_c_buf_p = yytext_ptr + offset;
01453                                         break;
01454                                 }
01455                         }
01456                 }
01457 
01458         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
01459         *yy_c_buf_p = '\0';     /* preserve yytext */
01460         yy_hold_char = *++yy_c_buf_p;
01461 
01462 
01463         return c;
01464         }
01465 #endif /* YY_NO_INPUT */
01466 
01467 #ifdef YY_USE_PROTOS
01468 void yyrestart( FILE *input_file )
01469 #else
01470 void yyrestart( input_file )
01471 FILE *input_file;
01472 #endif
01473         {
01474         if ( ! yy_current_buffer )
01475                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01476 
01477         yy_init_buffer( yy_current_buffer, input_file );
01478         yy_load_buffer_state();
01479         }
01480 
01481 
01482 #ifdef YY_USE_PROTOS
01483 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01484 #else
01485 void yy_switch_to_buffer( new_buffer )
01486 YY_BUFFER_STATE new_buffer;
01487 #endif
01488         {
01489         if ( yy_current_buffer == new_buffer )
01490                 return;
01491 
01492         if ( yy_current_buffer )
01493                 {
01494                 /* Flush out information for old buffer. */
01495                 *yy_c_buf_p = yy_hold_char;
01496                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01497                 yy_current_buffer->yy_n_chars = yy_n_chars;
01498                 }
01499 
01500         yy_current_buffer = new_buffer;
01501         yy_load_buffer_state();
01502 
01503         /* We don't actually know whether we did this switch during
01504          * EOF (yywrap()) processing, but the only time this flag
01505          * is looked at is after yywrap() is called, so it's safe
01506          * to go ahead and always set it.
01507          */
01508         yy_did_buffer_switch_on_eof = 1;
01509         }
01510 
01511 
01512 #ifdef YY_USE_PROTOS
01513 void yy_load_buffer_state( void )
01514 #else
01515 void yy_load_buffer_state()
01516 #endif
01517         {
01518         yy_n_chars = yy_current_buffer->yy_n_chars;
01519         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01520         yyin = yy_current_buffer->yy_input_file;
01521         yy_hold_char = *yy_c_buf_p;
01522         }
01523 
01524 
01525 #ifdef YY_USE_PROTOS
01526 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
01527 #else
01528 YY_BUFFER_STATE yy_create_buffer( file, size )
01529 FILE *file;
01530 int size;
01531 #endif
01532         {
01533         YY_BUFFER_STATE b;
01534 
01535         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01536         if ( ! b )
01537                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01538 
01539         b->yy_buf_size = size;
01540 
01541         /* yy_ch_buf has to be 2 characters longer than the size given because
01542          * we need to put in 2 end-of-buffer characters.
01543          */
01544         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
01545         if ( ! b->yy_ch_buf )
01546                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01547 
01548         b->yy_is_our_buffer = 1;
01549 
01550         yy_init_buffer( b, file );
01551 
01552         return b;
01553         }
01554 
01555 
01556 #ifdef YY_USE_PROTOS
01557 void yy_delete_buffer( YY_BUFFER_STATE b )
01558 #else
01559 void yy_delete_buffer( b )
01560 YY_BUFFER_STATE b;
01561 #endif
01562         {
01563         if ( ! b )
01564                 return;
01565 
01566         if ( b == yy_current_buffer )
01567                 yy_current_buffer = (YY_BUFFER_STATE) 0;
01568 
01569         if ( b->yy_is_our_buffer )
01570                 yy_flex_free( (void *) b->yy_ch_buf );
01571 
01572         yy_flex_free( (void *) b );
01573         }
01574 
01575 
01576 
01577 #ifdef YY_USE_PROTOS
01578 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
01579 #else
01580 void yy_init_buffer( b, file )
01581 YY_BUFFER_STATE b;
01582 FILE *file;
01583 #endif
01584 
01585 
01586         {
01587         yy_flush_buffer( b );
01588 
01589         b->yy_input_file = file;
01590         b->yy_fill_buffer = 1;
01591 
01592 #if YY_ALWAYS_INTERACTIVE
01593         b->yy_is_interactive = 1;
01594 #else
01595 #if YY_NEVER_INTERACTIVE
01596         b->yy_is_interactive = 0;
01597 #else
01598         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01599 #endif
01600 #endif
01601         }
01602 
01603 
01604 #ifdef YY_USE_PROTOS
01605 void yy_flush_buffer( YY_BUFFER_STATE b )
01606 #else
01607 void yy_flush_buffer( b )
01608 YY_BUFFER_STATE b;
01609 #endif
01610 
01611         {
01612         if ( ! b )
01613                 return;
01614 
01615         b->yy_n_chars = 0;
01616 
01617         /* We always need two end-of-buffer characters.  The first causes
01618          * a transition to the end-of-buffer state.  The second causes
01619          * a jam in that state.
01620          */
01621         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01622         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01623 
01624         b->yy_buf_pos = &b->yy_ch_buf[0];
01625 
01626         b->yy_at_bol = 1;
01627         b->yy_buffer_status = YY_BUFFER_NEW;
01628 
01629         if ( b == yy_current_buffer )
01630                 yy_load_buffer_state();
01631         }
01632 
01633 
01634 #ifndef YY_NO_SCAN_BUFFER
01635 #ifdef YY_USE_PROTOS
01636 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
01637 #else
01638 YY_BUFFER_STATE yy_scan_buffer( base, size )
01639 char *base;
01640 yy_size_t size;
01641 #endif
01642         {
01643         YY_BUFFER_STATE b;
01644 
01645         if ( size < 2 ||
01646              base[size-2] != YY_END_OF_BUFFER_CHAR ||
01647              base[size-1] != YY_END_OF_BUFFER_CHAR )
01648                 /* They forgot to leave room for the EOB's. */
01649                 return 0;
01650 
01651         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01652         if ( ! b )
01653                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01654 
01655         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
01656         b->yy_buf_pos = b->yy_ch_buf = base;
01657         b->yy_is_our_buffer = 0;
01658         b->yy_input_file = 0;
01659         b->yy_n_chars = b->yy_buf_size;
01660         b->yy_is_interactive = 0;
01661         b->yy_at_bol = 1;
01662         b->yy_fill_buffer = 0;
01663         b->yy_buffer_status = YY_BUFFER_NEW;
01664 
01665         yy_switch_to_buffer( b );
01666 
01667         return b;
01668         }
01669 #endif
01670 
01671 
01672 #ifndef YY_NO_SCAN_STRING
01673 #ifdef YY_USE_PROTOS
01674 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
01675 #else
01676 YY_BUFFER_STATE yy_scan_string( yy_str )
01677 yyconst char *yy_str;
01678 #endif
01679         {
01680         int len;
01681         for ( len = 0; yy_str[len]; ++len )
01682                 ;
01683 
01684         return yy_scan_bytes( yy_str, len );
01685         }
01686 #endif
01687 
01688 
01689 #ifndef YY_NO_SCAN_BYTES
01690 #ifdef YY_USE_PROTOS
01691 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
01692 #else
01693 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
01694 yyconst char *bytes;
01695 int len;
01696 #endif
01697         {
01698         YY_BUFFER_STATE b;
01699         char *buf;
01700         yy_size_t n;
01701         int i;
01702 
01703         /* Get memory for full buffer, including space for trailing EOB's. */
01704         n = len + 2;
01705         buf = (char *) yy_flex_alloc( n );
01706         if ( ! buf )
01707                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01708 
01709         for ( i = 0; i < len; ++i )
01710                 buf[i] = bytes[i];
01711 
01712         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
01713 
01714         b = yy_scan_buffer( buf, n );
01715         if ( ! b )
01716                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
01717 
01718         /* It's okay to grow etc. this buffer, and we should throw it
01719          * away when we're done.
01720          */
01721         b->yy_is_our_buffer = 1;
01722 
01723         return b;
01724         }
01725 #endif
01726 
01727 
01728 #ifndef YY_NO_PUSH_STATE
01729 #ifdef YY_USE_PROTOS
01730 static void yy_push_state( int new_state )
01731 #else
01732 static void yy_push_state( new_state )
01733 int new_state;
01734 #endif
01735         {
01736         if ( yy_start_stack_ptr >= yy_start_stack_depth )
01737                 {
01738                 yy_size_t new_size;
01739 
01740                 yy_start_stack_depth += YY_START_STACK_INCR;
01741                 new_size = yy_start_stack_depth * sizeof( int );
01742 
01743                 if ( ! yy_start_stack )
01744                         yy_start_stack = (int *) yy_flex_alloc( new_size );
01745 
01746                 else
01747                         yy_start_stack = (int *) yy_flex_realloc(
01748                                         (void *) yy_start_stack, new_size );
01749 
01750                 if ( ! yy_start_stack )
01751                         YY_FATAL_ERROR(
01752                         "out of memory expanding start-condition stack" );
01753                 }
01754 
01755         yy_start_stack[yy_start_stack_ptr++] = YY_START;
01756 
01757         BEGIN(new_state);
01758         }
01759 #endif
01760 
01761 
01762 #ifndef YY_NO_POP_STATE
01763 static void yy_pop_state()
01764         {
01765         if ( --yy_start_stack_ptr < 0 )
01766                 YY_FATAL_ERROR( "start-condition stack underflow" );
01767 
01768         BEGIN(yy_start_stack[yy_start_stack_ptr]);
01769         }
01770 #endif
01771 
01772 
01773 #ifndef YY_NO_TOP_STATE
01774 static int yy_top_state()
01775         {
01776         return yy_start_stack[yy_start_stack_ptr - 1];
01777         }
01778 #endif
01779 
01780 #ifndef YY_EXIT_FAILURE
01781 #define YY_EXIT_FAILURE 2
01782 #endif
01783 
01784 #ifdef YY_USE_PROTOS
01785 static void yy_fatal_error( yyconst char msg[] )
01786 #else
01787 static void yy_fatal_error( msg )
01788 char msg[];
01789 #endif
01790         {
01791         (void) fprintf( stderr, "%s\n", msg );
01792         exit( YY_EXIT_FAILURE );
01793         }
01794 
01795 
01796 
01797 /* Redefine yyless() so it works in section 3 code. */
01798 
01799 #undef yyless
01800 #define yyless(n) \
01801         do \
01802                 { \
01803                 /* Undo effects of setting up yytext. */ \
01804                 yytext[yyleng] = yy_hold_char; \
01805                 yy_c_buf_p = yytext + n; \
01806                 yy_hold_char = *yy_c_buf_p; \
01807                 *yy_c_buf_p = '\0'; \
01808                 yyleng = n; \
01809                 } \
01810         while ( 0 )
01811 
01812 
01813 /* Internal utility routines. */
01814 
01815 #ifndef yytext_ptr
01816 #ifdef YY_USE_PROTOS
01817 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
01818 #else
01819 static void yy_flex_strncpy( s1, s2, n )
01820 char *s1;
01821 yyconst char *s2;
01822 int n;
01823 #endif
01824         {
01825         register int i;
01826         for ( i = 0; i < n; ++i )
01827                 s1[i] = s2[i];
01828         }
01829 #endif
01830 
01831 #ifdef YY_NEED_STRLEN
01832 #ifdef YY_USE_PROTOS
01833 static int yy_flex_strlen( yyconst char *s )
01834 #else
01835 static int yy_flex_strlen( s )
01836 yyconst char *s;
01837 #endif
01838         {
01839         register int n;
01840         for ( n = 0; s[n]; ++n )
01841                 ;
01842 
01843         return n;
01844         }
01845 #endif
01846 
01847 
01848 #ifdef YY_USE_PROTOS
01849 static void *yy_flex_alloc( yy_size_t size )
01850 #else
01851 static void *yy_flex_alloc( size )
01852 yy_size_t size;
01853 #endif
01854         {
01855         return (void *) malloc( size );
01856         }
01857 
01858 #ifdef YY_USE_PROTOS
01859 static void *yy_flex_realloc( void *ptr, yy_size_t size )
01860 #else
01861 static void *yy_flex_realloc( ptr, size )
01862 void *ptr;
01863 yy_size_t size;
01864 #endif
01865         {
01866         /* The cast to (char *) in the following accommodates both
01867          * implementations that use char* generic pointers, and those
01868          * that use void* generic pointers.  It works with the latter
01869          * because both ANSI C and C++ allow castless assignment from
01870          * any pointer type to void*, and deal with argument conversions
01871          * as though doing an assignment.
01872          */
01873         return (void *) realloc( (char *) ptr, size );
01874         }
01875 
01876 #ifdef YY_USE_PROTOS
01877 static void yy_flex_free( void *ptr )
01878 #else
01879 static void yy_flex_free( ptr )
01880 void *ptr;
01881 #endif
01882         {
01883         free( ptr );
01884         }
01885 
01886 #if YY_MAIN
01887 int main()
01888         {
01889         yylex();
01890         return 0;
01891         }
01892 #endif
01893 #line 129 "tokenize.l"
01894 
01895 void init_parsing(FILE *fp, int isporn, int isscoring, char *dbname, int verbose)
01896 {
01897   //FILE *fp = fopen(file,"r");
01898   char line[5000];
01899   char *all_text = NULL,*temp=NULL;
01900 
01901   unsigned int somme;
01902 
01903   if(!isscoring)
01904   store_storeToken("~~nombre-pages~~", isporn);
01905   else score_initScoring();
01906 
01907   porn = isporn;
01908   scoring = isscoring;
01909 
01910   all_text = malloc(sizeof(char));
01911   temp = malloc(sizeof(char));
01912   strcpy(all_text,"");
01913   strcpy(temp,"");
01914 
01915   //printf("%s\n", file);
01916 
01917    while (feof(fp) == 0){
01918      fgets(line, 5000, fp);
01919      somme = strlen(line)+strlen(temp)+2;
01920      free(all_text);
01921      all_text = malloc(sizeof(char)*(somme));
01922          
01923      strcpy(all_text, temp);
01924      strcat(all_text, line);
01925      
01926      free(temp);
01927      temp = malloc(sizeof(char)*(strlen(all_text)+2));
01928      strcpy(temp, all_text);
01929 
01930    }
01931 
01932    //yyout = fopen("out.txt","w");
01933    all = yy_scan_string(all_text);
01934    yylex();
01935    yy_delete_buffer(all);
01936    cut_free();
01937   
01938    free(all_text); all_text=NULL;
01939    free(temp); temp=NULL;
01940    //fclose(fp);
01941    //fclose(yyout);
01942 
01943    if (isscoring){
01944      //double res = score_getProbability();
01945      //printf("PROBA : %f\n", res);
01946      score_getProbability(verbose);
01947      score_closedb();
01948    }else{
01949      store_storeAll(isporn);
01950    }
01951 }
01952 

Generated on Tue May 31 14:22:44 2005 for filterFlex by  doxygen 1.3.9.1