1/* A lexical scanner generated by flex */ 2 3/* Scanner skeleton version: 4 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern 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 40 286#define YY_END_OF_BUFFER 41 287static yyconst short int yy_accept[177] = 288 { 0, 289 0, 0, 41, 40, 39, 38, 35, 32, 33, 36, 290 40, 34, 37, 35, 35, 35, 35, 35, 35, 35, 291 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 292 35, 35, 35, 35, 35, 35, 36, 31, 37, 35, 293 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 294 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 295 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 296 35, 35, 7, 35, 35, 35, 35, 35, 35, 35, 297 35, 35, 35, 35, 35, 35, 22, 35, 35, 35, 298 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 299 300 35, 35, 35, 10, 11, 12, 35, 15, 35, 35, 301 35, 35, 35, 35, 35, 35, 35, 25, 26, 27, 302 35, 30, 35, 35, 35, 3, 35, 35, 35, 35, 303 35, 35, 35, 35, 35, 18, 35, 35, 35, 35, 304 35, 35, 35, 1, 2, 4, 5, 35, 35, 35, 305 35, 35, 16, 17, 19, 20, 35, 35, 35, 35, 306 35, 35, 8, 9, 13, 14, 35, 23, 24, 28, 307 29, 35, 35, 6, 21, 0 308 } ; 309 310static yyconst int yy_ec[256] = 311 { 0, 312 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 313 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 314 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 315 1, 3, 1, 1, 1, 4, 1, 1, 1, 5, 316 6, 7, 8, 9, 4, 4, 4, 4, 4, 4, 317 4, 4, 4, 4, 4, 4, 4, 4, 10, 1, 318 1, 1, 1, 1, 11, 12, 13, 14, 15, 16, 319 4, 17, 18, 4, 4, 19, 20, 21, 22, 23, 320 4, 24, 25, 26, 27, 28, 4, 29, 30, 4, 321 1, 4, 1, 1, 4, 1, 31, 32, 33, 34, 322 323 35, 36, 4, 37, 38, 4, 4, 39, 40, 41, 324 42, 43, 4, 44, 45, 46, 47, 48, 4, 49, 325 50, 4, 1, 1, 1, 1, 1, 1, 1, 1, 326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 330 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 333 334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 336 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 339 1, 1, 1, 1, 1 340 } ; 341 342static yyconst int yy_meta[51] = 343 { 0, 344 1, 2, 1, 3, 1, 1, 1, 1, 1, 1, 345 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 346 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 347 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 348 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 349 } ; 350 351static yyconst short int yy_base[180] = 352 { 0, 353 0, 0, 193, 194, 194, 194, 0, 194, 194, 0, 354 190, 194, 0, 177, 32, 37, 32, 163, 174, 170, 355 164, 171, 174, 169, 149, 15, 22, 17, 135, 146, 356 142, 136, 143, 146, 141, 0, 0, 194, 0, 161, 357 159, 158, 153, 147, 156, 143, 149, 148, 141, 150, 358 141, 135, 138, 127, 125, 124, 119, 113, 122, 109, 359 115, 114, 107, 116, 107, 101, 104, 43, 136, 135, 360 130, 129, 0, 119, 123, 118, 114, 118, 119, 122, 361 124, 25, 104, 103, 98, 97, 0, 87, 91, 86, 362 82, 86, 87, 90, 92, 105, 100, 97, 94, 93, 363 364 105, 106, 102, 0, 0, 0, 104, 0, 92, 75, 365 70, 67, 64, 63, 75, 76, 72, 0, 0, 0, 366 74, 0, 62, 91, 88, 0, 86, 85, 73, 85, 367 79, 83, 70, 62, 59, 0, 57, 56, 44, 56, 368 50, 54, 41, 0, 0, 0, 0, 63, 58, 59, 369 67, 66, 0, 0, 0, 0, 38, 33, 34, 42, 370 41, 51, 0, 0, 0, 0, 30, 0, 0, 0, 371 0, 43, 21, 0, 0, 194, 65, 66, 69 372 } ; 373 374static yyconst short int yy_def[180] = 375 { 0, 376 176, 1, 176, 176, 176, 176, 177, 176, 176, 178, 377 176, 176, 179, 177, 177, 177, 177, 177, 177, 177, 378 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 379 177, 177, 177, 177, 177, 177, 178, 176, 179, 177, 380 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 381 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 382 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 383 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 384 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 385 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 386 387 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 388 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 389 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 390 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 391 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 392 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 393 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 394 177, 177, 177, 177, 177, 0, 176, 176, 176 395 } ; 396 397static yyconst short int yy_nxt[245] = 398 { 0, 399 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 400 14, 7, 15, 16, 17, 18, 19, 7, 20, 7, 401 7, 21, 7, 22, 23, 7, 7, 24, 7, 7, 402 25, 7, 26, 27, 28, 29, 30, 7, 31, 7, 403 7, 32, 7, 33, 34, 7, 7, 35, 7, 7, 404 41, 43, 45, 55, 44, 42, 57, 59, 56, 58, 405 46, 96, 97, 110, 111, 60, 37, 36, 37, 39, 406 175, 39, 174, 173, 172, 171, 170, 169, 168, 167, 407 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 408 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 409 410 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 411 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 412 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 413 116, 115, 114, 113, 112, 109, 108, 107, 106, 105, 414 104, 103, 102, 101, 100, 99, 98, 95, 94, 93, 415 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 416 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 417 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 418 62, 61, 54, 53, 52, 51, 50, 49, 48, 47, 419 40, 38, 176, 3, 176, 176, 176, 176, 176, 176, 420 421 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 422 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 423 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 424 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 425 176, 176, 176, 176 426 } ; 427 428static yyconst short int yy_chk[245] = 429 { 0, 430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 435 15, 16, 17, 26, 16, 15, 27, 28, 26, 27, 436 17, 68, 68, 82, 82, 28, 178, 177, 178, 179, 437 173, 179, 172, 167, 162, 161, 160, 159, 158, 157, 438 152, 151, 150, 149, 148, 143, 142, 141, 140, 139, 439 138, 137, 135, 134, 133, 132, 131, 130, 129, 128, 440 441 127, 125, 124, 123, 121, 117, 116, 115, 114, 113, 442 112, 111, 110, 109, 107, 103, 102, 101, 100, 99, 443 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 444 88, 86, 85, 84, 83, 81, 80, 79, 78, 77, 445 76, 75, 74, 72, 71, 70, 69, 67, 66, 65, 446 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 447 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 448 44, 43, 42, 41, 40, 35, 34, 33, 32, 31, 449 30, 29, 25, 24, 23, 22, 21, 20, 19, 18, 450 14, 11, 3, 176, 176, 176, 176, 176, 176, 176, 451 452 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 453 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 454 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 455 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 456 176, 176, 176, 176 457 } ; 458 459static yy_state_type yy_last_accepting_state; 460static char *yy_last_accepting_cpos; 461 462/* The intent behind this definition is that it'll catch 463 * any uses of REJECT which flex missed. 464 */ 465#define REJECT reject_used_but_not_detected 466#define yymore() yymore_used_but_not_detected 467#define YY_MORE_ADJ 0 468#define YY_RESTORE_YY_MORE_OFFSET 469char *yytext; 470#line 1 "arlex.l" 471#define INITIAL 0 472#line 2 "arlex.l" 473/* arlex.l - Strange script language lexer */ 474 475/* Copyright 1992, 1997, 2000, 2001, 2002, 2003, 2004 476 Free Software Foundation, Inc. 477 478This file is part of GNU Binutils. 479 480This program is free software; you can redistribute it and/or modify 481it under the terms of the GNU General Public License as published by 482the Free Software Foundation; either version 2 of the License, or 483(at your option) any later version. 484 485This program is distributed in the hope that it will be useful, 486but WITHOUT ANY WARRANTY; without even the implied warranty of 487MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 488GNU General Public License for more details. 489 490You should have received a copy of the GNU General Public License 491along with this program; if not, write to the Free Software 492Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 493 494 495/* Contributed by Steve Chamberlain <sac@cygnus.com>. */ 496 497#define DONTDECLARE_MALLOC 498#include "ansidecl.h" 499#include "libiberty.h" 500#include "arparse.h" 501 502#define YY_NO_UNPUT 503 504extern int yylex (void); 505 506int linenumber; 507#line 508 "arlex.c" 508 509/* Macros after this point can all be overridden by user definitions in 510 * section 1. 511 */ 512 513#ifndef YY_SKIP_YYWRAP 514#ifdef __cplusplus 515extern "C" int yywrap YY_PROTO(( void )); 516#else 517extern int yywrap YY_PROTO(( void )); 518#endif 519#endif 520 521#ifndef YY_NO_UNPUT 522static void yyunput YY_PROTO(( int c, char *buf_ptr )); 523#endif 524 525#ifndef yytext_ptr 526static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 527#endif 528 529#ifdef YY_NEED_STRLEN 530static int yy_flex_strlen YY_PROTO(( yyconst char * )); 531#endif 532 533#ifndef YY_NO_INPUT 534#ifdef __cplusplus 535static int yyinput YY_PROTO(( void )); 536#else 537static int input YY_PROTO(( void )); 538#endif 539#endif 540 541#if YY_STACK_USED 542static int yy_start_stack_ptr = 0; 543static int yy_start_stack_depth = 0; 544static int *yy_start_stack = 0; 545#ifndef YY_NO_PUSH_STATE 546static void yy_push_state YY_PROTO(( int new_state )); 547#endif 548#ifndef YY_NO_POP_STATE 549static void yy_pop_state YY_PROTO(( void )); 550#endif 551#ifndef YY_NO_TOP_STATE 552static int yy_top_state YY_PROTO(( void )); 553#endif 554 555#else 556#define YY_NO_PUSH_STATE 1 557#define YY_NO_POP_STATE 1 558#define YY_NO_TOP_STATE 1 559#endif 560 561#ifdef YY_MALLOC_DECL 562YY_MALLOC_DECL 563#else 564#if __STDC__ 565#ifndef __cplusplus 566#include <stdlib.h> 567#endif 568#else 569/* Just try to get by without declaring the routines. This will fail 570 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 571 * or sizeof(void*) != sizeof(int). 572 */ 573#endif 574#endif 575 576/* Amount of stuff to slurp up with each read. */ 577#ifndef YY_READ_BUF_SIZE 578#define YY_READ_BUF_SIZE 8192 579#endif 580 581/* Copy whatever the last rule matched to the standard output. */ 582 583#ifndef ECHO 584/* This used to be an fputs(), but since the string might contain NUL's, 585 * we now use fwrite(). 586 */ 587#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 588#endif 589 590/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 591 * is returned in "result". 592 */ 593#ifndef YY_INPUT 594#define YY_INPUT(buf,result,max_size) \ 595 if ( yy_current_buffer->yy_is_interactive ) \ 596 { \ 597 int c = '*', n; \ 598 for ( n = 0; n < max_size && \ 599 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 600 buf[n] = (char) c; \ 601 if ( c == '\n' ) \ 602 buf[n++] = (char) c; \ 603 if ( c == EOF && ferror( yyin ) ) \ 604 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 605 result = n; \ 606 } \ 607 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 608 && ferror( yyin ) ) \ 609 YY_FATAL_ERROR( "input in flex scanner failed" ); 610#endif 611 612/* No semi-colon after return; correct usage is to write "yyterminate();" - 613 * we don't want an extra ';' after the "return" because that will cause 614 * some compilers to complain about unreachable statements. 615 */ 616#ifndef yyterminate 617#define yyterminate() return YY_NULL 618#endif 619 620/* Number of entries by which start-condition stack grows. */ 621#ifndef YY_START_STACK_INCR 622#define YY_START_STACK_INCR 25 623#endif 624 625/* Report a fatal error. */ 626#ifndef YY_FATAL_ERROR 627#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 628#endif 629 630/* Default declaration of generated scanner - a define so the user can 631 * easily add parameters. 632 */ 633#ifndef YY_DECL 634#define YY_DECL int yylex YY_PROTO(( void )) 635#endif 636 637/* Code executed at the beginning of each rule, after yytext and yyleng 638 * have been set up. 639 */ 640#ifndef YY_USER_ACTION 641#define YY_USER_ACTION 642#endif 643 644/* Code executed at the end of each rule. */ 645#ifndef YY_BREAK 646#define YY_BREAK break; 647#endif 648 649#define YY_RULE_SETUP \ 650 YY_USER_ACTION 651 652YY_DECL 653 { 654 register yy_state_type yy_current_state; 655 register char *yy_cp = NULL, *yy_bp = NULL; 656 register int yy_act; 657 658#line 41 "arlex.l" 659 660 661#line 662 "arlex.c" 662 663 if ( yy_init ) 664 { 665 yy_init = 0; 666 667#ifdef YY_USER_INIT 668 YY_USER_INIT; 669#endif 670 671 if ( ! yy_start ) 672 yy_start = 1; /* first start state */ 673 674 if ( ! yyin ) 675 yyin = stdin; 676 677 if ( ! yyout ) 678 yyout = stdout; 679 680 if ( ! yy_current_buffer ) 681 yy_current_buffer = 682 yy_create_buffer( yyin, YY_BUF_SIZE ); 683 684 yy_load_buffer_state(); 685 } 686 687 while ( 1 ) /* loops until end-of-file is reached */ 688 { 689 yy_cp = yy_c_buf_p; 690 691 /* Support of yytext. */ 692 *yy_cp = yy_hold_char; 693 694 /* yy_bp points to the position in yy_ch_buf of the start of 695 * the current run. 696 */ 697 yy_bp = yy_cp; 698 699 yy_current_state = yy_start; 700yy_match: 701 do 702 { 703 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 704 if ( yy_accept[yy_current_state] ) 705 { 706 yy_last_accepting_state = yy_current_state; 707 yy_last_accepting_cpos = yy_cp; 708 } 709 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 710 { 711 yy_current_state = (int) yy_def[yy_current_state]; 712 if ( yy_current_state >= 177 ) 713 yy_c = yy_meta[(unsigned int) yy_c]; 714 } 715 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 716 ++yy_cp; 717 } 718 while ( yy_base[yy_current_state] != 194 ); 719 720yy_find_action: 721 yy_act = yy_accept[yy_current_state]; 722 if ( yy_act == 0 ) 723 { /* have to back up */ 724 yy_cp = yy_last_accepting_cpos; 725 yy_current_state = yy_last_accepting_state; 726 yy_act = yy_accept[yy_current_state]; 727 } 728 729 YY_DO_BEFORE_ACTION; 730 731 732do_action: /* This label is used only to access EOF actions. */ 733 734 735 switch ( yy_act ) 736 { /* beginning of action switch */ 737 case 0: /* must back up */ 738 /* undo the effects of YY_DO_BEFORE_ACTION */ 739 *yy_cp = yy_hold_char; 740 yy_cp = yy_last_accepting_cpos; 741 yy_current_state = yy_last_accepting_state; 742 goto yy_find_action; 743 744case 1: 745YY_RULE_SETUP 746#line 43 "arlex.l" 747{ return ADDLIB; } 748 YY_BREAK 749case 2: 750YY_RULE_SETUP 751#line 44 "arlex.l" 752{ return ADDMOD; } 753 YY_BREAK 754case 3: 755YY_RULE_SETUP 756#line 45 "arlex.l" 757{ return CLEAR; } 758 YY_BREAK 759case 4: 760YY_RULE_SETUP 761#line 46 "arlex.l" 762{ return CREATE; } 763 YY_BREAK 764case 5: 765YY_RULE_SETUP 766#line 47 "arlex.l" 767{ return DELETE; } 768 YY_BREAK 769case 6: 770YY_RULE_SETUP 771#line 48 "arlex.l" 772{ return DIRECTORY; } 773 YY_BREAK 774case 7: 775YY_RULE_SETUP 776#line 49 "arlex.l" 777{ return END; } 778 YY_BREAK 779case 8: 780YY_RULE_SETUP 781#line 50 "arlex.l" 782{ return EXTRACT; } 783 YY_BREAK 784case 9: 785YY_RULE_SETUP 786#line 51 "arlex.l" 787{ return FULLDIR; } 788 YY_BREAK 789case 10: 790YY_RULE_SETUP 791#line 52 "arlex.l" 792{ return HELP; } 793 YY_BREAK 794case 11: 795YY_RULE_SETUP 796#line 53 "arlex.l" 797{ return LIST; } 798 YY_BREAK 799case 12: 800YY_RULE_SETUP 801#line 54 "arlex.l" 802{ return OPEN; } 803 YY_BREAK 804case 13: 805YY_RULE_SETUP 806#line 55 "arlex.l" 807{ return REPLACE; } 808 YY_BREAK 809case 14: 810YY_RULE_SETUP 811#line 56 "arlex.l" 812{ return VERBOSE; } 813 YY_BREAK 814case 15: 815YY_RULE_SETUP 816#line 57 "arlex.l" 817{ return SAVE; } 818 YY_BREAK 819case 16: 820YY_RULE_SETUP 821#line 58 "arlex.l" 822{ return ADDLIB; } 823 YY_BREAK 824case 17: 825YY_RULE_SETUP 826#line 59 "arlex.l" 827{ return ADDMOD; } 828 YY_BREAK 829case 18: 830YY_RULE_SETUP 831#line 60 "arlex.l" 832{ return CLEAR; } 833 YY_BREAK 834case 19: 835YY_RULE_SETUP 836#line 61 "arlex.l" 837{ return CREATE; } 838 YY_BREAK 839case 20: 840YY_RULE_SETUP 841#line 62 "arlex.l" 842{ return DELETE; } 843 YY_BREAK 844case 21: 845YY_RULE_SETUP 846#line 63 "arlex.l" 847{ return DIRECTORY; } 848 YY_BREAK 849case 22: 850YY_RULE_SETUP 851#line 64 "arlex.l" 852{ return END; } 853 YY_BREAK 854case 23: 855YY_RULE_SETUP 856#line 65 "arlex.l" 857{ return EXTRACT; } 858 YY_BREAK 859case 24: 860YY_RULE_SETUP 861#line 66 "arlex.l" 862{ return FULLDIR; } 863 YY_BREAK 864case 25: 865YY_RULE_SETUP 866#line 67 "arlex.l" 867{ return HELP; } 868 YY_BREAK 869case 26: 870YY_RULE_SETUP 871#line 68 "arlex.l" 872{ return LIST; } 873 YY_BREAK 874case 27: 875YY_RULE_SETUP 876#line 69 "arlex.l" 877{ return OPEN; } 878 YY_BREAK 879case 28: 880YY_RULE_SETUP 881#line 70 "arlex.l" 882{ return REPLACE; } 883 YY_BREAK 884case 29: 885YY_RULE_SETUP 886#line 71 "arlex.l" 887{ return VERBOSE; } 888 YY_BREAK 889case 30: 890YY_RULE_SETUP 891#line 72 "arlex.l" 892{ return SAVE; } 893 YY_BREAK 894case 31: 895YY_RULE_SETUP 896#line 73 "arlex.l" 897{ linenumber ++; } 898 YY_BREAK 899case 32: 900YY_RULE_SETUP 901#line 74 "arlex.l" 902{ return '('; } 903 YY_BREAK 904case 33: 905YY_RULE_SETUP 906#line 75 "arlex.l" 907{ return ')'; } 908 YY_BREAK 909case 34: 910YY_RULE_SETUP 911#line 76 "arlex.l" 912{ return ','; } 913 YY_BREAK 914case 35: 915YY_RULE_SETUP 916#line 77 "arlex.l" 917{ 918 yylval.name = xstrdup (yytext); 919 return FILENAME; 920 } 921 YY_BREAK 922case 36: 923YY_RULE_SETUP 924#line 81 "arlex.l" 925{ } 926 YY_BREAK 927case 37: 928YY_RULE_SETUP 929#line 82 "arlex.l" 930{ } 931 YY_BREAK 932case 38: 933YY_RULE_SETUP 934#line 83 "arlex.l" 935{ } 936 YY_BREAK 937case 39: 938YY_RULE_SETUP 939#line 84 "arlex.l" 940{ linenumber ++; return NEWLINE; } 941 YY_BREAK 942case 40: 943YY_RULE_SETUP 944#line 86 "arlex.l" 945ECHO; 946 YY_BREAK 947#line 948 "arlex.c" 948case YY_STATE_EOF(INITIAL): 949 yyterminate(); 950 951 case YY_END_OF_BUFFER: 952 { 953 /* Amount of text matched not including the EOB char. */ 954 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 955 956 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 957 *yy_cp = yy_hold_char; 958 YY_RESTORE_YY_MORE_OFFSET 959 960 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 961 { 962 /* We're scanning a new file or input source. It's 963 * possible that this happened because the user 964 * just pointed yyin at a new source and called 965 * yylex(). If so, then we have to assure 966 * consistency between yy_current_buffer and our 967 * globals. Here is the right place to do so, because 968 * this is the first action (other than possibly a 969 * back-up) that will match for the new input source. 970 */ 971 yy_n_chars = yy_current_buffer->yy_n_chars; 972 yy_current_buffer->yy_input_file = yyin; 973 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 974 } 975 976 /* Note that here we test for yy_c_buf_p "<=" to the position 977 * of the first EOB in the buffer, since yy_c_buf_p will 978 * already have been incremented past the NUL character 979 * (since all states make transitions on EOB to the 980 * end-of-buffer state). Contrast this with the test 981 * in input(). 982 */ 983 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 984 { /* This was really a NUL. */ 985 yy_state_type yy_next_state; 986 987 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 988 989 yy_current_state = yy_get_previous_state(); 990 991 /* Okay, we're now positioned to make the NUL 992 * transition. We couldn't have 993 * yy_get_previous_state() go ahead and do it 994 * for us because it doesn't know how to deal 995 * with the possibility of jamming (and we don't 996 * want to build jamming into it because then it 997 * will run more slowly). 998 */ 999 1000 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1001 1002 yy_bp = yytext_ptr + YY_MORE_ADJ; 1003 1004 if ( yy_next_state ) 1005 { 1006 /* Consume the NUL. */ 1007 yy_cp = ++yy_c_buf_p; 1008 yy_current_state = yy_next_state; 1009 goto yy_match; 1010 } 1011 1012 else 1013 { 1014 yy_cp = yy_c_buf_p; 1015 goto yy_find_action; 1016 } 1017 } 1018 1019 else switch ( yy_get_next_buffer() ) 1020 { 1021 case EOB_ACT_END_OF_FILE: 1022 { 1023 yy_did_buffer_switch_on_eof = 0; 1024 1025 if ( yywrap() ) 1026 { 1027 /* Note: because we've taken care in 1028 * yy_get_next_buffer() to have set up 1029 * yytext, we can now set up 1030 * yy_c_buf_p so that if some total 1031 * hoser (like flex itself) wants to 1032 * call the scanner after we return the 1033 * YY_NULL, it'll still work - another 1034 * YY_NULL will get returned. 1035 */ 1036 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1037 1038 yy_act = YY_STATE_EOF(YY_START); 1039 goto do_action; 1040 } 1041 1042 else 1043 { 1044 if ( ! yy_did_buffer_switch_on_eof ) 1045 YY_NEW_FILE; 1046 } 1047 break; 1048 } 1049 1050 case EOB_ACT_CONTINUE_SCAN: 1051 yy_c_buf_p = 1052 yytext_ptr + yy_amount_of_matched_text; 1053 1054 yy_current_state = yy_get_previous_state(); 1055 1056 yy_cp = yy_c_buf_p; 1057 yy_bp = yytext_ptr + YY_MORE_ADJ; 1058 goto yy_match; 1059 1060 case EOB_ACT_LAST_MATCH: 1061 yy_c_buf_p = 1062 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1063 1064 yy_current_state = yy_get_previous_state(); 1065 1066 yy_cp = yy_c_buf_p; 1067 yy_bp = yytext_ptr + YY_MORE_ADJ; 1068 goto yy_find_action; 1069 } 1070 break; 1071 } 1072 1073 default: 1074 YY_FATAL_ERROR( 1075 "fatal flex scanner internal error--no action found" ); 1076 } /* end of action switch */ 1077 } /* end of scanning one token */ 1078 } /* end of yylex */ 1079 1080 1081/* yy_get_next_buffer - try to read in a new buffer 1082 * 1083 * Returns a code representing an action: 1084 * EOB_ACT_LAST_MATCH - 1085 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1086 * EOB_ACT_END_OF_FILE - end of file 1087 */ 1088 1089static int yy_get_next_buffer() 1090 { 1091 register char *dest = yy_current_buffer->yy_ch_buf; 1092 register char *source = yytext_ptr; 1093 register int number_to_move, i; 1094 int ret_val; 1095 1096 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1097 YY_FATAL_ERROR( 1098 "fatal flex scanner internal error--end of buffer missed" ); 1099 1100 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1101 { /* Don't try to fill the buffer, so this is an EOF. */ 1102 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1103 { 1104 /* We matched a single character, the EOB, so 1105 * treat this as a final EOF. 1106 */ 1107 return EOB_ACT_END_OF_FILE; 1108 } 1109 1110 else 1111 { 1112 /* We matched some text prior to the EOB, first 1113 * process it. 1114 */ 1115 return EOB_ACT_LAST_MATCH; 1116 } 1117 } 1118 1119 /* Try to read more data. */ 1120 1121 /* First move last chars to start of buffer. */ 1122 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1123 1124 for ( i = 0; i < number_to_move; ++i ) 1125 *(dest++) = *(source++); 1126 1127 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1128 /* don't do the read, it's not guaranteed to return an EOF, 1129 * just force an EOF 1130 */ 1131 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1132 1133 else 1134 { 1135 int num_to_read = 1136 yy_current_buffer->yy_buf_size - number_to_move - 1; 1137 1138 while ( num_to_read <= 0 ) 1139 { /* Not enough room in the buffer - grow it. */ 1140#ifdef YY_USES_REJECT 1141 YY_FATAL_ERROR( 1142"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1143#else 1144 1145 /* just a shorter name for the current buffer */ 1146 YY_BUFFER_STATE b = yy_current_buffer; 1147 1148 int yy_c_buf_p_offset = 1149 (int) (yy_c_buf_p - b->yy_ch_buf); 1150 1151 if ( b->yy_is_our_buffer ) 1152 { 1153 int new_size = b->yy_buf_size * 2; 1154 1155 if ( new_size <= 0 ) 1156 b->yy_buf_size += b->yy_buf_size / 8; 1157 else 1158 b->yy_buf_size *= 2; 1159 1160 b->yy_ch_buf = (char *) 1161 /* Include room in for 2 EOB chars. */ 1162 yy_flex_realloc( (void *) b->yy_ch_buf, 1163 b->yy_buf_size + 2 ); 1164 } 1165 else 1166 /* Can't grow it, we don't own it. */ 1167 b->yy_ch_buf = 0; 1168 1169 if ( ! b->yy_ch_buf ) 1170 YY_FATAL_ERROR( 1171 "fatal error - scanner input buffer overflow" ); 1172 1173 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1174 1175 num_to_read = yy_current_buffer->yy_buf_size - 1176 number_to_move - 1; 1177#endif 1178 } 1179 1180 if ( num_to_read > YY_READ_BUF_SIZE ) 1181 num_to_read = YY_READ_BUF_SIZE; 1182 1183 /* Read in more data. */ 1184 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1185 yy_n_chars, num_to_read ); 1186 1187 yy_current_buffer->yy_n_chars = yy_n_chars; 1188 } 1189 1190 if ( yy_n_chars == 0 ) 1191 { 1192 if ( number_to_move == YY_MORE_ADJ ) 1193 { 1194 ret_val = EOB_ACT_END_OF_FILE; 1195 yyrestart( yyin ); 1196 } 1197 1198 else 1199 { 1200 ret_val = EOB_ACT_LAST_MATCH; 1201 yy_current_buffer->yy_buffer_status = 1202 YY_BUFFER_EOF_PENDING; 1203 } 1204 } 1205 1206 else 1207 ret_val = EOB_ACT_CONTINUE_SCAN; 1208 1209 yy_n_chars += number_to_move; 1210 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1211 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1212 1213 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1214 1215 return ret_val; 1216 } 1217 1218 1219/* yy_get_previous_state - get the state just before the EOB char was reached */ 1220 1221static yy_state_type yy_get_previous_state() 1222 { 1223 register yy_state_type yy_current_state; 1224 register char *yy_cp; 1225 1226 yy_current_state = yy_start; 1227 1228 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1229 { 1230 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1231 if ( yy_accept[yy_current_state] ) 1232 { 1233 yy_last_accepting_state = yy_current_state; 1234 yy_last_accepting_cpos = yy_cp; 1235 } 1236 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1237 { 1238 yy_current_state = (int) yy_def[yy_current_state]; 1239 if ( yy_current_state >= 177 ) 1240 yy_c = yy_meta[(unsigned int) yy_c]; 1241 } 1242 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1243 } 1244 1245 return yy_current_state; 1246 } 1247 1248 1249/* yy_try_NUL_trans - try to make a transition on the NUL character 1250 * 1251 * synopsis 1252 * next_state = yy_try_NUL_trans( current_state ); 1253 */ 1254 1255#ifdef YY_USE_PROTOS 1256static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1257#else 1258static yy_state_type yy_try_NUL_trans( yy_current_state ) 1259yy_state_type yy_current_state; 1260#endif 1261 { 1262 register int yy_is_jam; 1263 register char *yy_cp = yy_c_buf_p; 1264 1265 register YY_CHAR yy_c = 1; 1266 if ( yy_accept[yy_current_state] ) 1267 { 1268 yy_last_accepting_state = yy_current_state; 1269 yy_last_accepting_cpos = yy_cp; 1270 } 1271 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1272 { 1273 yy_current_state = (int) yy_def[yy_current_state]; 1274 if ( yy_current_state >= 177 ) 1275 yy_c = yy_meta[(unsigned int) yy_c]; 1276 } 1277 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1278 yy_is_jam = (yy_current_state == 176); 1279 1280 return yy_is_jam ? 0 : yy_current_state; 1281 } 1282 1283 1284#ifndef YY_NO_UNPUT 1285#ifdef YY_USE_PROTOS 1286static void yyunput( int c, register char *yy_bp ) 1287#else 1288static void yyunput( c, yy_bp ) 1289int c; 1290register char *yy_bp; 1291#endif 1292 { 1293 register char *yy_cp = yy_c_buf_p; 1294 1295 /* undo effects of setting up yytext */ 1296 *yy_cp = yy_hold_char; 1297 1298 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1299 { /* need to shift things up to make room */ 1300 /* +2 for EOB chars. */ 1301 register int number_to_move = yy_n_chars + 2; 1302 register char *dest = &yy_current_buffer->yy_ch_buf[ 1303 yy_current_buffer->yy_buf_size + 2]; 1304 register char *source = 1305 &yy_current_buffer->yy_ch_buf[number_to_move]; 1306 1307 while ( source > yy_current_buffer->yy_ch_buf ) 1308 *--dest = *--source; 1309 1310 yy_cp += (int) (dest - source); 1311 yy_bp += (int) (dest - source); 1312 yy_current_buffer->yy_n_chars = 1313 yy_n_chars = yy_current_buffer->yy_buf_size; 1314 1315 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1316 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1317 } 1318 1319 *--yy_cp = (char) c; 1320 1321 1322 yytext_ptr = yy_bp; 1323 yy_hold_char = *yy_cp; 1324 yy_c_buf_p = yy_cp; 1325 } 1326#endif /* ifndef YY_NO_UNPUT */ 1327 1328 1329#ifndef YY_NO_INPUT 1330#ifdef __cplusplus 1331static int yyinput() 1332#else 1333static int input() 1334#endif 1335 { 1336 int c; 1337 1338 *yy_c_buf_p = yy_hold_char; 1339 1340 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1341 { 1342 /* yy_c_buf_p now points to the character we want to return. 1343 * If this occurs *before* the EOB characters, then it's a 1344 * valid NUL; if not, then we've hit the end of the buffer. 1345 */ 1346 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1347 /* This was really a NUL. */ 1348 *yy_c_buf_p = '\0'; 1349 1350 else 1351 { /* need more input */ 1352 int offset = yy_c_buf_p - yytext_ptr; 1353 ++yy_c_buf_p; 1354 1355 switch ( yy_get_next_buffer() ) 1356 { 1357 case EOB_ACT_LAST_MATCH: 1358 /* This happens because yy_g_n_b() 1359 * sees that we've accumulated a 1360 * token and flags that we need to 1361 * try matching the token before 1362 * proceeding. But for input(), 1363 * there's no matching to consider. 1364 * So convert the EOB_ACT_LAST_MATCH 1365 * to EOB_ACT_END_OF_FILE. 1366 */ 1367 1368 /* Reset buffer status. */ 1369 yyrestart( yyin ); 1370 1371 /* fall through */ 1372 1373 case EOB_ACT_END_OF_FILE: 1374 { 1375 if ( yywrap() ) 1376 return EOF; 1377 1378 if ( ! yy_did_buffer_switch_on_eof ) 1379 YY_NEW_FILE; 1380#ifdef __cplusplus 1381 return yyinput(); 1382#else 1383 return input(); 1384#endif 1385 } 1386 1387 case EOB_ACT_CONTINUE_SCAN: 1388 yy_c_buf_p = yytext_ptr + offset; 1389 break; 1390 } 1391 } 1392 } 1393 1394 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1395 *yy_c_buf_p = '\0'; /* preserve yytext */ 1396 yy_hold_char = *++yy_c_buf_p; 1397 1398 1399 return c; 1400 } 1401#endif /* YY_NO_INPUT */ 1402 1403#ifdef YY_USE_PROTOS 1404void yyrestart( FILE *input_file ) 1405#else 1406void yyrestart( input_file ) 1407FILE *input_file; 1408#endif 1409 { 1410 if ( ! yy_current_buffer ) 1411 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1412 1413 yy_init_buffer( yy_current_buffer, input_file ); 1414 yy_load_buffer_state(); 1415 } 1416 1417 1418#ifdef YY_USE_PROTOS 1419void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1420#else 1421void yy_switch_to_buffer( new_buffer ) 1422YY_BUFFER_STATE new_buffer; 1423#endif 1424 { 1425 if ( yy_current_buffer == new_buffer ) 1426 return; 1427 1428 if ( yy_current_buffer ) 1429 { 1430 /* Flush out information for old buffer. */ 1431 *yy_c_buf_p = yy_hold_char; 1432 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1433 yy_current_buffer->yy_n_chars = yy_n_chars; 1434 } 1435 1436 yy_current_buffer = new_buffer; 1437 yy_load_buffer_state(); 1438 1439 /* We don't actually know whether we did this switch during 1440 * EOF (yywrap()) processing, but the only time this flag 1441 * is looked at is after yywrap() is called, so it's safe 1442 * to go ahead and always set it. 1443 */ 1444 yy_did_buffer_switch_on_eof = 1; 1445 } 1446 1447 1448#ifdef YY_USE_PROTOS 1449void yy_load_buffer_state( void ) 1450#else 1451void yy_load_buffer_state() 1452#endif 1453 { 1454 yy_n_chars = yy_current_buffer->yy_n_chars; 1455 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1456 yyin = yy_current_buffer->yy_input_file; 1457 yy_hold_char = *yy_c_buf_p; 1458 } 1459 1460 1461#ifdef YY_USE_PROTOS 1462YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1463#else 1464YY_BUFFER_STATE yy_create_buffer( file, size ) 1465FILE *file; 1466int size; 1467#endif 1468 { 1469 YY_BUFFER_STATE b; 1470 1471 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1472 if ( ! b ) 1473 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1474 1475 b->yy_buf_size = size; 1476 1477 /* yy_ch_buf has to be 2 characters longer than the size given because 1478 * we need to put in 2 end-of-buffer characters. 1479 */ 1480 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1481 if ( ! b->yy_ch_buf ) 1482 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1483 1484 b->yy_is_our_buffer = 1; 1485 1486 yy_init_buffer( b, file ); 1487 1488 return b; 1489 } 1490 1491 1492#ifdef YY_USE_PROTOS 1493void yy_delete_buffer( YY_BUFFER_STATE b ) 1494#else 1495void yy_delete_buffer( b ) 1496YY_BUFFER_STATE b; 1497#endif 1498 { 1499 if ( ! b ) 1500 return; 1501 1502 if ( b == yy_current_buffer ) 1503 yy_current_buffer = (YY_BUFFER_STATE) 0; 1504 1505 if ( b->yy_is_our_buffer ) 1506 yy_flex_free( (void *) b->yy_ch_buf ); 1507 1508 yy_flex_free( (void *) b ); 1509 } 1510 1511 1512 1513#ifdef YY_USE_PROTOS 1514void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1515#else 1516void yy_init_buffer( b, file ) 1517YY_BUFFER_STATE b; 1518FILE *file; 1519#endif 1520 1521 1522 { 1523 yy_flush_buffer( b ); 1524 1525 b->yy_input_file = file; 1526 b->yy_fill_buffer = 1; 1527 1528#if YY_ALWAYS_INTERACTIVE 1529 b->yy_is_interactive = 1; 1530#else 1531#if YY_NEVER_INTERACTIVE 1532 b->yy_is_interactive = 0; 1533#else 1534 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1535#endif 1536#endif 1537 } 1538 1539 1540#ifdef YY_USE_PROTOS 1541void yy_flush_buffer( YY_BUFFER_STATE b ) 1542#else 1543void yy_flush_buffer( b ) 1544YY_BUFFER_STATE b; 1545#endif 1546 1547 { 1548 if ( ! b ) 1549 return; 1550 1551 b->yy_n_chars = 0; 1552 1553 /* We always need two end-of-buffer characters. The first causes 1554 * a transition to the end-of-buffer state. The second causes 1555 * a jam in that state. 1556 */ 1557 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1558 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1559 1560 b->yy_buf_pos = &b->yy_ch_buf[0]; 1561 1562 b->yy_at_bol = 1; 1563 b->yy_buffer_status = YY_BUFFER_NEW; 1564 1565 if ( b == yy_current_buffer ) 1566 yy_load_buffer_state(); 1567 } 1568 1569 1570#ifndef YY_NO_SCAN_BUFFER 1571#ifdef YY_USE_PROTOS 1572YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1573#else 1574YY_BUFFER_STATE yy_scan_buffer( base, size ) 1575char *base; 1576yy_size_t size; 1577#endif 1578 { 1579 YY_BUFFER_STATE b; 1580 1581 if ( size < 2 || 1582 base[size-2] != YY_END_OF_BUFFER_CHAR || 1583 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1584 /* They forgot to leave room for the EOB's. */ 1585 return 0; 1586 1587 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1588 if ( ! b ) 1589 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1590 1591 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1592 b->yy_buf_pos = b->yy_ch_buf = base; 1593 b->yy_is_our_buffer = 0; 1594 b->yy_input_file = 0; 1595 b->yy_n_chars = b->yy_buf_size; 1596 b->yy_is_interactive = 0; 1597 b->yy_at_bol = 1; 1598 b->yy_fill_buffer = 0; 1599 b->yy_buffer_status = YY_BUFFER_NEW; 1600 1601 yy_switch_to_buffer( b ); 1602 1603 return b; 1604 } 1605#endif 1606 1607 1608#ifndef YY_NO_SCAN_STRING 1609#ifdef YY_USE_PROTOS 1610YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1611#else 1612YY_BUFFER_STATE yy_scan_string( yy_str ) 1613yyconst char *yy_str; 1614#endif 1615 { 1616 int len; 1617 for ( len = 0; yy_str[len]; ++len ) 1618 ; 1619 1620 return yy_scan_bytes( yy_str, len ); 1621 } 1622#endif 1623 1624 1625#ifndef YY_NO_SCAN_BYTES 1626#ifdef YY_USE_PROTOS 1627YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1628#else 1629YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1630yyconst char *bytes; 1631int len; 1632#endif 1633 { 1634 YY_BUFFER_STATE b; 1635 char *buf; 1636 yy_size_t n; 1637 int i; 1638 1639 /* Get memory for full buffer, including space for trailing EOB's. */ 1640 n = len + 2; 1641 buf = (char *) yy_flex_alloc( n ); 1642 if ( ! buf ) 1643 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1644 1645 for ( i = 0; i < len; ++i ) 1646 buf[i] = bytes[i]; 1647 1648 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1649 1650 b = yy_scan_buffer( buf, n ); 1651 if ( ! b ) 1652 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1653 1654 /* It's okay to grow etc. this buffer, and we should throw it 1655 * away when we're done. 1656 */ 1657 b->yy_is_our_buffer = 1; 1658 1659 return b; 1660 } 1661#endif 1662 1663 1664#ifndef YY_NO_PUSH_STATE 1665#ifdef YY_USE_PROTOS 1666static void yy_push_state( int new_state ) 1667#else 1668static void yy_push_state( new_state ) 1669int new_state; 1670#endif 1671 { 1672 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1673 { 1674 yy_size_t new_size; 1675 1676 yy_start_stack_depth += YY_START_STACK_INCR; 1677 new_size = yy_start_stack_depth * sizeof( int ); 1678 1679 if ( ! yy_start_stack ) 1680 yy_start_stack = (int *) yy_flex_alloc( new_size ); 1681 1682 else 1683 yy_start_stack = (int *) yy_flex_realloc( 1684 (void *) yy_start_stack, new_size ); 1685 1686 if ( ! yy_start_stack ) 1687 YY_FATAL_ERROR( 1688 "out of memory expanding start-condition stack" ); 1689 } 1690 1691 yy_start_stack[yy_start_stack_ptr++] = YY_START; 1692 1693 BEGIN(new_state); 1694 } 1695#endif 1696 1697 1698#ifndef YY_NO_POP_STATE 1699static void yy_pop_state() 1700 { 1701 if ( --yy_start_stack_ptr < 0 ) 1702 YY_FATAL_ERROR( "start-condition stack underflow" ); 1703 1704 BEGIN(yy_start_stack[yy_start_stack_ptr]); 1705 } 1706#endif 1707 1708 1709#ifndef YY_NO_TOP_STATE 1710static int yy_top_state() 1711 { 1712 return yy_start_stack[yy_start_stack_ptr - 1]; 1713 } 1714#endif 1715 1716#ifndef YY_EXIT_FAILURE 1717#define YY_EXIT_FAILURE 2 1718#endif 1719 1720#ifdef YY_USE_PROTOS 1721static void yy_fatal_error( yyconst char msg[] ) 1722#else 1723static void yy_fatal_error( msg ) 1724char msg[]; 1725#endif 1726 { 1727 (void) fprintf( stderr, "%s\n", msg ); 1728 exit( YY_EXIT_FAILURE ); 1729 } 1730 1731 1732 1733/* Redefine yyless() so it works in section 3 code. */ 1734 1735#undef yyless 1736#define yyless(n) \ 1737 do \ 1738 { \ 1739 /* Undo effects of setting up yytext. */ \ 1740 yytext[yyleng] = yy_hold_char; \ 1741 yy_c_buf_p = yytext + n; \ 1742 yy_hold_char = *yy_c_buf_p; \ 1743 *yy_c_buf_p = '\0'; \ 1744 yyleng = n; \ 1745 } \ 1746 while ( 0 ) 1747 1748 1749/* Internal utility routines. */ 1750 1751#ifndef yytext_ptr 1752#ifdef YY_USE_PROTOS 1753static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1754#else 1755static void yy_flex_strncpy( s1, s2, n ) 1756char *s1; 1757yyconst char *s2; 1758int n; 1759#endif 1760 { 1761 register int i; 1762 for ( i = 0; i < n; ++i ) 1763 s1[i] = s2[i]; 1764 } 1765#endif 1766 1767#ifdef YY_NEED_STRLEN 1768#ifdef YY_USE_PROTOS 1769static int yy_flex_strlen( yyconst char *s ) 1770#else 1771static int yy_flex_strlen( s ) 1772yyconst char *s; 1773#endif 1774 { 1775 register int n; 1776 for ( n = 0; s[n]; ++n ) 1777 ; 1778 1779 return n; 1780 } 1781#endif 1782 1783 1784#ifdef YY_USE_PROTOS 1785static void *yy_flex_alloc( yy_size_t size ) 1786#else 1787static void *yy_flex_alloc( size ) 1788yy_size_t size; 1789#endif 1790 { 1791 return (void *) malloc( size ); 1792 } 1793 1794#ifdef YY_USE_PROTOS 1795static void *yy_flex_realloc( void *ptr, yy_size_t size ) 1796#else 1797static void *yy_flex_realloc( ptr, size ) 1798void *ptr; 1799yy_size_t size; 1800#endif 1801 { 1802 /* The cast to (char *) in the following accommodates both 1803 * implementations that use char* generic pointers, and those 1804 * that use void* generic pointers. It works with the latter 1805 * because both ANSI C and C++ allow castless assignment from 1806 * any pointer type to void*, and deal with argument conversions 1807 * as though doing an assignment. 1808 */ 1809 return (void *) realloc( (char *) ptr, size ); 1810 } 1811 1812#ifdef YY_USE_PROTOS 1813static void yy_flex_free( void *ptr ) 1814#else 1815static void yy_flex_free( ptr ) 1816void *ptr; 1817#endif 1818 { 1819 free( ptr ); 1820 } 1821 1822#if YY_MAIN 1823int main() 1824 { 1825 yylex(); 1826 return 0; 1827 } 1828#endif 1829#line 86 "arlex.l" 1830 1831#ifndef yywrap 1832/* Needed for lex, though not flex. */ 1833int yywrap(void) { return 1; } 1834#endif 1835