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