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