Mercurial > vba-clojure
diff src/sdl/expr-lex.cpp @ 28:2efb971df515
bringing in SDL package
| author | Robert McIntyre <rlm@mit.edu> |
|---|---|
| date | Sun, 04 Mar 2012 21:06:50 -0600 |
| parents | f9f4f1b99eed |
| children |
line wrap: on
line diff
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/src/sdl/expr-lex.cpp Sun Mar 04 21:06:50 2012 -0600 1.3 @@ -0,0 +1,1590 @@ 1.4 +#line 2 "expr-lex.cpp" 1.5 +/* A lexical scanner generated by flex */ 1.6 + 1.7 +/* Scanner skeleton version: 1.8 + * $Header: /cvsroot/vba/VisualBoyAdvance/src/expr-lex.cpp,v 1.2 2003/06/06 14:17:21 forgotten Exp $ 1.9 + */ 1.10 + 1.11 +#define FLEX_SCANNER 1.12 +#define YY_FLEX_MAJOR_VERSION 2 1.13 +#define YY_FLEX_MINOR_VERSION 5 1.14 + 1.15 +#include <stdio.h> 1.16 +#ifdef __GNUC__ 1.17 +#include <unistd.h> 1.18 +#endif 1.19 + 1.20 + 1.21 +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 1.22 +#ifdef c_plusplus 1.23 +#ifndef __cplusplus 1.24 +#define __cplusplus 1.25 +#endif 1.26 +#endif 1.27 + 1.28 + 1.29 +#ifdef __cplusplus 1.30 + 1.31 +#include <stdlib.h> 1.32 + 1.33 +/* Use prototypes in function declarations. */ 1.34 +#define YY_USE_PROTOS 1.35 + 1.36 +/* The "const" storage-class-modifier is valid. */ 1.37 +#define YY_USE_CONST 1.38 + 1.39 +#else /* ! __cplusplus */ 1.40 + 1.41 +#if __STDC__ 1.42 + 1.43 +#define YY_USE_PROTOS 1.44 +#define YY_USE_CONST 1.45 + 1.46 +#endif /* __STDC__ */ 1.47 +#endif /* ! __cplusplus */ 1.48 + 1.49 +#ifdef __TURBOC__ 1.50 + #pragma warn -rch 1.51 + #pragma warn -use 1.52 +#include <io.h> 1.53 +#include <stdlib.h> 1.54 +#define YY_USE_CONST 1.55 +#define YY_USE_PROTOS 1.56 +#endif 1.57 + 1.58 +#ifdef YY_USE_CONST 1.59 +#define yyconst const 1.60 +#else 1.61 +#define yyconst 1.62 +#endif 1.63 + 1.64 + 1.65 +#ifdef YY_USE_PROTOS 1.66 +#define YY_PROTO(proto) proto 1.67 +#else 1.68 +#define YY_PROTO(proto) () 1.69 +#endif 1.70 + 1.71 +/* Returned upon end-of-file. */ 1.72 +#define YY_NULL 0 1.73 + 1.74 +/* Promotes a possibly negative, possibly signed char to an unsigned 1.75 + * integer for use as an array index. If the signed char is negative, 1.76 + * we want to instead treat it as an 8-bit unsigned char, hence the 1.77 + * double cast. 1.78 + */ 1.79 +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 1.80 + 1.81 +/* Enter a start condition. This macro really ought to take a parameter, 1.82 + * but we do it the disgusting crufty way forced on us by the ()-less 1.83 + * definition of BEGIN. 1.84 + */ 1.85 +#define BEGIN yy_start = 1 + 2 * 1.86 + 1.87 +/* Translate the current start state into a value that can be later handed 1.88 + * to BEGIN to return to the state. The YYSTATE alias is for lex 1.89 + * compatibility. 1.90 + */ 1.91 +#define YY_START ((yy_start - 1) / 2) 1.92 +#define YYSTATE YY_START 1.93 + 1.94 +/* Action number for EOF rule of a given start state. */ 1.95 +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 1.96 + 1.97 +/* Special action meaning "start processing a new file". */ 1.98 +#define YY_NEW_FILE yyrestart( yyin ) 1.99 + 1.100 +#define YY_END_OF_BUFFER_CHAR 0 1.101 + 1.102 +/* Size of default input buffer. */ 1.103 +#define YY_BUF_SIZE 16384 1.104 + 1.105 +typedef struct yy_buffer_state *YY_BUFFER_STATE; 1.106 + 1.107 +extern int yyleng; 1.108 +extern FILE *yyin, *yyout; 1.109 + 1.110 +#define EOB_ACT_CONTINUE_SCAN 0 1.111 +#define EOB_ACT_END_OF_FILE 1 1.112 +#define EOB_ACT_LAST_MATCH 2 1.113 + 1.114 +/* The funky do-while in the following #define is used to turn the definition 1.115 + * int a single C statement (which needs a semi-colon terminator). This 1.116 + * avoids problems with code like: 1.117 + * 1.118 + * if ( condition_holds ) 1.119 + * yyless( 5 ); 1.120 + * else 1.121 + * do_something_else(); 1.122 + * 1.123 + * Prior to using the do-while the compiler would get upset at the 1.124 + * "else" because it interpreted the "if" statement as being all 1.125 + * done when it reached the ';' after the yyless() call. 1.126 + */ 1.127 + 1.128 +/* Return all but the first 'n' matched characters back to the input stream. */ 1.129 + 1.130 +#define yyless(n) \ 1.131 + do \ 1.132 + { \ 1.133 + /* Undo effects of setting up yytext. */ \ 1.134 + *yy_cp = yy_hold_char; \ 1.135 + YY_RESTORE_YY_MORE_OFFSET \ 1.136 + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 1.137 + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 1.138 + } \ 1.139 + while ( 0 ) 1.140 + 1.141 +#define unput(c) yyunput( c, yytext_ptr ) 1.142 + 1.143 +/* The following is because we cannot portably get our hands on size_t 1.144 + * (without autoconf's help, which isn't available because we want 1.145 + * flex-generated scanners to compile on their own). 1.146 + */ 1.147 +typedef unsigned int yy_size_t; 1.148 + 1.149 + 1.150 +struct yy_buffer_state 1.151 + { 1.152 + FILE *yy_input_file; 1.153 + 1.154 + char *yy_ch_buf; /* input buffer */ 1.155 + char *yy_buf_pos; /* current position in input buffer */ 1.156 + 1.157 + /* Size of input buffer in bytes, not including room for EOB 1.158 + * characters. 1.159 + */ 1.160 + yy_size_t yy_buf_size; 1.161 + 1.162 + /* Number of characters read into yy_ch_buf, not including EOB 1.163 + * characters. 1.164 + */ 1.165 + int yy_n_chars; 1.166 + 1.167 + /* Whether we "own" the buffer - i.e., we know we created it, 1.168 + * and can realloc() it to grow it, and should free() it to 1.169 + * delete it. 1.170 + */ 1.171 + int yy_is_our_buffer; 1.172 + 1.173 + /* Whether this is an "interactive" input source; if so, and 1.174 + * if we're using stdio for input, then we want to use getc() 1.175 + * instead of fread(), to make sure we stop fetching input after 1.176 + * each newline. 1.177 + */ 1.178 + int yy_is_interactive; 1.179 + 1.180 + /* Whether we're considered to be at the beginning of a line. 1.181 + * If so, '^' rules will be active on the next match, otherwise 1.182 + * not. 1.183 + */ 1.184 + int yy_at_bol; 1.185 + 1.186 + /* Whether to try to fill the input buffer when we reach the 1.187 + * end of it. 1.188 + */ 1.189 + int yy_fill_buffer; 1.190 + 1.191 + int yy_buffer_status; 1.192 +#define YY_BUFFER_NEW 0 1.193 +#define YY_BUFFER_NORMAL 1 1.194 + /* When an EOF's been seen but there's still some text to process 1.195 + * then we mark the buffer as YY_EOF_PENDING, to indicate that we 1.196 + * shouldn't try reading from the input source any more. We might 1.197 + * still have a bunch of tokens to match, though, because of 1.198 + * possible backing-up. 1.199 + * 1.200 + * When we actually see the EOF, we change the status to "new" 1.201 + * (via yyrestart()), so that the user can continue scanning by 1.202 + * just pointing yyin at a new input file. 1.203 + */ 1.204 +#define YY_BUFFER_EOF_PENDING 2 1.205 + }; 1.206 + 1.207 +static YY_BUFFER_STATE yy_current_buffer = 0; 1.208 + 1.209 +/* We provide macros for accessing buffer states in case in the 1.210 + * future we want to put the buffer states in a more general 1.211 + * "scanner state". 1.212 + */ 1.213 +#define YY_CURRENT_BUFFER yy_current_buffer 1.214 + 1.215 + 1.216 +/* yy_hold_char holds the character lost when yytext is formed. */ 1.217 +static char yy_hold_char; 1.218 + 1.219 +static int yy_n_chars; /* number of characters read into yy_ch_buf */ 1.220 + 1.221 + 1.222 +int yyleng; 1.223 + 1.224 +/* Points to current character in buffer. */ 1.225 +static char *yy_c_buf_p = (char *) 0; 1.226 +static int yy_init = 1; /* whether we need to initialize */ 1.227 +static int yy_start = 0; /* start state number */ 1.228 + 1.229 +/* Flag which is used to allow yywrap()'s to do buffer switches 1.230 + * instead of setting up a fresh yyin. A bit of a hack ... 1.231 + */ 1.232 +static int yy_did_buffer_switch_on_eof; 1.233 + 1.234 +void yyrestart YY_PROTO(( FILE *input_file )); 1.235 + 1.236 +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 1.237 +void yy_load_buffer_state YY_PROTO(( void )); 1.238 +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 1.239 +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 1.240 +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 1.241 +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 1.242 +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 1.243 + 1.244 +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 1.245 +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 1.246 +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 1.247 + 1.248 +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 1.249 +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 1.250 +static void yy_flex_free YY_PROTO(( void * )); 1.251 + 1.252 +#define yy_new_buffer yy_create_buffer 1.253 + 1.254 +#define yy_set_interactive(is_interactive) \ 1.255 + { \ 1.256 + if ( ! yy_current_buffer ) \ 1.257 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 1.258 + yy_current_buffer->yy_is_interactive = is_interactive; \ 1.259 + } 1.260 + 1.261 +#define yy_set_bol(at_bol) \ 1.262 + { \ 1.263 + if ( ! yy_current_buffer ) \ 1.264 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 1.265 + yy_current_buffer->yy_at_bol = at_bol; \ 1.266 + } 1.267 + 1.268 +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 1.269 + 1.270 + 1.271 +#define yywrap() 1 1.272 +#define YY_SKIP_YYWRAP 1.273 +typedef unsigned char YY_CHAR; 1.274 +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 1.275 +typedef int yy_state_type; 1.276 +extern char *yytext; 1.277 +#define yytext_ptr yytext 1.278 + 1.279 +static yy_state_type yy_get_previous_state YY_PROTO(( void )); 1.280 +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 1.281 +static int yy_get_next_buffer YY_PROTO(( void )); 1.282 +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 1.283 + 1.284 +/* Done after the current pattern has been matched and before the 1.285 + * corresponding action - sets up yytext. 1.286 + */ 1.287 +#define YY_DO_BEFORE_ACTION \ 1.288 + yytext_ptr = yy_bp; \ 1.289 + yyleng = (int) (yy_cp - yy_bp); \ 1.290 + yy_hold_char = *yy_cp; \ 1.291 + *yy_cp = '\0'; \ 1.292 + yy_c_buf_p = yy_cp; 1.293 + 1.294 +#define YY_NUM_RULES 10 1.295 +#define YY_END_OF_BUFFER 11 1.296 +static yyconst short int yy_accept[24] = 1.297 + { 0, 1.298 + 0, 0, 11, 9, 8, 8, 6, 7, 9, 4, 1.299 + 3, 2, 2, 8, 5, 3, 2, 2, 2, 2, 1.300 + 2, 1, 0 1.301 + } ; 1.302 + 1.303 +static yyconst int yy_ec[256] = 1.304 + { 0, 1.305 + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1.306 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.307 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.308 + 1, 2, 1, 1, 1, 1, 1, 4, 1, 1, 1.309 + 1, 5, 1, 1, 6, 7, 1, 8, 8, 8, 1.310 + 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1.311 + 1, 9, 1, 1, 10, 10, 10, 10, 10, 10, 1.312 + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1.313 + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1.314 + 1, 1, 1, 1, 10, 1, 10, 10, 10, 10, 1.315 + 1.316 + 11, 12, 10, 10, 13, 10, 10, 10, 10, 10, 1.317 + 14, 10, 10, 10, 15, 10, 10, 10, 10, 10, 1.318 + 10, 16, 1, 1, 1, 1, 1, 1, 1, 1, 1.319 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.320 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.321 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.322 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.323 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.324 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.325 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.326 + 1.327 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.328 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.329 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.330 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.331 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.332 + 1, 1, 1, 1, 1 1.333 + } ; 1.334 + 1.335 +static yyconst int yy_meta[17] = 1.336 + { 0, 1.337 + 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1.338 + 2, 2, 2, 2, 2, 2 1.339 + } ; 1.340 + 1.341 +static yyconst short int yy_base[25] = 1.342 + { 0, 1.343 + 0, 0, 32, 33, 15, 17, 33, 33, 22, 33, 1.344 + 22, 0, 16, 19, 33, 20, 0, 11, 15, 11, 1.345 + 12, 0, 33, 21 1.346 + } ; 1.347 + 1.348 +static yyconst short int yy_def[25] = 1.349 + { 0, 1.350 + 23, 1, 23, 23, 23, 23, 23, 23, 23, 23, 1.351 + 23, 24, 24, 23, 23, 23, 24, 24, 24, 24, 1.352 + 24, 24, 0, 23 1.353 + } ; 1.354 + 1.355 +static yyconst short int yy_nxt[50] = 1.356 + { 0, 1.357 + 4, 5, 6, 7, 8, 9, 10, 11, 4, 12, 1.358 + 12, 12, 12, 12, 13, 12, 14, 14, 14, 14, 1.359 + 14, 14, 17, 22, 21, 20, 19, 16, 18, 16, 1.360 + 15, 23, 3, 23, 23, 23, 23, 23, 23, 23, 1.361 + 23, 23, 23, 23, 23, 23, 23, 23, 23 1.362 + } ; 1.363 + 1.364 +static yyconst short int yy_chk[50] = 1.365 + { 0, 1.366 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.367 + 1, 1, 1, 1, 1, 1, 5, 5, 6, 6, 1.368 + 14, 14, 24, 21, 20, 19, 18, 16, 13, 11, 1.369 + 9, 3, 23, 23, 23, 23, 23, 23, 23, 23, 1.370 + 23, 23, 23, 23, 23, 23, 23, 23, 23 1.371 + } ; 1.372 + 1.373 +static yy_state_type yy_last_accepting_state; 1.374 +static char *yy_last_accepting_cpos; 1.375 + 1.376 +/* The intent behind this definition is that it'll catch 1.377 + * any uses of REJECT which flex missed. 1.378 + */ 1.379 +#define REJECT reject_used_but_not_detected 1.380 +#define yymore() yymore_used_but_not_detected 1.381 +#define YY_MORE_ADJ 0 1.382 +#define YY_RESTORE_YY_MORE_OFFSET 1.383 +char *yytext; 1.384 +#line 1 "expr.l" 1.385 +#define INITIAL 0 1.386 +#line 2 "expr.l" 1.387 +#include "expr.cpp.h" 1.388 + 1.389 +#ifndef __GNUC__ 1.390 +#include <io.h> 1.391 +#define isatty _isatty 1.392 +#endif 1.393 + 1.394 +char *exprString; 1.395 +int exprCol; 1.396 + 1.397 +#define YY_INPUT(buf,result,max_size) \ 1.398 + { \ 1.399 + int c = *exprString++; \ 1.400 + exprCol++;\ 1.401 + result = (c == 0) ? YY_NULL : (buf[0] = c, 1); \ 1.402 + } 1.403 +#define YY_MAIN 0 1.404 +#line 400 "expr-lex.cpp" 1.405 + 1.406 +/* Macros after this point can all be overridden by user definitions in 1.407 + * section 1. 1.408 + */ 1.409 + 1.410 +#ifndef YY_SKIP_YYWRAP 1.411 +#ifdef __cplusplus 1.412 +extern "C" int yywrap YY_PROTO(( void )); 1.413 +#else 1.414 +extern int yywrap YY_PROTO(( void )); 1.415 +#endif 1.416 +#endif 1.417 + 1.418 +#ifndef YY_NO_UNPUT 1.419 +static void yyunput YY_PROTO(( int c, char *buf_ptr )); 1.420 +#endif 1.421 + 1.422 +#ifndef yytext_ptr 1.423 +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 1.424 +#endif 1.425 + 1.426 +#ifdef YY_NEED_STRLEN 1.427 +static int yy_flex_strlen YY_PROTO(( yyconst char * )); 1.428 +#endif 1.429 + 1.430 +#ifndef YY_NO_INPUT 1.431 +#ifdef __cplusplus 1.432 +static int yyinput YY_PROTO(( void )); 1.433 +#else 1.434 +static int input YY_PROTO(( void )); 1.435 +#endif 1.436 +#endif 1.437 + 1.438 +#if YY_STACK_USED 1.439 +static int yy_start_stack_ptr = 0; 1.440 +static int yy_start_stack_depth = 0; 1.441 +static int *yy_start_stack = 0; 1.442 +#ifndef YY_NO_PUSH_STATE 1.443 +static void yy_push_state YY_PROTO(( int new_state )); 1.444 +#endif 1.445 +#ifndef YY_NO_POP_STATE 1.446 +static void yy_pop_state YY_PROTO(( void )); 1.447 +#endif 1.448 +#ifndef YY_NO_TOP_STATE 1.449 +static int yy_top_state YY_PROTO(( void )); 1.450 +#endif 1.451 + 1.452 +#else 1.453 +#define YY_NO_PUSH_STATE 1 1.454 +#define YY_NO_POP_STATE 1 1.455 +#define YY_NO_TOP_STATE 1 1.456 +#endif 1.457 + 1.458 +#ifdef YY_MALLOC_DECL 1.459 +YY_MALLOC_DECL 1.460 +#else 1.461 +#if __STDC__ 1.462 +#ifndef __cplusplus 1.463 +#include <stdlib.h> 1.464 +#endif 1.465 +#else 1.466 +/* Just try to get by without declaring the routines. This will fail 1.467 + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 1.468 + * or sizeof(void*) != sizeof(int). 1.469 + */ 1.470 +#endif 1.471 +#endif 1.472 + 1.473 +/* Amount of stuff to slurp up with each read. */ 1.474 +#ifndef YY_READ_BUF_SIZE 1.475 +#define YY_READ_BUF_SIZE 8192 1.476 +#endif 1.477 + 1.478 +/* Copy whatever the last rule matched to the standard output. */ 1.479 + 1.480 +#ifndef ECHO 1.481 +/* This used to be an fputs(), but since the string might contain NUL's, 1.482 + * we now use fwrite(). 1.483 + */ 1.484 +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 1.485 +#endif 1.486 + 1.487 +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 1.488 + * is returned in "result". 1.489 + */ 1.490 +#ifndef YY_INPUT 1.491 +#define YY_INPUT(buf,result,max_size) \ 1.492 + if ( yy_current_buffer->yy_is_interactive ) \ 1.493 + { \ 1.494 + int c = '*', n; \ 1.495 + for ( n = 0; n < max_size && \ 1.496 + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 1.497 + buf[n] = (char) c; \ 1.498 + if ( c == '\n' ) \ 1.499 + buf[n++] = (char) c; \ 1.500 + if ( c == EOF && ferror( yyin ) ) \ 1.501 + YY_FATAL_ERROR( "input in flex scanner failed" ); \ 1.502 + result = n; \ 1.503 + } \ 1.504 + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 1.505 + && ferror( yyin ) ) \ 1.506 + YY_FATAL_ERROR( "input in flex scanner failed" ); 1.507 +#endif 1.508 + 1.509 +/* No semi-colon after return; correct usage is to write "yyterminate();" - 1.510 + * we don't want an extra ';' after the "return" because that will cause 1.511 + * some compilers to complain about unreachable statements. 1.512 + */ 1.513 +#ifndef yyterminate 1.514 +#define yyterminate() return YY_NULL 1.515 +#endif 1.516 + 1.517 +/* Number of entries by which start-condition stack grows. */ 1.518 +#ifndef YY_START_STACK_INCR 1.519 +#define YY_START_STACK_INCR 25 1.520 +#endif 1.521 + 1.522 +/* Report a fatal error. */ 1.523 +#ifndef YY_FATAL_ERROR 1.524 +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 1.525 +#endif 1.526 + 1.527 +/* Default declaration of generated scanner - a define so the user can 1.528 + * easily add parameters. 1.529 + */ 1.530 +#ifndef YY_DECL 1.531 +#define YY_DECL int yylex YY_PROTO(( void )) 1.532 +#endif 1.533 + 1.534 +/* Code executed at the beginning of each rule, after yytext and yyleng 1.535 + * have been set up. 1.536 + */ 1.537 +#ifndef YY_USER_ACTION 1.538 +#define YY_USER_ACTION 1.539 +#endif 1.540 + 1.541 +/* Code executed at the end of each rule. */ 1.542 +#ifndef YY_BREAK 1.543 +#define YY_BREAK break; 1.544 +#endif 1.545 + 1.546 +#define YY_RULE_SETUP \ 1.547 + YY_USER_ACTION 1.548 + 1.549 +YY_DECL 1.550 + { 1.551 + register yy_state_type yy_current_state; 1.552 + register char *yy_cp = NULL, *yy_bp = NULL; 1.553 + register int yy_act; 1.554 + 1.555 +#line 31 "expr.l" 1.556 + 1.557 + 1.558 +#line 554 "expr-lex.cpp" 1.559 + 1.560 + if ( yy_init ) 1.561 + { 1.562 + yy_init = 0; 1.563 + 1.564 +#ifdef YY_USER_INIT 1.565 + YY_USER_INIT; 1.566 +#endif 1.567 + 1.568 + if ( ! yy_start ) 1.569 + yy_start = 1; /* first start state */ 1.570 + 1.571 + if ( ! yyin ) 1.572 + yyin = stdin; 1.573 + 1.574 + if ( ! yyout ) 1.575 + yyout = stdout; 1.576 + 1.577 + if ( ! yy_current_buffer ) 1.578 + yy_current_buffer = 1.579 + yy_create_buffer( yyin, YY_BUF_SIZE ); 1.580 + 1.581 + yy_load_buffer_state(); 1.582 + } 1.583 + 1.584 + while ( 1 ) /* loops until end-of-file is reached */ 1.585 + { 1.586 + yy_cp = yy_c_buf_p; 1.587 + 1.588 + /* Support of yytext. */ 1.589 + *yy_cp = yy_hold_char; 1.590 + 1.591 + /* yy_bp points to the position in yy_ch_buf of the start of 1.592 + * the current run. 1.593 + */ 1.594 + yy_bp = yy_cp; 1.595 + 1.596 + yy_current_state = yy_start; 1.597 +yy_match: 1.598 + do 1.599 + { 1.600 + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 1.601 + if ( yy_accept[yy_current_state] ) 1.602 + { 1.603 + yy_last_accepting_state = yy_current_state; 1.604 + yy_last_accepting_cpos = yy_cp; 1.605 + } 1.606 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1.607 + { 1.608 + yy_current_state = (int) yy_def[yy_current_state]; 1.609 + if ( yy_current_state >= 24 ) 1.610 + yy_c = yy_meta[(unsigned int) yy_c]; 1.611 + } 1.612 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1.613 + ++yy_cp; 1.614 + } 1.615 + while ( yy_base[yy_current_state] != 33 ); 1.616 + 1.617 +yy_find_action: 1.618 + yy_act = yy_accept[yy_current_state]; 1.619 + if ( yy_act == 0 ) 1.620 + { /* have to back up */ 1.621 + yy_cp = yy_last_accepting_cpos; 1.622 + yy_current_state = yy_last_accepting_state; 1.623 + yy_act = yy_accept[yy_current_state]; 1.624 + } 1.625 + 1.626 + YY_DO_BEFORE_ACTION; 1.627 + 1.628 + 1.629 +do_action: /* This label is used only to access EOF actions. */ 1.630 + 1.631 + 1.632 + switch ( yy_act ) 1.633 + { /* beginning of action switch */ 1.634 + case 0: /* must back up */ 1.635 + /* undo the effects of YY_DO_BEFORE_ACTION */ 1.636 + *yy_cp = yy_hold_char; 1.637 + yy_cp = yy_last_accepting_cpos; 1.638 + yy_current_state = yy_last_accepting_state; 1.639 + goto yy_find_action; 1.640 + 1.641 +case 1: 1.642 +YY_RULE_SETUP 1.643 +#line 33 "expr.l" 1.644 +{ 1.645 + return TOKEN_SIZEOF; 1.646 +} 1.647 + YY_BREAK 1.648 +case 2: 1.649 +YY_RULE_SETUP 1.650 +#line 37 "expr.l" 1.651 +{ 1.652 + return TOKEN_IDENTIFIER; 1.653 +} 1.654 + YY_BREAK 1.655 +case 3: 1.656 +YY_RULE_SETUP 1.657 +#line 41 "expr.l" 1.658 +{ 1.659 + return TOKEN_NUMBER; 1.660 +} 1.661 + YY_BREAK 1.662 +case 4: 1.663 +YY_RULE_SETUP 1.664 +#line 45 "expr.l" 1.665 +{ 1.666 + return TOKEN_DOT; 1.667 +} 1.668 + YY_BREAK 1.669 +case 5: 1.670 +YY_RULE_SETUP 1.671 +#line 49 "expr.l" 1.672 +{ 1.673 + return TOKEN_ARROW; 1.674 +} 1.675 + YY_BREAK 1.676 +case 6: 1.677 +YY_RULE_SETUP 1.678 +#line 53 "expr.l" 1.679 +{ 1.680 + return TOKEN_ADDR; 1.681 +} 1.682 + YY_BREAK 1.683 +case 7: 1.684 +YY_RULE_SETUP 1.685 +#line 57 "expr.l" 1.686 +{ 1.687 + return TOKEN_STAR; 1.688 +} 1.689 + YY_BREAK 1.690 +case 8: 1.691 +YY_RULE_SETUP 1.692 +#line 61 "expr.l" 1.693 + 1.694 + YY_BREAK 1.695 +case 9: 1.696 +YY_RULE_SETUP 1.697 +#line 63 "expr.l" 1.698 +return *yytext; 1.699 + YY_BREAK 1.700 +case 10: 1.701 +YY_RULE_SETUP 1.702 +#line 65 "expr.l" 1.703 +ECHO; 1.704 + YY_BREAK 1.705 +#line 701 "expr-lex.cpp" 1.706 +case YY_STATE_EOF(INITIAL): 1.707 + yyterminate(); 1.708 + 1.709 + case YY_END_OF_BUFFER: 1.710 + { 1.711 + /* Amount of text matched not including the EOB char. */ 1.712 + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1.713 + 1.714 + /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1.715 + *yy_cp = yy_hold_char; 1.716 + YY_RESTORE_YY_MORE_OFFSET 1.717 + 1.718 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1.719 + { 1.720 + /* We're scanning a new file or input source. It's 1.721 + * possible that this happened because the user 1.722 + * just pointed yyin at a new source and called 1.723 + * yylex(). If so, then we have to assure 1.724 + * consistency between yy_current_buffer and our 1.725 + * globals. Here is the right place to do so, because 1.726 + * this is the first action (other than possibly a 1.727 + * back-up) that will match for the new input source. 1.728 + */ 1.729 + yy_n_chars = yy_current_buffer->yy_n_chars; 1.730 + yy_current_buffer->yy_input_file = yyin; 1.731 + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1.732 + } 1.733 + 1.734 + /* Note that here we test for yy_c_buf_p "<=" to the position 1.735 + * of the first EOB in the buffer, since yy_c_buf_p will 1.736 + * already have been incremented past the NUL character 1.737 + * (since all states make transitions on EOB to the 1.738 + * end-of-buffer state). Contrast this with the test 1.739 + * in input(). 1.740 + */ 1.741 + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1.742 + { /* This was really a NUL. */ 1.743 + yy_state_type yy_next_state; 1.744 + 1.745 + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1.746 + 1.747 + yy_current_state = yy_get_previous_state(); 1.748 + 1.749 + /* Okay, we're now positioned to make the NUL 1.750 + * transition. We couldn't have 1.751 + * yy_get_previous_state() go ahead and do it 1.752 + * for us because it doesn't know how to deal 1.753 + * with the possibility of jamming (and we don't 1.754 + * want to build jamming into it because then it 1.755 + * will run more slowly). 1.756 + */ 1.757 + 1.758 + yy_next_state = yy_try_NUL_trans( yy_current_state ); 1.759 + 1.760 + yy_bp = yytext_ptr + YY_MORE_ADJ; 1.761 + 1.762 + if ( yy_next_state ) 1.763 + { 1.764 + /* Consume the NUL. */ 1.765 + yy_cp = ++yy_c_buf_p; 1.766 + yy_current_state = yy_next_state; 1.767 + goto yy_match; 1.768 + } 1.769 + 1.770 + else 1.771 + { 1.772 + yy_cp = yy_c_buf_p; 1.773 + goto yy_find_action; 1.774 + } 1.775 + } 1.776 + 1.777 + else switch ( yy_get_next_buffer() ) 1.778 + { 1.779 + case EOB_ACT_END_OF_FILE: 1.780 + { 1.781 + yy_did_buffer_switch_on_eof = 0; 1.782 + 1.783 + if ( yywrap() ) 1.784 + { 1.785 + /* Note: because we've taken care in 1.786 + * yy_get_next_buffer() to have set up 1.787 + * yytext, we can now set up 1.788 + * yy_c_buf_p so that if some total 1.789 + * hoser (like flex itself) wants to 1.790 + * call the scanner after we return the 1.791 + * YY_NULL, it'll still work - another 1.792 + * YY_NULL will get returned. 1.793 + */ 1.794 + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1.795 + 1.796 + yy_act = YY_STATE_EOF(YY_START); 1.797 + goto do_action; 1.798 + } 1.799 + 1.800 + else 1.801 + { 1.802 + if ( ! yy_did_buffer_switch_on_eof ) 1.803 + YY_NEW_FILE; 1.804 + } 1.805 + break; 1.806 + } 1.807 + 1.808 + case EOB_ACT_CONTINUE_SCAN: 1.809 + yy_c_buf_p = 1.810 + yytext_ptr + yy_amount_of_matched_text; 1.811 + 1.812 + yy_current_state = yy_get_previous_state(); 1.813 + 1.814 + yy_cp = yy_c_buf_p; 1.815 + yy_bp = yytext_ptr + YY_MORE_ADJ; 1.816 + goto yy_match; 1.817 + 1.818 + case EOB_ACT_LAST_MATCH: 1.819 + yy_c_buf_p = 1.820 + &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1.821 + 1.822 + yy_current_state = yy_get_previous_state(); 1.823 + 1.824 + yy_cp = yy_c_buf_p; 1.825 + yy_bp = yytext_ptr + YY_MORE_ADJ; 1.826 + goto yy_find_action; 1.827 + } 1.828 + break; 1.829 + } 1.830 + 1.831 + default: 1.832 + YY_FATAL_ERROR( 1.833 + "fatal flex scanner internal error--no action found" ); 1.834 + } /* end of action switch */ 1.835 + } /* end of scanning one token */ 1.836 + } /* end of yylex */ 1.837 + 1.838 + 1.839 +/* yy_get_next_buffer - try to read in a new buffer 1.840 + * 1.841 + * Returns a code representing an action: 1.842 + * EOB_ACT_LAST_MATCH - 1.843 + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1.844 + * EOB_ACT_END_OF_FILE - end of file 1.845 + */ 1.846 + 1.847 +static int yy_get_next_buffer() 1.848 + { 1.849 + register char *dest = yy_current_buffer->yy_ch_buf; 1.850 + register char *source = yytext_ptr; 1.851 + register int number_to_move, i; 1.852 + int ret_val; 1.853 + 1.854 + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1.855 + YY_FATAL_ERROR( 1.856 + "fatal flex scanner internal error--end of buffer missed" ); 1.857 + 1.858 + if ( yy_current_buffer->yy_fill_buffer == 0 ) 1.859 + { /* Don't try to fill the buffer, so this is an EOF. */ 1.860 + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1.861 + { 1.862 + /* We matched a single character, the EOB, so 1.863 + * treat this as a final EOF. 1.864 + */ 1.865 + return EOB_ACT_END_OF_FILE; 1.866 + } 1.867 + 1.868 + else 1.869 + { 1.870 + /* We matched some text prior to the EOB, first 1.871 + * process it. 1.872 + */ 1.873 + return EOB_ACT_LAST_MATCH; 1.874 + } 1.875 + } 1.876 + 1.877 + /* Try to read more data. */ 1.878 + 1.879 + /* First move last chars to start of buffer. */ 1.880 + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1.881 + 1.882 + for ( i = 0; i < number_to_move; ++i ) 1.883 + *(dest++) = *(source++); 1.884 + 1.885 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1.886 + /* don't do the read, it's not guaranteed to return an EOF, 1.887 + * just force an EOF 1.888 + */ 1.889 + yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1.890 + 1.891 + else 1.892 + { 1.893 + int num_to_read = 1.894 + yy_current_buffer->yy_buf_size - number_to_move - 1; 1.895 + 1.896 + while ( num_to_read <= 0 ) 1.897 + { /* Not enough room in the buffer - grow it. */ 1.898 +#ifdef YY_USES_REJECT 1.899 + YY_FATAL_ERROR( 1.900 +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1.901 +#else 1.902 + 1.903 + /* just a shorter name for the current buffer */ 1.904 + YY_BUFFER_STATE b = yy_current_buffer; 1.905 + 1.906 + int yy_c_buf_p_offset = 1.907 + (int) (yy_c_buf_p - b->yy_ch_buf); 1.908 + 1.909 + if ( b->yy_is_our_buffer ) 1.910 + { 1.911 + int new_size = b->yy_buf_size * 2; 1.912 + 1.913 + if ( new_size <= 0 ) 1.914 + b->yy_buf_size += b->yy_buf_size / 8; 1.915 + else 1.916 + b->yy_buf_size *= 2; 1.917 + 1.918 + b->yy_ch_buf = (char *) 1.919 + /* Include room in for 2 EOB chars. */ 1.920 + yy_flex_realloc( (void *) b->yy_ch_buf, 1.921 + b->yy_buf_size + 2 ); 1.922 + } 1.923 + else 1.924 + /* Can't grow it, we don't own it. */ 1.925 + b->yy_ch_buf = 0; 1.926 + 1.927 + if ( ! b->yy_ch_buf ) 1.928 + YY_FATAL_ERROR( 1.929 + "fatal error - scanner input buffer overflow" ); 1.930 + 1.931 + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1.932 + 1.933 + num_to_read = yy_current_buffer->yy_buf_size - 1.934 + number_to_move - 1; 1.935 +#endif 1.936 + } 1.937 + 1.938 + if ( num_to_read > YY_READ_BUF_SIZE ) 1.939 + num_to_read = YY_READ_BUF_SIZE; 1.940 + 1.941 + /* Read in more data. */ 1.942 + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1.943 + yy_n_chars, num_to_read ); 1.944 + 1.945 + yy_current_buffer->yy_n_chars = yy_n_chars; 1.946 + } 1.947 + 1.948 + if ( yy_n_chars == 0 ) 1.949 + { 1.950 + if ( number_to_move == YY_MORE_ADJ ) 1.951 + { 1.952 + ret_val = EOB_ACT_END_OF_FILE; 1.953 + yyrestart( yyin ); 1.954 + } 1.955 + 1.956 + else 1.957 + { 1.958 + ret_val = EOB_ACT_LAST_MATCH; 1.959 + yy_current_buffer->yy_buffer_status = 1.960 + YY_BUFFER_EOF_PENDING; 1.961 + } 1.962 + } 1.963 + 1.964 + else 1.965 + ret_val = EOB_ACT_CONTINUE_SCAN; 1.966 + 1.967 + yy_n_chars += number_to_move; 1.968 + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1.969 + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1.970 + 1.971 + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1.972 + 1.973 + return ret_val; 1.974 + } 1.975 + 1.976 + 1.977 +/* yy_get_previous_state - get the state just before the EOB char was reached */ 1.978 + 1.979 +static yy_state_type yy_get_previous_state() 1.980 + { 1.981 + register yy_state_type yy_current_state; 1.982 + register char *yy_cp; 1.983 + 1.984 + yy_current_state = yy_start; 1.985 + 1.986 + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1.987 + { 1.988 + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1.989 + if ( yy_accept[yy_current_state] ) 1.990 + { 1.991 + yy_last_accepting_state = yy_current_state; 1.992 + yy_last_accepting_cpos = yy_cp; 1.993 + } 1.994 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1.995 + { 1.996 + yy_current_state = (int) yy_def[yy_current_state]; 1.997 + if ( yy_current_state >= 24 ) 1.998 + yy_c = yy_meta[(unsigned int) yy_c]; 1.999 + } 1.1000 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1.1001 + } 1.1002 + 1.1003 + return yy_current_state; 1.1004 + } 1.1005 + 1.1006 + 1.1007 +/* yy_try_NUL_trans - try to make a transition on the NUL character 1.1008 + * 1.1009 + * synopsis 1.1010 + * next_state = yy_try_NUL_trans( current_state ); 1.1011 + */ 1.1012 + 1.1013 +#ifdef YY_USE_PROTOS 1.1014 +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1.1015 +#else 1.1016 +static yy_state_type yy_try_NUL_trans( yy_current_state ) 1.1017 +yy_state_type yy_current_state; 1.1018 +#endif 1.1019 + { 1.1020 + register int yy_is_jam; 1.1021 + register char *yy_cp = yy_c_buf_p; 1.1022 + 1.1023 + register YY_CHAR yy_c = 1; 1.1024 + if ( yy_accept[yy_current_state] ) 1.1025 + { 1.1026 + yy_last_accepting_state = yy_current_state; 1.1027 + yy_last_accepting_cpos = yy_cp; 1.1028 + } 1.1029 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1.1030 + { 1.1031 + yy_current_state = (int) yy_def[yy_current_state]; 1.1032 + if ( yy_current_state >= 24 ) 1.1033 + yy_c = yy_meta[(unsigned int) yy_c]; 1.1034 + } 1.1035 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1.1036 + yy_is_jam = (yy_current_state == 23); 1.1037 + 1.1038 + return yy_is_jam ? 0 : yy_current_state; 1.1039 + } 1.1040 + 1.1041 + 1.1042 +#ifndef YY_NO_UNPUT 1.1043 +#ifdef YY_USE_PROTOS 1.1044 +static void yyunput( int c, register char *yy_bp ) 1.1045 +#else 1.1046 +static void yyunput( c, yy_bp ) 1.1047 +int c; 1.1048 +register char *yy_bp; 1.1049 +#endif 1.1050 + { 1.1051 + register char *yy_cp = yy_c_buf_p; 1.1052 + 1.1053 + /* undo effects of setting up yytext */ 1.1054 + *yy_cp = yy_hold_char; 1.1055 + 1.1056 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1.1057 + { /* need to shift things up to make room */ 1.1058 + /* +2 for EOB chars. */ 1.1059 + register int number_to_move = yy_n_chars + 2; 1.1060 + register char *dest = &yy_current_buffer->yy_ch_buf[ 1.1061 + yy_current_buffer->yy_buf_size + 2]; 1.1062 + register char *source = 1.1063 + &yy_current_buffer->yy_ch_buf[number_to_move]; 1.1064 + 1.1065 + while ( source > yy_current_buffer->yy_ch_buf ) 1.1066 + *--dest = *--source; 1.1067 + 1.1068 + yy_cp += (int) (dest - source); 1.1069 + yy_bp += (int) (dest - source); 1.1070 + yy_current_buffer->yy_n_chars = 1.1071 + yy_n_chars = yy_current_buffer->yy_buf_size; 1.1072 + 1.1073 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1.1074 + YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1.1075 + } 1.1076 + 1.1077 + *--yy_cp = (char) c; 1.1078 + 1.1079 + 1.1080 + yytext_ptr = yy_bp; 1.1081 + yy_hold_char = *yy_cp; 1.1082 + yy_c_buf_p = yy_cp; 1.1083 + } 1.1084 +#endif /* ifndef YY_NO_UNPUT */ 1.1085 + 1.1086 + 1.1087 +#ifdef __cplusplus 1.1088 +static int yyinput() 1.1089 +#else 1.1090 +static int input() 1.1091 +#endif 1.1092 + { 1.1093 + int c; 1.1094 + 1.1095 + *yy_c_buf_p = yy_hold_char; 1.1096 + 1.1097 + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1.1098 + { 1.1099 + /* yy_c_buf_p now points to the character we want to return. 1.1100 + * If this occurs *before* the EOB characters, then it's a 1.1101 + * valid NUL; if not, then we've hit the end of the buffer. 1.1102 + */ 1.1103 + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1.1104 + /* This was really a NUL. */ 1.1105 + *yy_c_buf_p = '\0'; 1.1106 + 1.1107 + else 1.1108 + { /* need more input */ 1.1109 + int offset = yy_c_buf_p - yytext_ptr; 1.1110 + ++yy_c_buf_p; 1.1111 + 1.1112 + switch ( yy_get_next_buffer() ) 1.1113 + { 1.1114 + case EOB_ACT_LAST_MATCH: 1.1115 + /* This happens because yy_g_n_b() 1.1116 + * sees that we've accumulated a 1.1117 + * token and flags that we need to 1.1118 + * try matching the token before 1.1119 + * proceeding. But for input(), 1.1120 + * there's no matching to consider. 1.1121 + * So convert the EOB_ACT_LAST_MATCH 1.1122 + * to EOB_ACT_END_OF_FILE. 1.1123 + */ 1.1124 + 1.1125 + /* Reset buffer status. */ 1.1126 + yyrestart( yyin ); 1.1127 + 1.1128 + /* fall through */ 1.1129 + 1.1130 + case EOB_ACT_END_OF_FILE: 1.1131 + { 1.1132 + if ( yywrap() ) 1.1133 + return EOF; 1.1134 + 1.1135 + if ( ! yy_did_buffer_switch_on_eof ) 1.1136 + YY_NEW_FILE; 1.1137 +#ifdef __cplusplus 1.1138 + return yyinput(); 1.1139 +#else 1.1140 + return input(); 1.1141 +#endif 1.1142 + } 1.1143 + 1.1144 + case EOB_ACT_CONTINUE_SCAN: 1.1145 + yy_c_buf_p = yytext_ptr + offset; 1.1146 + break; 1.1147 + } 1.1148 + } 1.1149 + } 1.1150 + 1.1151 + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1.1152 + *yy_c_buf_p = '\0'; /* preserve yytext */ 1.1153 + yy_hold_char = *++yy_c_buf_p; 1.1154 + 1.1155 + 1.1156 + return c; 1.1157 + } 1.1158 + 1.1159 + 1.1160 +#ifdef YY_USE_PROTOS 1.1161 +void yyrestart( FILE *input_file ) 1.1162 +#else 1.1163 +void yyrestart( input_file ) 1.1164 +FILE *input_file; 1.1165 +#endif 1.1166 + { 1.1167 + if ( ! yy_current_buffer ) 1.1168 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1.1169 + 1.1170 + yy_init_buffer( yy_current_buffer, input_file ); 1.1171 + yy_load_buffer_state(); 1.1172 + } 1.1173 + 1.1174 + 1.1175 +#ifdef YY_USE_PROTOS 1.1176 +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1.1177 +#else 1.1178 +void yy_switch_to_buffer( new_buffer ) 1.1179 +YY_BUFFER_STATE new_buffer; 1.1180 +#endif 1.1181 + { 1.1182 + if ( yy_current_buffer == new_buffer ) 1.1183 + return; 1.1184 + 1.1185 + if ( yy_current_buffer ) 1.1186 + { 1.1187 + /* Flush out information for old buffer. */ 1.1188 + *yy_c_buf_p = yy_hold_char; 1.1189 + yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1.1190 + yy_current_buffer->yy_n_chars = yy_n_chars; 1.1191 + } 1.1192 + 1.1193 + yy_current_buffer = new_buffer; 1.1194 + yy_load_buffer_state(); 1.1195 + 1.1196 + /* We don't actually know whether we did this switch during 1.1197 + * EOF (yywrap()) processing, but the only time this flag 1.1198 + * is looked at is after yywrap() is called, so it's safe 1.1199 + * to go ahead and always set it. 1.1200 + */ 1.1201 + yy_did_buffer_switch_on_eof = 1; 1.1202 + } 1.1203 + 1.1204 + 1.1205 +#ifdef YY_USE_PROTOS 1.1206 +void yy_load_buffer_state( void ) 1.1207 +#else 1.1208 +void yy_load_buffer_state() 1.1209 +#endif 1.1210 + { 1.1211 + yy_n_chars = yy_current_buffer->yy_n_chars; 1.1212 + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1.1213 + yyin = yy_current_buffer->yy_input_file; 1.1214 + yy_hold_char = *yy_c_buf_p; 1.1215 + } 1.1216 + 1.1217 + 1.1218 +#ifdef YY_USE_PROTOS 1.1219 +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1.1220 +#else 1.1221 +YY_BUFFER_STATE yy_create_buffer( file, size ) 1.1222 +FILE *file; 1.1223 +int size; 1.1224 +#endif 1.1225 + { 1.1226 + YY_BUFFER_STATE b; 1.1227 + 1.1228 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1.1229 + if ( ! b ) 1.1230 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1.1231 + 1.1232 + b->yy_buf_size = size; 1.1233 + 1.1234 + /* yy_ch_buf has to be 2 characters longer than the size given because 1.1235 + * we need to put in 2 end-of-buffer characters. 1.1236 + */ 1.1237 + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1.1238 + if ( ! b->yy_ch_buf ) 1.1239 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1.1240 + 1.1241 + b->yy_is_our_buffer = 1; 1.1242 + 1.1243 + yy_init_buffer( b, file ); 1.1244 + 1.1245 + return b; 1.1246 + } 1.1247 + 1.1248 + 1.1249 +#ifdef YY_USE_PROTOS 1.1250 +void yy_delete_buffer( YY_BUFFER_STATE b ) 1.1251 +#else 1.1252 +void yy_delete_buffer( b ) 1.1253 +YY_BUFFER_STATE b; 1.1254 +#endif 1.1255 + { 1.1256 + if ( ! b ) 1.1257 + return; 1.1258 + 1.1259 + if ( b == yy_current_buffer ) 1.1260 + yy_current_buffer = (YY_BUFFER_STATE) 0; 1.1261 + 1.1262 + if ( b->yy_is_our_buffer ) 1.1263 + yy_flex_free( (void *) b->yy_ch_buf ); 1.1264 + 1.1265 + yy_flex_free( (void *) b ); 1.1266 + } 1.1267 + 1.1268 + 1.1269 + 1.1270 +#ifdef YY_USE_PROTOS 1.1271 +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1.1272 +#else 1.1273 +void yy_init_buffer( b, file ) 1.1274 +YY_BUFFER_STATE b; 1.1275 +FILE *file; 1.1276 +#endif 1.1277 + 1.1278 + 1.1279 + { 1.1280 + yy_flush_buffer( b ); 1.1281 + 1.1282 + b->yy_input_file = file; 1.1283 + b->yy_fill_buffer = 1; 1.1284 + 1.1285 +#if YY_ALWAYS_INTERACTIVE 1.1286 + b->yy_is_interactive = 1; 1.1287 +#else 1.1288 +#if YY_NEVER_INTERACTIVE 1.1289 + b->yy_is_interactive = 0; 1.1290 +#else 1.1291 + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1.1292 +#endif 1.1293 +#endif 1.1294 + } 1.1295 + 1.1296 + 1.1297 +#ifdef YY_USE_PROTOS 1.1298 +void yy_flush_buffer( YY_BUFFER_STATE b ) 1.1299 +#else 1.1300 +void yy_flush_buffer( b ) 1.1301 +YY_BUFFER_STATE b; 1.1302 +#endif 1.1303 + 1.1304 + { 1.1305 + if ( ! b ) 1.1306 + return; 1.1307 + 1.1308 + b->yy_n_chars = 0; 1.1309 + 1.1310 + /* We always need two end-of-buffer characters. The first causes 1.1311 + * a transition to the end-of-buffer state. The second causes 1.1312 + * a jam in that state. 1.1313 + */ 1.1314 + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1.1315 + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1.1316 + 1.1317 + b->yy_buf_pos = &b->yy_ch_buf[0]; 1.1318 + 1.1319 + b->yy_at_bol = 1; 1.1320 + b->yy_buffer_status = YY_BUFFER_NEW; 1.1321 + 1.1322 + if ( b == yy_current_buffer ) 1.1323 + yy_load_buffer_state(); 1.1324 + } 1.1325 + 1.1326 + 1.1327 +#ifndef YY_NO_SCAN_BUFFER 1.1328 +#ifdef YY_USE_PROTOS 1.1329 +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1.1330 +#else 1.1331 +YY_BUFFER_STATE yy_scan_buffer( base, size ) 1.1332 +char *base; 1.1333 +yy_size_t size; 1.1334 +#endif 1.1335 + { 1.1336 + YY_BUFFER_STATE b; 1.1337 + 1.1338 + if ( size < 2 || 1.1339 + base[size-2] != YY_END_OF_BUFFER_CHAR || 1.1340 + base[size-1] != YY_END_OF_BUFFER_CHAR ) 1.1341 + /* They forgot to leave room for the EOB's. */ 1.1342 + return 0; 1.1343 + 1.1344 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1.1345 + if ( ! b ) 1.1346 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1.1347 + 1.1348 + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1.1349 + b->yy_buf_pos = b->yy_ch_buf = base; 1.1350 + b->yy_is_our_buffer = 0; 1.1351 + b->yy_input_file = 0; 1.1352 + b->yy_n_chars = b->yy_buf_size; 1.1353 + b->yy_is_interactive = 0; 1.1354 + b->yy_at_bol = 1; 1.1355 + b->yy_fill_buffer = 0; 1.1356 + b->yy_buffer_status = YY_BUFFER_NEW; 1.1357 + 1.1358 + yy_switch_to_buffer( b ); 1.1359 + 1.1360 + return b; 1.1361 + } 1.1362 +#endif 1.1363 + 1.1364 + 1.1365 +#ifndef YY_NO_SCAN_STRING 1.1366 +#ifdef YY_USE_PROTOS 1.1367 +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1.1368 +#else 1.1369 +YY_BUFFER_STATE yy_scan_string( yy_str ) 1.1370 +yyconst char *yy_str; 1.1371 +#endif 1.1372 + { 1.1373 + int len; 1.1374 + for ( len = 0; yy_str[len]; ++len ) 1.1375 + ; 1.1376 + 1.1377 + return yy_scan_bytes( yy_str, len ); 1.1378 + } 1.1379 +#endif 1.1380 + 1.1381 + 1.1382 +#ifndef YY_NO_SCAN_BYTES 1.1383 +#ifdef YY_USE_PROTOS 1.1384 +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1.1385 +#else 1.1386 +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1.1387 +yyconst char *bytes; 1.1388 +int len; 1.1389 +#endif 1.1390 + { 1.1391 + YY_BUFFER_STATE b; 1.1392 + char *buf; 1.1393 + yy_size_t n; 1.1394 + int i; 1.1395 + 1.1396 + /* Get memory for full buffer, including space for trailing EOB's. */ 1.1397 + n = len + 2; 1.1398 + buf = (char *) yy_flex_alloc( n ); 1.1399 + if ( ! buf ) 1.1400 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1.1401 + 1.1402 + for ( i = 0; i < len; ++i ) 1.1403 + buf[i] = bytes[i]; 1.1404 + 1.1405 + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1.1406 + 1.1407 + b = yy_scan_buffer( buf, n ); 1.1408 + if ( ! b ) 1.1409 + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1.1410 + 1.1411 + /* It's okay to grow etc. this buffer, and we should throw it 1.1412 + * away when we're done. 1.1413 + */ 1.1414 + b->yy_is_our_buffer = 1; 1.1415 + 1.1416 + return b; 1.1417 + } 1.1418 +#endif 1.1419 + 1.1420 + 1.1421 +#ifndef YY_NO_PUSH_STATE 1.1422 +#ifdef YY_USE_PROTOS 1.1423 +static void yy_push_state( int new_state ) 1.1424 +#else 1.1425 +static void yy_push_state( new_state ) 1.1426 +int new_state; 1.1427 +#endif 1.1428 + { 1.1429 + if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1.1430 + { 1.1431 + yy_size_t new_size; 1.1432 + 1.1433 + yy_start_stack_depth += YY_START_STACK_INCR; 1.1434 + new_size = yy_start_stack_depth * sizeof( int ); 1.1435 + 1.1436 + if ( ! yy_start_stack ) 1.1437 + yy_start_stack = (int *) yy_flex_alloc( new_size ); 1.1438 + 1.1439 + else 1.1440 + yy_start_stack = (int *) yy_flex_realloc( 1.1441 + (void *) yy_start_stack, new_size ); 1.1442 + 1.1443 + if ( ! yy_start_stack ) 1.1444 + YY_FATAL_ERROR( 1.1445 + "out of memory expanding start-condition stack" ); 1.1446 + } 1.1447 + 1.1448 + yy_start_stack[yy_start_stack_ptr++] = YY_START; 1.1449 + 1.1450 + BEGIN(new_state); 1.1451 + } 1.1452 +#endif 1.1453 + 1.1454 + 1.1455 +#ifndef YY_NO_POP_STATE 1.1456 +static void yy_pop_state() 1.1457 + { 1.1458 + if ( --yy_start_stack_ptr < 0 ) 1.1459 + YY_FATAL_ERROR( "start-condition stack underflow" ); 1.1460 + 1.1461 + BEGIN(yy_start_stack[yy_start_stack_ptr]); 1.1462 + } 1.1463 +#endif 1.1464 + 1.1465 + 1.1466 +#ifndef YY_NO_TOP_STATE 1.1467 +static int yy_top_state() 1.1468 + { 1.1469 + return yy_start_stack[yy_start_stack_ptr - 1]; 1.1470 + } 1.1471 +#endif 1.1472 + 1.1473 +#ifndef YY_EXIT_FAILURE 1.1474 +#define YY_EXIT_FAILURE 2 1.1475 +#endif 1.1476 + 1.1477 +#ifdef YY_USE_PROTOS 1.1478 +static void yy_fatal_error( yyconst char msg[] ) 1.1479 +#else 1.1480 +static void yy_fatal_error( msg ) 1.1481 +char msg[]; 1.1482 +#endif 1.1483 + { 1.1484 + (void) fprintf( stderr, "%s\n", msg ); 1.1485 + exit( YY_EXIT_FAILURE ); 1.1486 + } 1.1487 + 1.1488 + 1.1489 + 1.1490 +/* Redefine yyless() so it works in section 3 code. */ 1.1491 + 1.1492 +#undef yyless 1.1493 +#define yyless(n) \ 1.1494 + do \ 1.1495 + { \ 1.1496 + /* Undo effects of setting up yytext. */ \ 1.1497 + yytext[yyleng] = yy_hold_char; \ 1.1498 + yy_c_buf_p = yytext + n; \ 1.1499 + yy_hold_char = *yy_c_buf_p; \ 1.1500 + *yy_c_buf_p = '\0'; \ 1.1501 + yyleng = n; \ 1.1502 + } \ 1.1503 + while ( 0 ) 1.1504 + 1.1505 + 1.1506 +/* Internal utility routines. */ 1.1507 + 1.1508 +#ifndef yytext_ptr 1.1509 +#ifdef YY_USE_PROTOS 1.1510 +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1.1511 +#else 1.1512 +static void yy_flex_strncpy( s1, s2, n ) 1.1513 +char *s1; 1.1514 +yyconst char *s2; 1.1515 +int n; 1.1516 +#endif 1.1517 + { 1.1518 + register int i; 1.1519 + for ( i = 0; i < n; ++i ) 1.1520 + s1[i] = s2[i]; 1.1521 + } 1.1522 +#endif 1.1523 + 1.1524 +#ifdef YY_NEED_STRLEN 1.1525 +#ifdef YY_USE_PROTOS 1.1526 +static int yy_flex_strlen( yyconst char *s ) 1.1527 +#else 1.1528 +static int yy_flex_strlen( s ) 1.1529 +yyconst char *s; 1.1530 +#endif 1.1531 + { 1.1532 + register int n; 1.1533 + for ( n = 0; s[n]; ++n ) 1.1534 + ; 1.1535 + 1.1536 + return n; 1.1537 + } 1.1538 +#endif 1.1539 + 1.1540 + 1.1541 +#ifdef YY_USE_PROTOS 1.1542 +static void *yy_flex_alloc( yy_size_t size ) 1.1543 +#else 1.1544 +static void *yy_flex_alloc( size ) 1.1545 +yy_size_t size; 1.1546 +#endif 1.1547 + { 1.1548 + return (void *) malloc( size ); 1.1549 + } 1.1550 + 1.1551 +#ifdef YY_USE_PROTOS 1.1552 +static void *yy_flex_realloc( void *ptr, yy_size_t size ) 1.1553 +#else 1.1554 +static void *yy_flex_realloc( ptr, size ) 1.1555 +void *ptr; 1.1556 +yy_size_t size; 1.1557 +#endif 1.1558 + { 1.1559 + /* The cast to (char *) in the following accommodates both 1.1560 + * implementations that use char* generic pointers, and those 1.1561 + * that use void* generic pointers. It works with the latter 1.1562 + * because both ANSI C and C++ allow castless assignment from 1.1563 + * any pointer type to void*, and deal with argument conversions 1.1564 + * as though doing an assignment. 1.1565 + */ 1.1566 + return (void *) realloc( (char *) ptr, size ); 1.1567 + } 1.1568 + 1.1569 +#ifdef YY_USE_PROTOS 1.1570 +static void yy_flex_free( void *ptr ) 1.1571 +#else 1.1572 +static void yy_flex_free( ptr ) 1.1573 +void *ptr; 1.1574 +#endif 1.1575 + { 1.1576 + free( ptr ); 1.1577 + } 1.1578 + 1.1579 +#if YY_MAIN 1.1580 +int main() 1.1581 + { 1.1582 + yylex(); 1.1583 + return 0; 1.1584 + } 1.1585 +#endif 1.1586 +#line 65 "expr.l" 1.1587 + 1.1588 + 1.1589 +void exprCleanBuffer() 1.1590 +{ 1.1591 + yy_delete_buffer(yy_current_buffer); 1.1592 + yy_init = 1; 1.1593 +}