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