calclex.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:40k
源码类别:

数学计算

开发平台:

Unix_Linux

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