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