00001
00002
00003
00004
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
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
00028 #define YY_USE_PROTOS
00029
00030
00031 #define YY_USE_CONST
00032
00033 #else
00034
00035 #if __STDC__
00036
00037 #define YY_USE_PROTOS
00038 #define YY_USE_CONST
00039
00040 #endif
00041 #endif
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
00066 #define YY_NULL 0
00067
00068
00069
00070
00071
00072
00073 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00074
00075
00076
00077
00078
00079 #define BEGIN yy_start = 1 + 2 *
00080
00081
00082
00083
00084
00085 #define YY_START ((yy_start - 1) / 2)
00086 #define YYSTATE YY_START
00087
00088
00089 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00090
00091
00092 #define YY_NEW_FILE yyrestart( yyin )
00093
00094 #define YY_END_OF_BUFFER_CHAR 0
00095
00096
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
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124 #define yyless(n) \
00125 do \
00126 { \
00127 \
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; \
00132 } \
00133 while ( 0 )
00134
00135 #define unput(c) yyunput( c, yytext_ptr )
00136
00137
00138
00139
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;
00149 char *yy_buf_pos;
00150
00151
00152
00153
00154 yy_size_t yy_buf_size;
00155
00156
00157
00158
00159 int yy_n_chars;
00160
00161
00162
00163
00164
00165 int yy_is_our_buffer;
00166
00167
00168
00169
00170
00171
00172 int yy_is_interactive;
00173
00174
00175
00176
00177
00178 int yy_at_bol;
00179
00180
00181
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
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198 #define YY_BUFFER_EOF_PENDING 2
00199 };
00200
00201 static YY_BUFFER_STATE yy_current_buffer = 0;
00202
00203
00204
00205
00206
00207 #define YY_CURRENT_BUFFER yy_current_buffer
00208
00209
00210
00211 static char yy_hold_char;
00212
00213 static int yy_n_chars;
00214
00215
00216 int yyleng;
00217
00218
00219 static char *yy_c_buf_p = (char *) 0;
00220 static int yy_init = 1;
00221 static int yy_start = 0;
00222
00223
00224
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
00276
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
00510
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
00547
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
00607
00608
00609
00610 #endif
00611 #endif
00612
00613
00614 #ifndef YY_READ_BUF_SIZE
00615 #define YY_READ_BUF_SIZE 8192
00616 #endif
00617
00618
00619
00620 #ifndef ECHO
00621
00622
00623
00624 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00625 #endif
00626
00627
00628
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
00650
00651
00652
00653 #ifndef yyterminate
00654 #define yyterminate() return YY_NULL
00655 #endif
00656
00657
00658 #ifndef YY_START_STACK_INCR
00659 #define YY_START_STACK_INCR 25
00660 #endif
00661
00662
00663 #ifndef YY_FATAL_ERROR
00664 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00665 #endif
00666
00667
00668
00669
00670 #ifndef YY_DECL
00671 #define YY_DECL int yylex YY_PROTO(( void ))
00672 #endif
00673
00674
00675
00676
00677 #ifndef YY_USER_ACTION
00678 #define YY_USER_ACTION
00679 #endif
00680
00681
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;
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 )
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
00735 *yy_cp = yy_hold_char;
00736
00737
00738
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 {
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:
00776
00777
00778 switch ( yy_act )
00779 {
00780 case 0:
00781
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
01018 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01019
01020
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
01027
01028
01029
01030
01031
01032
01033
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
01041
01042
01043
01044
01045
01046
01047 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01048 {
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
01056
01057
01058
01059
01060
01061
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
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
01092
01093
01094
01095
01096
01097
01098
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 }
01141 }
01142 }
01143
01144
01145
01146
01147
01148
01149
01150
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 {
01166 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01167 {
01168
01169
01170
01171 return EOB_ACT_END_OF_FILE;
01172 }
01173
01174 else
01175 {
01176
01177
01178
01179 return EOB_ACT_LAST_MATCH;
01180 }
01181 }
01182
01183
01184
01185
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
01193
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 {
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
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
01226 yy_flex_realloc( (void *) b->yy_ch_buf,
01227 b->yy_buf_size + 2 );
01228 }
01229 else
01230
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
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
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
01314
01315
01316
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
01360 *yy_cp = yy_hold_char;
01361
01362 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01363 {
01364
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
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
01407
01408
01409
01410 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01411
01412 *yy_c_buf_p = '\0';
01413
01414 else
01415 {
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
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433 yyrestart( yyin );
01434
01435
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;
01459 *yy_c_buf_p = '\0';
01460 yy_hold_char = *++yy_c_buf_p;
01461
01462
01463 return c;
01464 }
01465 #endif
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
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
01504
01505
01506
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
01542
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
01618
01619
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
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;
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
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
01719
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
01798
01799 #undef yyless
01800 #define yyless(n) \
01801 do \
01802 { \
01803 \
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
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
01867
01868
01869
01870
01871
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
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
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
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
01941
01942
01943 if (isscoring){
01944
01945
01946 score_getProbability(verbose);
01947 score_closedb();
01948 }else{
01949 store_storeAll(isporn);
01950 }
01951 }
01952