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