lexer.c (58964B)
1 /************************************************************************* 2 * This file is part of Crosroads 1.23, a load balancer and fail over 3 * utility for TCP. Copyright (c) Karel Kubat, distributed under GPL. 4 * Visit http://crossroads.e-tunity.com for information. 5 *************************************************************************/ 6 #line 2 "lexer.c" 7 /* A lexical scanner generated by flex */ 8 9 /* Scanner skeleton version: 10 * $Header: /cvs/root/flex/flex/skel.c,v 1.2 2004/05/07 00:28:17 jkh Exp $ 11 */ 12 13 #define FLEX_SCANNER 14 #define YY_FLEX_MAJOR_VERSION 2 15 #define YY_FLEX_MINOR_VERSION 5 16 17 #include <stdio.h> 18 19 20 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 21 #ifdef c_plusplus 22 #ifndef __cplusplus 23 #define __cplusplus 24 #endif 25 #endif 26 27 28 #ifdef __cplusplus 29 30 #include <stdlib.h> 31 #include <unistd.h> 32 33 /* Use prototypes in function declarations. */ 34 #define YY_USE_PROTOS 35 36 /* The "const" storage-class-modifier is valid. */ 37 #define YY_USE_CONST 38 39 #else /* ! __cplusplus */ 40 41 #if __STDC__ 42 43 #define YY_USE_PROTOS 44 #define YY_USE_CONST 45 46 #endif /* __STDC__ */ 47 #endif /* ! __cplusplus */ 48 49 #ifdef __TURBOC__ 50 #pragma warn -rch 51 #pragma warn -use 52 #include <io.h> 53 #include <stdlib.h> 54 #define YY_USE_CONST 55 #define YY_USE_PROTOS 56 #endif 57 58 #ifdef YY_USE_CONST 59 #define yyconst const 60 #else 61 #define yyconst 62 #endif 63 64 65 #ifdef YY_USE_PROTOS 66 #define YY_PROTO(proto) proto 67 #else 68 #define YY_PROTO(proto) () 69 #endif 70 71 /* Returned upon end-of-file. */ 72 #define YY_NULL 0 73 74 /* Promotes a possibly negative, possibly signed char to an unsigned 75 * integer for use as an array index. If the signed char is negative, 76 * we want to instead treat it as an 8-bit unsigned char, hence the 77 * double cast. 78 */ 79 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 80 81 /* Enter a start condition. This macro really ought to take a parameter, 82 * but we do it the disgusting crufty way forced on us by the ()-less 83 * definition of BEGIN. 84 */ 85 #define BEGIN yy_start = 1 + 2 * 86 87 /* Translate the current start state into a value that can be later handed 88 * to BEGIN to return to the state. The YYSTATE alias is for lex 89 * compatibility. 90 */ 91 #define YY_START ((yy_start - 1) / 2) 92 #define YYSTATE YY_START 93 94 /* Action number for EOF rule of a given start state. */ 95 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 96 97 /* Special action meaning "start processing a new file". */ 98 #define YY_NEW_FILE yyrestart( yyin ) 99 100 #define YY_END_OF_BUFFER_CHAR 0 101 102 /* Size of default input buffer. */ 103 #define YY_BUF_SIZE 16384 104 105 typedef struct yy_buffer_state *YY_BUFFER_STATE; 106 107 extern int yyleng; 108 extern FILE *yyin, *yyout; 109 110 #define EOB_ACT_CONTINUE_SCAN 0 111 #define EOB_ACT_END_OF_FILE 1 112 #define EOB_ACT_LAST_MATCH 2 113 114 /* The funky do-while in the following #define is used to turn the definition 115 * int a single C statement (which needs a semi-colon terminator). This 116 * avoids problems with code like: 117 * 118 * if ( condition_holds ) 119 * yyless( 5 ); 120 * else 121 * do_something_else(); 122 * 123 * Prior to using the do-while the compiler would get upset at the 124 * "else" because it interpreted the "if" statement as being all 125 * done when it reached the ';' after the yyless() call. 126 */ 127 128 /* Return all but the first 'n' matched characters back to the input stream. */ 129 130 #define yyless(n) \ 131 do \ 132 { \ 133 /* Undo effects of setting up yytext. */ \ 134 *yy_cp = yy_hold_char; \ 135 YY_RESTORE_YY_MORE_OFFSET \ 136 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 137 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 138 } \ 139 while ( 0 ) 140 141 #define unput(c) yyunput( c, yytext_ptr ) 142 143 /* The following is because we cannot portably get our hands on size_t 144 * (without autoconf's help, which isn't available because we want 145 * flex-generated scanners to compile on their own). 146 */ 147 typedef unsigned int yy_size_t; 148 149 150 struct yy_buffer_state 151 { 152 FILE *yy_input_file; 153 154 char *yy_ch_buf; /* input buffer */ 155 char *yy_buf_pos; /* current position in input buffer */ 156 157 /* Size of input buffer in bytes, not including room for EOB 158 * characters. 159 */ 160 yy_size_t yy_buf_size; 161 162 /* Number of characters read into yy_ch_buf, not including EOB 163 * characters. 164 */ 165 int yy_n_chars; 166 167 /* Whether we "own" the buffer - i.e., we know we created it, 168 * and can realloc() it to grow it, and should free() it to 169 * delete it. 170 */ 171 int yy_is_our_buffer; 172 173 /* Whether this is an "interactive" input source; if so, and 174 * if we're using stdio for input, then we want to use getc() 175 * instead of fread(), to make sure we stop fetching input after 176 * each newline. 177 */ 178 int yy_is_interactive; 179 180 /* Whether we're considered to be at the beginning of a line. 181 * If so, '^' rules will be active on the next match, otherwise 182 * not. 183 */ 184 int yy_at_bol; 185 186 /* Whether to try to fill the input buffer when we reach the 187 * end of it. 188 */ 189 int yy_fill_buffer; 190 191 int yy_buffer_status; 192 #define YY_BUFFER_NEW 0 193 #define YY_BUFFER_NORMAL 1 194 /* When an EOF's been seen but there's still some text to process 195 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 196 * shouldn't try reading from the input source any more. We might 197 * still have a bunch of tokens to match, though, because of 198 * possible backing-up. 199 * 200 * When we actually see the EOF, we change the status to "new" 201 * (via yyrestart()), so that the user can continue scanning by 202 * just pointing yyin at a new input file. 203 */ 204 #define YY_BUFFER_EOF_PENDING 2 205 }; 206 207 static YY_BUFFER_STATE yy_current_buffer = 0; 208 209 /* We provide macros for accessing buffer states in case in the 210 * future we want to put the buffer states in a more general 211 * "scanner state". 212 */ 213 #define YY_CURRENT_BUFFER yy_current_buffer 214 215 216 /* yy_hold_char holds the character lost when yytext is formed. */ 217 static char yy_hold_char; 218 219 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 220 221 222 int yyleng; 223 224 /* Points to current character in buffer. */ 225 static char *yy_c_buf_p = (char *) 0; 226 static int yy_init = 1; /* whether we need to initialize */ 227 static int yy_start = 0; /* start state number */ 228 229 /* Flag which is used to allow yywrap()'s to do buffer switches 230 * instead of setting up a fresh yyin. A bit of a hack ... 231 */ 232 static int yy_did_buffer_switch_on_eof; 233 234 void yyrestart YY_PROTO(( FILE *input_file )); 235 236 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 237 void yy_load_buffer_state YY_PROTO(( void )); 238 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 239 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 240 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 241 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 242 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 243 244 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 245 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 246 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 247 248 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 249 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 250 static void yy_flex_free YY_PROTO(( void * )); 251 252 #define yy_new_buffer yy_create_buffer 253 254 #define yy_set_interactive(is_interactive) \ 255 { \ 256 if ( ! yy_current_buffer ) \ 257 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 258 yy_current_buffer->yy_is_interactive = is_interactive; \ 259 } 260 261 #define yy_set_bol(at_bol) \ 262 { \ 263 if ( ! yy_current_buffer ) \ 264 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 265 yy_current_buffer->yy_at_bol = at_bol; \ 266 } 267 268 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 269 270 typedef unsigned char YY_CHAR; 271 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 272 typedef int yy_state_type; 273 extern char *yytext; 274 #define yytext_ptr yytext 275 276 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 277 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 278 static int yy_get_next_buffer YY_PROTO(( void )); 279 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 280 281 /* Done after the current pattern has been matched and before the 282 * corresponding action - sets up yytext. 283 */ 284 #define YY_DO_BEFORE_ACTION \ 285 yytext_ptr = yy_bp; \ 286 yyleng = (int) (yy_cp - yy_bp); \ 287 yy_hold_char = *yy_cp; \ 288 *yy_cp = '\0'; \ 289 yy_c_buf_p = yy_cp; 290 291 #define YY_NUM_RULES 64 292 #define YY_END_OF_BUFFER 65 293 static yyconst short int yy_accept[404] = 294 { 0, 295 0, 0, 0, 0, 0, 0, 65, 53, 51, 52, 296 53, 53, 50, 49, 49, 49, 49, 49, 49, 49, 297 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 298 49, 49, 62, 63, 61, 62, 62, 60, 57, 56, 299 57, 51, 0, 1, 54, 0, 50, 49, 49, 49, 300 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 301 49, 49, 49, 48, 49, 47, 49, 49, 49, 49, 302 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 303 49, 0, 58, 0, 59, 55, 0, 2, 49, 49, 304 27, 49, 49, 49, 49, 49, 49, 49, 49, 49, 305 306 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 307 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 308 49, 49, 49, 49, 49, 49, 47, 49, 49, 49, 309 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 310 49, 49, 49, 49, 29, 49, 49, 49, 49, 6, 311 5, 49, 49, 49, 49, 49, 49, 49, 49, 49, 312 49, 26, 49, 49, 49, 49, 49, 49, 49, 49, 313 49, 49, 49, 49, 49, 49, 49, 14, 49, 49, 314 49, 49, 49, 35, 49, 49, 49, 49, 49, 49, 315 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 316 317 49, 49, 49, 49, 49, 49, 4, 49, 49, 49, 318 20, 49, 49, 49, 49, 49, 49, 49, 34, 49, 319 18, 49, 49, 15, 49, 49, 49, 7, 49, 49, 320 49, 49, 49, 13, 49, 49, 49, 49, 49, 49, 321 8, 9, 49, 49, 21, 49, 49, 49, 49, 49, 322 49, 49, 33, 49, 49, 3, 49, 49, 49, 49, 323 49, 49, 49, 10, 49, 49, 49, 49, 49, 49, 324 49, 49, 49, 49, 46, 44, 49, 49, 49, 49, 325 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 326 49, 49, 45, 43, 49, 49, 49, 49, 49, 49, 327 328 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 329 49, 49, 49, 49, 49, 49, 49, 19, 49, 49, 330 49, 49, 49, 49, 17, 49, 49, 49, 28, 49, 331 31, 49, 49, 49, 49, 49, 49, 49, 49, 32, 332 49, 49, 49, 49, 49, 49, 49, 24, 49, 49, 333 49, 49, 49, 49, 16, 49, 49, 49, 49, 49, 334 36, 49, 49, 49, 49, 49, 22, 49, 49, 49, 335 49, 49, 49, 30, 49, 49, 49, 49, 49, 49, 336 12, 49, 49, 49, 37, 40, 49, 49, 49, 23, 337 49, 38, 41, 49, 49, 49, 25, 49, 49, 11, 338 339 39, 42, 0 340 } ; 341 342 static yyconst int yy_ec[256] = 343 { 0, 344 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 345 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 347 1, 4, 1, 5, 6, 1, 1, 1, 7, 1, 348 1, 8, 1, 1, 1, 1, 9, 10, 10, 10, 349 10, 10, 10, 10, 10, 10, 10, 1, 11, 1, 350 1, 1, 1, 1, 12, 12, 12, 12, 12, 12, 351 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 352 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 353 1, 1, 1, 1, 12, 1, 13, 14, 15, 16, 354 355 17, 18, 19, 20, 21, 12, 22, 23, 24, 25, 356 26, 27, 12, 28, 29, 30, 31, 32, 33, 34, 357 35, 36, 1, 1, 1, 1, 1, 1, 1, 1, 358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 360 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 361 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 362 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 363 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 364 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 365 366 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 367 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 368 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 369 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 370 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 371 1, 1, 1, 1, 1 372 } ; 373 374 static yyconst int yy_meta[37] = 375 { 0, 376 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 377 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 378 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 379 2, 2, 2, 2, 2, 2 380 } ; 381 382 static yyconst short int yy_base[411] = 383 { 0, 384 0, 0, 34, 39, 44, 45, 432, 433, 47, 433, 385 428, 46, 420, 0, 40, 45, 403, 40, 394, 414, 386 396, 412, 398, 44, 397, 47, 55, 54, 393, 404, 387 403, 402, 433, 433, 433, 413, 410, 433, 433, 433, 388 407, 66, 412, 433, 433, 411, 403, 0, 396, 388, 389 375, 382, 393, 382, 62, 381, 68, 376, 380, 373, 390 379, 371, 366, 0, 381, 69, 381, 369, 371, 363, 391 363, 51, 369, 371, 363, 71, 363, 372, 360, 366, 392 357, 380, 433, 377, 433, 433, 380, 433, 75, 356, 393 0, 364, 358, 363, 352, 346, 348, 354, 349, 360, 394 395 337, 344, 343, 352, 339, 340, 351, 340, 351, 333, 396 334, 331, 344, 338, 333, 325, 77, 334, 340, 328, 397 335, 335, 334, 322, 335, 329, 0, 324, 329, 312, 398 319, 77, 313, 317, 313, 324, 303, 321, 302, 318, 399 322, 304, 305, 315, 0, 305, 314, 308, 315, 0, 400 0, 301, 294, 309, 78, 301, 306, 305, 299, 289, 401 301, 0, 305, 291, 296, 294, 286, 295, 296, 286, 402 284, 283, 283, 294, 289, 288, 289, 0, 75, 273, 403 274, 276, 275, 0, 276, 270, 273, 275, 267, 266, 404 278, 271, 263, 255, 254, 269, 266, 271, 256, 254, 405 406 266, 250, 80, 82, 265, 261, 0, 262, 248, 249, 407 0, 246, 252, 248, 258, 259, 258, 245, 0, 239, 408 0, 243, 241, 0, 249, 248, 232, 0, 90, 243, 409 247, 246, 92, 0, 235, 242, 235, 231, 233, 238, 410 0, 0, 239, 232, 0, 231, 234, 226, 229, 230, 411 224, 229, 0, 226, 230, 0, 218, 225, 215, 210, 412 212, 215, 211, 0, 206, 205, 206, 216, 208, 210, 413 202, 199, 202, 201, 0, 0, 202, 207, 204, 208, 414 201, 200, 190, 191, 192, 187, 185, 189, 183, 178, 415 192, 191, 0, 0, 193, 177, 187, 182, 181, 179, 416 417 183, 190, 172, 176, 175, 179, 178, 175, 169, 165, 418 175, 168, 175, 174, 165, 172, 162, 0, 157, 170, 419 170, 159, 162, 152, 0, 164, 163, 158, 0, 155, 420 0, 147, 163, 162, 144, 145, 147, 150, 153, 0, 421 153, 142, 150, 153, 152, 147, 137, 0, 146, 145, 422 140, 139, 129, 133, 0, 133, 130, 126, 137, 136, 423 0, 132, 133, 132, 131, 130, 0, 129, 128, 115, 424 111, 125, 124, 0, 112, 111, 125, 124, 110, 107, 425 0, 121, 105, 104, 0, 0, 115, 114, 98, 0, 426 105, 0, 0, 110, 109, 82, 0, 79, 31, 0, 427 428 0, 0, 433, 113, 115, 117, 38, 119, 121, 123 429 } ; 430 431 static yyconst short int yy_def[411] = 432 { 0, 433 403, 1, 404, 404, 405, 405, 403, 403, 403, 403, 434 406, 403, 403, 407, 407, 407, 407, 407, 407, 407, 435 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 436 407, 407, 403, 403, 403, 408, 409, 403, 403, 403, 437 403, 403, 406, 403, 403, 410, 403, 407, 407, 407, 438 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 439 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 440 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 441 407, 408, 403, 409, 403, 403, 410, 403, 407, 407, 442 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 443 444 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 445 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 446 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 447 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 448 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 449 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 450 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 451 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 452 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 453 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 454 455 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 456 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 457 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 458 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 459 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 460 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 461 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 462 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 463 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 464 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 465 466 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 467 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 468 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 469 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 470 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 471 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 472 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 473 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 474 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 475 407, 407, 407, 407, 407, 407, 407, 407, 407, 407, 476 477 407, 407, 0, 403, 403, 403, 403, 403, 403, 403 478 } ; 479 480 static yyconst short int yy_nxt[470] = 481 { 0, 482 8, 9, 10, 9, 8, 11, 8, 8, 12, 13, 483 8, 14, 15, 16, 17, 18, 19, 20, 14, 21, 484 14, 14, 14, 22, 23, 24, 25, 26, 27, 28, 485 29, 30, 31, 14, 32, 14, 34, 35, 36, 48, 486 37, 34, 35, 36, 38, 37, 40, 40, 42, 38, 487 42, 41, 41, 45, 46, 49, 57, 53, 402, 69, 488 58, 65, 50, 70, 51, 54, 52, 42, 66, 42, 489 59, 72, 71, 75, 73, 67, 95, 96, 116, 55, 490 117, 76, 100, 121, 74, 108, 109, 97, 77, 128, 491 98, 156, 101, 170, 190, 213, 239, 110, 191, 171, 492 493 237, 122, 214, 129, 259, 157, 401, 238, 264, 260, 494 240, 400, 265, 33, 33, 39, 39, 43, 43, 82, 495 82, 84, 84, 87, 87, 399, 398, 397, 396, 395, 496 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 497 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 498 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, 499 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 500 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 501 344, 343, 342, 341, 340, 339, 338, 337, 336, 335, 502 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 503 504 324, 323, 322, 321, 320, 319, 318, 317, 316, 315, 505 314, 313, 264, 312, 311, 310, 309, 308, 307, 306, 506 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 507 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 508 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 509 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 510 263, 262, 261, 258, 257, 256, 255, 254, 253, 252, 511 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 512 241, 236, 235, 234, 233, 232, 231, 230, 229, 228, 513 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 514 515 217, 216, 215, 212, 211, 210, 209, 208, 207, 206, 516 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 517 195, 194, 193, 192, 189, 188, 187, 186, 185, 184, 518 183, 64, 182, 181, 180, 179, 178, 177, 176, 175, 519 174, 173, 172, 169, 168, 167, 166, 165, 164, 163, 520 162, 127, 161, 160, 159, 158, 155, 154, 153, 152, 521 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 522 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 523 131, 130, 88, 85, 83, 127, 126, 125, 124, 123, 524 120, 119, 118, 115, 114, 113, 112, 111, 64, 107, 525 526 106, 105, 104, 103, 102, 99, 94, 93, 92, 91, 527 90, 89, 47, 88, 44, 86, 85, 83, 81, 80, 528 79, 78, 68, 64, 63, 62, 61, 60, 56, 47, 529 44, 403, 7, 403, 403, 403, 403, 403, 403, 403, 530 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 531 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 532 403, 403, 403, 403, 403, 403, 403, 403, 403 533 } ; 534 535 static yyconst short int yy_chk[470] = 536 { 0, 537 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 538 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 539 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 540 1, 1, 1, 1, 1, 1, 3, 3, 3, 407, 541 3, 4, 4, 4, 3, 4, 5, 6, 9, 4, 542 9, 5, 6, 12, 12, 15, 18, 16, 399, 26, 543 18, 24, 15, 26, 15, 16, 15, 42, 24, 42, 544 18, 27, 26, 28, 27, 24, 55, 55, 72, 16, 545 72, 28, 57, 76, 27, 66, 66, 55, 28, 89, 546 55, 117, 57, 132, 155, 179, 204, 66, 155, 132, 547 548 203, 76, 179, 89, 229, 117, 398, 203, 233, 229, 549 204, 396, 233, 404, 404, 405, 405, 406, 406, 408, 550 408, 409, 409, 410, 410, 395, 394, 391, 389, 388, 551 387, 384, 383, 382, 380, 379, 378, 377, 376, 375, 552 373, 372, 371, 370, 369, 368, 366, 365, 364, 363, 553 362, 360, 359, 358, 357, 356, 354, 353, 352, 351, 554 350, 349, 347, 346, 345, 344, 343, 342, 341, 339, 555 338, 337, 336, 335, 334, 333, 332, 330, 328, 327, 556 326, 324, 323, 322, 321, 320, 319, 317, 316, 315, 557 314, 313, 312, 311, 310, 309, 308, 307, 306, 305, 558 559 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 560 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 561 282, 281, 280, 279, 278, 277, 274, 273, 272, 271, 562 270, 269, 268, 267, 266, 265, 263, 262, 261, 260, 563 259, 258, 257, 255, 254, 252, 251, 250, 249, 248, 564 247, 246, 244, 243, 240, 239, 238, 237, 236, 235, 565 232, 231, 230, 227, 226, 225, 223, 222, 220, 218, 566 217, 216, 215, 214, 213, 212, 210, 209, 208, 206, 567 205, 202, 201, 200, 199, 198, 197, 196, 195, 194, 568 193, 192, 191, 190, 189, 188, 187, 186, 185, 183, 569 570 182, 181, 180, 177, 176, 175, 174, 173, 172, 171, 571 170, 169, 168, 167, 166, 165, 164, 163, 161, 160, 572 159, 158, 157, 156, 154, 153, 152, 149, 148, 147, 573 146, 144, 143, 142, 141, 140, 139, 138, 137, 136, 574 135, 134, 133, 131, 130, 129, 128, 126, 125, 124, 575 123, 122, 121, 120, 119, 118, 116, 115, 114, 113, 576 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 577 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 578 92, 90, 87, 84, 82, 81, 80, 79, 78, 77, 579 75, 74, 73, 71, 70, 69, 68, 67, 65, 63, 580 581 62, 61, 60, 59, 58, 56, 54, 53, 52, 51, 582 50, 49, 47, 46, 43, 41, 37, 36, 32, 31, 583 30, 29, 25, 23, 22, 21, 20, 19, 17, 13, 584 11, 7, 403, 403, 403, 403, 403, 403, 403, 403, 585 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 586 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 587 403, 403, 403, 403, 403, 403, 403, 403, 403 588 } ; 589 590 static yy_state_type yy_last_accepting_state; 591 static char *yy_last_accepting_cpos; 592 593 /* The intent behind this definition is that it'll catch 594 * any uses of REJECT which flex missed. 595 */ 596 #define REJECT reject_used_but_not_detected 597 #define yymore() yymore_used_but_not_detected 598 #define YY_MORE_ADJ 0 599 #define YY_RESTORE_YY_MORE_OFFSET 600 char *yytext; 601 #line 1 "lexer.l" 602 #define INITIAL 0 603 #line 2 "lexer.l" 604 #include "crossroads.h" 605 #include "parser.h" 606 607 /* Required by flex */ 608 static int yywrap () { 609 return (1); 610 } 611 612 /* Lexer debugging related */ 613 // #define LEXER_DEBUG 614 #ifdef LEXER_DEBUG 615 static void lmsg (char const *x) { 616 printf ("L: %s\n", x); 617 } 618 static void llmsg (char const *x, char const *y) { 619 printf ("L: %s %s\n", x, y); 620 } 621 #else 622 # define lmsg(x) 623 # define llmsg(x,y) 624 #endif 625 #define stringstate 1 626 #define commentstate 2 627 628 #line 624 "lexer.c" 629 630 /* Macros after this point can all be overridden by user definitions in 631 * section 1. 632 */ 633 634 #ifndef YY_SKIP_YYWRAP 635 #ifdef __cplusplus 636 extern "C" int yywrap YY_PROTO(( void )); 637 #else 638 extern int yywrap YY_PROTO(( void )); 639 #endif 640 #endif 641 642 #ifndef YY_NO_UNPUT 643 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 644 #endif 645 646 #ifndef yytext_ptr 647 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 648 #endif 649 650 #ifdef YY_NEED_STRLEN 651 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 652 #endif 653 654 #ifndef YY_NO_INPUT 655 #ifdef __cplusplus 656 static int yyinput YY_PROTO(( void )); 657 #else 658 static int input YY_PROTO(( void )); 659 #endif 660 #endif 661 662 #if YY_STACK_USED 663 static int yy_start_stack_ptr = 0; 664 static int yy_start_stack_depth = 0; 665 static int *yy_start_stack = 0; 666 #ifndef YY_NO_PUSH_STATE 667 static void yy_push_state YY_PROTO(( int new_state )); 668 #endif 669 #ifndef YY_NO_POP_STATE 670 static void yy_pop_state YY_PROTO(( void )); 671 #endif 672 #ifndef YY_NO_TOP_STATE 673 static int yy_top_state YY_PROTO(( void )); 674 #endif 675 676 #else 677 #define YY_NO_PUSH_STATE 1 678 #define YY_NO_POP_STATE 1 679 #define YY_NO_TOP_STATE 1 680 #endif 681 682 #ifdef YY_MALLOC_DECL 683 YY_MALLOC_DECL 684 #else 685 #if __STDC__ 686 #ifndef __cplusplus 687 #include <stdlib.h> 688 #endif 689 #else 690 /* Just try to get by without declaring the routines. This will fail 691 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 692 * or sizeof(void*) != sizeof(int). 693 */ 694 #endif 695 #endif 696 697 /* Amount of stuff to slurp up with each read. */ 698 #ifndef YY_READ_BUF_SIZE 699 #define YY_READ_BUF_SIZE 8192 700 #endif 701 702 /* Copy whatever the last rule matched to the standard output. */ 703 704 #ifndef ECHO 705 /* This used to be an fputs(), but since the string might contain NUL's, 706 * we now use fwrite(). 707 */ 708 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 709 #endif 710 711 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 712 * is returned in "result". 713 */ 714 #ifndef YY_INPUT 715 #define YY_INPUT(buf,result,max_size) \ 716 if ( yy_current_buffer->yy_is_interactive ) \ 717 { \ 718 int c = '*', n; \ 719 for ( n = 0; n < max_size && \ 720 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 721 buf[n] = (char) c; \ 722 if ( c == '\n' ) \ 723 buf[n++] = (char) c; \ 724 if ( c == EOF && ferror( yyin ) ) \ 725 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 726 result = n; \ 727 } \ 728 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 729 && ferror( yyin ) ) \ 730 YY_FATAL_ERROR( "input in flex scanner failed" ); 731 #endif 732 733 /* No semi-colon after return; correct usage is to write "yyterminate();" - 734 * we don't want an extra ';' after the "return" because that will cause 735 * some compilers to complain about unreachable statements. 736 */ 737 #ifndef yyterminate 738 #define yyterminate() return YY_NULL 739 #endif 740 741 /* Number of entries by which start-condition stack grows. */ 742 #ifndef YY_START_STACK_INCR 743 #define YY_START_STACK_INCR 25 744 #endif 745 746 /* Report a fatal error. */ 747 #ifndef YY_FATAL_ERROR 748 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 749 #endif 750 751 /* Default declaration of generated scanner - a define so the user can 752 * easily add parameters. 753 */ 754 #ifndef YY_DECL 755 #define YY_DECL int yylex YY_PROTO(( void )) 756 #endif 757 758 /* Code executed at the beginning of each rule, after yytext and yyleng 759 * have been set up. 760 */ 761 #ifndef YY_USER_ACTION 762 #define YY_USER_ACTION 763 #endif 764 765 /* Code executed at the end of each rule. */ 766 #ifndef YY_BREAK 767 #define YY_BREAK break; 768 #endif 769 770 #define YY_RULE_SETUP \ 771 YY_USER_ACTION 772 773 YY_DECL 774 { 775 register yy_state_type yy_current_state; 776 register char *yy_cp, *yy_bp; 777 register int yy_act; 778 779 #line 27 "lexer.l" 780 781 782 #line 778 "lexer.c" 783 784 if ( yy_init ) 785 { 786 yy_init = 0; 787 788 #ifdef YY_USER_INIT 789 YY_USER_INIT; 790 #endif 791 792 if ( ! yy_start ) 793 yy_start = 1; /* first start state */ 794 795 if ( ! yyin ) 796 yyin = stdin; 797 798 if ( ! yyout ) 799 yyout = stdout; 800 801 if ( ! yy_current_buffer ) 802 yy_current_buffer = 803 yy_create_buffer( yyin, YY_BUF_SIZE ); 804 805 yy_load_buffer_state(); 806 } 807 808 while ( 1 ) /* loops until end-of-file is reached */ 809 { 810 yy_cp = yy_c_buf_p; 811 812 /* Support of yytext. */ 813 *yy_cp = yy_hold_char; 814 815 /* yy_bp points to the position in yy_ch_buf of the start of 816 * the current run. 817 */ 818 yy_bp = yy_cp; 819 820 yy_current_state = yy_start; 821 yy_match: 822 do 823 { 824 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 825 if ( yy_accept[yy_current_state] ) 826 { 827 yy_last_accepting_state = yy_current_state; 828 yy_last_accepting_cpos = yy_cp; 829 } 830 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 831 { 832 yy_current_state = (int) yy_def[yy_current_state]; 833 if ( yy_current_state >= 404 ) 834 yy_c = yy_meta[(unsigned int) yy_c]; 835 } 836 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 837 ++yy_cp; 838 } 839 while ( yy_base[yy_current_state] != 433 ); 840 841 yy_find_action: 842 yy_act = yy_accept[yy_current_state]; 843 if ( yy_act == 0 ) 844 { /* have to back up */ 845 yy_cp = yy_last_accepting_cpos; 846 yy_current_state = yy_last_accepting_state; 847 yy_act = yy_accept[yy_current_state]; 848 } 849 850 YY_DO_BEFORE_ACTION; 851 852 853 do_action: /* This label is used only to access EOF actions. */ 854 855 856 switch ( yy_act ) 857 { /* beginning of action switch */ 858 case 0: /* must back up */ 859 /* undo the effects of YY_DO_BEFORE_ACTION */ 860 *yy_cp = yy_hold_char; 861 yy_cp = yy_last_accepting_cpos; 862 yy_current_state = yy_last_accepting_state; 863 goto yy_find_action; 864 865 case 1: 866 YY_RULE_SETUP 867 #line 29 "lexer.l" 868 { 869 lmsg ("comment"); 870 yylineno++; 871 } 872 YY_BREAK 873 case 2: 874 YY_RULE_SETUP 875 #line 34 "lexer.l" 876 { 877 lmsg ("comment"); 878 yylineno++; 879 } 880 YY_BREAK 881 case 3: 882 YY_RULE_SETUP 883 #line 39 "lexer.l" 884 { 885 lmsg ("service"); 886 return (SERVICE); 887 } 888 YY_BREAK 889 case 4: 890 YY_RULE_SETUP 891 #line 44 "lexer.l" 892 { 893 lmsg ("bindto"); 894 BEGIN (stringstate); 895 free (laststring); 896 laststring = 0; 897 return (BINDTO); 898 } 899 YY_BREAK 900 case 5: 901 YY_RULE_SETUP 902 #line 52 "lexer.l" 903 { 904 lmsg ("port"); 905 return (PORT); 906 } 907 YY_BREAK 908 case 6: 909 YY_RULE_SETUP 910 #line 57 "lexer.l" 911 { 912 lmsg ("over"); 913 return (OVER); 914 } 915 YY_BREAK 916 case 7: 917 YY_RULE_SETUP 918 #line 62 "lexer.l" 919 { 920 lmsg ("shmkey"); 921 return (SHMKEY); 922 } 923 YY_BREAK 924 case 8: 925 YY_RULE_SETUP 926 #line 67 "lexer.l" 927 { 928 lmsg ("backend"); 929 return (BACKEND); 930 } 931 YY_BREAK 932 case 9: 933 YY_RULE_SETUP 934 #line 72 "lexer.l" 935 { 936 lmsg ("backlog"); 937 return (BACKLOG); 938 } 939 YY_BREAK 940 case 10: 941 YY_RULE_SETUP 942 #line 77 "lexer.l" 943 { 944 lmsg ("verbosity"); 945 return (VERBOSITY); 946 } 947 YY_BREAK 948 case 11: 949 YY_RULE_SETUP 950 #line 82 "lexer.l" 951 { 952 lmsg ("connectiontimeout"); 953 return (CONNECTIONTIMEOUT); 954 } 955 YY_BREAK 956 case 12: 957 YY_RULE_SETUP 958 #line 87 "lexer.l" 959 { 960 lmsg ("maxconnections"); 961 return (MAXCONNECTIONS); 962 } 963 YY_BREAK 964 case 13: 965 YY_RULE_SETUP 966 #line 92 "lexer.l" 967 { 968 lmsg ("weight"); 969 return (WEIGHT); 970 } 971 YY_BREAK 972 case 14: 973 YY_RULE_SETUP 974 #line 97 "lexer.l" 975 { 976 lmsg ("decay"); 977 return (DECAY); 978 } 979 YY_BREAK 980 case 15: 981 YY_RULE_SETUP 982 #line 102 "lexer.l" 983 { 984 lmsg ("server"); 985 BEGIN (stringstate); 986 free (laststring); 987 laststring = 0; 988 return (SERVER); 989 } 990 YY_BREAK 991 case 16: 992 YY_RULE_SETUP 993 #line 110 "lexer.l" 994 { 995 lmsg ("dispatchmode"); 996 return (DISPATCHMODE); 997 } 998 YY_BREAK 999 case 17: 1000 YY_RULE_SETUP 1001 #line 115 "lexer.l" 1002 { 1003 lmsg ("roundrobin"); 1004 return (ROUNDROBIN); 1005 } 1006 YY_BREAK 1007 case 18: 1008 YY_RULE_SETUP 1009 #line 120 "lexer.l" 1010 { 1011 lmsg ("random"); 1012 return (RANDOM); 1013 } 1014 YY_BREAK 1015 case 19: 1016 YY_RULE_SETUP 1017 #line 125 "lexer.l" 1018 { 1019 lmsg ("byduration"); 1020 return (BYDURATION); 1021 } 1022 YY_BREAK 1023 case 20: 1024 YY_RULE_SETUP 1025 #line 130 "lexer.l" 1026 { 1027 lmsg ("bysize"); 1028 return (BYSIZE); 1029 } 1030 YY_BREAK 1031 case 21: 1032 YY_RULE_SETUP 1033 #line 135 "lexer.l" 1034 { 1035 lmsg ("byorder"); 1036 return (BYORDER); 1037 } 1038 YY_BREAK 1039 case 22: 1040 YY_RULE_SETUP 1041 #line 140 "lexer.l" 1042 { 1043 lmsg ("byconnections"); 1044 return (BYCONNECTIONS); 1045 } 1046 YY_BREAK 1047 case 23: 1048 YY_RULE_SETUP 1049 #line 145 "lexer.l" 1050 { 1051 lmsg ("externalhandler"); 1052 BEGIN (stringstate); 1053 free (laststring); 1054 laststring = 0; 1055 return (EXTERNALHANDLER); 1056 } 1057 YY_BREAK 1058 case 24: 1059 YY_RULE_SETUP 1060 #line 153 "lexer.l" 1061 { 1062 lmsg ("useraccount"); 1063 BEGIN (stringstate); 1064 free (laststring); 1065 laststring = 0; 1066 return (USERACCOUNT); 1067 } 1068 YY_BREAK 1069 case 25: 1070 YY_RULE_SETUP 1071 #line 161 "lexer.l" 1072 { 1073 lmsg ("revivinginterval"); 1074 return (REVIVINGINTERVAL); 1075 } 1076 YY_BREAK 1077 case 26: 1078 YY_RULE_SETUP 1079 #line 166 "lexer.l" 1080 { 1081 lmsg ("type"); 1082 return (TYPE); 1083 } 1084 YY_BREAK 1085 case 27: 1086 YY_RULE_SETUP 1087 #line 171 "lexer.l" 1088 { 1089 lmsg ("any"); 1090 return (ANY); 1091 } 1092 YY_BREAK 1093 case 28: 1094 YY_RULE_SETUP 1095 #line 176 "lexer.l" 1096 { 1097 lmsg ("stickyhttp"); 1098 warning ("The 'stickyhttp protocol is obsolte.\n" 1099 "You should change to 'http'."); 1100 return (HTTP); 1101 } 1102 YY_BREAK 1103 case 29: 1104 YY_RULE_SETUP 1105 #line 183 "lexer.l" 1106 { 1107 lmsg ("http"); 1108 return (HTTP); 1109 } 1110 YY_BREAK 1111 case 30: 1112 YY_RULE_SETUP 1113 #line 188 "lexer.l" 1114 { 1115 lmsg ("throughputlog"); 1116 BEGIN (stringstate); 1117 free (laststring); 1118 laststring = 0; 1119 return (THROUGHPUTLOG); 1120 } 1121 YY_BREAK 1122 case 31: 1123 YY_RULE_SETUP 1124 #line 196 "lexer.l" 1125 { 1126 lmsg ("trafficlog"); 1127 BEGIN (stringstate); 1128 free (laststring); 1129 laststring = 0; 1130 return (TRAFFICLOG); 1131 } 1132 YY_BREAK 1133 case 32: 1134 YY_RULE_SETUP 1135 #line 204 "lexer.l" 1136 { 1137 lmsg ("dumptraffic"); 1138 warning ("The 'dumptraffic' statement is obsolete.\n" 1139 "You should change to 'trafficlog'."); 1140 BEGIN (stringstate); 1141 free (laststring); 1142 laststring = 0; 1143 return (TRAFFICLOG); 1144 } 1145 YY_BREAK 1146 case 33: 1147 YY_RULE_SETUP 1148 #line 214 "lexer.l" 1149 { 1150 lmsg ("onstart"); 1151 BEGIN (stringstate); 1152 free (laststring); 1153 laststring = 0; 1154 return (ONSTART); 1155 } 1156 YY_BREAK 1157 case 34: 1158 YY_RULE_SETUP 1159 #line 222 "lexer.l" 1160 { 1161 lmsg ("onfail"); 1162 BEGIN (stringstate); 1163 free (laststring); 1164 laststring = 0; 1165 return (ONFAIL); 1166 } 1167 YY_BREAK 1168 case 35: 1169 YY_RULE_SETUP 1170 #line 230 "lexer.l" 1171 { 1172 lmsg ("onend"); 1173 BEGIN (stringstate); 1174 free (laststring); 1175 laststring = 0; 1176 return (ONEND); 1177 } 1178 YY_BREAK 1179 case 36: 1180 YY_RULE_SETUP 1181 #line 238 "lexer.l" 1182 { 1183 lmsg ("stickycookie"); 1184 BEGIN (stringstate); 1185 free (laststring); 1186 laststring = 0; 1187 return (STICKYCOOKIE); 1188 } 1189 YY_BREAK 1190 case 37: 1191 YY_RULE_SETUP 1192 #line 246 "lexer.l" 1193 { 1194 lmsg ("addclientheader"); 1195 BEGIN (stringstate); 1196 free (laststring); 1197 laststring = 0; 1198 return (ADDCLIENTHEADER); 1199 } 1200 YY_BREAK 1201 case 38: 1202 YY_RULE_SETUP 1203 #line 254 "lexer.l" 1204 { 1205 lmsg ("setclientheader"); 1206 BEGIN (stringstate); 1207 free (laststring); 1208 laststring = 0; 1209 return (SETCLIENTHEADER); 1210 } 1211 YY_BREAK 1212 case 39: 1213 YY_RULE_SETUP 1214 #line 262 "lexer.l" 1215 { 1216 lmsg ("appendclientheader"); 1217 BEGIN (stringstate); 1218 free (laststring); 1219 laststring = 0; 1220 return (APPENDCLIENTHEADER); 1221 } 1222 YY_BREAK 1223 case 40: 1224 YY_RULE_SETUP 1225 #line 270 "lexer.l" 1226 { 1227 lmsg ("addserverheader"); 1228 BEGIN (stringstate); 1229 free (laststring); 1230 laststring = 0; 1231 return (ADDSERVERHEADER); 1232 } 1233 YY_BREAK 1234 case 41: 1235 YY_RULE_SETUP 1236 #line 278 "lexer.l" 1237 { 1238 lmsg ("setserverheader"); 1239 BEGIN (stringstate); 1240 free (laststring); 1241 laststring = 0; 1242 return (SETSERVERHEADER); 1243 } 1244 YY_BREAK 1245 case 42: 1246 YY_RULE_SETUP 1247 #line 286 "lexer.l" 1248 { 1249 lmsg ("appendserverheader"); 1250 BEGIN (stringstate); 1251 free (laststring); 1252 laststring = 0; 1253 return (APPENDSERVERHEADER); 1254 } 1255 YY_BREAK 1256 case 43: 1257 YY_RULE_SETUP 1258 #line 294 "lexer.l" 1259 { 1260 lmsg ("allowfrom"); 1261 BEGIN (stringstate); 1262 free (laststring); 1263 laststring = 0; 1264 return (ALLOWFROM); 1265 } 1266 YY_BREAK 1267 case 44: 1268 YY_RULE_SETUP 1269 #line 302 "lexer.l" 1270 { 1271 lmsg ("denyfrom"); 1272 BEGIN (stringstate); 1273 free (laststring); 1274 laststring = 0; 1275 return (DENYFROM); 1276 } 1277 YY_BREAK 1278 case 45: 1279 YY_RULE_SETUP 1280 #line 310 "lexer.l" 1281 { 1282 lmsg ("allowfile"); 1283 BEGIN (stringstate); 1284 free (laststring); 1285 laststring = 0; 1286 return (ALLOWFILE); 1287 } 1288 YY_BREAK 1289 case 46: 1290 YY_RULE_SETUP 1291 #line 318 "lexer.l" 1292 { 1293 lmsg ("denyfile"); 1294 BEGIN (stringstate); 1295 free (laststring); 1296 laststring = 0; 1297 return (DENYFILE); 1298 } 1299 YY_BREAK 1300 case 47: 1301 YY_RULE_SETUP 1302 #line 326 "lexer.l" 1303 { 1304 lmsg ("on"); 1305 return (ON); 1306 } 1307 YY_BREAK 1308 case 48: 1309 YY_RULE_SETUP 1310 #line 331 "lexer.l" 1311 { 1312 lmsg ("off"); 1313 return (OFF); 1314 } 1315 YY_BREAK 1316 case 49: 1317 YY_RULE_SETUP 1318 #line 336 "lexer.l" 1319 { 1320 llmsg ("identifier", yytext); 1321 return (IDENTIFIER); 1322 } 1323 YY_BREAK 1324 case 50: 1325 YY_RULE_SETUP 1326 #line 341 "lexer.l" 1327 { 1328 llmsg ("number", yytext); 1329 return (NUMBER); 1330 } 1331 YY_BREAK 1332 case 51: 1333 YY_RULE_SETUP 1334 #line 346 "lexer.l" 1335 { 1336 lmsg ("space(s)"); 1337 } 1338 YY_BREAK 1339 case 52: 1340 YY_RULE_SETUP 1341 #line 350 "lexer.l" 1342 { 1343 lmsg ("newline"); 1344 yylineno++; 1345 } 1346 YY_BREAK 1347 case 53: 1348 YY_RULE_SETUP 1349 #line 355 "lexer.l" 1350 { 1351 llmsg ("lone char", yytext); 1352 return (*yytext); 1353 } 1354 YY_BREAK 1355 case 54: 1356 YY_RULE_SETUP 1357 #line 360 "lexer.l" 1358 { 1359 lmsg ("C-comment starts"); 1360 BEGIN(commentstate); 1361 } 1362 YY_BREAK 1363 case 55: 1364 YY_RULE_SETUP 1365 #line 364 "lexer.l" 1366 { 1367 lmsg ("C-comment ends"); 1368 BEGIN(0); 1369 } 1370 YY_BREAK 1371 case 56: 1372 YY_RULE_SETUP 1373 #line 368 "lexer.l" 1374 { 1375 yylineno++; 1376 } 1377 YY_BREAK 1378 case 57: 1379 YY_RULE_SETUP 1380 #line 371 "lexer.l" 1381 ; 1382 YY_BREAK 1383 case 58: 1384 YY_RULE_SETUP 1385 #line 373 "lexer.l" 1386 { 1387 llmsg ("string part", yytext); 1388 laststring = xstrcat (laststring, yytext + 1); 1389 laststring[strlen(laststring) - 1] = 0; 1390 } 1391 YY_BREAK 1392 case 59: 1393 YY_RULE_SETUP 1394 #line 378 "lexer.l" 1395 { 1396 llmsg ("string part", yytext); 1397 laststring = xstrcat (laststring, yytext + 1); 1398 laststring[strlen(laststring) - 1] = 0; 1399 } 1400 YY_BREAK 1401 case 60: 1402 YY_RULE_SETUP 1403 #line 383 "lexer.l" 1404 { 1405 BEGIN (0); 1406 unput (';'); 1407 llmsg ("string", laststring); 1408 return (STRING); 1409 } 1410 YY_BREAK 1411 case 61: 1412 YY_RULE_SETUP 1413 #line 389 "lexer.l" 1414 { 1415 if (laststring) { 1416 laststring = xstrcat (laststring, yytext); 1417 llmsg ("string part", yytext); 1418 } 1419 } 1420 YY_BREAK 1421 case 62: 1422 YY_RULE_SETUP 1423 #line 395 "lexer.l" 1424 { 1425 llmsg ("string part", yytext); 1426 laststring = xstrcat (laststring, yytext); 1427 } 1428 YY_BREAK 1429 case 63: 1430 YY_RULE_SETUP 1431 #line 399 "lexer.l" 1432 { 1433 if (laststring) { 1434 laststring = xstrcat (laststring, " "); 1435 lmsg ("string part: newline, now space"); 1436 } 1437 yylineno++; 1438 } 1439 YY_BREAK 1440 case 64: 1441 YY_RULE_SETUP 1442 #line 406 "lexer.l" 1443 ECHO; 1444 YY_BREAK 1445 #line 1441 "lexer.c" 1446 case YY_STATE_EOF(INITIAL): 1447 case YY_STATE_EOF(stringstate): 1448 case YY_STATE_EOF(commentstate): 1449 yyterminate(); 1450 1451 case YY_END_OF_BUFFER: 1452 { 1453 /* Amount of text matched not including the EOB char. */ 1454 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1455 1456 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1457 *yy_cp = yy_hold_char; 1458 YY_RESTORE_YY_MORE_OFFSET 1459 1460 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1461 { 1462 /* We're scanning a new file or input source. It's 1463 * possible that this happened because the user 1464 * just pointed yyin at a new source and called 1465 * yylex(). If so, then we have to assure 1466 * consistency between yy_current_buffer and our 1467 * globals. Here is the right place to do so, because 1468 * this is the first action (other than possibly a 1469 * back-up) that will match for the new input source. 1470 */ 1471 yy_n_chars = yy_current_buffer->yy_n_chars; 1472 yy_current_buffer->yy_input_file = yyin; 1473 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1474 } 1475 1476 /* Note that here we test for yy_c_buf_p "<=" to the position 1477 * of the first EOB in the buffer, since yy_c_buf_p will 1478 * already have been incremented past the NUL character 1479 * (since all states make transitions on EOB to the 1480 * end-of-buffer state). Contrast this with the test 1481 * in input(). 1482 */ 1483 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1484 { /* This was really a NUL. */ 1485 yy_state_type yy_next_state; 1486 1487 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1488 1489 yy_current_state = yy_get_previous_state(); 1490 1491 /* Okay, we're now positioned to make the NUL 1492 * transition. We couldn't have 1493 * yy_get_previous_state() go ahead and do it 1494 * for us because it doesn't know how to deal 1495 * with the possibility of jamming (and we don't 1496 * want to build jamming into it because then it 1497 * will run more slowly). 1498 */ 1499 1500 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1501 1502 yy_bp = yytext_ptr + YY_MORE_ADJ; 1503 1504 if ( yy_next_state ) 1505 { 1506 /* Consume the NUL. */ 1507 yy_cp = ++yy_c_buf_p; 1508 yy_current_state = yy_next_state; 1509 goto yy_match; 1510 } 1511 1512 else 1513 { 1514 yy_cp = yy_c_buf_p; 1515 goto yy_find_action; 1516 } 1517 } 1518 1519 else switch ( yy_get_next_buffer() ) 1520 { 1521 case EOB_ACT_END_OF_FILE: 1522 { 1523 yy_did_buffer_switch_on_eof = 0; 1524 1525 if ( yywrap() ) 1526 { 1527 /* Note: because we've taken care in 1528 * yy_get_next_buffer() to have set up 1529 * yytext, we can now set up 1530 * yy_c_buf_p so that if some total 1531 * hoser (like flex itself) wants to 1532 * call the scanner after we return the 1533 * YY_NULL, it'll still work - another 1534 * YY_NULL will get returned. 1535 */ 1536 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1537 1538 yy_act = YY_STATE_EOF(YY_START); 1539 goto do_action; 1540 } 1541 1542 else 1543 { 1544 if ( ! yy_did_buffer_switch_on_eof ) 1545 YY_NEW_FILE; 1546 } 1547 break; 1548 } 1549 1550 case EOB_ACT_CONTINUE_SCAN: 1551 yy_c_buf_p = 1552 yytext_ptr + yy_amount_of_matched_text; 1553 1554 yy_current_state = yy_get_previous_state(); 1555 1556 yy_cp = yy_c_buf_p; 1557 yy_bp = yytext_ptr + YY_MORE_ADJ; 1558 goto yy_match; 1559 1560 case EOB_ACT_LAST_MATCH: 1561 yy_c_buf_p = 1562 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1563 1564 yy_current_state = yy_get_previous_state(); 1565 1566 yy_cp = yy_c_buf_p; 1567 yy_bp = yytext_ptr + YY_MORE_ADJ; 1568 goto yy_find_action; 1569 } 1570 break; 1571 } 1572 1573 default: 1574 YY_FATAL_ERROR( 1575 "fatal flex scanner internal error--no action found" ); 1576 } /* end of action switch */ 1577 } /* end of scanning one token */ 1578 } /* end of yylex */ 1579 1580 1581 /* yy_get_next_buffer - try to read in a new buffer 1582 * 1583 * Returns a code representing an action: 1584 * EOB_ACT_LAST_MATCH - 1585 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1586 * EOB_ACT_END_OF_FILE - end of file 1587 */ 1588 1589 static int yy_get_next_buffer() 1590 { 1591 register char *dest = yy_current_buffer->yy_ch_buf; 1592 register char *source = yytext_ptr; 1593 register int number_to_move, i; 1594 int ret_val; 1595 1596 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1597 YY_FATAL_ERROR( 1598 "fatal flex scanner internal error--end of buffer missed" ); 1599 1600 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1601 { /* Don't try to fill the buffer, so this is an EOF. */ 1602 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1603 { 1604 /* We matched a single character, the EOB, so 1605 * treat this as a final EOF. 1606 */ 1607 return EOB_ACT_END_OF_FILE; 1608 } 1609 1610 else 1611 { 1612 /* We matched some text prior to the EOB, first 1613 * process it. 1614 */ 1615 return EOB_ACT_LAST_MATCH; 1616 } 1617 } 1618 1619 /* Try to read more data. */ 1620 1621 /* First move last chars to start of buffer. */ 1622 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1623 1624 for ( i = 0; i < number_to_move; ++i ) 1625 *(dest++) = *(source++); 1626 1627 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1628 /* don't do the read, it's not guaranteed to return an EOF, 1629 * just force an EOF 1630 */ 1631 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1632 1633 else 1634 { 1635 int num_to_read = 1636 yy_current_buffer->yy_buf_size - number_to_move - 1; 1637 1638 while ( num_to_read <= 0 ) 1639 { /* Not enough room in the buffer - grow it. */ 1640 #ifdef YY_USES_REJECT 1641 YY_FATAL_ERROR( 1642 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1643 #else 1644 1645 /* just a shorter name for the current buffer */ 1646 YY_BUFFER_STATE b = yy_current_buffer; 1647 1648 int yy_c_buf_p_offset = 1649 (int) (yy_c_buf_p - b->yy_ch_buf); 1650 1651 if ( b->yy_is_our_buffer ) 1652 { 1653 int new_size = b->yy_buf_size * 2; 1654 1655 if ( new_size <= 0 ) 1656 b->yy_buf_size += b->yy_buf_size / 8; 1657 else 1658 b->yy_buf_size *= 2; 1659 1660 b->yy_ch_buf = (char *) 1661 /* Include room in for 2 EOB chars. */ 1662 yy_flex_realloc( (void *) b->yy_ch_buf, 1663 b->yy_buf_size + 2 ); 1664 } 1665 else 1666 /* Can't grow it, we don't own it. */ 1667 b->yy_ch_buf = 0; 1668 1669 if ( ! b->yy_ch_buf ) 1670 YY_FATAL_ERROR( 1671 "fatal error - scanner input buffer overflow" ); 1672 1673 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1674 1675 num_to_read = yy_current_buffer->yy_buf_size - 1676 number_to_move - 1; 1677 #endif 1678 } 1679 1680 if ( num_to_read > YY_READ_BUF_SIZE ) 1681 num_to_read = YY_READ_BUF_SIZE; 1682 1683 /* Read in more data. */ 1684 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1685 yy_n_chars, num_to_read ); 1686 1687 yy_current_buffer->yy_n_chars = yy_n_chars; 1688 } 1689 1690 if ( yy_n_chars == 0 ) 1691 { 1692 if ( number_to_move == YY_MORE_ADJ ) 1693 { 1694 ret_val = EOB_ACT_END_OF_FILE; 1695 yyrestart( yyin ); 1696 } 1697 1698 else 1699 { 1700 ret_val = EOB_ACT_LAST_MATCH; 1701 yy_current_buffer->yy_buffer_status = 1702 YY_BUFFER_EOF_PENDING; 1703 } 1704 } 1705 1706 else 1707 ret_val = EOB_ACT_CONTINUE_SCAN; 1708 1709 yy_n_chars += number_to_move; 1710 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1711 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1712 1713 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1714 1715 return ret_val; 1716 } 1717 1718 1719 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1720 1721 static yy_state_type yy_get_previous_state() 1722 { 1723 register yy_state_type yy_current_state; 1724 register char *yy_cp; 1725 1726 yy_current_state = yy_start; 1727 1728 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1729 { 1730 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1731 if ( yy_accept[yy_current_state] ) 1732 { 1733 yy_last_accepting_state = yy_current_state; 1734 yy_last_accepting_cpos = yy_cp; 1735 } 1736 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1737 { 1738 yy_current_state = (int) yy_def[yy_current_state]; 1739 if ( yy_current_state >= 404 ) 1740 yy_c = yy_meta[(unsigned int) yy_c]; 1741 } 1742 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1743 } 1744 1745 return yy_current_state; 1746 } 1747 1748 1749 /* yy_try_NUL_trans - try to make a transition on the NUL character 1750 * 1751 * synopsis 1752 * next_state = yy_try_NUL_trans( current_state ); 1753 */ 1754 1755 #ifdef YY_USE_PROTOS 1756 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1757 #else 1758 static yy_state_type yy_try_NUL_trans( yy_current_state ) 1759 yy_state_type yy_current_state; 1760 #endif 1761 { 1762 register int yy_is_jam; 1763 register char *yy_cp = yy_c_buf_p; 1764 1765 register YY_CHAR yy_c = 1; 1766 if ( yy_accept[yy_current_state] ) 1767 { 1768 yy_last_accepting_state = yy_current_state; 1769 yy_last_accepting_cpos = yy_cp; 1770 } 1771 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1772 { 1773 yy_current_state = (int) yy_def[yy_current_state]; 1774 if ( yy_current_state >= 404 ) 1775 yy_c = yy_meta[(unsigned int) yy_c]; 1776 } 1777 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1778 yy_is_jam = (yy_current_state == 403); 1779 1780 return yy_is_jam ? 0 : yy_current_state; 1781 } 1782 1783 1784 #ifndef YY_NO_UNPUT 1785 #ifdef YY_USE_PROTOS 1786 static void yyunput( int c, register char *yy_bp ) 1787 #else 1788 static void yyunput( c, yy_bp ) 1789 int c; 1790 register char *yy_bp; 1791 #endif 1792 { 1793 register char *yy_cp = yy_c_buf_p; 1794 1795 /* undo effects of setting up yytext */ 1796 *yy_cp = yy_hold_char; 1797 1798 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1799 { /* need to shift things up to make room */ 1800 /* +2 for EOB chars. */ 1801 register int number_to_move = yy_n_chars + 2; 1802 register char *dest = &yy_current_buffer->yy_ch_buf[ 1803 yy_current_buffer->yy_buf_size + 2]; 1804 register char *source = 1805 &yy_current_buffer->yy_ch_buf[number_to_move]; 1806 1807 while ( source > yy_current_buffer->yy_ch_buf ) 1808 *--dest = *--source; 1809 1810 yy_cp += (int) (dest - source); 1811 yy_bp += (int) (dest - source); 1812 yy_current_buffer->yy_n_chars = 1813 yy_n_chars = yy_current_buffer->yy_buf_size; 1814 1815 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1816 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1817 } 1818 1819 *--yy_cp = (char) c; 1820 1821 1822 yytext_ptr = yy_bp; 1823 yy_hold_char = *yy_cp; 1824 yy_c_buf_p = yy_cp; 1825 } 1826 #endif /* ifndef YY_NO_UNPUT */ 1827 1828 1829 #ifdef __cplusplus 1830 static int yyinput() 1831 #else 1832 static int input() 1833 #endif 1834 { 1835 int c; 1836 1837 *yy_c_buf_p = yy_hold_char; 1838 1839 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1840 { 1841 /* yy_c_buf_p now points to the character we want to return. 1842 * If this occurs *before* the EOB characters, then it's a 1843 * valid NUL; if not, then we've hit the end of the buffer. 1844 */ 1845 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1846 /* This was really a NUL. */ 1847 *yy_c_buf_p = '\0'; 1848 1849 else 1850 { /* need more input */ 1851 int offset = yy_c_buf_p - yytext_ptr; 1852 ++yy_c_buf_p; 1853 1854 switch ( yy_get_next_buffer() ) 1855 { 1856 case EOB_ACT_LAST_MATCH: 1857 /* This happens because yy_g_n_b() 1858 * sees that we've accumulated a 1859 * token and flags that we need to 1860 * try matching the token before 1861 * proceeding. But for input(), 1862 * there's no matching to consider. 1863 * So convert the EOB_ACT_LAST_MATCH 1864 * to EOB_ACT_END_OF_FILE. 1865 */ 1866 1867 /* Reset buffer status. */ 1868 yyrestart( yyin ); 1869 1870 /* fall through */ 1871 1872 case EOB_ACT_END_OF_FILE: 1873 { 1874 if ( yywrap() ) 1875 return EOF; 1876 1877 if ( ! yy_did_buffer_switch_on_eof ) 1878 YY_NEW_FILE; 1879 #ifdef __cplusplus 1880 return yyinput(); 1881 #else 1882 return input(); 1883 #endif 1884 } 1885 1886 case EOB_ACT_CONTINUE_SCAN: 1887 yy_c_buf_p = yytext_ptr + offset; 1888 break; 1889 } 1890 } 1891 } 1892 1893 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1894 *yy_c_buf_p = '\0'; /* preserve yytext */ 1895 yy_hold_char = *++yy_c_buf_p; 1896 1897 1898 return c; 1899 } 1900 1901 1902 #ifdef YY_USE_PROTOS 1903 void yyrestart( FILE *input_file ) 1904 #else 1905 void yyrestart( input_file ) 1906 FILE *input_file; 1907 #endif 1908 { 1909 if ( ! yy_current_buffer ) 1910 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1911 1912 yy_init_buffer( yy_current_buffer, input_file ); 1913 yy_load_buffer_state(); 1914 } 1915 1916 1917 #ifdef YY_USE_PROTOS 1918 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1919 #else 1920 void yy_switch_to_buffer( new_buffer ) 1921 YY_BUFFER_STATE new_buffer; 1922 #endif 1923 { 1924 if ( yy_current_buffer == new_buffer ) 1925 return; 1926 1927 if ( yy_current_buffer ) 1928 { 1929 /* Flush out information for old buffer. */ 1930 *yy_c_buf_p = yy_hold_char; 1931 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1932 yy_current_buffer->yy_n_chars = yy_n_chars; 1933 } 1934 1935 yy_current_buffer = new_buffer; 1936 yy_load_buffer_state(); 1937 1938 /* We don't actually know whether we did this switch during 1939 * EOF (yywrap()) processing, but the only time this flag 1940 * is looked at is after yywrap() is called, so it's safe 1941 * to go ahead and always set it. 1942 */ 1943 yy_did_buffer_switch_on_eof = 1; 1944 } 1945 1946 1947 #ifdef YY_USE_PROTOS 1948 void yy_load_buffer_state( void ) 1949 #else 1950 void yy_load_buffer_state() 1951 #endif 1952 { 1953 yy_n_chars = yy_current_buffer->yy_n_chars; 1954 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1955 yyin = yy_current_buffer->yy_input_file; 1956 yy_hold_char = *yy_c_buf_p; 1957 } 1958 1959 1960 #ifdef YY_USE_PROTOS 1961 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1962 #else 1963 YY_BUFFER_STATE yy_create_buffer( file, size ) 1964 FILE *file; 1965 int size; 1966 #endif 1967 { 1968 YY_BUFFER_STATE b; 1969 1970 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1971 if ( ! b ) 1972 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1973 1974 b->yy_buf_size = size; 1975 1976 /* yy_ch_buf has to be 2 characters longer than the size given because 1977 * we need to put in 2 end-of-buffer characters. 1978 */ 1979 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1980 if ( ! b->yy_ch_buf ) 1981 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1982 1983 b->yy_is_our_buffer = 1; 1984 1985 yy_init_buffer( b, file ); 1986 1987 return b; 1988 } 1989 1990 1991 #ifdef YY_USE_PROTOS 1992 void yy_delete_buffer( YY_BUFFER_STATE b ) 1993 #else 1994 void yy_delete_buffer( b ) 1995 YY_BUFFER_STATE b; 1996 #endif 1997 { 1998 if ( ! b ) 1999 return; 2000 2001 if ( b == yy_current_buffer ) 2002 yy_current_buffer = (YY_BUFFER_STATE) 0; 2003 2004 if ( b->yy_is_our_buffer ) 2005 yy_flex_free( (void *) b->yy_ch_buf ); 2006 2007 yy_flex_free( (void *) b ); 2008 } 2009 2010 2011 #ifndef YY_ALWAYS_INTERACTIVE 2012 #ifndef YY_NEVER_INTERACTIVE 2013 extern int isatty YY_PROTO(( int )); 2014 #endif 2015 #endif 2016 2017 #ifdef YY_USE_PROTOS 2018 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 2019 #else 2020 void yy_init_buffer( b, file ) 2021 YY_BUFFER_STATE b; 2022 FILE *file; 2023 #endif 2024 2025 2026 { 2027 yy_flush_buffer( b ); 2028 2029 b->yy_input_file = file; 2030 b->yy_fill_buffer = 1; 2031 2032 #if YY_ALWAYS_INTERACTIVE 2033 b->yy_is_interactive = 1; 2034 #else 2035 #if YY_NEVER_INTERACTIVE 2036 b->yy_is_interactive = 0; 2037 #else 2038 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 2039 #endif 2040 #endif 2041 } 2042 2043 2044 #ifdef YY_USE_PROTOS 2045 void yy_flush_buffer( YY_BUFFER_STATE b ) 2046 #else 2047 void yy_flush_buffer( b ) 2048 YY_BUFFER_STATE b; 2049 #endif 2050 2051 { 2052 if ( ! b ) 2053 return; 2054 2055 b->yy_n_chars = 0; 2056 2057 /* We always need two end-of-buffer characters. The first causes 2058 * a transition to the end-of-buffer state. The second causes 2059 * a jam in that state. 2060 */ 2061 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 2062 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 2063 2064 b->yy_buf_pos = &b->yy_ch_buf[0]; 2065 2066 b->yy_at_bol = 1; 2067 b->yy_buffer_status = YY_BUFFER_NEW; 2068 2069 if ( b == yy_current_buffer ) 2070 yy_load_buffer_state(); 2071 } 2072 2073 2074 #ifndef YY_NO_SCAN_BUFFER 2075 #ifdef YY_USE_PROTOS 2076 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 2077 #else 2078 YY_BUFFER_STATE yy_scan_buffer( base, size ) 2079 char *base; 2080 yy_size_t size; 2081 #endif 2082 { 2083 YY_BUFFER_STATE b; 2084 2085 if ( size < 2 || 2086 base[size-2] != YY_END_OF_BUFFER_CHAR || 2087 base[size-1] != YY_END_OF_BUFFER_CHAR ) 2088 /* They forgot to leave room for the EOB's. */ 2089 return 0; 2090 2091 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 2092 if ( ! b ) 2093 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 2094 2095 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 2096 b->yy_buf_pos = b->yy_ch_buf = base; 2097 b->yy_is_our_buffer = 0; 2098 b->yy_input_file = 0; 2099 b->yy_n_chars = b->yy_buf_size; 2100 b->yy_is_interactive = 0; 2101 b->yy_at_bol = 1; 2102 b->yy_fill_buffer = 0; 2103 b->yy_buffer_status = YY_BUFFER_NEW; 2104 2105 yy_switch_to_buffer( b ); 2106 2107 return b; 2108 } 2109 #endif 2110 2111 2112 #ifndef YY_NO_SCAN_STRING 2113 #ifdef YY_USE_PROTOS 2114 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 2115 #else 2116 YY_BUFFER_STATE yy_scan_string( yy_str ) 2117 yyconst char *yy_str; 2118 #endif 2119 { 2120 int len; 2121 for ( len = 0; yy_str[len]; ++len ) 2122 ; 2123 2124 return yy_scan_bytes( yy_str, len ); 2125 } 2126 #endif 2127 2128 2129 #ifndef YY_NO_SCAN_BYTES 2130 #ifdef YY_USE_PROTOS 2131 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 2132 #else 2133 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 2134 yyconst char *bytes; 2135 int len; 2136 #endif 2137 { 2138 YY_BUFFER_STATE b; 2139 char *buf; 2140 yy_size_t n; 2141 int i; 2142 2143 /* Get memory for full buffer, including space for trailing EOB's. */ 2144 n = len + 2; 2145 buf = (char *) yy_flex_alloc( n ); 2146 if ( ! buf ) 2147 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2148 2149 for ( i = 0; i < len; ++i ) 2150 buf[i] = bytes[i]; 2151 2152 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 2153 2154 b = yy_scan_buffer( buf, n ); 2155 if ( ! b ) 2156 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2157 2158 /* It's okay to grow etc. this buffer, and we should throw it 2159 * away when we're done. 2160 */ 2161 b->yy_is_our_buffer = 1; 2162 2163 return b; 2164 } 2165 #endif 2166 2167 2168 #ifndef YY_NO_PUSH_STATE 2169 #ifdef YY_USE_PROTOS 2170 static void yy_push_state( int new_state ) 2171 #else 2172 static void yy_push_state( new_state ) 2173 int new_state; 2174 #endif 2175 { 2176 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 2177 { 2178 yy_size_t new_size; 2179 2180 yy_start_stack_depth += YY_START_STACK_INCR; 2181 new_size = yy_start_stack_depth * sizeof( int ); 2182 2183 if ( ! yy_start_stack ) 2184 yy_start_stack = (int *) yy_flex_alloc( new_size ); 2185 2186 else 2187 yy_start_stack = (int *) yy_flex_realloc( 2188 (void *) yy_start_stack, new_size ); 2189 2190 if ( ! yy_start_stack ) 2191 YY_FATAL_ERROR( 2192 "out of memory expanding start-condition stack" ); 2193 } 2194 2195 yy_start_stack[yy_start_stack_ptr++] = YY_START; 2196 2197 BEGIN(new_state); 2198 } 2199 #endif 2200 2201 2202 #ifndef YY_NO_POP_STATE 2203 static void yy_pop_state() 2204 { 2205 if ( --yy_start_stack_ptr < 0 ) 2206 YY_FATAL_ERROR( "start-condition stack underflow" ); 2207 2208 BEGIN(yy_start_stack[yy_start_stack_ptr]); 2209 } 2210 #endif 2211 2212 2213 #ifndef YY_NO_TOP_STATE 2214 static int yy_top_state() 2215 { 2216 return yy_start_stack[yy_start_stack_ptr - 1]; 2217 } 2218 #endif 2219 2220 #ifndef YY_EXIT_FAILURE 2221 #define YY_EXIT_FAILURE 2 2222 #endif 2223 2224 #ifdef YY_USE_PROTOS 2225 static void yy_fatal_error( yyconst char msg[] ) 2226 #else 2227 static void yy_fatal_error( msg ) 2228 char msg[]; 2229 #endif 2230 { 2231 (void) fprintf( stderr, "%s\n", msg ); 2232 exit( YY_EXIT_FAILURE ); 2233 } 2234 2235 2236 2237 /* Redefine yyless() so it works in section 3 code. */ 2238 2239 #undef yyless 2240 #define yyless(n) \ 2241 do \ 2242 { \ 2243 /* Undo effects of setting up yytext. */ \ 2244 yytext[yyleng] = yy_hold_char; \ 2245 yy_c_buf_p = yytext + n; \ 2246 yy_hold_char = *yy_c_buf_p; \ 2247 *yy_c_buf_p = '\0'; \ 2248 yyleng = n; \ 2249 } \ 2250 while ( 0 ) 2251 2252 2253 /* Internal utility routines. */ 2254 2255 #ifndef yytext_ptr 2256 #ifdef YY_USE_PROTOS 2257 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 2258 #else 2259 static void yy_flex_strncpy( s1, s2, n ) 2260 char *s1; 2261 yyconst char *s2; 2262 int n; 2263 #endif 2264 { 2265 register int i; 2266 for ( i = 0; i < n; ++i ) 2267 s1[i] = s2[i]; 2268 } 2269 #endif 2270 2271 #ifdef YY_NEED_STRLEN 2272 #ifdef YY_USE_PROTOS 2273 static int yy_flex_strlen( yyconst char *s ) 2274 #else 2275 static int yy_flex_strlen( s ) 2276 yyconst char *s; 2277 #endif 2278 { 2279 register int n; 2280 for ( n = 0; s[n]; ++n ) 2281 ; 2282 2283 return n; 2284 } 2285 #endif 2286 2287 2288 #ifdef YY_USE_PROTOS 2289 static void *yy_flex_alloc( yy_size_t size ) 2290 #else 2291 static void *yy_flex_alloc( size ) 2292 yy_size_t size; 2293 #endif 2294 { 2295 return (void *) malloc( size ); 2296 } 2297 2298 #ifdef YY_USE_PROTOS 2299 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 2300 #else 2301 static void *yy_flex_realloc( ptr, size ) 2302 void *ptr; 2303 yy_size_t size; 2304 #endif 2305 { 2306 /* The cast to (char *) in the following accommodates both 2307 * implementations that use char* generic pointers, and those 2308 * that use void* generic pointers. It works with the latter 2309 * because both ANSI C and C++ allow castless assignment from 2310 * any pointer type to void*, and deal with argument conversions 2311 * as though doing an assignment. 2312 */ 2313 return (void *) realloc( (char *) ptr, size ); 2314 } 2315 2316 #ifdef YY_USE_PROTOS 2317 static void yy_flex_free( void *ptr ) 2318 #else 2319 static void yy_flex_free( ptr ) 2320 void *ptr; 2321 #endif 2322 { 2323 free( ptr ); 2324 } 2325 2326 #if YY_MAIN 2327 int main() 2328 { 2329 yylex(); 2330 return 0; 2331 } 2332 #endif 2333 #line 406 "lexer.l"