* Bug #14374 fixed - Parser did not manage comments properly in shellmode
[scilab.git] / scilab / modules / ast / src / cpp / parse / scanscilab.cpp
1
2 #line 3 "src/cpp/parse/scanscilab.cpp"
3
4 #define  YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 35
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with  platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36  * if you want the limit (max/min) macros for int types.
37  */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41
42 #include <inttypes.h>
43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
49 #else
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t;
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
56
57 /* Limits of integral types. */
58 #ifndef INT8_MIN
59 #define INT8_MIN               (-128)
60 #endif
61 #ifndef INT16_MIN
62 #define INT16_MIN              (-32767-1)
63 #endif
64 #ifndef INT32_MIN
65 #define INT32_MIN              (-2147483647-1)
66 #endif
67 #ifndef INT8_MAX
68 #define INT8_MAX               (127)
69 #endif
70 #ifndef INT16_MAX
71 #define INT16_MAX              (32767)
72 #endif
73 #ifndef INT32_MAX
74 #define INT32_MAX              (2147483647)
75 #endif
76 #ifndef UINT8_MAX
77 #define UINT8_MAX              (255U)
78 #endif
79 #ifndef UINT16_MAX
80 #define UINT16_MAX             (65535U)
81 #endif
82 #ifndef UINT32_MAX
83 #define UINT32_MAX             (4294967295U)
84 #endif
85
86 #endif /* ! C99 */
87
88 #endif /* ! FLEXINT_H */
89
90 #ifdef __cplusplus
91
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94
95 #else   /* ! __cplusplus */
96
97 /* C99 requires __STDC__ to be defined as 1. */
98 #if defined (__STDC__)
99
100 #define YY_USE_CONST
101
102 #endif  /* defined (__STDC__) */
103 #endif  /* ! __cplusplus */
104
105 #ifdef YY_USE_CONST
106 #define yyconst const
107 #else
108 #define yyconst
109 #endif
110
111 /* Returned upon end-of-file. */
112 #define YY_NULL 0
113
114 /* Promotes a possibly negative, possibly signed char to an unsigned
115  * integer for use as an array index.  If the signed char is negative,
116  * we want to instead treat it as an 8-bit unsigned char, hence the
117  * double cast.
118  */
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120
121 /* Enter a start condition.  This macro really ought to take a parameter,
122  * but we do it the disgusting crufty way forced on us by the ()-less
123  * definition of BEGIN.
124  */
125 #define BEGIN (yy_start) = 1 + 2 *
126
127 /* Translate the current start state into a value that can be later handed
128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
129  * compatibility.
130  */
131 #define YY_START (((yy_start) - 1) / 2)
132 #define YYSTATE YY_START
133
134 /* Action number for EOF rule of a given start state. */
135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136
137 /* Special action meaning "start processing a new file". */
138 #define YY_NEW_FILE yyrestart(yyin  )
139
140 #define YY_END_OF_BUFFER_CHAR 0
141
142 /* Size of default input buffer. */
143 #ifndef YY_BUF_SIZE
144 #ifdef __ia64__
145 /* On IA-64, the buffer size is 16k, not 8k.
146  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
147  * Ditto for the __ia64__ case accordingly.
148  */
149 #define YY_BUF_SIZE 32768
150 #else
151 #define YY_BUF_SIZE 16384
152 #endif /* __ia64__ */
153 #endif
154
155 /* The state buf must be large enough to hold one state per character in the main buffer.
156  */
157 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
158
159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
160 #define YY_TYPEDEF_YY_BUFFER_STATE
161 typedef struct yy_buffer_state *YY_BUFFER_STATE;
162 #endif
163
164 extern int yyleng;
165
166 extern FILE *yyin, *yyout;
167
168 #define EOB_ACT_CONTINUE_SCAN 0
169 #define EOB_ACT_END_OF_FILE 1
170 #define EOB_ACT_LAST_MATCH 2
171
172 #define YY_LESS_LINENO(n)
173
174 /* Return all but the first "n" matched characters back to the input stream. */
175 #define yyless(n) \
176         do \
177                 { \
178                 /* Undo effects of setting up yytext. */ \
179         int yyless_macro_arg = (n); \
180         YY_LESS_LINENO(yyless_macro_arg);\
181                 *yy_cp = (yy_hold_char); \
182                 YY_RESTORE_YY_MORE_OFFSET \
183                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
184                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
185                 } \
186         while ( 0 )
187
188 #define unput(c) yyunput( c, (yytext_ptr)  )
189
190 #ifndef YY_TYPEDEF_YY_SIZE_T
191 #define YY_TYPEDEF_YY_SIZE_T
192 typedef size_t yy_size_t;
193 #endif
194
195 #ifndef YY_STRUCT_YY_BUFFER_STATE
196 #define YY_STRUCT_YY_BUFFER_STATE
197 struct yy_buffer_state
198 {
199 FILE *yy_input_file;
200
201 char *yy_ch_buf;                /* input buffer */
202 char *yy_buf_pos;               /* current position in input buffer */
203
204 /* Size of input buffer in bytes, not including room for EOB
205  * characters.
206  */
207 yy_size_t yy_buf_size;
208
209 /* Number of characters read into yy_ch_buf, not including EOB
210  * characters.
211  */
212 int yy_n_chars;
213
214 /* Whether we "own" the buffer - i.e., we know we created it,
215  * and can realloc() it to grow it, and should free() it to
216  * delete it.
217  */
218 int yy_is_our_buffer;
219
220 /* Whether this is an "interactive" input source; if so, and
221  * if we're using stdio for input, then we want to use getc()
222  * instead of fread(), to make sure we stop fetching input after
223  * each newline.
224  */
225 int yy_is_interactive;
226
227 /* Whether we're considered to be at the beginning of a line.
228  * If so, '^' rules will be active on the next match, otherwise
229  * not.
230  */
231 int yy_at_bol;
232
233 int yy_bs_lineno; /**< The line count. */
234 int yy_bs_column; /**< The column count. */
235
236 /* Whether to try to fill the input buffer when we reach the
237  * end of it.
238  */
239 int yy_fill_buffer;
240
241 int yy_buffer_status;
242
243 #define YY_BUFFER_NEW 0
244 #define YY_BUFFER_NORMAL 1
245 /* When an EOF's been seen but there's still some text to process
246  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
247  * shouldn't try reading from the input source any more.  We might
248  * still have a bunch of tokens to match, though, because of
249  * possible backing-up.
250  *
251  * When we actually see the EOF, we change the status to "new"
252  * (via yyrestart()), so that the user can continue scanning by
253  * just pointing yyin at a new input file.
254  */
255 #define YY_BUFFER_EOF_PENDING 2
256
257 };
258 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
259
260 /* Stack of input buffers. */
261 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
262 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
263 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
264
265 /* We provide macros for accessing buffer states in case in the
266  * future we want to put the buffer states in a more general
267  * "scanner state".
268  *
269  * Returns the top of the stack, or NULL.
270  */
271 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
272                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
273                           : NULL)
274
275 /* Same as previous macro, but useful when we know that the buffer stack is not
276  * NULL or when we need an lvalue. For internal use only.
277  */
278 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
279
280 /* yy_hold_char holds the character lost when yytext is formed. */
281 static char yy_hold_char;
282 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
283 int yyleng;
284
285 /* Points to current character in buffer. */
286 static char *yy_c_buf_p = (char *) 0;
287 static int yy_init = 0;         /* whether we need to initialize */
288 static int yy_start = 0;        /* start state number */
289
290 /* Flag which is used to allow yywrap()'s to do buffer switches
291  * instead of setting up a fresh yyin.  A bit of a hack ...
292  */
293 static int yy_did_buffer_switch_on_eof;
294
295 void yyrestart (FILE *input_file  );
296 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
297 YY_BUFFER_STATE yy_create_buffer (FILE *file, int size  );
298 void yy_delete_buffer (YY_BUFFER_STATE b  );
299 void yy_flush_buffer (YY_BUFFER_STATE b  );
300 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
301 void yypop_buffer_state (void );
302
303 static void yyensure_buffer_stack (void );
304 static void yy_load_buffer_state (void );
305 static void yy_init_buffer (YY_BUFFER_STATE b, FILE *file  );
306
307 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
308
309 YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size  );
310 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
311 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, int len  );
312
313 void *yyalloc (yy_size_t  );
314 void *yyrealloc (void *, yy_size_t  );
315 void yyfree (void *  );
316
317 #define yy_new_buffer yy_create_buffer
318
319 #define yy_set_interactive(is_interactive) \
320         { \
321         if ( ! YY_CURRENT_BUFFER ){ \
322         yyensure_buffer_stack (); \
323                 YY_CURRENT_BUFFER_LVALUE =    \
324             yy_create_buffer(yyin,YY_BUF_SIZE ); \
325         } \
326         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
327         }
328
329 #define yy_set_bol(at_bol) \
330         { \
331         if ( ! YY_CURRENT_BUFFER ){\
332         yyensure_buffer_stack (); \
333                 YY_CURRENT_BUFFER_LVALUE =    \
334             yy_create_buffer(yyin,YY_BUF_SIZE ); \
335         } \
336         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
337         }
338
339 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
340
341 /* Begin user sect3 */
342
343 #define yywrap(n) 1
344 #define YY_SKIP_YYWRAP
345
346 typedef unsigned char YY_CHAR;
347
348 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
349
350 typedef int yy_state_type;
351
352 extern int yylineno;
353
354 int yylineno = 1;
355
356 extern char *yytext;
357 #define yytext_ptr yytext
358
359 static yy_state_type yy_get_previous_state (void );
360 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
361 static int yy_get_next_buffer (void );
362 static void yy_fatal_error (yyconst char msg[]  );
363
364 /* Done after the current pattern has been matched and before the
365  * corresponding action - sets up yytext.
366  */
367 #define YY_DO_BEFORE_ACTION \
368         (yytext_ptr) = yy_bp; \
369         yyleng = (size_t) (yy_cp - yy_bp); \
370         (yy_hold_char) = *yy_cp; \
371         *yy_cp = '\0'; \
372         (yy_c_buf_p) = yy_cp;
373
374 #define YY_NUM_RULES 145
375 #define YY_END_OF_BUFFER 146
376 /* This struct is not used in this scanner,
377    but its presence is necessary. */
378 struct yy_trans_info
379 {
380 flex_int32_t yy_verify;
381 flex_int32_t yy_nxt;
382 };
383 static yyconst flex_int16_t yy_acclist[946] =
384 {
385 0,
386 16408,  123,  123,  133,  133,  113,  113,  109,  109,  146,
387 84,  145,   80,   84,  145,   81,  145,   81,   84,  145,
388 78,   84,  145,   75,   84,  145,   27,   84,  145,   75,
389 84,  145,   30,   84,  145,   79,   84,  145,   34,   84,
390 145,   35,   84,  145,   48,   84,  145,   47,   84,  145,
391 37,   84,  145,   46,   84,  145,   67,   84,  145,   49,
392 84,  145,   69,   84,  145,   38,   84,  145,   36,   84,
393 145,   60,   84,  145,   64,   84,  145,   61,   84,  145,
394 26,   84,  145,   65,   84,  145,   50,   84,  145,   66,
395 84,  145,   51,   84,  145,   75,   84,  145,   75,   84,
396
397 145,   75,   84,  145,   75,   84,  145,   75,   84,  145,
398 75,   84,  145,   75,   84,  145,   75,   84,  145,   75,
399 84,  145,   75,   84,  145,   75,   84,  145,   39,   84,
400 145,   32,   84,  145,   40,   84,  145,   26,   84,  145,
401 84,  145,   84,  145,   84,  145,   84,  145,   84,  145,
402 84,  145,   84,  145,   84,  145,   84,  145,   80,   84,
403 145, 16408,   75,   84,  145,   27,   84,  145,   75,   84,
404 145,   75,   84,  145,   75,   84,  145,   75,   84,  145,
405 75,   84,  145,   75,   84,  145,   75,   84,  145,   75,
406 84,  145,   75,   84,  145,   75,   84,  145,   75,   84,
407
408 145,   75,   84,  145,   84,  145,   84,  145,   84,  145,
409 84,  145,   84,  145,   84,  145,   84,  145,   84,  145,
410 84,  145,  123,  124,  145,  122,  145,  122,  124,  145,
411 120,  124,  145,  119,  124,  145,  124,  145,  133,  134,
412 145,  132,  145,  132,  134,  145,  129,  134,  145,  130,
413 134,  145,  134,  145,  113,  114,  145,  112,  145,  112,
414 114,  145,  114,  145,  114,  145,  109,  145,  108,  145,
415 108,  145,  107,  145,  106,  107,  145,  103,  145,  103,
416 107,  145,  107,  145,   98,  145,   80,   98,  145,   89,
417 145,   89,   98,  145,   78,   98,  145,   75,   98,  145,
418
419 27,   98,  145,   75,   98,  145,   30,   98,  145,   79,
420 98,  145,   85,   87,   98,  145,   86,   98,  145,   48,
421 98,  145,   92,   98,  145,   37,   98,  145,   94,   98,
422 145,   67,   98,  145,   49,   98,  145,   69,   98,  145,
423 38,   88,   98,  145,   36,   98,  145,   60,   98,  145,
424 64,   98,  145,   61,   98,  145,   26,   98,  145,   65,
425 98,  145,   50,   98,  145,   90,   98,  145,   51,   98,
426 145,   39,   98,  145,   32,   98,  145,   91,   98,  145,
427 26,   98,  145,   98,  145,   98,  145,   98,  145,   98,
428 145,   98,  145,   98,  145,   98,  145,   98,  145,  144,
429
430 145,  135,  145,  138,  145,  138,  145,   78,  145,   79,
431 145,  140,  144,  145,  137,  145,  144,  145,  136,  145,
432 141,  144,  145,  139,  144,  145,  142,  144,  145,  143,
433 144,  145,  145,   25,  145,  145,   25,  145,  145,   25,
434 145,   25,  145,   25,  145,   25,  145,   25,  145,   25,
435 145,   25,  145,   25,  145,   25,  145,   25,  145,   25,
436 145,  145,  145,  145,  145,  145,  145,  145,  145,   80,
437 82,   82,   81,   75,   75,    3,   29,   75,    2,   28,
438 75,   31,   51,   41,   42,   68,   43,   74,   44,   45,
439 76,   77,   73,   69,   62,   59,   58,   63,   75,   75,
440
441 75,   17,   75,   75,   75,   75,   75,    4,   75,   75,
442 75,   75,   75,   75,   75,   75,   33,   75,   80, 16408,
443 75,   75,    3,   29,   75,    2,   28,   75,   75,   75,
444 75,   17,   75,   75,   75,   75,   75,    4,   75,   75,
445 75,   75,   75,   75,   75,   75,   75,  123,  122,  115,
446 116,  117,  118,  133,  132,  125,  126,  127,  128,  113,
447 112,  110,  111,  109,  108,  106,  103,  104,  105,   80,
448 87,   96,   97,   88,   89,   29,   75,   28,   75,  101,
449 88,  144,  135,  138,   76,  144,   77,  144,   25,   25,
450 3,   25,    2,   25,   25,   25,   25,   17,   25,   25,
451
452 25,   25,   25,    4,   25,   25,   25,   25,   25,   25,
453 25,   25,   25,   83,   83,   55,   52,   53,   54,   56,
454 72,   73,   70,   71,   57,   75,   75,   75,   75,   75,
455 8,   75,   15,   75,   75,   75,   75,   75,   75,   75,
456 75,   20,   75,   75,    1,   75, 8216, 8216,   75,   75,
457 75,   75,   75,    8,   75,   15,   75,   75,   75,   75,
458 75,   75,   75,   75,   20,   75,   75,    1,   75,  121,
459 121,  131,  131,   93,   95,  102,   99,  100,   25,   25,
460 25,   25,   25,    8,   25,   15,   25,   25,   25,   25,
461 25,   25,   25,   25,   20,   25,   25,   75,   12,   75,
462
463 75,   75,    6,   75,   75,   75,   75,   75,   75,   75,
464 75,    5,   75,   75,    1,    1,   75,    1,    1,    1,
465 1,    1,    1,    1,    1,   75, 8216,   75,   12,   75,
466 75,   75,    6,   75,   75,   75,   75,   75,   75,   75,
467 75,    5,   75,   75,    1,    1,   75,    1,    1,    1,
468 1,    1,    1,    1,    1,   75,   25,   12,   25,   25,
469 25,    6,   25,   25,   25,   25,   25,   25,   25,   25,
470 5,   25,   25,   25,   75,   75,   18,   75,   21,   75,
471 75,   75,   75,   75,   75,   75,   75,   75,   75,   16,
472 75,    1,    1,    1,    1,    1,    1,    1,   75,   75,
473
474 18,   75,   21,   75,   75,   75,   75,   75,   75,   75,
475 75,   75,   75,   16,   75,    1, 8216,    1, 8216,    1,
476 1,    1,    1,    1,    1,    1,   25,   25,   18,   25,
477 21,   25,   25,   25,   25,   25,   25,   25,   25,   25,
478 25,   16,   25,   75,    7,   75,   75,   75,   75,   23,
479 75,   22,   75,    9,   75,   10,   75,    1,    1,    1,
480 75,    7,   75,   75,   75,   75,   23,   75,   22,   75,
481 9,   75,   10,   75,    1, 8216,    1,    1,    1,   25,
482 7,   25,   25,   25,   25,   23,   25,   22,   25,    9,
483 25,   10,   25,   75,   75,   75,   75,    1,   75,   75,
484
485 75,   75,   75,    1,   75,   25,   25,   25,   25,   19,
486 75,   75,   13,   75,   75,   19,   75,   75,   13,   75,
487 75,   19,   25,   25,   13,   25,   25,   75,   11,   75,
488 75,   11,   75,   25,   11,   25,   75,   75,   25,   14,
489 75,   14,   75,   14,   25
490 } ;
491
492 static yyconst flex_int16_t yy_accept[816] =
493 {
494 0,
495 1,    1,    2,    3,    4,    5,    6,    7,    8,    9,
496 10,   10,   10,   10,   10,   10,   10,   10,   10,   11,
497 13,   16,   18,   21,   24,   27,   30,   33,   36,   39,
498 42,   45,   48,   51,   54,   57,   60,   63,   66,   69,
499 72,   75,   78,   81,   84,   87,   90,   93,   96,   99,
500 102,  105,  108,  111,  114,  117,  120,  123,  126,  129,
501 132,  135,  138,  141,  143,  145,  147,  149,  151,  153,
502 155,  157,  159,  163,  166,  169,  172,  175,  178,  181,
503 184,  187,  190,  193,  196,  199,  202,  205,  207,  209,
504 211,  213,  215,  217,  219,  221,  223,  226,  228,  231,
505
506 234,  237,  239,  242,  244,  247,  250,  253,  255,  258,
507 260,  263,  265,  267,  269,  271,  273,  275,  278,  280,
508 283,  285,  287,  290,  292,  295,  298,  301,  304,  307,
509 310,  313,  317,  320,  323,  326,  329,  332,  335,  338,
510 341,  345,  348,  351,  354,  357,  360,  363,  366,  369,
511 372,  375,  378,  381,  384,  386,  388,  390,  392,  394,
512 396,  398,  400,  402,  404,  406,  408,  410,  412,  415,
513 417,  419,  421,  424,  427,  430,  433,  434,  436,  437,
514 439,  440,  442,  444,  446,  448,  450,  452,  454,  456,
515 458,  460,  462,  463,  464,  465,  466,  467,  468,  469,
516
517 470,  471,  472,  473,  473,  473,  474,  475,  475,  475,
518 475,  475,  475,  475,  475,  475,  476,  476,  476,  476,
519 476,  476,  476,  476,  476,  479,  482,  483,  484,  484,
520 485,  486,  487,  488,  489,  490,  491,  492,  492,  493,
521 494,  495,  495,  495,  495,  496,  497,  497,  498,  498,
522 499,  499,  499,  500,  501,  502,  504,  505,  506,  507,
523 508,  510,  511,  512,  513,  514,  515,  516,  517,  518,
524 518,  519,  519,  519,  519,  519,  519,  519,  519,  519,
525 521,  521,  521,  521,  521,  521,  521,  521,  521,  521,
526 521,  521,  522,  522,  522,  522,  522,  522,  522,  522,
527
528 522,  523,  523,  523,  523,  523,  523,  523,  523,  523,
529 526,  529,  530,  531,  532,  534,  535,  536,  537,  538,
530 540,  541,  542,  543,  544,  545,  546,  547,  548,  548,
531 548,  548,  548,  548,  548,  548,  548,  549,  550,  551,
532 552,  553,  554,  554,  555,  556,  557,  558,  559,  560,
533 560,  561,  562,  563,  564,  565,  566,  567,  568,  569,
534 570,  571,  572,  573,  574,  574,  575,  576,  578,  580,
535 580,  580,  581,  582,  583,  584,  585,  587,  589,  590,
536 590,  590,  590,  590,  590,  590,  590,  590,  591,  591,
537 591,  591,  591,  591,  591,  591,  591,  593,  595,  596,
538
539 597,  598,  600,  601,  602,  603,  604,  606,  607,  608,
540 609,  610,  611,  612,  613,  614,  614,  614,  614,  614,
541 614,  614,  614,  615,  616,  616,  616,  616,  616,  616,
542 616,  616,  616,  616,  616,  616,  616,  616,  616,  617,
543 618,  619,  620,  621,  622,  623,  623,  624,  624,  625,
544 626,  627,  628,  629,  630,  631,  633,  635,  636,  637,
545 638,  639,  640,  641,  642,  644,  645,  647,  647,  647,
546 647,  647,  647,  647,  647,  647,  647,  647,  647,  647,
547 647,  647,  647,  647,  647,  647,  647,  647,  647,  647,
548 647,  647,  647,  647,  647,  647,  648,  649,  649,  649,
549
550 649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
551 649,  649,  650,  651,  652,  653,  654,  656,  658,  659,
552 660,  661,  662,  663,  664,  665,  667,  668,  670,  670,
553 670,  670,  671,  672,  673,  674,  675,  676,  677,  678,
554 679,  679,  679,  679,  679,  679,  679,  679,  679,  679,
555 679,  679,  679,  679,  679,  680,  681,  682,  683,  684,
556 686,  688,  689,  690,  691,  692,  693,  694,  695,  697,
557 698,  698,  698,  698,  698,  698,  698,  698,  698,  698,
558 699,  701,  702,  703,  705,  706,  707,  708,  709,  710,
559 711,  712,  714,  715,  716,  718,  719,  720,  721,  722,
560
561 723,  724,  725,  726,  727,  727,  727,  727,  727,  727,
562 727,  727,  727,  727,  727,  727,  727,  727,  727,  727,
563 727,  727,  728,  728,  728,  728,  728,  728,  728,  729,
564 731,  732,  733,  735,  736,  737,  738,  739,  740,  741,
565 742,  744,  745,  746,  748,  749,  750,  751,  752,  753,
566 754,  755,  756,  757,  757,  757,  757,  757,  757,  757,
567 758,  760,  761,  762,  764,  765,  766,  767,  768,  769,
568 770,  771,  773,  774,  775,  776,  777,  779,  781,  782,
569 783,  784,  785,  786,  787,  788,  789,  790,  792,  793,
570 794,  795,  796,  797,  798,  799,  799,  799,  799,  799,
571
572 799,  799,  799,  800,  801,  803,  805,  806,  807,  808,
573 809,  810,  811,  812,  813,  814,  816,  818,  820,  821,
574 822,  823,  824,  825,  826,  827,  828,  829,  831,  833,
575 834,  835,  836,  837,  838,  839,  840,  841,  842,  844,
576 845,  847,  848,  849,  850,  852,  854,  856,  858,  859,
577 860,  861,  861,  861,  862,  864,  865,  866,  867,  869,
578 871,  873,  875,  877,  878,  879,  880,  881,  883,  884,
579 885,  886,  888,  890,  892,  894,  895,  896,  897,  898,
580 900,  901,  902,  903,  904,  906,  907,  908,  909,  910,
581 912,  913,  915,  916,  918,  919,  921,  922,  924,  925,
582
583 927,  928,  929,  931,  932,  934,  935,  937,  938,  939,
584 940,  942,  944,  946,  946
585 } ;
586
587 static yyconst flex_int32_t yy_ec[256] =
588 {
589 0,
590 1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
591 2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
592 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
593 1,    2,    1,    5,    6,    7,    8,    9,   10,   11,
594 12,   13,   14,   15,   16,   17,   18,   19,   19,   19,
595 19,   19,   19,   19,   19,   19,   19,   20,   21,   22,
596 23,   24,    6,   25,    6,    6,    6,   26,   27,   28,
597 6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
598 6,    6,    6,   29,    6,    6,    6,    6,    6,    6,
599 30,   31,   32,   33,    6,    1,   34,   35,   36,   37,
600
601 38,   39,    6,   40,   41,    6,   42,   43,   44,   45,
602 46,    6,    6,   47,   48,   49,   50,    6,   51,    6,
603 52,    6,   53,   54,   55,   56,    1,   57,   57,   57,
604 57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
605 57,   57,   57,   58,   58,   58,   58,   58,   58,   58,
606 58,   58,   58,   58,   58,   58,   58,   58,   58,   59,
607 59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
608 59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
609 59,   59,   59,   59,   59,   59,   60,   59,   59,   59,
610 61,    1,    1,   62,   62,   62,   62,   62,   62,   62,
611
612 62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
613 62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
614 62,   62,   62,   63,   64,   64,   64,   64,   64,   64,
615 64,   64,   64,   64,   64,   64,   65,   66,   67,   68,
616 69,   69,   69,   70,    1,    1,    1,    1,    1,    1,
617 1,    1,    1,    1,    1
618 } ;
619
620 static yyconst flex_int32_t yy_meta[71] =
621 {
622 0,
623 1,    2,    3,    4,    5,    6,    6,    7,    1,    5,
624 8,    1,    9,    1,   10,    1,   11,    9,   12,    1,
625 10,    8,    8,    8,    1,    6,    6,    6,    6,    1,
626 1,    1,    1,    6,    6,    6,    6,    6,    6,    6,
627 6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
628 6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
629 1,    6,    6,    6,    6,    6,    6,    6,    6,    6
630 } ;
631
632 static yyconst flex_int16_t yy_base[841] =
633 {
634 0,
635 0,   70,  138,  141,  149,  157,  160,  166,  146,  153,
636 173,  178,  196,    0,  265,  320,  376,    0, 1114, 4153,
637 183,  270,  279, 4153,  239,  248,  419, 1090, 4153, 4153,
638 4153,  155, 4153, 4153, 4153,  336,  175,  310, 4153, 4153,
639 269,  272,  275,  276, 4153, 1079, 4153, 4153,  311,  421,
640 423,  323,  425,  451,  463,  465,  467,  470,  492, 4153,
641 1040, 4153,  454,  465,  273,  476,  132,  485,  490,  469,
642 495, 1034,  555,  505,  514,  624,  557,  559,  561,  599,
643 563,  601,  606,  608,  630,  636,  667,  640,  304,  651,
644 137,  660,  665,  505,  670, 1026,    0, 4153, 1076,  274,
645
646 351, 1056,    0, 4153, 1068,  365,  456, 1047,    0, 4153,
647 1054, 1027, 1025,    0, 4153, 1031, 4153,  960, 4153,  953,
648 460, 4153,  730,  639,  659, 4153,  709,  697,  740,  900,
649 4153, 4153, 4153,  446,  888, 4153,  886,  763,  598,  766,
650 893, 4153,  537,  474,  647,  649, 4153,  876, 4153, 4153,
651 4153,  833, 4153,  654,  694,  572,  740,  239,  748,  644,
652 753,  824,    0,  877, 4153,  859, 4153, 4153,    0, 4153,
653 495, 4153,    0,    0,    0,    0, 4153,  753,  762,  805,
654 581,  808,  812,  810,  837,  814,  849,  855,  861,  863,
655 868,  890,  863,  654,  874,  262,  883,  867,  888,  795,
656
657 768, 4153,  845,  948,  951,  955,  932,  925,  727,  930,
658 316,  935,  919,  940,  788,    0,  945,  877,  950,  609,
659 955,  959,  964,  745,  998, 1000, 4153, 4153,    0, 4153,
660 498,  767,  758, 1014,  732, 4153, 4153,    0, 4153, 1017,
661 1039,  726,  897,  733, 4153, 4153,  772, 4153,  883, 4153,
662 1030,    0, 1031, 1033, 1039, 1046, 1058, 1061, 1064, 1073,
663 1076, 1080, 1088, 1095, 1102, 1111, 1117, 1124, 4153, 1040,
664 1119, 1117, 1122, 1127, 1132, 1137, 1142, 1147, 1152, 1212,
665 1159, 1168, 1182,  914, 1187,  720, 1192, 1196, 1201,  686,
666 1261, 1244, 1207, 1111, 1230,  733, 1237, 1241, 1246,  682,
667
668 1267, 1251, 1254, 1261,  901, 1266, 1280, 1285,  679, 1319,
669 1321, 1323, 1325, 1337, 1328, 1350, 1355, 1362, 1367, 1374,
670 1379, 1386, 1393, 1398, 1402, 1415, 1417, 1420, 1413, 1418,
671 1423, 1428, 1433, 1438, 1443, 1448,    0, 4153, 4153, 4153,
672 4153, 4153, 1267,    0, 4153, 4153, 4153, 4153, 4153, 1507,
673 0, 4153, 4153, 4153,    0, 4153,  682, 4153, 4153, 4153,
674 1511, 4153,  833, 1029,  665,  676, 1514, 1491, 1504,  654,
675 626,  622,  612,    0,  601, 4153,    0,    0, 1508, 1491,
676 1401, 1501,  907, 1506, 1510, 1515,  544, 1515, 1529, 1485,
677 1534,  910, 1539, 1543, 1548,  540, 1582, 1584, 1586, 1588,
678
679 1600, 1591, 1613, 1618, 1625, 1630, 1637, 1642, 1649, 1656,
680 1661, 1665, 1678, 1680, 1683, 1676, 1681, 1686, 1691, 1696,
681 1701, 1706, 4153,  592, 1711, 1716, 1721, 1726, 1731, 1736,
682 1741, 1746, 1751, 1756, 1761, 1766, 1771, 1776, 4153, 4153,
683 4153, 4153, 4153, 4153, 1819,  521,  519,  482,  446, 4153,
684 1813, 1811, 1815, 1830, 1837, 1839, 1842, 1844, 1856, 1861,
685 1868, 1870, 1873, 1875, 1887, 1899, 1948, 1872, 1886, 1962,
686 2022, 1968, 1495, 1973, 1075, 1978, 1665, 1983,  400, 2043,
687 1989, 1880, 1994, 1097, 1999, 2003, 2008,  314, 2013, 2018,
688 2036, 2041, 2057, 2062, 2067, 4153, 2127, 2073, 2082, 2087,
689
690 2095, 2100, 2105, 2110, 2115, 2120, 2125, 2130, 2135, 2140,
691 2145, 2179, 2181, 2186, 2188, 2195, 2203, 2210, 2212, 2217,
692 2225, 2229, 2234, 2241, 2248, 2253, 2256, 2305, 2319, 2324,
693 2329, 4153,  356, 4153,  354,  326,  324,  256,  166,  154,
694 2334, 2339, 2344, 2349, 2354, 2359, 2364, 2369, 2374, 2379,
695 2384, 2389, 2394, 2399, 2433, 2435, 2440, 2442, 2449, 2457,
696 2464, 2466, 2471, 2479, 2483, 2488, 2495, 2502, 2507, 2510,
697 2503, 2508, 2513, 2518, 2523, 2528, 2533, 2538, 2543, 2577,
698 2579, 2581, 2583, 2586, 2605, 2608, 2611, 2617, 2620, 2634,
699 2636, 2648, 2650,    0,    0, 2633, 2021, 2643, 1160, 2648,
700
701 2652, 2657,  108, 2691, 2664, 2674, 2684, 2689, 2694, 2699,
702 2704, 2709, 2714, 2719, 2724, 2729, 2734, 2739, 2744, 2749,
703 2754, 2814, 2760, 2769, 2774, 2782, 2787, 2792, 2826, 2828,
704 2830, 2832, 2835, 2854, 2857, 2860, 2866, 2869, 2883, 2885,
705 2897, 2899, 2928,    0, 2883, 2076, 2897, 1323, 2902, 2668,
706 2907,   90, 2941, 2914, 2928, 2934, 2939, 2944, 2949, 2983,
707 2985, 2987, 2989, 2992, 3011, 3014, 3017, 3023, 3026, 3040,
708 3042, 3054, 3056, 3058, 3070,    0, 3072, 3084, 3086, 3088,
709 3100, 3112, 3115, 3118, 3130, 3134, 3142, 3148, 3135, 3141,
710 3146, 3151, 3156, 3161, 3166, 3171, 3176, 3181, 3186, 3191,
711
712 3196,    0, 3230,    0, 3232, 3234, 3237, 3239, 3246, 3261,
713 3264, 3268, 3280, 3283, 3295, 3292,    0, 1515, 3279, 3288,
714 3293, 3298, 3303, 3308, 3313, 3347,    0, 3349, 3351, 3354,
715 3356, 3363, 3378, 3381, 3385, 3397, 3400, 3412, 3409, 3415,
716 3427, 3431, 3440, 3434, 3443, 3449, 3456, 3462, 3449, 3455,
717 3460,    0,    0, 3494, 3496, 3498, 3500, 3512, 3503, 3526,
718 3528, 3530, 3560, 3513, 3527, 3532, 3566, 3568, 3570, 3572,
719 3584, 3575, 3598, 3600, 3602, 3606, 3614, 3628, 3630,    0,
720 3632, 3636, 3654, 3658,    0, 3662, 3666, 3680, 3684, 3688,
721 3702, 3706, 3710, 3718, 3724, 3732, 3740, 3746, 3755, 3748,
722
723 3762, 3764, 3770, 3777, 3779, 3786, 3792, 3801, 3808, 3810,
724 3805, 3823, 3832, 4153, 3881, 3893, 3905, 3917, 3929, 3941,
725 3948, 3955, 3966, 3972, 3979, 3991, 4003, 4015, 4027, 4039,
726 4046, 4053, 4065, 4076, 4087, 4097, 4104, 4116, 4128, 4140
727 } ;
728
729 static yyconst flex_int16_t yy_def[841] =
730 {
731 0,
732 814,  814,  815,  815,  816,  816,  817,  817,  818,  818,
733 819,  819,  814,   13,  820,  820,  814,   17,  814,  814,
734 814,  814,  814,  814,  821,  822,  821,  814,  814,  814,
735 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
736 814,  814,  814,  814,  814,  814,  814,  814,   27,   27,
737 27,   27,   27,   27,   27,   27,   27,   27,   27,  814,
738 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
739 814,  814,  823,  824,  825,  824,   76,   76,   76,   76,
740 76,   76,   76,   76,   76,   76,   76,  814,  814,  814,
741 814,  814,  814,  814,  814,  814,  826,  814,  814,  814,
742
743 814,  814,  827,  814,  814,  814,  814,  814,  828,  814,
744 814,  814,  814,  829,  814,  814,  814,  814,  814,  814,
745 814,  814,  814,  814,  814,  814,   27,  822,   27,  814,
746 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
747 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
748 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
749 814,  814,  830,  814,  814,  814,  814,  814,  830,  814,
750 830,  814,  830,  830,  830,  830,  814,  831,  832,  831,
751 814,  180,  180,  180,  180,  180,  180,  180,  180,  180,
752 180,  180,  814,  814,  814,  814,  814,  814,  814,  814,
753
754 814,  814,  814,  814,  814,  814,   27,  814,  814,  814,
755 814,  814,  814,  814,  814,  128,  814,  814,  814,  814,
756 814,  814,  814,  814,   27,   27,  814,  814,  833,  814,
757 814,  814,  814,  814,  814,  814,  814,  834,  814,  814,
758 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
759 814,  835,   27,   27,   27,   27,   27,   27,   27,   27,
760 27,   27,   27,   27,   27,   27,   27,   27,  814,  814,
761 27,  814,  814,  814,  814,  814,  814,  814,  814,  823,
762 836,  837,  814,  814,  814,  814,  814,  814,  814,  814,
763 838,   76,  814,  814,  814,  814,  814,  814,  814,  814,
764
765 825,  814,  814,  814,  814,  814,  814,  814,  814,   76,
766 76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
767 76,   76,   76,   76,   76,   76,   76,   76,  814,  814,
768 814,  814,  814,  814,  814,  814,  826,  814,  814,  814,
769 814,  814,  814,  827,  814,  814,  814,  814,  814,  814,
770 828,  814,  814,  814,  829,  814,  814,  814,  814,  814,
771 814,  814,  814,  814,  814,  814,  814,   27,   27,  814,
772 814,  814,  814,  830,  814,  814,  830,  830,  180,  814,
773 814,  814,  814,  814,  814,  814,  814,  832,  814,  814,
774 814,  814,  814,  814,  814,  814,  180,  180,  180,  180,
775
776 180,  180,  180,  180,  180,  180,  180,  180,  180,  180,
777 180,  180,  180,  180,  180,  814,  814,  814,  814,  814,
778 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
779 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
780 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
781 27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
782 27,   27,   27,   27,   27,   27,  814,  814,  814,  814,
783 836,  814,  814,  814,  814,  814,  814,  814,  814,  837,
784 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
785 814,  814,  814,  814,  814,  814,  838,  814,  814,  814,
786
787 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
788 814,   76,   76,   76,   76,   76,   76,   76,   76,   76,
789 76,   76,   76,   76,   76,   76,   76,  814,  814,  814,
790 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
791 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
792 814,  814,  814,  814,  180,  180,  180,  180,  180,  180,
793 180,  180,  180,  180,  180,  180,  180,  180,  180,  180,
794 814,  814,  814,  814,  814,  814,  814,  814,  814,   27,
795 27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
796 27,   27,   27,  839,  467,  839,  839,  839,  839,  839,
797
798 839,  839,  839,   27,  814,  814,  814,  814,  814,  814,
799 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
800 814,  838,  814,  814,  814,  814,  814,  814,   76,   76,
801 76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
802 76,   76,  840,  528,  839,  839,  839,  839,  839,  839,
803 839,  839,   76,  814,  814,  814,  814,  814,  814,  180,
804 180,  180,  180,  180,  180,  180,  180,  180,  180,  180,
805 180,  180,  180,  180,   27,  128,   27,   27,   27,   27,
806 27,   27,   27,   27,   27,   27,   27,   27,  839,  839,
807 839,  839,  839,  839,  839,  814,  814,  814,  814,  814,
808
809 814,  471,   76,  301,   76,   76,   76,   76,   76,   76,
810 76,   76,   76,   76,   76,   76,  839,  840,  839,  839,
811 839,  839,  839,  839,  839,  180,  388,  180,  180,  180,
812 180,  180,  180,  180,  180,  180,  180,  180,  180,   27,
813 27,   27,   27,   27,   27,   27,   27,   27,  839,  839,
814 839,  471,  480,   76,   76,   76,   76,   76,   76,   76,
815 76,   76,  840,  839,  839,  839,  180,  180,  180,  180,
816 180,  180,  180,  180,  180,   27,   27,   27,   27,  467,
817 76,   76,   76,   76,  528,  180,  180,  180,  180,   27,
818 27,   27,   27,   76,   76,   76,   76,  180,  180,  180,
819
820 180,   27,   27,   76,   76,  180,  180,   27,   76,  180,
821 27,   76,  180,    0,  814,  814,  814,  814,  814,  814,
822 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
823 814,  814,  814,  814,  814,  814,  814,  814,  814,  814
824 } ;
825
826 static yyconst flex_int16_t yy_nxt[4224] =
827 {
828 0,
829 20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
830 30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
831 40,   41,   42,   43,   44,   25,   25,   25,   25,   45,
832 46,   47,   48,   25,   49,   50,   51,   52,   53,   25,
833 54,   25,   25,   25,   25,   55,   56,   57,   58,   25,
834 59,   25,   60,   61,   62,   63,   20,   20,   20,   20,
835 20,   64,   65,   66,   67,   68,   69,   70,   71,   72,
836 20,   73,   22,   23,   24,   74,   75,   76,   28,   29,
837 30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
838 40,   41,   42,   43,   44,   74,   74,   74,   74,   45,
839
840 46,   47,   48,   74,   77,   78,   79,   80,   81,   74,
841 82,   74,   74,   74,   74,   83,   84,   85,   86,   74,
842 87,   74,   60,   61,   62,   63,   20,   20,   20,   20,
843 20,   88,   89,   90,   91,   92,   93,   94,   95,   96,
844 98,   99,  100,   98,   99,  100,  725,  101,  115,  116,
845 101,  104,  105,  106,  102,  115,  116,  102,  107,  104,
846 105,  106,  110,  111,  695,  108,  107,  228,  110,  111,
847 540,  229,  112,  108,  118,  119,  120,  113,  112,  118,
848 119,  120,  539,  113,  201,  202,  203,  237,  274,  274,
849 121,  238,  239,  331,  331,  121,  122,  123,  124,  125,
850
851 126,  127,  128,  129,  130,  131,  132,  133,  134,  135,
852 136,  137,  138,  139,  140,  141,  142,  143,  144,  145,
853 146,  127,  127,  127,  127,  147,  148,  149,  150,  127,
854 127,  127,  127,  127,  127,  127,  127,  127,  127,  127,
855 127,  127,  127,  127,  127,  127,  127,  127,  151,  152,
856 153,  154,  122,  122,  122,  122,  122,  155,  156,  157,
857 158,  159,  159,  160,  161,  162,  164,  165,  166,  167,
858 244,  204,  538,  247,  168,  169,  249,  251,  339,  170,
859 204,  206,  171,  340,  205,  172,  173,  174,  175,  176,
860 205,  245,  246,  205,  248,  274,  274,  250,  246,  205,
861
862 208,  209,  210,  211,  212,  212,  213,  214,  215,  217,
863 218,  219,  220,  221,  221,  222,  223,  224,  418,  418,
864 176,  164,  165,  166,  167,  537,  240,  536,  241,  168,
865 169,  272,  272,  272,  170,  242,  243,  171,  207,  207,
866 172,  173,  174,  175,  176,  230,  242,  243,  231,  207,
867 207,  207,  232,  233,  234,  341,  534,  253,  532,  207,
868 342,  207,  329,  329,  329,  257,  235,  258,  236,  346,
869 618,  207,  427,  427,  347,  176,  177,  177,  177,  177,
870 177,  178,  179,  180,  177,  177,  177,  177,  177,  177,
871 177,  177,  177,  181,  177,  177,  177,  177,  177,  177,
872
873 177,  178,  178,  178,  178,  177,  177,  177,  177,  178,
874 182,  183,  184,  185,  186,  178,  187,  178,  178,  178,
875 178,  188,  189,  190,  191,  178,  192,  178,  177,  177,
876 177,  177,  177,  177,  177,  177,  177,  193,  194,  195,
877 196,  197,  197,  198,  199,  200,  225,  226,  207,  207,
878 207,  207,  207,  207,  254,  270,  611,  225,  228,  207,
879 348,  207,  229,  207,  449,  349,  255,  226,  256,  207,
880 259,  207,  359,  207,  260,  247,  246,  360,  207,  207,
881 208,  209,  210,  211,  212,  212,  213,  214,  215,  261,
882 207,  207,  207,  207,  207,  207,  248,  207,  207,  207,
883
884 449,  207,  263,  207,  264,  207,  291,  377,  207,  266,
885 236,  262,  378,  207,  440,  207,  267,  265,  207,  207,
886 207,  271,  271,  271,  271,  271,  277,  277,  277,  277,
887 207,  268,  273,  273,  273,  273,  273,  447,  244,  447,
888 207,  275,  275,  275,  275,  275,  275,  275,  275,  276,
889 275,  278,  278,  278,  278,  278,  280,  202,  203,  245,
890 246,  282,  334,  334,  334,  334,  293,  294,  295,  296,
891 297,  297,  298,  299,  300,  302,  303,  304,  305,  306,
892 306,  307,  308,  309,  292,  292,  292,  292,  292,  292,
893 292,  292,  313,  237,  423,  292,  554,  292,  239,  292,
894
895 547,  292,  375,  312,  314,  292,  315,  292,  318,  292,
896 237,  292,  319,  373,  238,  239,  283,  284,  285,  286,
897 287,  287,  288,  289,  290,  291,  292,  292,  292,  292,
898 272,  272,  272,  292,  292,  292,  292,  292,  372,  320,
899 204,  316,  540,  317,  292,  322,  292,  292,  249,  292,
900 251,  310,  311,  205,  321,  270,  292,  292,  292,  205,
901 204,  367,  310,  292,  292,  434,  434,  323,  292,  250,
902 539,  246,  311,  205,  292,  325,  246,  373,  292,  205,
903 324,  538,  326,  357,  292,  293,  294,  295,  296,  297,
904 297,  298,  299,  300,  292,  292,  328,  328,  328,  328,
905
906 328,  277,  277,  277,  277,  292,  327,  330,  330,  330,
907 330,  330,  416,  416,  416,  292,  332,  332,  332,  332,
908 332,  332,  332,  332,  333,  332,  335,  335,  335,  335,
909 335,  361,  202,  203,  244,  511,  207,  207,  504,  446,
910 362,  446,  495,  363,  447,  364,  365,  207,  442,  366,
911 271,  271,  271,  271,  271,  245,  246,  207,  217,  218,
912 219,  220,  221,  221,  222,  223,  224,  368,  369,  201,
913 202,  203,  230,  247,  441,  231,  491,  491,  368,  372,
914 233,  234,  240,  232,  241,  425,  425,  425,  369,  500,
915 500,  242,  243,  235,  248,  236,  273,  273,  273,  273,
916
917 273,  438,  242,  243,  275,  275,  275,  275,  275,  278,
918 278,  278,  278,  278,  380,  381,  382,  383,  384,  384,
919 385,  386,  387,  389,  390,  391,  392,  393,  393,  394,
920 395,  396,  397,  398,  536,  379,  379,  379,  379,  379,
921 379,  379,  379,  397,  431,  400,  379,  202,  379,  370,
922 379,  422,  379,  398,  399,  402,  379,  401,  379,  405,
923 379,  376,  379,  406,  379,  379,  380,  381,  382,  383,
924 384,  384,  385,  386,  387,  379,  379,  379,  375,  403,
925 279,  404,  379,  379,  249,  379,  269,  407,  379,  379,
926 379,  379,  252,  379,  373,  379,  379,  379,  409,  379,
927
928 410,  379,  371,  408,  370,  250,  379,  412,  227,  379,
929 448,  379,  448,  411,  413,  449,  379,  379,  379,  415,
930 415,  415,  415,  415,  420,  420,  420,  420,  379,  414,
931 417,  417,  417,  417,  417,  432,  432,  432,  379,  419,
932 419,  419,  419,  419,  421,  421,  421,  421,  421,  204,
933 423,  424,  204,  423,  424,  358,  204,  507,  507,  207,
934 207,  357,  205,  543,  543,  205,  550,  550,  205,  205,
935 207,  205,  489,  489,  489,  205,  429,  429,  429,  429,
936 207,  207,  207,  207,  207,  207,  426,  426,  426,  426,
937 426,  428,  428,  428,  428,  428,  430,  430,  430,  430,
938
939 430,  216,  216,  216,  216,  216,  433,  433,  433,  433,
940 433,  435,  435,  435,  435,  435,  436,  436,  436,  436,
941 437,  437,  437,  437,  437,  207,  207,  207,  207,  444,
942 537,  251,  234,  356,  444,  445,  207,  354,  207,  242,
943 243,  270,  242,  243,  353,  371,  207,  444,  207,  444,
944 242,  243,  246,  242,  243,  240,  352,  241,  207,  207,
945 207,  207,  246,  350,  242,  243,  207,  207,  451,  207,
946 345,  207,  343,  207,  207,  242,  243,  207,  338,  207,
947 452,  453,  336,  454,  207,  207,  207,  207,  207,  207,
948 279,  207,  207,  269,  207,  252,  207,  456,  227,  207,
949
950 207,  207,  207,  207,  207,  455,  207,  207,  207,  207,
951 457,  207,  207,  814,  207,  207,  207,  458,  207,  459,
952 814,  207,  207,  207,  207,  814,  207,  814,  207,  207,
953 207,  607,  607,  207,  814,  460,  461,  462,  207,  207,
954 207,  814,  463,  207,  207,  207,  207,  207,  464,  207,
955 207,  207,  207,  614,  614,  207,  814,  207,  814,  207,
956 291,  814,  207,  814,  466,  207,  814,  207,  465,  498,
957 498,  498,  207,  271,  271,  271,  271,  271,  271,  271,
958 271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
959 271,  271,  271,  271,  271,  271,  271,  467,  468,  468,
960
961 468,  468,  468,  469,  469,  469,  469,  469,  470,  470,
962 470,  470,  470,  280,  202,  203,  691,  691,  282,  814,
963 472,  473,  474,  475,  476,  476,  477,  478,  479,  481,
964 482,  483,  484,  485,  485,  486,  487,  488,  281,  281,
965 281,  281,  281,  490,  490,  490,  490,  490,  492,  492,
966 492,  492,  492,  493,  493,  493,  493,  494,  494,  494,
967 494,  494,  291,  292,  292,  292,  292,  292,  291,  532,
968 533,  292,  292,  283,  284,  285,  286,  287,  287,  288,
969 289,  290,  292,  343,  814,  497,  499,  499,  499,  499,
970 499,  814,  292,  501,  501,  501,  501,  501,  502,  502,
971
972 502,  502,  503,  503,  503,  503,  503,  301,  301,  301,
973 301,  301,  505,  505,  505,  814,  497,  506,  506,  506,
974 506,  506,  508,  508,  508,  508,  508,  814,  302,  303,
975 304,  305,  306,  306,  307,  308,  309,  509,  509,  509,
976 509,  510,  510,  510,  510,  510,  292,  292,  292,  292,
977 292,  292,  292,  292,  814,  292,  292,  292,  814,  292,
978 512,  292,  814,  292,  292,  292,  292,  292,  814,  292,
979 814,  292,  513,  514,  814,  292,  292,  292,  292,  721,
980 721,  515,  292,  292,  814,  292,  814,  814,  292,  292,
981 292,  517,  814,  292,  292,  292,  814,  516,  292,  814,
982
983 292,  292,  292,  292,  814,  292,  292,  292,  518,  814,
984 292,  519,  292,  292,  292,  292,  814,  292,  520,  814,
985 292,  292,  292,  814,  292,  292,  292,  292,  814,  292,
986 292,  292,  814,  521,  522,  523,  292,  814,  524,  525,
987 292,  292,  292,  292,  292,  292,  292,  292,  292,  814,
988 292,  814,  814,  292,  814,  292,  814,  527,  292,  541,
989 541,  541,  814,  292,  814,  292,  526,  814,  292,  328,
990 328,  328,  328,  328,  328,  328,  328,  328,  328,  328,
991 328,  328,  328,  328,  328,  328,  328,  328,  328,  328,
992 328,  328,  328,  528,  529,  529,  529,  529,  529,  530,
993
994 530,  530,  530,  530,  531,  531,  531,  531,  531,  534,
995 535,  814,  361,  202,  203,  204,  763,  496,  207,  207,
996 814,  362,  814,  350,  363,  814,  364,  365,  205,  207,
997 366,  207,  207,  814,  205,  379,  379,  594,  814,  207,
998 814,  814,  207,  548,  548,  548,  379,  379,  379,  379,
999 379,  379,  207,  605,  605,  605,  379,  542,  542,  542,
1000 542,  542,  544,  544,  544,  544,  544,  545,  545,  545,
1001 545,  546,  546,  546,  546,  546,  389,  390,  391,  392,
1002 393,  393,  394,  395,  396,  388,  388,  388,  388,  388,
1003 549,  549,  549,  549,  549,  551,  551,  551,  551,  551,
1004
1005 552,  552,  552,  552,  553,  553,  553,  553,  553,  379,
1006 379,  379,  379,  379,  379,  379,  379,  814,  379,  379,
1007 379,  814,  379,  555,  379,  814,  379,  379,  379,  379,
1008 379,  814,  379,  814,  379,  556,  557,  814,  379,  379,
1009 379,  379,  814,  814,  558,  379,  379,  814,  379,  814,
1010 814,  379,  379,  379,  560,  814,  379,  379,  379,  814,
1011 559,  379,  814,  379,  379,  379,  379,  814,  379,  379,
1012 379,  561,  814,  379,  562,  379,  379,  379,  379,  814,
1013 379,  563,  814,  379,  379,  379,  814,  379,  379,  379,
1014 379,  814,  379,  379,  379,  814,  564,  565,  566,  379,
1015
1016 814,  567,  568,  379,  379,  379,  379,  379,  379,  379,
1017 379,  379,  814,  379,  814,  814,  379,  814,  379,  814,
1018 570,  379,  609,  609,  609,  609,  379,  814,  379,  569,
1019 814,  379,  415,  415,  415,  415,  415,  415,  415,  415,
1020 415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
1021 415,  415,  571,  571,  571,  571,  571,  572,  572,  572,
1022 572,  572,  573,  573,  573,  573,  573,  207,  207,  207,
1023 207,  207,  207,  207,  207,  207,  207,  207,  207,  207,
1024 207,  207,  207,  207,  207,  207,  207,  574,  574,  574,
1025 574,  574,  575,  575,  575,  575,  575,  576,  576,  576,
1026
1027 576,  576,  216,  216,  216,  216,  216,  216,  216,  216,
1028 216,  216,  216,  216,  216,  216,  216,  216,  216,  216,
1029 216,  216,  577,  577,  577,  577,  577,  578,  578,  578,
1030 578,  578,  579,  579,  579,  579,  579,  445,  207,  207,
1031 207,  207,  207,  207,  242,  243,  580,  814,  581,  207,
1032 582,  207,  814,  207,  814,  242,  243,  207,  207,  207,
1033 814,  207,  814,  207,  207,  207,  207,  207,  207,  207,
1034 207,  207,  207,  814,  584,  207,  814,  585,  583,  586,
1035 207,  814,  207,  207,  207,  207,  814,  207,  207,  207,
1036 207,  814,  207,  587,  207,  207,  207,  207,  207,  207,
1037
1038 207,  207,  207,  207,  207,  814,  207,  590,  207,  207,
1039 588,  207,  814,  207,  207,  207,  207,  589,  207,  592,
1040 814,  591,  814,  207,  814,  207,  207,  207,  604,  604,
1041 604,  604,  604,  814,  814,  207,  814,  207,  612,  612,
1042 612,  593,  604,  604,  604,  604,  604,  207,  594,  594,
1043 814,  594,  594,  595,  595,  594,  594,  594,  594,  594,
1044 594,  594,  594,  594,  594,  594,  595,  594,  594,  594,
1045 594,  594,  594,  595,  595,  595,  595,  594,  594,  594,
1046 594,  595,  595,  595,  595,  595,  595,  595,  595,  595,
1047 595,  595,  595,  595,  595,  595,  595,  595,  595,  595,
1048
1049 594,  594,  594,  594,  594,  594,  594,  594,  594,  596,
1050 597,  598,  599,  600,  600,  601,  602,  603,  604,  604,
1051 604,  604,  604,  291,  471,  471,  471,  471,  471,  606,
1052 606,  606,  606,  606,  608,  608,  608,  608,  608,  610,
1053 610,  610,  610,  610,  291,  480,  480,  480,  480,  480,
1054 613,  613,  613,  613,  613,  615,  615,  615,  615,  615,
1055 616,  616,  616,  616,  617,  617,  617,  617,  617,  281,
1056 281,  281,  281,  281,  281,  281,  281,  281,  281,  689,
1057 689,  689,  814,  472,  473,  474,  475,  476,  476,  477,
1058 478,  479,  281,  281,  281,  281,  281,  281,  281,  281,
1059
1060 281,  281,  814,  814,  481,  482,  483,  484,  485,  485,
1061 486,  487,  488,  619,  619,  619,  619,  619,  620,  620,
1062 620,  620,  620,  621,  621,  621,  621,  621,  622,  292,
1063 292,  292,  292,  292,  719,  719,  719,  496,  292,  292,
1064 292,  292,  292,  292,  292,  292,  292,  292,  496,  814,
1065 496,  292,  292,  292,  292,  292,  623,  623,  623,  623,
1066 623,  624,  624,  624,  624,  624,  625,  625,  625,  625,
1067 625,  301,  301,  301,  301,  301,  301,  301,  301,  301,
1068 301,  301,  301,  301,  301,  301,  301,  301,  301,  301,
1069 301,  626,  626,  626,  626,  626,  627,  627,  627,  627,
1070
1071 627,  628,  628,  628,  628,  628,  292,  292,  292,  292,
1072 814,  814,  629,  292,  292,  292,  292,  292,  630,  292,
1073 814,  631,  292,  292,  292,  814,  292,  292,  814,  292,
1074 292,  292,  633,  292,  292,  814,  632,  292,  292,  292,
1075 292,  634,  814,  292,  292,  292,  814,  635,  292,  814,
1076 292,  292,  292,  292,  636,  292,  292,  292,  292,  814,
1077 292,  292,  292,  292,  814,  292,  814,  292,  292,  292,
1078 814,  639,  292,  292,  637,  292,  292,  292,  638,  292,
1079 292,  292,  292,  292,  292,  814,  292,  814,  814,  640,
1080 814,  292,  641,  814,  292,  814,  292,  814,  642,  814,
1081
1082 814,  292,  814,  814,  292,  594,  643,  814,  594,  594,
1083 644,  644,  594,  594,  594,  594,  594,  594,  594,  594,
1084 594,  594,  594,  644,  594,  594,  594,  594,  594,  594,
1085 644,  644,  644,  644,  594,  594,  594,  594,  644,  644,
1086 644,  644,  644,  644,  644,  644,  644,  644,  644,  644,
1087 644,  644,  644,  644,  644,  644,  644,  594,  594,  594,
1088 594,  594,  594,  594,  594,  594,  645,  646,  647,  648,
1089 649,  649,  650,  651,  652,  653,  653,  653,  653,  653,
1090 653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
1091 379,  379,  379,  379,  379,  379,  379,  379,  379,  379,
1092
1093 379,  379,  379,  379,  379,  379,  379,  379,  379,  379,
1094 654,  654,  654,  654,  654,  655,  655,  655,  655,  655,
1095 656,  656,  656,  656,  656,  388,  388,  388,  388,  388,
1096 388,  388,  388,  388,  388,  388,  388,  388,  388,  388,
1097 388,  388,  388,  388,  388,  657,  657,  657,  657,  657,
1098 658,  658,  658,  658,  658,  659,  659,  659,  659,  659,
1099 379,  379,  379,  379,  814,  814,  660,  379,  379,  379,
1100 379,  379,  661,  379,  814,  662,  379,  379,  379,  814,
1101 379,  379,  814,  379,  379,  379,  664,  379,  379,  814,
1102 663,  379,  379,  379,  379,  665,  814,  379,  379,  379,
1103
1104 814,  666,  379,  814,  379,  379,  379,  379,  667,  379,
1105 379,  379,  379,  814,  379,  379,  379,  379,  814,  379,
1106 814,  379,  379,  379,  814,  670,  379,  379,  668,  379,
1107 379,  379,  669,  379,  379,  379,  379,  379,  379,  814,
1108 379,  814,  814,  671,  814,  379,  672,  814,  379,  814,
1109 379,  814,  673,  814,  814,  379,  814,  814,  379,  674,
1110 674,  674,  674,  674,  674,  674,  674,  674,  674,  674,
1111 674,  674,  674,  674,  675,  675,  675,  675,  675,  675,
1112 675,  675,  675,  675,  675,  675,  675,  675,  675,  676,
1113 676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1114
1115 676,  676,  676,  676,  207,  207,  207,  207,  207,  207,
1116 207,  207,  814,  207,  207,  207,  814,  207,  677,  207,
1117 678,  207,  814,  679,  207,  207,  680,  207,  814,  207,
1118 814,  207,  207,  207,  207,  207,  207,  814,  207,  207,
1119 814,  814,  814,  207,  207,  207,  207,  207,  207,  207,
1120 814,  814,  814,  207,  681,  207,  682,  683,  207,  207,
1121 684,  207,  207,  207,  207,  207,  685,  814,  207,  686,
1122 814,  687,  207,  814,  207,  207,  207,  207,  207,  814,
1123 814,  814,  207,  814,  207,  814,  207,  688,  207,  595,
1124 595,  595,  595,  595,  814,  814,  207,  814,  207,  690,
1125
1126 690,  690,  690,  690,  692,  692,  692,  692,  692,  693,
1127 693,  693,  693,  694,  694,  694,  694,  694,  207,  207,
1128 471,  471,  471,  471,  471,  723,  723,  723,  723,  207,
1129 471,  471,  471,  471,  471,  814,  814,  814,  814,  207,
1130 471,  471,  471,  471,  471,  471,  471,  471,  471,  471,
1131 696,  696,  696,  696,  696,  697,  697,  697,  697,  697,
1132 698,  698,  698,  698,  698,  480,  480,  480,  480,  480,
1133 480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
1134 480,  480,  480,  480,  480,  699,  699,  699,  699,  699,
1135 700,  700,  700,  700,  700,  701,  701,  701,  701,  701,
1136
1137 702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
1138 702,  702,  702,  702,  702,  622,  703,  703,  703,  703,
1139 703,  814,  814,  814,  496,  703,  703,  703,  703,  703,
1140 703,  703,  703,  703,  703,  496,  814,  496,  704,  704,
1141 704,  704,  704,  704,  704,  704,  704,  704,  704,  704,
1142 704,  704,  704,  292,  292,  292,  292,  292,  292,  292,
1143 292,  814,  292,  292,  292,  814,  292,  705,  292,  706,
1144 292,  814,  707,  292,  292,  708,  292,  814,  292,  814,
1145 292,  292,  292,  292,  292,  292,  814,  292,  292,  814,
1146 814,  814,  292,  292,  292,  292,  292,  292,  292,  814,
1147
1148 814,  814,  292,  709,  292,  710,  711,  292,  292,  712,
1149 292,  292,  292,  292,  292,  713,  814,  292,  714,  814,
1150 715,  292,  814,  292,  292,  292,  292,  292,  814,  643,
1151 496,  292,  814,  292,  814,  292,  716,  292,  594,  644,
1152 644,  644,  644,  644,  814,  292,  814,  292,  814,  594,
1153 594,  594,  718,  720,  720,  720,  720,  720,  722,  722,
1154 722,  722,  722,  724,  724,  724,  724,  724,  292,  292,
1155 726,  726,  726,  726,  726,  814,  814,  814,  814,  292,
1156 814,  814,  814,  718,  726,  726,  726,  726,  726,  292,
1157 726,  726,  726,  726,  726,  727,  727,  727,  727,  727,
1158
1159 727,  727,  727,  727,  727,  727,  727,  727,  727,  727,
1160 379,  379,  379,  379,  379,  379,  379,  379,  814,  379,
1161 379,  379,  814,  379,  728,  379,  729,  379,  814,  730,
1162 379,  379,  731,  379,  814,  379,  814,  379,  379,  379,
1163 379,  379,  379,  814,  379,  379,  814,  814,  814,  379,
1164 379,  379,  379,  379,  379,  379,  814,  814,  814,  379,
1165 732,  379,  733,  734,  379,  379,  735,  379,  379,  379,
1166 379,  379,  736,  814,  379,  737,  814,  738,  379,  814,
1167 379,  379,  379,  379,  379,  379,  379,  814,  379,  814,
1168 379,  814,  379,  739,  379,  814,  379,  207,  207,  207,
1169
1170 207,  814,  379,  814,  379,  814,  379,  814,  207,  814,
1171 207,  207,  207,  207,  207,  207,  207,  814,  207,  814,
1172 207,  814,  207,  814,  207,  814,  741,  207,  207,  814,
1173 740,  814,  207,  814,  207,  814,  207,  814,  207,  207,
1174 207,  814,  207,  207,  742,  207,  207,  814,  207,  814,
1175 207,  814,  743,  207,  814,  745,  207,  207,  207,  814,
1176 207,  207,  207,  207,  814,  744,  207,  814,  207,  207,
1177 207,  814,  207,  814,  746,  207,  207,  814,  207,  814,
1178 207,  748,  747,  814,  814,  814,  207,  814,  814,  814,
1179 207,  595,  595,  595,  595,  595,  207,  595,  595,  595,
1180
1181 595,  595,  595,  595,  595,  595,  595,  595,  595,  595,
1182 595,  595,  749,  749,  749,  749,  749,  750,  750,  750,
1183 750,  750,  751,  751,  751,  751,  751,  752,  752,  752,
1184 752,  752,  752,  752,  752,  752,  752,  752,  752,  752,
1185 752,  752,  753,  753,  753,  753,  753,  753,  753,  753,
1186 753,  753,  753,  753,  753,  753,  753,  292,  292,  292,
1187 292,  292,  292,  814,  292,  292,  292,  292,  292,  814,
1188 292,  814,  292,  292,  292,  292,  814,  755,  292,  814,
1189 292,  754,  292,  814,  292,  292,  814,  292,  292,  292,
1190 756,  292,  292,  814,  292,  292,  292,  814,  814,  292,
1191
1192 814,  757,  292,  814,  814,  759,  292,  292,  292,  292,
1193 292,  292,  292,  814,  758,  814,  292,  814,  292,  292,
1194 292,  292,  292,  292,  760,  814,  814,  814,  292,  814,
1195 292,  761,  814,  292,  762,  644,  644,  644,  644,  644,
1196 292,  814,  814,  292,  644,  644,  644,  644,  644,  644,
1197 644,  644,  644,  644,  644,  644,  644,  644,  644,  764,
1198 764,  764,  764,  764,  765,  765,  765,  765,  765,  766,
1199 766,  766,  766,  766,  379,  379,  379,  379,  379,  379,
1200 814,  379,  379,  379,  379,  379,  814,  379,  814,  379,
1201 379,  379,  379,  814,  768,  379,  814,  379,  767,  379,
1202
1203 814,  379,  379,  814,  379,  379,  379,  769,  379,  379,
1204 814,  379,  379,  379,  814,  814,  379,  814,  770,  379,
1205 814,  814,  772,  379,  379,  379,  379,  379,  379,  379,
1206 814,  771,  814,  379,  814,  379,  379,  379,  379,  379,
1207 379,  773,  207,  207,  814,  379,  814,  379,  774,  814,
1208 379,  775,  814,  207,  207,  207,  814,  379,  207,  207,
1209 379,  207,  207,  207,  776,  207,  777,  207,  207,  207,
1210 207,  207,  207,  814,  779,  207,  207,  207,  207,  207,
1211 814,  207,  207,  207,  207,  778,  814,  207,  207,  207,
1212 207,  207,  814,  814,  207,  814,  814,  207,  814,  814,
1213
1214 207,  814,  814,  814,  207,  780,  780,  780,  780,  780,
1215 207,  780,  780,  780,  780,  780,  780,  780,  780,  780,
1216 780,  292,  292,  292,  292,  292,  292,  292,  292,  814,
1217 292,  292,  292,  782,  292,  814,  292,  814,  292,  292,
1218 292,  292,  292,  781,  292,  783,  292,  814,  292,  814,
1219 292,  292,  784,  292,  292,  292,  292,  292,  292,  814,
1220 292,  763,  496,  814,  292,  814,  292,  814,  292,  785,
1221 785,  785,  785,  785,  292,  814,  292,  814,  292,  814,
1222 814,  814,  594,  785,  785,  785,  785,  785,  785,  785,
1223 785,  785,  785,  379,  379,  379,  379,  379,  379,  379,
1224
1225 379,  814,  379,  379,  379,  787,  379,  814,  379,  814,
1226 379,  379,  379,  379,  379,  786,  379,  788,  379,  814,
1227 379,  814,  379,  379,  789,  379,  379,  379,  379,  379,
1228 379,  814,  379,  207,  207,  814,  379,  814,  379,  814,
1229 379,  207,  207,  790,  207,  814,  379,  814,  379,  814,
1230 379,  814,  207,  814,  207,  207,  207,  207,  207,  292,
1231 292,  814,  791,  292,  292,  814,  207,  814,  207,  794,
1232 292,  814,  792,  814,  292,  814,  207,  793,  207,  814,
1233 292,  292,  292,  814,  795,  292,  292,  814,  814,  379,
1234 379,  814,  292,  379,  379,  814,  292,  814,  796,  798,
1235
1236 379,  814,  292,  814,  379,  797,  292,  379,  379,  814,
1237 379,  379,  379,  814,  799,  207,  207,  814,  379,  814,
1238 814,  814,  379,  814,  800,  814,  207,  814,  379,  207,
1239 207,  801,  379,  207,  207,  814,  207,  207,  207,  814,
1240 207,  814,  802,  814,  207,  292,  292,  803,  207,  814,
1241 207,  292,  292,  814,  207,  814,  292,  814,  207,  292,
1242 292,  814,  292,  814,  804,  814,  292,  292,  292,  814,
1243 292,  814,  292,  379,  379,  379,  379,  805,  292,  814,
1244 292,  814,  379,  379,  379,  814,  379,  814,  292,  379,
1245 379,  207,  207,  379,  379,  806,  379,  207,  207,  807,
1246
1247 379,  814,  207,  379,  292,  292,  292,  292,  207,  808,
1248 379,  814,  207,  379,  379,  292,  814,  292,  207,  379,
1249 379,  814,  809,  814,  379,  292,  814,  292,  207,  207,
1250 379,  810,  207,  207,  379,  292,  292,  379,  379,  207,
1251 379,  814,  814,  207,  814,  811,  292,  814,  379,  207,
1252 292,  292,  812,  207,  813,  814,  292,  814,  379,  379,
1253 379,  292,  814,  814,  814,  814,  814,  814,  814,  814,
1254 379,  292,  814,  814,  814,  814,  814,  814,  814,  814,
1255 379,   97,   97,   97,   97,   97,   97,   97,   97,   97,
1256 97,   97,   97,  103,  103,  103,  103,  103,  103,  103,
1257
1258 103,  103,  103,  103,  103,  109,  109,  109,  109,  109,
1259 109,  109,  109,  109,  109,  109,  109,  114,  114,  114,
1260 114,  114,  114,  114,  114,  114,  114,  114,  114,  117,
1261 117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
1262 117,  163,  163,  163,  163,  163,  163,  163,  163,  163,
1263 163,  163,  163,  207,  814,  814,  814,  814,  814,  207,
1264 216,  814,  814,  814,  814,  814,  216,  281,  281,  281,
1265 814,  281,  281,  292,  814,  814,  814,  292,  814,  814,
1266 814,  814,  814,  292,  301,  814,  814,  814,  814,  814,
1267 301,  337,  337,  814,  814,  814,  337,  337,  337,  337,
1268
1269 337,  814,  337,  344,  344,  814,  814,  814,  344,  344,
1270 344,  344,  344,  814,  344,  351,  351,  814,  814,  351,
1271 351,  351,  351,  814,  351,  351,  351,  355,  355,  814,
1272 814,  355,  355,  355,  355,  355,  355,  355,  355,  374,
1273 814,  814,  814,  814,  374,  374,  374,  374,  814,  374,
1274 374,  379,  814,  814,  814,  814,  814,  379,  388,  814,
1275 814,  814,  814,  814,  388,  439,  439,  439,  439,  439,
1276 439,  439,  439,  439,  439,  439,  443,  443,  443,  443,
1277 443,  443,  443,  443,  443,  443,  443,  450,  450,  450,
1278 450,  450,  450,  450,  450,  450,  450,  450,  471,  814,
1279
1280 814,  814,  471,  814,  814,  814,  814,  814,  471,  480,
1281 814,  814,  814,  814,  814,  480,  496,  496,  496,  496,
1282 496,  496,  496,  814,  496,  496,  496,  496,  594,  594,
1283 814,  594,  594,  594,  594,  594,  594,  594,  594,  594,
1284 717,  717,  717,  717,  717,  717,  717,  717,  717,  717,
1285 717,  717,   19,  814,  814,  814,  814,  814,  814,  814,
1286 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1287 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1288 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1289 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1290
1291 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1292 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1293 814,  814,  814
1294 } ;
1295
1296 static yyconst flex_int16_t yy_chk[4224] =
1297 {
1298 0,
1299 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1300 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1301 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1302 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1303 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1304 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1305 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1306 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1307 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1308 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1309
1310 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1311 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1312 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1313 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1314 3,    3,    3,    4,    4,    4,  652,    3,    9,    9,
1315 4,    5,    5,    5,    3,   10,   10,    4,    5,    6,
1316 6,    6,    7,    7,  603,    5,    6,   32,    8,    8,
1317 540,   32,    7,    6,   11,   11,   11,    7,    8,   12,
1318 12,   12,  539,    8,   21,   21,   21,   37,   67,   67,
1319 11,   37,   37,   91,   91,   12,   13,   13,   13,   13,
1320
1321 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1322 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1323 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1324 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1325 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1326 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1327 13,   13,   13,   13,   13,   13,   15,   15,   15,   15,
1328 41,   22,  538,   42,   15,   15,   43,   44,  100,   15,
1329 23,   23,   15,  100,   22,   15,   15,   15,   15,   15,
1330 22,   41,   41,   23,   42,  158,  158,   43,   44,   23,
1331
1332 25,   25,   25,   25,   25,   25,   25,   25,   25,   26,
1333 26,   26,   26,   26,   26,   26,   26,   26,  196,  196,
1334 15,   16,   16,   16,   16,  537,   38,  536,   38,   16,
1335 16,   65,   65,   65,   16,   38,   38,   16,   49,   49,
1336 16,   16,   16,   16,   16,   36,   38,   38,   36,   49,
1337 52,   52,   36,   36,   36,  101,  535,   49,  533,   49,
1338 101,   52,   89,   89,   89,   52,   36,   52,   36,  106,
1339 488,   52,  211,  211,  106,   16,   17,   17,   17,   17,
1340 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1341 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1342
1343 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1344 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1345 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1346 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1347 17,   17,   17,   17,   17,   17,   27,   27,   50,   50,
1348 51,   51,   53,   53,   50,   63,  479,   27,  134,   50,
1349 107,   51,  134,   53,  449,  107,   50,   27,   51,   50,
1350 53,   51,  121,   53,   53,  144,   63,  121,   54,   54,
1351 27,   27,   27,   27,   27,   27,   27,   27,   27,   54,
1352 55,   55,   56,   56,   57,   57,  144,   58,   58,   54,
1353
1354 448,   55,   56,   56,   57,   57,   74,  171,   58,   58,
1355 231,   55,  171,   56,  231,   57,   58,   57,   58,   59,
1356 59,   64,   64,   64,   64,   64,   70,   70,   70,   70,
1357 59,   59,   66,   66,   66,   66,   66,  447,  143,  446,
1358 59,   68,   68,   68,   68,   68,   69,   69,   69,   69,
1359 69,   71,   71,   71,   71,   71,   73,   73,   73,  143,
1360 143,   73,   94,   94,   94,   94,   74,   74,   74,   74,
1361 74,   74,   74,   74,   74,   75,   75,   75,   75,   75,
1362 75,   75,   75,   75,   77,   77,   78,   78,   79,   79,
1363 81,   81,   78,  181,  424,   77,  396,   78,  181,   79,
1364
1365 387,   81,  375,   77,   78,   77,   79,   78,   81,   79,
1366 139,   81,   81,  373,  139,  139,   73,   73,   73,   73,
1367 73,   73,   73,   73,   73,   76,   80,   80,   82,   82,
1368 156,  156,  156,   83,   83,   84,   84,   80,  372,   82,
1369 124,   80,  371,   80,   83,   84,   84,   80,  145,   82,
1370 146,   76,   76,  124,   83,  154,   84,   85,   85,  124,
1371 125,  125,   76,   86,   86,  220,  220,   85,   85,  145,
1372 370,  146,   76,  125,   86,   86,  154,  366,   85,  125,
1373 85,  365,   86,  357,   86,   76,   76,   76,   76,   76,
1374 76,   76,   76,   76,   87,   87,   88,   88,   88,   88,
1375
1376 88,  160,  160,  160,  160,   87,   87,   90,   90,   90,
1377 90,   90,  194,  194,  194,   87,   92,   92,   92,   92,
1378 92,   93,   93,   93,   93,   93,   95,   95,   95,   95,
1379 95,  123,  123,  123,  244,  309,  127,  127,  300,  242,
1380 123,  242,  290,  123,  242,  123,  123,  127,  235,  123,
1381 155,  155,  155,  155,  155,  244,  244,  127,  128,  128,
1382 128,  128,  128,  128,  128,  128,  128,  129,  129,  201,
1383 201,  201,  138,  247,  233,  138,  286,  286,  129,  138,
1384 138,  138,  140,  232,  140,  209,  209,  209,  129,  296,
1385 296,  140,  140,  138,  247,  138,  157,  157,  157,  157,
1386
1387 157,  224,  140,  140,  159,  159,  159,  159,  159,  161,
1388 161,  161,  161,  161,  178,  178,  178,  178,  178,  178,
1389 178,  178,  178,  179,  179,  179,  179,  179,  179,  179,
1390 179,  179,  180,  180,  363,  182,  182,  184,  184,  183,
1391 183,  186,  186,  180,  215,  183,  182,  203,  184,  363,
1392 183,  200,  186,  180,  182,  184,  182,  183,  184,  186,
1393 183,  166,  186,  186,  185,  185,  180,  180,  180,  180,
1394 180,  180,  180,  180,  180,  185,  187,  187,  164,  185,
1395 162,  185,  188,  188,  249,  185,  152,  187,  189,  189,
1396 190,  190,  148,  188,  141,  191,  191,  187,  189,  189,
1397
1398 190,  190,  137,  188,  135,  249,  191,  191,  130,  189,
1399 243,  190,  243,  190,  191,  243,  191,  192,  192,  193,
1400 193,  193,  193,  193,  198,  198,  198,  198,  192,  192,
1401 195,  195,  195,  195,  195,  218,  218,  218,  192,  197,
1402 197,  197,  197,  197,  199,  199,  199,  199,  199,  204,
1403 204,  204,  205,  205,  205,  120,  206,  305,  305,  207,
1404 207,  118,  204,  383,  383,  205,  392,  392,  204,  206,
1405 207,  205,  284,  284,  284,  206,  213,  213,  213,  213,
1406 207,  208,  208,  208,  208,  208,  210,  210,  210,  210,
1407 210,  212,  212,  212,  212,  212,  214,  214,  214,  214,
1408
1409 214,  217,  217,  217,  217,  217,  219,  219,  219,  219,
1410 219,  221,  221,  221,  221,  221,  222,  222,  222,  222,
1411 223,  223,  223,  223,  223,  225,  225,  226,  226,  240,
1412 364,  251,  234,  116,  240,  240,  225,  113,  226,  234,
1413 234,  270,  240,  240,  112,  364,  225,  240,  226,  240,
1414 234,  234,  251,  240,  240,  241,  111,  241,  253,  253,
1415 254,  254,  270,  108,  241,  241,  255,  255,  253,  253,
1416 105,  254,  102,  256,  256,  241,  241,  255,   99,  253,
1417 254,  254,   96,  255,  256,  257,  257,  255,  258,  258,
1418 72,  259,  259,   61,  256,   46,  257,  258,   28,  258,
1419
1420 260,  260,  259,  261,  261,  257,  257,  262,  262,  258,
1421 259,  260,  259,   19,  261,  263,  263,  260,  262,  262,
1422 0,  260,  264,  264,  261,    0,  263,    0,  262,  265,
1423 265,  475,  475,  264,    0,  263,  263,  264,  266,  266,
1424 265,    0,  265,  264,  267,  267,  271,  271,  266,  266,
1425 265,  268,  268,  484,  484,  267,    0,  271,    0,  266,
1426 281,    0,  268,    0,  268,  267,    0,  271,  267,  294,
1427 294,  294,  268,  272,  272,  272,  272,  272,  273,  273,
1428 273,  273,  273,  274,  274,  274,  274,  274,  275,  275,
1429 275,  275,  275,  276,  276,  276,  276,  276,  277,  277,
1430
1431 277,  277,  277,  278,  278,  278,  278,  278,  279,  279,
1432 279,  279,  279,  280,  280,  280,  599,  599,  280,    0,
1433 281,  281,  281,  281,  281,  281,  281,  281,  281,  282,
1434 282,  282,  282,  282,  282,  282,  282,  282,  283,  283,
1435 283,  283,  283,  285,  285,  285,  285,  285,  287,  287,
1436 287,  287,  287,  288,  288,  288,  288,  289,  289,  289,
1437 289,  289,  291,  293,  293,  293,  293,  293,  301,  343,
1438 343,  292,  292,  280,  280,  280,  280,  280,  280,  280,
1439 280,  280,  292,  343,    0,  291,  295,  295,  295,  295,
1440 295,    0,  292,  297,  297,  297,  297,  297,  298,  298,
1441
1442 298,  298,  299,  299,  299,  299,  299,  302,  302,  302,
1443 302,  302,  303,  303,  303,    0,  291,  304,  304,  304,
1444 304,  304,  306,  306,  306,  306,  306,    0,  301,  301,
1445 301,  301,  301,  301,  301,  301,  301,  307,  307,  307,
1446 307,  308,  308,  308,  308,  308,  310,  310,  311,  311,
1447 312,  312,  313,  313,    0,  315,  315,  310,    0,  311,
1448 312,  312,    0,  313,  314,  314,  315,  310,    0,  311,
1449 0,  312,  313,  313,    0,  314,  315,  316,  316,  648,
1450 648,  314,  317,  317,    0,  314,    0,    0,  316,  318,
1451 318,  317,    0,  317,  319,  319,    0,  316,  316,    0,
1452
1453 318,  320,  320,  317,    0,  319,  321,  321,  318,    0,
1454 318,  319,  320,  322,  322,  319,    0,  321,  321,    0,
1455 323,  323,  320,    0,  322,  324,  324,  321,    0,  325,
1456 325,  323,    0,  322,  322,  323,  324,    0,  324,  325,
1457 325,  323,  326,  326,  327,  327,  324,  328,  328,    0,
1458 325,    0,    0,  326,    0,  327,    0,  327,  328,  381,
1459 381,  381,    0,  326,    0,  327,  326,    0,  328,  329,
1460 329,  329,  329,  329,  330,  330,  330,  330,  330,  331,
1461 331,  331,  331,  331,  332,  332,  332,  332,  332,  333,
1462 333,  333,  333,  333,  334,  334,  334,  334,  334,  335,
1463
1464 335,  335,  335,  335,  336,  336,  336,  336,  336,  350,
1465 350,    0,  361,  361,  361,  367,  718,  718,  368,  368,
1466 0,  361,    0,  350,  361,    0,  361,  361,  367,  368,
1467 361,  369,  369,    0,  367,  379,  379,  718,    0,  368,
1468 0,    0,  369,  390,  390,  390,  379,  380,  380,  380,
1469 380,  380,  369,  473,  473,  473,  379,  382,  382,  382,
1470 382,  382,  384,  384,  384,  384,  384,  385,  385,  385,
1471 385,  386,  386,  386,  386,  386,  388,  388,  388,  388,
1472 388,  388,  388,  388,  388,  389,  389,  389,  389,  389,
1473 391,  391,  391,  391,  391,  393,  393,  393,  393,  393,
1474
1475 394,  394,  394,  394,  395,  395,  395,  395,  395,  397,
1476 397,  398,  398,  399,  399,  400,  400,    0,  402,  402,
1477 397,    0,  398,  399,  399,    0,  400,  401,  401,  402,
1478 397,    0,  398,    0,  399,  400,  400,    0,  401,  402,
1479 403,  403,    0,    0,  401,  404,  404,    0,  401,    0,
1480 0,  403,  405,  405,  404,    0,  404,  406,  406,    0,
1481 403,  403,    0,  405,  407,  407,  404,    0,  406,  408,
1482 408,  405,    0,  405,  406,  407,  409,  409,  406,    0,
1483 408,  408,    0,  410,  410,  407,    0,  409,  411,  411,
1484 408,    0,  412,  412,  410,    0,  409,  409,  410,  411,
1485
1486 0,  411,  412,  412,  410,  413,  413,  414,  414,  411,
1487 415,  415,    0,  412,    0,    0,  413,    0,  414,    0,
1488 414,  415,  477,  477,  477,  477,  413,    0,  414,  413,
1489 0,  415,  416,  416,  416,  416,  416,  417,  417,  417,
1490 417,  417,  418,  418,  418,  418,  418,  419,  419,  419,
1491 419,  419,  420,  420,  420,  420,  420,  421,  421,  421,
1492 421,  421,  422,  422,  422,  422,  422,  425,  425,  425,
1493 425,  425,  426,  426,  426,  426,  426,  427,  427,  427,
1494 427,  427,  428,  428,  428,  428,  428,  429,  429,  429,
1495 429,  429,  430,  430,  430,  430,  430,  431,  431,  431,
1496
1497 431,  431,  432,  432,  432,  432,  432,  433,  433,  433,
1498 433,  433,  434,  434,  434,  434,  434,  435,  435,  435,
1499 435,  435,  436,  436,  436,  436,  436,  437,  437,  437,
1500 437,  437,  438,  438,  438,  438,  438,  445,  452,  452,
1501 451,  451,  453,  453,  445,  445,  451,    0,  452,  452,
1502 453,  451,    0,  453,    0,  445,  445,  454,  454,  452,
1503 0,  451,    0,  453,  455,  455,  456,  456,  454,  457,
1504 457,  458,  458,    0,  455,  455,    0,  456,  454,  458,
1505 457,    0,  458,  459,  459,  455,    0,  456,  460,  460,
1506 457,    0,  458,  459,  459,  461,  461,  462,  462,  460,
1507
1508 463,  463,  464,  464,  459,    0,  461,  462,  462,  460,
1509 460,  463,    0,  464,  465,  465,  461,  461,  462,  464,
1510 0,  463,    0,  464,    0,  465,  466,  466,  468,  468,
1511 468,  468,  468,    0,    0,  465,    0,  466,  482,  482,
1512 482,  466,  469,  469,  469,  469,  469,  466,  467,  467,
1513 0,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1514 467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1515 467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1516 467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1517 467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1518
1519 467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
1520 467,  467,  467,  467,  467,  467,  467,  467,  470,  470,
1521 470,  470,  470,  471,  472,  472,  472,  472,  472,  474,
1522 474,  474,  474,  474,  476,  476,  476,  476,  476,  478,
1523 478,  478,  478,  478,  480,  481,  481,  481,  481,  481,
1524 483,  483,  483,  483,  483,  485,  485,  485,  485,  485,
1525 486,  486,  486,  486,  487,  487,  487,  487,  487,  489,
1526 489,  489,  489,  489,  490,  490,  490,  490,  490,  597,
1527 597,  597,    0,  471,  471,  471,  471,  471,  471,  471,
1528 471,  471,  491,  491,  491,  491,  491,  492,  492,  492,
1529
1530 492,  492,    0,    0,  480,  480,  480,  480,  480,  480,
1531 480,  480,  480,  493,  493,  493,  493,  493,  494,  494,
1532 494,  494,  494,  495,  495,  495,  495,  495,  497,  498,
1533 498,  498,  498,  498,  646,  646,  646,  497,  499,  499,
1534 499,  499,  499,  500,  500,  500,  500,  500,  497,    0,
1535 497,  501,  501,  501,  501,  501,  502,  502,  502,  502,
1536 502,  503,  503,  503,  503,  503,  504,  504,  504,  504,
1537 504,  505,  505,  505,  505,  505,  506,  506,  506,  506,
1538 506,  507,  507,  507,  507,  507,  508,  508,  508,  508,
1539 508,  509,  509,  509,  509,  509,  510,  510,  510,  510,
1540
1541 510,  511,  511,  511,  511,  511,  512,  512,  513,  513,
1542 0,    0,  512,  514,  514,  515,  515,  512,  513,  513,
1543 0,  514,  516,  516,  514,    0,  515,  512,    0,  513,
1544 517,  517,  516,  516,  514,    0,  515,  518,  518,  519,
1545 519,  517,    0,  516,  520,  520,    0,  519,  518,    0,
1546 519,  517,  521,  521,  520,  520,  522,  522,  518,    0,
1547 519,  523,  523,  521,    0,  520,    0,  522,  524,  524,
1548 0,  523,  523,  521,  521,  525,  525,  522,  522,  524,
1549 526,  526,  523,  527,  527,    0,  525,    0,    0,  524,
1550 0,  526,  525,    0,  527,    0,  525,    0,  527,    0,
1551
1552 0,  526,    0,    0,  527,  528,  528,    0,  528,  528,
1553 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1554 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1555 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1556 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1557 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1558 528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
1559 528,  528,  528,  528,  528,  529,  529,  529,  529,  529,
1560 530,  530,  530,  530,  530,  531,  531,  531,  531,  531,
1561 541,  541,  541,  541,  541,  542,  542,  542,  542,  542,
1562
1563 543,  543,  543,  543,  543,  544,  544,  544,  544,  544,
1564 545,  545,  545,  545,  545,  546,  546,  546,  546,  546,
1565 547,  547,  547,  547,  547,  548,  548,  548,  548,  548,
1566 549,  549,  549,  549,  549,  550,  550,  550,  550,  550,
1567 551,  551,  551,  551,  551,  552,  552,  552,  552,  552,
1568 553,  553,  553,  553,  553,  554,  554,  554,  554,  554,
1569 555,  555,  556,  556,    0,    0,  555,  557,  557,  558,
1570 558,  555,  556,  556,    0,  557,  559,  559,  557,    0,
1571 558,  555,    0,  556,  560,  560,  559,  559,  557,    0,
1572 558,  561,  561,  562,  562,  560,    0,  559,  563,  563,
1573
1574 0,  562,  561,    0,  562,  560,  564,  564,  563,  563,
1575 565,  565,  561,    0,  562,  566,  566,  564,    0,  563,
1576 0,  565,  567,  567,    0,  566,  566,  564,  564,  568,
1577 568,  565,  565,  567,  569,  569,  566,  570,  570,    0,
1578 568,    0,    0,  567,    0,  569,  568,    0,  570,    0,
1579 568,    0,  570,    0,    0,  569,    0,    0,  570,  571,
1580 571,  571,  571,  571,  572,  572,  572,  572,  572,  573,
1581 573,  573,  573,  573,  574,  574,  574,  574,  574,  575,
1582 575,  575,  575,  575,  576,  576,  576,  576,  576,  577,
1583 577,  577,  577,  577,  578,  578,  578,  578,  578,  579,
1584
1585 579,  579,  579,  579,  580,  580,  581,  581,  582,  582,
1586 583,  583,    0,  584,  584,  580,    0,  581,  580,  582,
1587 582,  583,    0,  583,  584,  580,  584,  581,    0,  582,
1588 0,  583,  585,  585,  584,  586,  586,    0,  587,  587,
1589 0,    0,    0,  585,  588,  588,  586,  589,  589,  587,
1590 0,    0,    0,  585,  585,  588,  586,  587,  589,  587,
1591 588,  590,  590,  591,  591,  588,  589,    0,  589,  590,
1592 0,  591,  590,    0,  591,  592,  592,  593,  593,    0,
1593 0,    0,  590,    0,  591,    0,  592,  593,  593,  596,
1594 596,  596,  596,  596,    0,    0,  592,    0,  593,  598,
1595
1596 598,  598,  598,  598,  600,  600,  600,  600,  600,  601,
1597 601,  601,  601,  602,  602,  602,  602,  602,  604,  604,
1598 605,  605,  605,  605,  605,  650,  650,  650,  650,  604,
1599 606,  606,  606,  606,  606,    0,    0,    0,    0,  604,
1600 607,  607,  607,  607,  607,  608,  608,  608,  608,  608,
1601 609,  609,  609,  609,  609,  610,  610,  610,  610,  610,
1602 611,  611,  611,  611,  611,  612,  612,  612,  612,  612,
1603 613,  613,  613,  613,  613,  614,  614,  614,  614,  614,
1604 615,  615,  615,  615,  615,  616,  616,  616,  616,  616,
1605 617,  617,  617,  617,  617,  618,  618,  618,  618,  618,
1606
1607 619,  619,  619,  619,  619,  620,  620,  620,  620,  620,
1608 621,  621,  621,  621,  621,  622,  623,  623,  623,  623,
1609 623,    0,    0,    0,  622,  624,  624,  624,  624,  624,
1610 625,  625,  625,  625,  625,  622,    0,  622,  626,  626,
1611 626,  626,  626,  627,  627,  627,  627,  627,  628,  628,
1612 628,  628,  628,  629,  629,  630,  630,  631,  631,  632,
1613 632,    0,  633,  633,  629,    0,  630,  629,  631,  631,
1614 632,    0,  632,  633,  629,  633,  630,    0,  631,    0,
1615 632,  634,  634,  633,  635,  635,    0,  636,  636,    0,
1616 0,    0,  634,  637,  637,  635,  638,  638,  636,    0,
1617
1618 0,    0,  634,  634,  637,  635,  636,  638,  636,  637,
1619 639,  639,  640,  640,  637,  638,    0,  638,  639,    0,
1620 640,  639,    0,  640,  641,  641,  642,  642,    0,  643,
1621 643,  639,    0,  640,    0,  641,  642,  642,  643,  645,
1622 645,  645,  645,  645,    0,  641,    0,  642,    0,  643,
1623 643,  643,  643,  647,  647,  647,  647,  647,  649,  649,
1624 649,  649,  649,  651,  651,  651,  651,  651,  653,  653,
1625 654,  654,  654,  654,  654,    0,    0,    0,    0,  653,
1626 0,    0,    0,  643,  655,  655,  655,  655,  655,  653,
1627 656,  656,  656,  656,  656,  657,  657,  657,  657,  657,
1628
1629 658,  658,  658,  658,  658,  659,  659,  659,  659,  659,
1630 660,  660,  661,  661,  662,  662,  663,  663,    0,  664,
1631 664,  660,    0,  661,  660,  662,  662,  663,    0,  663,
1632 664,  660,  664,  661,    0,  662,    0,  663,  665,  665,
1633 664,  666,  666,    0,  667,  667,    0,    0,    0,  665,
1634 668,  668,  666,  669,  669,  667,    0,    0,    0,  665,
1635 665,  668,  666,  667,  669,  667,  668,  670,  670,  671,
1636 671,  668,  669,    0,  669,  670,    0,  671,  670,    0,
1637 671,  672,  672,  673,  673,  674,  674,    0,  670,    0,
1638 671,    0,  672,  673,  673,    0,  674,  675,  675,  677,
1639
1640 677,    0,  672,    0,  673,    0,  674,    0,  675,    0,
1641 677,  678,  678,  679,  679,  680,  680,    0,  675,    0,
1642 677,    0,  678,    0,  679,    0,  680,  681,  681,    0,
1643 679,    0,  678,    0,  679,    0,  680,    0,  681,  682,
1644 682,    0,  683,  683,  681,  684,  684,    0,  681,    0,
1645 682,    0,  682,  683,    0,  684,  684,  685,  685,    0,
1646 682,  686,  686,  683,    0,  683,  684,    0,  685,  687,
1647 687,    0,  686,    0,  685,  688,  688,    0,  685,    0,
1648 687,  687,  686,    0,    0,    0,  688,    0,    0,    0,
1649 687,  689,  689,  689,  689,  689,  688,  690,  690,  690,
1650
1651 690,  690,  691,  691,  691,  691,  691,  692,  692,  692,
1652 692,  692,  693,  693,  693,  693,  693,  694,  694,  694,
1653 694,  694,  695,  695,  695,  695,  695,  696,  696,  696,
1654 696,  696,  697,  697,  697,  697,  697,  698,  698,  698,
1655 698,  698,  699,  699,  699,  699,  699,  700,  700,  700,
1656 700,  700,  701,  701,  701,  701,  701,  703,  703,  705,
1657 705,  706,  706,    0,  707,  707,  708,  708,  703,    0,
1658 705,    0,  706,  709,  709,  707,    0,  708,  703,    0,
1659 705,  707,  706,    0,  709,  707,    0,  708,  710,  710,
1660 709,  711,  711,    0,  709,  712,  712,    0,    0,  710,
1661
1662 0,  710,  711,    0,    0,  712,  712,  713,  713,  710,
1663 714,  714,  711,    0,  711,    0,  712,    0,  713,  716,
1664 716,  714,  715,  715,  713,    0,    0,    0,  713,    0,
1665 716,  714,    0,  715,  715,  719,  719,  719,  719,  719,
1666 716,    0,    0,  715,  720,  720,  720,  720,  720,  721,
1667 721,  721,  721,  721,  722,  722,  722,  722,  722,  723,
1668 723,  723,  723,  723,  724,  724,  724,  724,  724,  725,
1669 725,  725,  725,  725,  726,  726,  728,  728,  729,  729,
1670 0,  730,  730,  731,  731,  726,    0,  728,    0,  729,
1671 732,  732,  730,    0,  731,  726,    0,  728,  730,  729,
1672
1673 0,  732,  730,    0,  731,  733,  733,  732,  734,  734,
1674 0,  732,  735,  735,    0,    0,  733,    0,  733,  734,
1675 0,    0,  735,  735,  736,  736,  733,  737,  737,  734,
1676 0,  734,    0,  735,    0,  736,  739,  739,  737,  738,
1677 738,  736,  740,  740,    0,  736,    0,  739,  737,    0,
1678 738,  738,    0,  740,  741,  741,    0,  739,  742,  742,
1679 738,  744,  744,  740,  740,  741,  742,  743,  743,  742,
1680 745,  745,  744,    0,  744,  741,  746,  746,  743,  742,
1681 0,  745,  744,  747,  747,  743,    0,  746,  743,  748,
1682 748,  745,    0,    0,  747,    0,    0,  746,    0,    0,
1683
1684 748,    0,    0,    0,  747,  749,  749,  749,  749,  749,
1685 748,  750,  750,  750,  750,  750,  751,  751,  751,  751,
1686 751,  754,  754,  755,  755,  756,  756,  757,  757,    0,
1687 759,  759,  754,  756,  755,    0,  756,    0,  757,  758,
1688 758,  759,  754,  754,  755,  757,  756,    0,  757,    0,
1689 758,  759,  758,  760,  760,  761,  761,  762,  762,    0,
1690 758,  763,  763,    0,  760,    0,  761,    0,  762,  764,
1691 764,  764,  764,  764,  760,    0,  761,    0,  762,    0,
1692 0,    0,  763,  765,  765,  765,  765,  765,  766,  766,
1693 766,  766,  766,  767,  767,  768,  768,  769,  769,  770,
1694
1695 770,    0,  772,  772,  767,  769,  768,    0,  769,    0,
1696 770,  771,  771,  772,  767,  767,  768,  770,  769,    0,
1697 770,    0,  771,  772,  771,  773,  773,  774,  774,  775,
1698 775,    0,  771,  776,  776,    0,  773,    0,  774,    0,
1699 775,  777,  777,  776,  776,    0,  773,    0,  774,    0,
1700 775,    0,  777,    0,  776,  778,  778,  779,  779,  781,
1701 781,    0,  777,  782,  782,    0,  778,    0,  779,  781,
1702 781,    0,  778,    0,  782,    0,  778,  779,  779,    0,
1703 781,  783,  783,    0,  782,  784,  784,    0,    0,  786,
1704 786,    0,  783,  787,  787,    0,  784,    0,  783,  786,
1705
1706 786,    0,  783,    0,  787,  784,  784,  788,  788,    0,
1707 786,  789,  789,    0,  787,  790,  790,    0,  788,    0,
1708 0,    0,  789,    0,  788,    0,  790,    0,  788,  791,
1709 791,  789,  789,  792,  792,    0,  790,  793,  793,    0,
1710 791,    0,  791,    0,  792,  794,  794,  793,  793,    0,
1711 791,  795,  795,    0,  792,    0,  794,    0,  793,  796,
1712 796,    0,  795,    0,  795,    0,  794,  797,  797,    0,
1713 796,    0,  795,  798,  798,  800,  800,  797,  797,    0,
1714 796,    0,  799,  799,  798,    0,  800,    0,  797,  801,
1715 801,  802,  802,  799,  798,  799,  800,  803,  803,  801,
1716
1717 801,    0,  802,  799,  804,  804,  805,  805,  803,  802,
1718 801,    0,  802,  806,  806,  804,    0,  805,  803,  807,
1719 807,    0,  804,    0,  806,  804,    0,  805,  808,  808,
1720 807,  806,  811,  811,  806,  809,  809,  810,  810,  808,
1721 807,    0,    0,  811,    0,  808,  809,    0,  810,  808,
1722 812,  812,  809,  811,  810,    0,  809,    0,  810,  813,
1723 813,  812,    0,    0,    0,    0,    0,    0,    0,    0,
1724 813,  812,    0,    0,    0,    0,    0,    0,    0,    0,
1725 813,  815,  815,  815,  815,  815,  815,  815,  815,  815,
1726 815,  815,  815,  816,  816,  816,  816,  816,  816,  816,
1727
1728 816,  816,  816,  816,  816,  817,  817,  817,  817,  817,
1729 817,  817,  817,  817,  817,  817,  817,  818,  818,  818,
1730 818,  818,  818,  818,  818,  818,  818,  818,  818,  819,
1731 819,  819,  819,  819,  819,  819,  819,  819,  819,  819,
1732 819,  820,  820,  820,  820,  820,  820,  820,  820,  820,
1733 820,  820,  820,  821,    0,    0,    0,    0,    0,  821,
1734 822,    0,    0,    0,    0,    0,  822,  823,  823,  823,
1735 0,  823,  823,  824,    0,    0,    0,  824,    0,    0,
1736 0,    0,    0,  824,  825,    0,    0,    0,    0,    0,
1737 825,  826,  826,    0,    0,    0,  826,  826,  826,  826,
1738
1739 826,    0,  826,  827,  827,    0,    0,    0,  827,  827,
1740 827,  827,  827,    0,  827,  828,  828,    0,    0,  828,
1741 828,  828,  828,    0,  828,  828,  828,  829,  829,    0,
1742 0,  829,  829,  829,  829,  829,  829,  829,  829,  830,
1743 0,    0,    0,    0,  830,  830,  830,  830,    0,  830,
1744 830,  831,    0,    0,    0,    0,    0,  831,  832,    0,
1745 0,    0,    0,    0,  832,  833,  833,  833,  833,  833,
1746 833,  833,  833,  833,  833,  833,  834,  834,  834,  834,
1747 834,  834,  834,  834,  834,  834,  834,  835,  835,  835,
1748 835,  835,  835,  835,  835,  835,  835,  835,  836,    0,
1749
1750 0,    0,  836,    0,    0,    0,    0,    0,  836,  837,
1751 0,    0,    0,    0,    0,  837,  838,  838,  838,  838,
1752 838,  838,  838,    0,  838,  838,  838,  838,  839,  839,
1753 0,  839,  839,  839,  839,  839,  839,  839,  839,  839,
1754 840,  840,  840,  840,  840,  840,  840,  840,  840,  840,
1755 840,  840,  814,  814,  814,  814,  814,  814,  814,  814,
1756 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1757 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1758 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1759 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1760
1761 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1762 814,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1763 814,  814,  814
1764 } ;
1765
1766 extern int yy_flex_debug;
1767 int yy_flex_debug = 0;
1768
1769 static yy_state_type *yy_state_buf = 0, *yy_state_ptr = 0;
1770 static char *yy_full_match;
1771 static int yy_lp;
1772 static int yy_looking_for_trail_begin = 0;
1773 static int yy_full_lp;
1774 static int *yy_full_state;
1775 #define YY_TRAILING_MASK 0x2000
1776 #define YY_TRAILING_HEAD_MASK 0x4000
1777 #define REJECT \
1778 { \
1779 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1780 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1781 (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
1782 (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
1783 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
1784 ++(yy_lp); \
1785 goto find_rule; \
1786 }
1787
1788 #define yymore() yymore_used_but_not_detected
1789 #define YY_MORE_ADJ 0
1790 #define YY_RESTORE_YY_MORE_OFFSET
1791 char *yytext;
1792 /*
1793  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
1794  *  Copyright (C) 2008-2012 - Scilab Enterprises - Bruno JOFRET
1795  *
1796  * Copyright (C) 2012 - 2016 - Scilab Enterprises
1797  *
1798  * This file is hereby licensed under the terms of the GNU GPL v2.0,
1799  * pursuant to article 5.3.4 of the CeCILL v.2.1.
1800  * This file was originally licensed under the terms of the CeCILL v2.1,
1801  * and continues to be available under such terms.
1802  * For more information, see the COPYING file which you should have received
1803  * along with this program.
1804  *
1805  */
1806
1807 #include <stack>
1808
1809 #include "isatty.hxx"
1810 #include "parse.hxx"
1811 #include "parser_private.hxx"
1812
1813 #include "context.hxx"
1814
1815 extern "C"
1816 {
1817 #include "charEncoding.h"
1818 #include "sci_malloc.h"
1819 }
1820
1821 static std::stack<int> paren_levels;
1822
1823 static int comment_level = 0;
1824 static int last_token = 0;
1825 static int linebreak_stored_token = 0;
1826 static bool linebreak_stored_space = FALSE;
1827 static int exit_status = PARSE_ERROR;
1828 static int str_opener_column = 0;
1829 static std::string current_file;
1830 static std::string program_name;
1831
1832 static std::string pstBuffer;
1833
1834 extern void yyerror(std::string);
1835
1836 #define YY_USER_ACTION                          \
1837     yylloc.first_column = yylloc.last_column; yylloc.last_column += yyleng;
1838 //yylloc.last_column += yyleng;
1839
1840 /* -*- Verbose Special Debug -*- */
1841 //#define DEV
1842 //#define TOKENDEV
1843
1844 #ifdef DEV
1845 #define DEBUG(x) std::cout << "[DEBUG] " << x << std::endl;
1846 #else
1847 #define DEBUG(x) /* Nothing */
1848 #endif
1849
1850 #ifdef DEV
1851 std::string token_to_string(int);
1852 #endif
1853
1854 #define INITIAL 0
1855 #define SIMPLESTRING 1
1856 #define DOUBLESTRING 2
1857 #define REGIONCOMMENT 3
1858 #define LINECOMMENT 4
1859 #define LINEBREAK 5
1860 #define MATRIX 6
1861 #define SHELLMODE 7
1862 #define BEGINID 8
1863
1864 #ifndef YY_EXTRA_TYPE
1865 #define YY_EXTRA_TYPE void *
1866 #endif
1867
1868 static int yy_init_globals (void );
1869
1870 /* Accessor methods to globals.
1871    These are made visible to non-reentrant scanners for convenience. */
1872
1873 int yylex_destroy (void );
1874
1875 int yyget_debug (void );
1876
1877 void yyset_debug (int debug_flag  );
1878
1879 YY_EXTRA_TYPE yyget_extra (void );
1880
1881 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1882
1883 FILE *yyget_in (void );
1884
1885 void yyset_in  (FILE * in_str  );
1886
1887 FILE *yyget_out (void );
1888
1889 void yyset_out  (FILE * out_str  );
1890
1891 int yyget_leng (void );
1892
1893 char *yyget_text (void );
1894
1895 int yyget_lineno (void );
1896
1897 void yyset_lineno (int line_number  );
1898
1899 /* Macros after this point can all be overridden by user definitions in
1900  * section 1.
1901  */
1902
1903 #ifndef YY_SKIP_YYWRAP
1904 #ifdef __cplusplus
1905 extern "C" int yywrap (void );
1906 #else
1907 extern int yywrap (void );
1908 #endif
1909 #endif
1910
1911 static void yyunput (int c, char *buf_ptr  );
1912
1913 #ifndef yytext_ptr
1914 static void yy_flex_strncpy (char *, yyconst char *, int );
1915 #endif
1916
1917 #ifdef YY_NEED_STRLEN
1918 static int yy_flex_strlen (yyconst char * );
1919 #endif
1920
1921 #ifndef YY_NO_INPUT
1922
1923 #ifdef __cplusplus
1924 static int yyinput (void );
1925 #else
1926 static int input (void );
1927 #endif
1928
1929 #endif
1930
1931 static int yy_start_stack_ptr = 0;
1932 static int yy_start_stack_depth = 0;
1933 static int *yy_start_stack = NULL;
1934
1935 static void yy_push_state (int new_state );
1936
1937 static void yy_pop_state (void );
1938
1939 static int yy_top_state (void );
1940
1941 /* Amount of stuff to slurp up with each read. */
1942 #ifndef YY_READ_BUF_SIZE
1943 #ifdef __ia64__
1944 /* On IA-64, the buffer size is 16k, not 8k */
1945 #define YY_READ_BUF_SIZE 16384
1946 #else
1947 #define YY_READ_BUF_SIZE 8192
1948 #endif /* __ia64__ */
1949 #endif
1950
1951 /* Copy whatever the last rule matched to the standard output. */
1952 #ifndef ECHO
1953 /* This used to be an fputs(), but since the string might contain NUL's,
1954  * we now use fwrite().
1955  */
1956 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1957 #endif
1958
1959 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1960  * is returned in "result".
1961  */
1962 #ifndef YY_INPUT
1963 #define YY_INPUT(buf,result,max_size) \
1964         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1965                 { \
1966                 int c = '*'; \
1967                 size_t n; \
1968                 for ( n = 0; n < max_size && \
1969                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1970                         buf[n] = (char) c; \
1971                 if ( c == '\n' ) \
1972                         buf[n++] = (char) c; \
1973                 if ( c == EOF && ferror( yyin ) ) \
1974                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1975                 result = n; \
1976                 } \
1977         else \
1978                 { \
1979                 errno=0; \
1980                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1981                         { \
1982                         if( errno != EINTR) \
1983                                 { \
1984                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1985                                 break; \
1986                                 } \
1987                         errno=0; \
1988                         clearerr(yyin); \
1989                         } \
1990                 }\
1991 \
1992  
1993 #endif
1994
1995 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1996  * we don't want an extra ';' after the "return" because that will cause
1997  * some compilers to complain about unreachable statements.
1998  */
1999 #ifndef yyterminate
2000 #define yyterminate() return YY_NULL
2001 #endif
2002
2003 /* Number of entries by which start-condition stack grows. */
2004 #ifndef YY_START_STACK_INCR
2005 #define YY_START_STACK_INCR 25
2006 #endif
2007
2008 /* Report a fatal error. */
2009 #ifndef YY_FATAL_ERROR
2010 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2011 #endif
2012
2013 /* end tables serialization structures and prototypes */
2014
2015 /* Default declaration of generated scanner - a define so the user can
2016  * easily add parameters.
2017  */
2018 #ifndef YY_DECL
2019 #define YY_DECL_IS_OURS 1
2020
2021 extern int yylex (void);
2022
2023 #define YY_DECL int yylex (void)
2024 #endif /* !YY_DECL */
2025
2026 /* Code executed at the beginning of each rule, after yytext and yyleng
2027  * have been set up.
2028  */
2029 #ifndef YY_USER_ACTION
2030 #define YY_USER_ACTION
2031 #endif
2032
2033 /* Code executed at the end of each rule. */
2034 #ifndef YY_BREAK
2035 #define YY_BREAK break;
2036 #endif
2037
2038 #define YY_RULE_SETUP \
2039         if ( yyleng > 0 ) \
2040                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
2041                                 (yytext[yyleng - 1] == '\n'); \
2042         YY_USER_ACTION
2043
2044 /** The main scanner function which does all the work.
2045  */
2046 YY_DECL
2047 {
2048 register yy_state_type yy_current_state;
2049 register char * yy_cp, *yy_bp;
2050 register int yy_act;
2051
2052 if ( !(yy_init) )
2053 {
2054     (yy_init) = 1;
2055
2056 #ifdef YY_USER_INIT
2057     YY_USER_INIT;
2058 #endif
2059
2060     /* Create the reject buffer large enough to save one state per allowed character. */
2061     if ( ! (yy_state_buf) )
2062     {
2063         (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
2064     }
2065     if ( ! (yy_state_buf) )
2066     {
2067         YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
2068     }
2069
2070     if ( ! (yy_start) )
2071     {
2072         (yy_start) = 1;    /* first start state */
2073     }
2074
2075     if ( ! yyin )
2076     {
2077         yyin = stdin;
2078     }
2079
2080     if ( ! yyout )
2081     {
2082         yyout = stdout;
2083     }
2084
2085     if ( ! YY_CURRENT_BUFFER )
2086     {
2087         yyensure_buffer_stack ();
2088         YY_CURRENT_BUFFER_LVALUE =
2089             yy_create_buffer(yyin, YY_BUF_SIZE );
2090     }
2091
2092     yy_load_buffer_state( );
2093 }
2094
2095 while ( 1 )             /* loops until end-of-file is reached */
2096 {
2097     yy_cp = (yy_c_buf_p);
2098
2099     /* Support of yytext. */
2100     *yy_cp = (yy_hold_char);
2101
2102     /* yy_bp points to the position in yy_ch_buf of the start of
2103      * the current run.
2104      */
2105     yy_bp = yy_cp;
2106
2107     yy_current_state = (yy_start);
2108     yy_current_state += YY_AT_BOL();
2109
2110     (yy_state_ptr) = (yy_state_buf);
2111     *(yy_state_ptr)++ = yy_current_state;
2112
2113 yy_match:
2114     do
2115     {
2116         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
2117         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2118         {
2119             yy_current_state = (int) yy_def[yy_current_state];
2120             if ( yy_current_state >= 815 )
2121             {
2122                 yy_c = yy_meta[(unsigned int) yy_c];
2123             }
2124         }
2125         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2126         *(yy_state_ptr)++ = yy_current_state;
2127         ++yy_cp;
2128     }
2129     while ( yy_base[yy_current_state] != 4153 );
2130
2131 yy_find_action:
2132     yy_current_state = *--(yy_state_ptr);
2133     (yy_lp) = yy_accept[yy_current_state];
2134 find_rule: /* we branch to this label when backing up */
2135     for ( ; ; ) /* until we find what rule we matched */
2136     {
2137         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
2138         {
2139             yy_act = yy_acclist[(yy_lp)];
2140             if ( yy_act & YY_TRAILING_HEAD_MASK ||
2141                     (yy_looking_for_trail_begin) )
2142             {
2143                 if ( yy_act == (yy_looking_for_trail_begin) )
2144                 {
2145                     (yy_looking_for_trail_begin) = 0;
2146                     yy_act &= ~YY_TRAILING_HEAD_MASK;
2147                     break;
2148                 }
2149             }
2150             else if ( yy_act & YY_TRAILING_MASK )
2151             {
2152                 (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
2153                 (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
2154             }
2155             else
2156             {
2157                 (yy_full_match) = yy_cp;
2158                 (yy_full_state) = (yy_state_ptr);
2159                 (yy_full_lp) = (yy_lp);
2160                 break;
2161             }
2162             ++(yy_lp);
2163             goto find_rule;
2164         }
2165         --yy_cp;
2166         yy_current_state = *--(yy_state_ptr);
2167         (yy_lp) = yy_accept[yy_current_state];
2168     }
2169
2170     YY_DO_BEFORE_ACTION;
2171
2172 do_action:      /* This label is used only to access EOF actions. */
2173
2174     switch ( yy_act )
2175     {
2176             /* beginning of action switch */
2177         case 1:
2178             *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2179             (yy_c_buf_p) = yy_cp = yy_bp + 3;
2180             YY_DO_BEFORE_ACTION; /* set up yytext again */
2181             YY_RULE_SETUP
2182             {
2183                 // BOM found ==> ignored
2184             }
2185             YY_BREAK
2186         case 2:
2187             YY_RULE_SETUP
2188             {
2189                 BEGIN(INITIAL);
2190                 return scan_throw(BOOLTRUE);
2191             }
2192             YY_BREAK
2193         case 3:
2194             YY_RULE_SETUP
2195             {
2196                 BEGIN(INITIAL);
2197                 return scan_throw(BOOLFALSE);
2198             }
2199             YY_BREAK
2200         case 4:
2201             YY_RULE_SETUP
2202             {
2203                 if (last_token != DOT)
2204                 {
2205                     ParserSingleInstance::pushControlStatus(Parser::WithinIf);
2206                 }
2207                 DEBUG("BEGIN(INITIAL)");
2208                 BEGIN(INITIAL);
2209                 return scan_throw(IF);
2210             }
2211             YY_BREAK
2212         case 5:
2213             YY_RULE_SETUP
2214             {
2215                 DEBUG("BEGIN(INITIAL)");
2216                 BEGIN(INITIAL);
2217                 return scan_throw(THEN);
2218             }
2219             YY_BREAK
2220         case 6:
2221             YY_RULE_SETUP
2222             {
2223                 if (last_token != DOT)
2224                 {
2225                     // Pop to step out IF
2226                     ParserSingleInstance::popControlStatus();
2227                     ParserSingleInstance::pushControlStatus(Parser::WithinElse);
2228                 }
2229                 DEBUG("BEGIN(INITIAL)");
2230                 BEGIN(INITIAL);
2231                 return scan_throw(ELSE);
2232             }
2233             YY_BREAK
2234         case 7:
2235             YY_RULE_SETUP
2236             {
2237                 if (last_token != DOT)
2238                 {
2239                     ParserSingleInstance::popControlStatus();
2240                     ParserSingleInstance::pushControlStatus(Parser::WithinElseIf);
2241                 }
2242                 DEBUG("BEGIN(INITIAL)");
2243                 BEGIN(INITIAL);
2244                 return scan_throw(ELSEIF);
2245             }
2246             YY_BREAK
2247         case 8:
2248             YY_RULE_SETUP
2249             {
2250                 if (last_token != DOT)
2251                 {
2252                     ParserSingleInstance::popControlStatus();
2253                 }
2254                 DEBUG("BEGIN(INITIAL)");
2255                 BEGIN(INITIAL);
2256                 return scan_throw(END);
2257             }
2258             YY_BREAK
2259         case 9:
2260             YY_RULE_SETUP
2261             {
2262                 if (last_token != DOT)
2263                 {
2264                     ParserSingleInstance::pushControlStatus(Parser::WithinSelect);
2265                 }
2266                 DEBUG("BEGIN(INITIAL)");
2267                 BEGIN(INITIAL);
2268                 return scan_throw(SELECT);
2269             }
2270             YY_BREAK
2271         case 10:
2272             YY_RULE_SETUP
2273             {
2274                 if (last_token != DOT)
2275                 {
2276                     ParserSingleInstance::pushControlStatus(Parser::WithinSwitch);
2277                 }
2278                 DEBUG("BEGIN(INITIAL)");
2279                 BEGIN(INITIAL);
2280                 return scan_throw(SWITCH);
2281             }
2282             YY_BREAK
2283         case 11:
2284             YY_RULE_SETUP
2285             {
2286                 if (last_token != DOT)
2287                 {
2288                     ParserSingleInstance::popControlStatus();
2289                     ParserSingleInstance::pushControlStatus(Parser::WithinOtherwise);
2290                 }
2291                 DEBUG("BEGIN(INITIAL)");
2292                 BEGIN(INITIAL);
2293                 return scan_throw(OTHERWISE);
2294             }
2295             YY_BREAK
2296         case 12:
2297             YY_RULE_SETUP
2298             {
2299                 if (last_token != DOT)
2300                 {
2301                     ParserSingleInstance::popControlStatus();
2302                     ParserSingleInstance::pushControlStatus(Parser::WithinCase);
2303                 }
2304                 DEBUG("BEGIN(INITIAL)");
2305                 BEGIN(INITIAL);
2306                 return scan_throw(CASE);
2307             }
2308             YY_BREAK
2309         case 13:
2310             YY_RULE_SETUP
2311             {
2312                 if (last_token != DOT)
2313                 {
2314                     ParserSingleInstance::pushControlStatus(Parser::WithinFunction);
2315                 }
2316                 DEBUG("BEGIN(INITIAL)");
2317                 BEGIN(INITIAL);
2318                 return scan_throw(FUNCTION);
2319             }
2320             YY_BREAK
2321         case 14:
2322             YY_RULE_SETUP
2323             {
2324                 if (last_token != DOT)
2325                 {
2326                     ParserSingleInstance::popControlStatus();
2327                 }
2328                 DEBUG("BEGIN(INITIAL)");
2329                 BEGIN(INITIAL);
2330                 return scan_throw(ENDFUNCTION);
2331             }
2332             YY_BREAK
2333         case 15:
2334             YY_RULE_SETUP
2335             {
2336                 if (last_token != DOT)
2337                 {
2338                     ParserSingleInstance::pushControlStatus(Parser::WithinFor);
2339                 }
2340                 BEGIN(INITIAL);
2341                 return scan_throw(FOR);
2342             }
2343             YY_BREAK
2344         case 16:
2345             YY_RULE_SETUP
2346             {
2347                 if (last_token != DOT)
2348                 {
2349                     ParserSingleInstance::pushControlStatus(Parser::WithinWhile);
2350                 }
2351                 BEGIN(INITIAL);
2352                 return scan_throw(WHILE);
2353             }
2354             YY_BREAK
2355         case 17:
2356             YY_RULE_SETUP
2357             {
2358                 BEGIN(INITIAL);
2359                 return scan_throw(DO);
2360             }
2361             YY_BREAK
2362         case 18:
2363             YY_RULE_SETUP
2364             {
2365                 BEGIN(INITIAL);
2366                 return scan_throw(BREAK);
2367             }
2368             YY_BREAK
2369         case 19:
2370             YY_RULE_SETUP
2371             {
2372                 BEGIN(INITIAL);
2373                 return scan_throw(CONTINUE);
2374             }
2375             YY_BREAK
2376         case 20:
2377             YY_RULE_SETUP
2378             {
2379                 ParserSingleInstance::pushControlStatus(Parser::WithinTry);
2380                 BEGIN(INITIAL);
2381                 return scan_throw(TRY);
2382             }
2383             YY_BREAK
2384         case 21:
2385             YY_RULE_SETUP
2386             {
2387                 // Pop to step out TRY
2388                 ParserSingleInstance::popControlStatus();
2389                 ParserSingleInstance::pushControlStatus(Parser::WithinCatch);
2390                 BEGIN(INITIAL);
2391                 return scan_throw(CATCH);
2392             }
2393             YY_BREAK
2394         case 22:
2395             YY_RULE_SETUP
2396             {
2397                 BEGIN(INITIAL);
2398                 return scan_throw(RETURN);
2399             }
2400             YY_BREAK
2401         case 23:
2402             YY_RULE_SETUP
2403             {
2404                 BEGIN(INITIAL);
2405                 return scan_throw(RETURN);
2406             }
2407             YY_BREAK
2408         case 24:
2409             /* rule 24 can match eol */
2410             YY_RULE_SETUP
2411             {
2412                 BEGIN(BEGINID);
2413             }
2414             YY_BREAK
2415
2416         case 25:
2417             YY_RULE_SETUP
2418             {
2419                 wchar_t *pwText = to_wide_string(yytext);
2420                 if (yytext != NULL && pwText == NULL)
2421                 {
2422                     std::string str = "Can\'t convert \'";
2423                     str += yytext;
2424                     str += "\' to UTF-8";
2425                     BEGIN(INITIAL);
2426                     yyerror(str);
2427                     return scan_throw(FLEX_ERROR);
2428                 }
2429                 yylval.str = new std::wstring(pwText);
2430                 FREE(pwText);
2431                 types::InternalType * pIT = symbol::Context::getInstance()->get(symbol::Symbol(*yylval.str));
2432                 if (pIT && pIT->isCallable())
2433                 {
2434                     scan_throw(ID);
2435                     BEGIN(SHELLMODE);
2436                 }
2437                 else
2438                 {
2439                     BEGIN(INITIAL);
2440                     return scan_throw(ID);
2441                 }
2442             }
2443             YY_BREAK
2444
2445         case 26:
2446             YY_RULE_SETUP
2447             {
2448                 return scan_throw(NOT);
2449             }
2450             YY_BREAK
2451         case 27:
2452             YY_RULE_SETUP
2453             {
2454                 return scan_throw(DOLLAR);
2455             }
2456             YY_BREAK
2457         case 28:
2458             YY_RULE_SETUP
2459             {
2460                 return scan_throw(BOOLTRUE);
2461             }
2462             YY_BREAK
2463         case 29:
2464             YY_RULE_SETUP
2465             {
2466                 return scan_throw(BOOLFALSE);
2467             }
2468             YY_BREAK
2469         case 30:
2470             YY_RULE_SETUP
2471             {
2472                 return scan_throw(AND);
2473             }
2474             YY_BREAK
2475         case 31:
2476             YY_RULE_SETUP
2477             {
2478                 return scan_throw(ANDAND);
2479             }
2480             YY_BREAK
2481         case 32:
2482             YY_RULE_SETUP
2483             {
2484                 return scan_throw(OR);
2485             }
2486             YY_BREAK
2487         case 33:
2488             YY_RULE_SETUP
2489             {
2490                 return scan_throw(OROR);
2491             }
2492             YY_BREAK
2493         case 34:
2494             YY_RULE_SETUP
2495             {
2496                 return scan_throw(LPAREN);
2497             }
2498             YY_BREAK
2499         case 35:
2500             YY_RULE_SETUP
2501             {
2502                 return scan_throw(RPAREN);
2503             }
2504             YY_BREAK
2505         case 36:
2506             YY_RULE_SETUP
2507             {
2508                 scan_step();
2509                 return scan_throw(SEMI);
2510             }
2511             YY_BREAK
2512         case 37:
2513             YY_RULE_SETUP
2514             {
2515                 scan_step();
2516                 return scan_throw(COMMA);
2517             }
2518             YY_BREAK
2519         case 38:
2520             YY_RULE_SETUP
2521             {
2522                 return scan_throw(COLON);
2523             }
2524             YY_BREAK
2525         case 39:
2526             YY_RULE_SETUP
2527             {
2528                 yy_push_state(MATRIX);
2529                 paren_levels.push(0);
2530                 ParserSingleInstance::pushControlStatus(Parser::WithinCell);
2531                 return scan_throw(LBRACE);
2532             }
2533             YY_BREAK
2534         case 40:
2535             YY_RULE_SETUP
2536             {
2537                 return scan_throw(RBRACE);
2538             }
2539             YY_BREAK
2540         case 41:
2541             YY_RULE_SETUP
2542             {
2543                 return scan_throw(DOTQUOTE);
2544             }
2545             YY_BREAK
2546         case 42:
2547             YY_RULE_SETUP
2548             {
2549                 return scan_throw(DOTTIMES);
2550             }
2551             YY_BREAK
2552         case 43:
2553             YY_RULE_SETUP
2554             {
2555                 return scan_throw(DOTRDIVIDE);
2556             }
2557             YY_BREAK
2558         case 44:
2559             YY_RULE_SETUP
2560             {
2561                 return scan_throw(DOTLDIVIDE);
2562             }
2563             YY_BREAK
2564         case 45:
2565             YY_RULE_SETUP
2566             {
2567                 return scan_throw(DOTPOWER);
2568             }
2569             YY_BREAK
2570         case 46:
2571             YY_RULE_SETUP
2572             {
2573                 return scan_throw(MINUS);
2574             }
2575             YY_BREAK
2576         case 47:
2577             YY_RULE_SETUP
2578             {
2579                 return scan_throw(PLUS);
2580             }
2581             YY_BREAK
2582         case 48:
2583             YY_RULE_SETUP
2584             {
2585                 return scan_throw(TIMES);
2586             }
2587             YY_BREAK
2588         case 49:
2589             YY_RULE_SETUP
2590             {
2591                 return scan_throw(RDIVIDE);
2592             }
2593             YY_BREAK
2594         case 50:
2595             YY_RULE_SETUP
2596             {
2597                 return scan_throw(LDIVIDE);
2598             }
2599             YY_BREAK
2600         case 51:
2601             YY_RULE_SETUP
2602             {
2603                 return scan_throw(POWER);
2604             }
2605             YY_BREAK
2606         case 52:
2607             YY_RULE_SETUP
2608             {
2609                 return scan_throw(KRONTIMES);
2610             }
2611             YY_BREAK
2612         case 53:
2613             YY_RULE_SETUP
2614             {
2615                 return scan_throw(KRONRDIVIDE);
2616             }
2617             YY_BREAK
2618         case 54:
2619             YY_RULE_SETUP
2620             {
2621                 return scan_throw(KRONLDIVIDE);
2622             }
2623             YY_BREAK
2624         case 55:
2625             /* rule 55 can match eol */
2626             YY_RULE_SETUP
2627             {
2628                 unput(yytext[yyleng - 1]);
2629                 return scan_throw(CONTROLTIMES);
2630             }
2631             YY_BREAK
2632         case 56:
2633             /* rule 56 can match eol */
2634             YY_RULE_SETUP
2635             {
2636                 unput(yytext[yyleng - 1]);
2637                 return scan_throw(CONTROLRDIVIDE);
2638             }
2639             YY_BREAK
2640         case 57:
2641             /* rule 57 can match eol */
2642             YY_RULE_SETUP
2643             {
2644                 unput(yytext[yyleng - 1]);
2645                 return scan_throw(CONTROLLDIVIDE);
2646             }
2647             YY_BREAK
2648         case 58:
2649             YY_RULE_SETUP
2650             {
2651                 return scan_throw(EQ);
2652             }
2653             YY_BREAK
2654         case 59:
2655             YY_RULE_SETUP
2656             {
2657                 return scan_throw(NE);
2658             }
2659             YY_BREAK
2660         case 60:
2661             YY_RULE_SETUP
2662             {
2663                 return scan_throw(LT);
2664             }
2665             YY_BREAK
2666         case 61:
2667             YY_RULE_SETUP
2668             {
2669                 return scan_throw(GT);
2670             }
2671             YY_BREAK
2672         case 62:
2673             YY_RULE_SETUP
2674             {
2675                 return scan_throw(LE);
2676             }
2677             YY_BREAK
2678         case 63:
2679             YY_RULE_SETUP
2680             {
2681                 return scan_throw(GE);
2682             }
2683             YY_BREAK
2684         case 64:
2685             YY_RULE_SETUP
2686             {
2687                 return scan_throw(ASSIGN);
2688             }
2689             YY_BREAK
2690         case 65:
2691             YY_RULE_SETUP
2692             {
2693                 DEBUG("yy_push_state(MATRIX)");
2694                 yy_push_state(MATRIX);
2695                 paren_levels.push(0);
2696                 ParserSingleInstance::pushControlStatus(Parser::WithinMatrix);
2697                 return scan_throw(LBRACK);
2698             }
2699             YY_BREAK
2700         case 66:
2701             YY_RULE_SETUP
2702             {
2703                 return scan_throw(RBRACK);
2704             }
2705             YY_BREAK
2706         case 67:
2707             YY_RULE_SETUP
2708             {
2709                 return scan_throw(DOT);
2710             }
2711             YY_BREAK
2712         case 68:
2713             YY_RULE_SETUP
2714             {
2715                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
2716                 yy_push_state(LINEBREAK);
2717             }
2718             YY_BREAK
2719         case 69:
2720             YY_RULE_SETUP
2721             {
2722                 yylval.number = atof(yytext);
2723 #ifdef TOKENDEV
2724                 std::cout << "--> [DEBUG] INTEGER : " << yytext << std::endl;
2725 #endif
2726                 //  scan_step();
2727                 return scan_throw(VARINT);
2728             }
2729             YY_BREAK
2730         case 70:
2731             YY_RULE_SETUP
2732             {
2733                 scan_exponent_convert(yytext);
2734                 yylval.number = atof(yytext);
2735 #ifdef TOKENDEV
2736                 std::cout << "--> [DEBUG] FLOATING : " << yytext << std::endl;
2737 #endif
2738                 //scan_step();
2739                 return scan_throw(VARFLOAT);
2740             }
2741             YY_BREAK
2742         case 71:
2743             YY_RULE_SETUP
2744             {
2745                 yylval.number = atof(yytext);
2746 #ifdef TOKENDEV
2747                 std::cout << "--> [DEBUG] FLOATING : " << yytext << std::endl;
2748 #endif
2749                 //scan_step();
2750                 return scan_throw(VARFLOAT);
2751             }
2752             YY_BREAK
2753         case 72:
2754             *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2755             (yy_c_buf_p) = yy_cp -= 1;
2756             YY_DO_BEFORE_ACTION; /* set up yytext again */
2757             YY_RULE_SETUP
2758             {
2759
2760                 yylval.number = atof(yytext);
2761 #ifdef TOKENDEV
2762                 std::cout << "--> [DEBUG] NUMBER WITH DOT AS LAST CHARACTER : " << yytext << std::endl;
2763 #endif
2764                 //  scan_step();
2765                 unput('.');
2766                 yylloc.last_column--;
2767                 return scan_throw(NUM);
2768             }
2769             YY_BREAK
2770         case 73:
2771             YY_RULE_SETUP
2772             {
2773                 yylval.number = atof(yytext);
2774 #ifdef TOKENDEV
2775                 std::cout << "--> [DEBUG] NUMBER : " << yytext << std::endl;
2776 #endif
2777                 //  scan_step();
2778                 return scan_throw(NUM);
2779             }
2780             YY_BREAK
2781         case 74:
2782             YY_RULE_SETUP
2783             {
2784                 yylval.number = atof(yytext);
2785 #ifdef TOKENDEV
2786                 std::cout << "--> [DEBUG] LITTLE : " << yytext << std::endl;
2787 #endif
2788                 //  scan_step();
2789                 return scan_throw(NUM);
2790             }
2791             YY_BREAK
2792         case 75:
2793             YY_RULE_SETUP
2794             {
2795                 wchar_t *pwText = to_wide_string(yytext);
2796                 if (yytext != NULL && pwText == NULL)
2797                 {
2798                     std::string str = "Can\'t convert \'";
2799                     str += yytext;
2800                     str += "\' to UTF-8";
2801                     BEGIN(INITIAL);
2802                     yyerror(str);
2803                     return scan_throw(FLEX_ERROR);
2804                 }
2805                 yylval.str = new std::wstring(pwText);
2806                 FREE(pwText);
2807 #ifdef TOKENDEV
2808                 std::cout << "--> [DEBUG] ID : " << yytext << std::endl;
2809 #endif
2810                 //  scan_step();
2811                 return scan_throw(ID);
2812             }
2813             YY_BREAK
2814         case 76:
2815             YY_RULE_SETUP
2816             {
2817                 yylval.comment = new std::wstring();
2818                 comment_level = 1;
2819                 ParserSingleInstance::pushControlStatus(Parser::WithinBlockComment);
2820                 yy_push_state(REGIONCOMMENT);
2821             }
2822             YY_BREAK
2823         case 77:
2824             YY_RULE_SETUP
2825             {
2826                 pstBuffer.clear();
2827                 yy_push_state(LINECOMMENT);
2828             }
2829             YY_BREAK
2830         case 78:
2831             YY_RULE_SETUP
2832             {
2833                 pstBuffer.clear();
2834                 str_opener_column = yylloc.first_column;
2835                 yy_push_state(DOUBLESTRING);
2836             }
2837             YY_BREAK
2838         case 79:
2839             YY_RULE_SETUP
2840             {
2841                 /*
2842                 ** Matrix Transposition special behaviour
2843                 ** ID' []' toto()' are transposition call
2844                 */
2845                 if (last_token == ID
2846                 || last_token == RBRACK
2847                 || last_token == RPAREN
2848                 || last_token == RBRACE
2849                 || last_token == VARINT
2850                 || last_token == VARFLOAT
2851                 || last_token == NUM
2852                 || last_token == BOOLTRUE
2853                 || last_token == BOOLFALSE)
2854                 {
2855                     return scan_throw(QUOTE);
2856                 }
2857                 else
2858                 {
2859                     pstBuffer.clear();
2860                     str_opener_column = yylloc.first_column;
2861                     yy_push_state(SIMPLESTRING);
2862                 }
2863             }
2864             YY_BREAK
2865         case 80:
2866             YY_RULE_SETUP
2867             {
2868                 scan_step();
2869             }
2870             YY_BREAK
2871         case 81:
2872             /* rule 81 can match eol */
2873             YY_RULE_SETUP
2874             {
2875                 yylloc.last_line += 1;
2876                 yylloc.last_column = 1;
2877                 scan_step();
2878                 if (last_token != EOL)
2879                 {
2880                     return scan_throw(EOL);
2881                 }
2882
2883             }
2884             YY_BREAK
2885         case 82:
2886             /* rule 82 can match eol */
2887             YY_RULE_SETUP
2888             {
2889                 yylloc.last_line += 1;
2890                 yylloc.last_column = 1;
2891                 scan_step();
2892                 if (last_token != EOL)
2893                 {
2894                     return scan_throw(EOL);
2895                 }
2896                 scan_throw(EOL);
2897             }
2898             YY_BREAK
2899         case 83:
2900             /* rule 83 can match eol */
2901             YY_RULE_SETUP
2902             {
2903                 yylloc.last_line += 2;
2904                 yylloc.last_column = 1;
2905                 scan_step();
2906                 if (last_token != EOL)
2907                 {
2908                     return scan_throw(EOL);
2909                 }
2910                 scan_throw(EOL);
2911             }
2912             YY_BREAK
2913         case 84:
2914             YY_RULE_SETUP
2915             {
2916                 std::string str = "Unexpected token \'";
2917                 str += yytext;
2918                 str += "\'";
2919                 BEGIN(INITIAL);
2920                 yyerror(str);
2921                 return scan_throw(FLEX_ERROR);
2922             }
2923             YY_BREAK
2924
2925         case 85:
2926             YY_RULE_SETUP
2927             {
2928                 ++paren_levels.top();
2929                 return scan_throw(LPAREN);
2930             }
2931             YY_BREAK
2932         case 86:
2933             YY_RULE_SETUP
2934             {
2935                 --paren_levels.top();
2936                 return scan_throw(RPAREN);
2937             }
2938             YY_BREAK
2939         case 87:
2940             YY_RULE_SETUP
2941             {
2942                 unput(yytext[yyleng - 1]);
2943                 if (last_token == ID
2944                 || last_token == RPAREN
2945                 || last_token == QUOTE
2946                 || last_token == VARINT
2947                 || last_token == VARFLOAT
2948                 || last_token == NUM)
2949                 {
2950                     return scan_throw(COMMA);
2951                 }
2952             }
2953             YY_BREAK
2954         case 88:
2955             YY_RULE_SETUP
2956             {
2957                 return scan_throw(COLON);
2958             }
2959             YY_BREAK
2960         case 89:
2961             /* rule 89 can match eol */
2962             YY_RULE_SETUP
2963             {
2964                 yylloc.last_line += 1;
2965                 yylloc.last_column = 1;
2966                 if (last_token != DOTS && last_token != EOL)
2967                 {
2968                     return scan_throw(EOL);
2969                 }
2970                 scan_throw(EOL);
2971             }
2972             YY_BREAK
2973         case 90:
2974             YY_RULE_SETUP
2975             {
2976                 DEBUG("yy_pop_state()");
2977                 yy_pop_state();
2978                 paren_levels.pop();
2979                 ParserSingleInstance::popControlStatus();
2980                 return scan_throw(RBRACK);
2981             }
2982             YY_BREAK
2983         case 91:
2984             YY_RULE_SETUP
2985             {
2986                 yy_pop_state();
2987                 paren_levels.pop();
2988                 ParserSingleInstance::popControlStatus();
2989                 return scan_throw(RBRACE);
2990             }
2991             YY_BREAK
2992         case 92:
2993         case 93:
2994             YY_RULE_SETUP
2995             {
2996                 // _+_ is always meaning a PLUS token
2997                 // + alone is a plus if and only if it does not
2998                 // fall into the {spaces}{plus} rule (in matrices space is coding)
2999                 // as Flex is greedy the {plus} rule is only applied
3000                 // if no {spaces}{plus} is found
3001                 // Examples:
3002                 // ========
3003                 // [1 + 2 3] must be understood as [(1+2), 3]
3004                 // [1 +2 3] must be understood as [1, 2, 3]
3005                 // [1 +...
3006                 // 2] must be understood as [(1+2)]
3007                 return scan_throw(PLUS);
3008             }
3009             YY_BREAK
3010         case 94:
3011         case 95:
3012             YY_RULE_SETUP
3013             {
3014                 // _-_ is always meaning a MINUS token
3015                 // - alone is a MINUS only if and only if it does not
3016                 // fall into the {spaces}{minus} rule (in matrices space is coding)
3017                 // as Flex is greedy the {minus} rule is only applied
3018                 // if no {spaces}{minus} is found
3019                 // Examples:
3020                 // ========
3021                 // [1 - 2 3] must be understood as [(1-2), 3]
3022                 // [1 -2 3] must be understood as [1, -2, 3]
3023                 // [1 -...
3024                 // 2] must be understood as [(1-2)]
3025                 return scan_throw(MINUS);
3026             }
3027             YY_BREAK
3028         case 96:
3029             YY_RULE_SETUP
3030             {
3031                 // This rule is made to take into account the coding spaces in matrices.
3032                 // It is important to distinguish between a space coding a matrix column separator
3033                 // and a simple non coding space around the PLUS operator
3034                 // Examples
3035                 // ========
3036                 // [a + b] == [(a + b)]
3037                 // but [a +b] == [a, b] and plus here is unary
3038                 // the space is non coding:
3039                 // * after any other binary operator __op__
3040                 //   Example : [a __op__ +b]
3041                 // * after brackets or parentheses delimiters
3042                 //   Example : [(1*2*a) +3]
3043                 // * at the beginning of a line
3044                 //   Example : [3 ...
3045                 //              _+2]
3046
3047                 // no need to unput the '+'
3048                 if (last_token != LBRACK
3049                 && last_token != EOL
3050                 && last_token != SEMI
3051                 && last_token != COMMA
3052                 && last_token != DOTTIMES
3053                 && last_token != DOTRDIVIDE
3054                 && last_token != DOTLDIVIDE
3055                 && last_token != DOTPOWER
3056                 && last_token != MINUS
3057                 && last_token != PLUS
3058                 && last_token != TIMES
3059                 && last_token != RDIVIDE
3060                 && last_token != LDIVIDE
3061                 && last_token != POWER
3062                 && last_token != KRONTIMES
3063                 && last_token != KRONRDIVIDE
3064                 && last_token != KRONLDIVIDE
3065                 && last_token != EQ
3066                 && last_token != NE
3067                 && last_token != LT
3068                 && last_token != GT
3069                 && last_token != LE
3070                 && last_token != GE
3071                 && paren_levels.top() == 0)
3072                 {
3073                     return scan_throw(COMMA);
3074                 }
3075                 else
3076                 {
3077                     unput('+');
3078                     yylloc.last_column--;
3079                 }
3080             }
3081             YY_BREAK
3082         case 97:
3083             YY_RULE_SETUP
3084             {
3085                 // See {spaces}{plus} rule for the rationale
3086
3087                 unput('-');
3088                 yylloc.last_column--;
3089                 if (last_token != LBRACK
3090                 && last_token != EOL
3091                 && last_token != SEMI
3092                 && last_token != COMMA
3093                 && last_token != DOTTIMES
3094                 && last_token != DOTRDIVIDE
3095                 && last_token != DOTLDIVIDE
3096                 && last_token != DOTPOWER
3097                 && last_token != MINUS
3098                 && last_token != PLUS
3099                 && last_token != TIMES
3100                 && last_token != RDIVIDE
3101                 && last_token != LDIVIDE
3102                 && last_token != POWER
3103                 && last_token != KRONTIMES
3104                 && last_token != KRONRDIVIDE
3105                 && last_token != KRONLDIVIDE
3106                 && last_token != EQ
3107                 && last_token != NE
3108                 && last_token != LT
3109                 && last_token != GT
3110                 && last_token != LE
3111                 && last_token != GE
3112                 && paren_levels.top() == 0)
3113                 {
3114                     return scan_throw(COMMA);
3115                 }
3116             }
3117             YY_BREAK
3118         case 98:
3119             YY_RULE_SETUP
3120             {
3121                 std::string str = "Unexpected token \'";
3122                 str += yytext;
3123                 str += "\' within a matrix.";
3124                 BEGIN(INITIAL);
3125                 yyerror(str);
3126                 return scan_throw(FLEX_ERROR);
3127             }
3128             YY_BREAK
3129             /* {next} rules
3130                * ============
3131                * Scilab can perform a line continuation with the ..
3132                * In matrices as space may be coding extra care must be taken when parsing {next}
3133                * Some states must be preserved to parse next line and to revert to a proper state
3134                * after the ... // comments or ... \/* comments *\/
3135                */
3136         case 99:
3137             YY_RULE_SETUP
3138             {
3139                 // This rule is made to take into account a +... without spaces after plus
3140                 // if one simply ignores the next a situation like this could arise
3141                 // Example
3142                 // =======
3143                 // A = [1 +...
3144                 // 2]
3145                 //
3146                 // what is meant by the user [1 +2] ? or [1 + 2]
3147                 // simply ignoring the ... would yield the 1st situation [1, 2]
3148                 // We consider this is NOT proper and instead that the user meant a binary plus
3149                 // split is two lines
3150                 // The same rationale applies to minus.
3151
3152                 linebreak_stored_space = FALSE; // no spaces before ...
3153                 linebreak_stored_token = PLUS; // keep last token to restore
3154                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
3155                 yy_push_state(LINEBREAK);
3156                 return scan_throw(PLUS);
3157             }
3158             YY_BREAK
3159         case 100:
3160             YY_RULE_SETUP
3161             {
3162                 // see {spaces}*{minus}{next} for the rationale
3163
3164                 linebreak_stored_space = FALSE; // no spaces before ...
3165                 linebreak_stored_token = MINUS; // keep last token to restore
3166                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
3167                 yy_push_state(LINEBREAK);
3168                 return scan_throw(MINUS);
3169             }
3170             YY_BREAK
3171         case 101:
3172             YY_RULE_SETUP
3173             {
3174                 // Store the state of the previously scanned token for next rule
3175                 // Only considerations of coding spaces is important for the parser
3176
3177                 linebreak_stored_space = FALSE; // no spaces before ...
3178                 linebreak_stored_token = last_token; // keep last token to restore state
3179                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
3180                 yy_push_state(LINEBREAK);
3181             }
3182             YY_BREAK
3183         case 102:
3184             YY_RULE_SETUP
3185             {
3186                 // Store the state of the previously scanned token for next rule
3187                 // Only considerations of coding spaces is important for the parser
3188
3189                 linebreak_stored_space = TRUE; // no spaces before ...
3190                 linebreak_stored_token = last_token; // keep last token to restore state
3191                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
3192                 yy_push_state(LINEBREAK);
3193             }
3194             YY_BREAK
3195         case YY_STATE_EOF(MATRIX):
3196         {
3197             yy_pop_state();
3198             paren_levels.pop();
3199         }
3200         YY_BREAK
3201
3202         case 103:
3203             /* rule 103 can match eol */
3204             YY_RULE_SETUP
3205             {
3206                 yylloc.last_line += 1;
3207                 yylloc.last_column = 1;
3208                 scan_step();
3209                 last_token = linebreak_stored_token;
3210                 if (linebreak_stored_space)
3211                 {
3212                     // This is important to restore coding spaces as if ... was not present
3213                     unput(' ');
3214                     linebreak_stored_space = FALSE;
3215                 }
3216                 yy_pop_state();
3217                 ParserSingleInstance::popControlStatus();
3218             }
3219             YY_BREAK
3220         case 104:
3221             YY_RULE_SETUP
3222             {
3223                 yylval.comment = new std::wstring();
3224                 comment_level = 1;
3225                 ParserSingleInstance::pushControlStatus(Parser::WithinBlockComment);
3226                 yy_push_state(REGIONCOMMENT);
3227             }
3228             YY_BREAK
3229         case 105:
3230             YY_RULE_SETUP
3231             {
3232                 scan_throw(DOTS);
3233                 pstBuffer.clear();
3234                 yy_push_state(LINECOMMENT);
3235             }
3236             YY_BREAK
3237         case 106:
3238             YY_RULE_SETUP
3239             {
3240                 /* Do nothing... */
3241             }
3242             YY_BREAK
3243         case YY_STATE_EOF(LINEBREAK):
3244         {
3245             yy_pop_state();
3246         }
3247         YY_BREAK
3248         case 107:
3249             YY_RULE_SETUP
3250             {
3251                 // The following case is not handled by the parser
3252                 // a line of code ... /* some multiline
3253                 // comments */ continued here;
3254                 // without the special case telling we are after comments
3255                 // will generate the error as follows:
3256
3257                 // Any characters after ... yields to an error
3258                 std::string str = "Unexpected token \'";
3259                 str += yytext;
3260                 str += "\' after line break with .. or ...";
3261                 yy_pop_state();
3262                 ParserSingleInstance::popControlStatus();
3263                 BEGIN(INITIAL);
3264                 yyerror(str);
3265                 return scan_throw(FLEX_ERROR);
3266             }
3267             YY_BREAK
3268
3269         case 108:
3270             /* rule 108 can match eol */
3271             YY_RULE_SETUP
3272             {
3273                 //yylloc.last_line += 1;
3274                 //yylloc.last_column = 1;
3275                 //scan_step();
3276                 yy_pop_state();
3277                 for (int i = yyleng - 1 ; i >= 0 ; --i)
3278                 {
3279                     //std::cerr << "Unputting i = {" << i << "}" << std::endl;
3280                     //std::cerr << "Unputting {" << yytext[i] << "}" << std::endl;
3281                     unput(yytext[i]);
3282                     yylloc.last_column--;
3283                 }
3284                 /*
3285                 ** To forgot comments after lines break
3286                 */
3287                 if (last_token != DOTS)
3288                 {
3289                     //std::cerr << "pstBuffer = {" << *pstBuffer << "}" << std::endl;
3290                     //std::cerr << "pstBuffer->c_str() = {" << pstBuffer->c_str() << "}" << std::endl;
3291                     wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3292                     //std::wcerr << L"pwstBuffer = W{" << pwstBuffer << L"}" << std::endl;
3293                     if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3294                     {
3295                         pstBuffer.clear();
3296                         std::string str = "Can\'t convert \'";
3297                         str += pstBuffer.c_str();
3298                         str += "\' to UTF-8";
3299                         BEGIN(INITIAL);
3300                         yyerror(str);
3301                         return scan_throw(FLEX_ERROR);
3302                     }
3303                     yylval.comment = new std::wstring(pwstBuffer);
3304                     pstBuffer.clear();
3305                     FREE (pwstBuffer);
3306                     return scan_throw(COMMENT);
3307                 }
3308                 else
3309                 {
3310                     pstBuffer.clear();
3311                 }
3312             }
3313             YY_BREAK
3314         case YY_STATE_EOF(LINECOMMENT):
3315         {
3316             yy_pop_state();
3317             wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3318             if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3319             {
3320                 pstBuffer.clear();
3321                 std::string str = "Can\'t convert \'";
3322                 str += pstBuffer.c_str();
3323                 str += "\' to UTF-8";
3324                 BEGIN(INITIAL);
3325                 yyerror(str);
3326                 return scan_throw(FLEX_ERROR);
3327             }
3328             yylval.comment = new std::wstring(pwstBuffer);
3329             pstBuffer.clear();
3330             FREE (pwstBuffer);
3331             return scan_throw(COMMENT);
3332         }
3333         YY_BREAK
3334         case 109:
3335             YY_RULE_SETUP
3336             {
3337                 // Put the char in a temporary CHAR buffer to go through UTF-8 trouble
3338                 // only translate to WCHAR_T when popping state.
3339                 pstBuffer += yytext;
3340             }
3341             YY_BREAK
3342
3343         case 110:
3344             YY_RULE_SETUP
3345             {
3346                 --comment_level;
3347                 if (comment_level == 0)
3348                 {
3349                     ParserSingleInstance::popControlStatus();
3350                     yy_pop_state();
3351                     //return scan_throw(BLOCKCOMMENT);
3352                 }
3353             }
3354             YY_BREAK
3355         case 111:
3356             YY_RULE_SETUP
3357             {
3358                 ++comment_level;
3359                 yy_push_state(REGIONCOMMENT);
3360             }
3361             YY_BREAK
3362         case 112:
3363             /* rule 112 can match eol */
3364             YY_RULE_SETUP
3365             {
3366                 yylloc.last_line += 1;
3367                 yylloc.last_column = 1;
3368                 scan_step();
3369                 *yylval.comment += L"\n//";
3370             }
3371             YY_BREAK
3372         case 113:
3373         case 114:
3374             YY_RULE_SETUP
3375             {
3376                 wchar_t *pwText = to_wide_string(yytext);
3377                 *yylval.comment += std::wstring(pwText);
3378                 FREE(pwText);
3379             }
3380             YY_BREAK
3381         case YY_STATE_EOF(REGIONCOMMENT):
3382         {
3383             yy_pop_state();
3384             //    std::string str = "unexpected end of file in a comment";
3385             //    scan_error(str);
3386         }
3387         YY_BREAK
3388
3389         case 115:
3390             YY_RULE_SETUP
3391             {
3392                 pstBuffer += "\"";
3393             }
3394             YY_BREAK
3395         case 116:
3396             YY_RULE_SETUP
3397             {
3398                 pstBuffer += "'";
3399             }
3400             YY_BREAK
3401         case 117:
3402             YY_RULE_SETUP
3403             {
3404                 pstBuffer += "\"";
3405             }
3406             YY_BREAK
3407         case 118:
3408             YY_RULE_SETUP
3409             {
3410                 pstBuffer += "'";
3411             }
3412             YY_BREAK
3413         case 119:
3414             YY_RULE_SETUP
3415             {
3416                 yy_pop_state();
3417                 //scan_step();
3418                 wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3419                 if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3420                 {
3421                     pstBuffer.clear();
3422                     std::string str = "Can\'t convert \'";
3423                     str += pstBuffer.c_str();
3424                     str += "\' to UTF-8";
3425                     BEGIN(INITIAL);
3426                     yyerror(str);
3427                     return scan_throw(FLEX_ERROR);
3428                 }
3429                 yylval.str = new std::wstring(pwstBuffer);
3430                 pstBuffer.clear();
3431                 FREE(pwstBuffer);
3432                 yylloc.first_column = str_opener_column;
3433                 return scan_throw(STR);
3434             }
3435             YY_BREAK
3436         case 120:
3437             YY_RULE_SETUP
3438             {
3439                 pstBuffer.clear();
3440                 BEGIN(INITIAL);
3441                 yyerror("Heterogeneous string detected, starting with \' and ending with \".");
3442                 return scan_throw(FLEX_ERROR);
3443             }
3444             YY_BREAK
3445         case 121:
3446             /* rule 121 can match eol */
3447             YY_RULE_SETUP
3448             {
3449                 yylloc.last_line += 1;
3450                 yylloc.last_column = 1;
3451                 /* Do nothing... Just skip */
3452             }
3453             YY_BREAK
3454         case 122:
3455             /* rule 122 can match eol */
3456             YY_RULE_SETUP
3457             {
3458                 pstBuffer.clear();
3459                 yylloc.last_line += 1;
3460                 yylloc.last_column = 1;
3461                 BEGIN(INITIAL);
3462                 yyerror("Unexpected end of line in a string.");
3463                 return scan_throw(FLEX_ERROR);
3464             }
3465             YY_BREAK
3466         case YY_STATE_EOF(SIMPLESTRING):
3467         {
3468             pstBuffer.clear();
3469             BEGIN(INITIAL);
3470             yyerror("Unexpected end of file in a string.");
3471             return scan_throw(FLEX_ERROR);
3472         }
3473         YY_BREAK
3474         case 123:
3475         case 124:
3476             YY_RULE_SETUP
3477             {
3478                 //scan_step();
3479                 pstBuffer += yytext;
3480             }
3481             YY_BREAK
3482
3483         case 125:
3484             YY_RULE_SETUP
3485             {
3486                 pstBuffer += "\"";
3487             }
3488             YY_BREAK
3489         case 126:
3490             YY_RULE_SETUP
3491             {
3492                 pstBuffer += "'";
3493             }
3494             YY_BREAK
3495         case 127:
3496             YY_RULE_SETUP
3497             {
3498                 pstBuffer += "\"";
3499             }
3500             YY_BREAK
3501         case 128:
3502             YY_RULE_SETUP
3503             {
3504                 pstBuffer += "'";
3505             }
3506             YY_BREAK
3507         case 129:
3508             YY_RULE_SETUP
3509             {
3510                 yy_pop_state();
3511                 //scan_step();
3512                 wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3513                 if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3514                 {
3515                     pstBuffer.clear();
3516                     std::string str = "Can\'t convert \'";
3517                     str += pstBuffer.c_str();
3518                     str += "\' to UTF-8";
3519                     BEGIN(INITIAL);
3520                     yyerror(str);
3521                     return scan_throw(FLEX_ERROR);
3522                 }
3523                 yylval.str = new std::wstring(pwstBuffer);
3524                 pstBuffer.clear();
3525                 FREE(pwstBuffer);
3526                 yylloc.first_column = str_opener_column;
3527                 return scan_throw(STR);
3528             }
3529             YY_BREAK
3530         case 130:
3531             YY_RULE_SETUP
3532             {
3533                 pstBuffer.clear();
3534                 BEGIN(INITIAL);
3535                 yyerror("Heterogeneous string detected, starting with \" and ending with \'.");
3536                 return scan_throw(FLEX_ERROR);
3537             }
3538             YY_BREAK
3539         case 131:
3540             /* rule 131 can match eol */
3541             YY_RULE_SETUP
3542             {
3543                 yylloc.last_line += 1;
3544                 yylloc.last_column = 1;
3545                 /* Do nothing... Just skip */
3546             }
3547             YY_BREAK
3548         case 132:
3549             /* rule 132 can match eol */
3550             YY_RULE_SETUP
3551             {
3552                 pstBuffer.clear();
3553                 yylloc.last_line += 1;
3554                 yylloc.last_column = 1;
3555                 BEGIN(INITIAL);
3556                 yyerror("Unexpected end of line in a string.");
3557                 return scan_throw(FLEX_ERROR);
3558             }
3559             YY_BREAK
3560         case YY_STATE_EOF(DOUBLESTRING):
3561         {
3562             pstBuffer.clear();
3563             BEGIN(INITIAL);
3564             yyerror("Unexpected end of file in a string.");
3565             return scan_throw(FLEX_ERROR);
3566         }
3567         YY_BREAK
3568         case 133:
3569         case 134:
3570             YY_RULE_SETUP
3571             {
3572                 //scan_step();
3573                 pstBuffer += yytext;
3574             }
3575             YY_BREAK
3576
3577         case 135:
3578             YY_RULE_SETUP
3579             {
3580                 if (last_token == ID)
3581                 {
3582                     scan_throw(SPACES);
3583                     return ID;
3584                 }
3585             }
3586             YY_BREAK
3587         case 136:
3588             YY_RULE_SETUP
3589             {
3590                 BEGIN(INITIAL);
3591                 scan_step();
3592                 return scan_throw(SEMI);
3593             }
3594             YY_BREAK
3595         case 137:
3596             YY_RULE_SETUP
3597             {
3598                 BEGIN(INITIAL);
3599                 scan_step();
3600                 return scan_throw(COMMA);
3601             }
3602             YY_BREAK
3603         case 138:
3604             /* rule 138 can match eol */
3605             YY_RULE_SETUP
3606             {
3607                 BEGIN(INITIAL);
3608                 yylloc.last_line += 1;
3609                 yylloc.last_column = 1;
3610                 scan_step();
3611                 return scan_throw(EOL);
3612             }
3613             YY_BREAK
3614         case 139:
3615             YY_RULE_SETUP
3616             {
3617                 if (last_token == STR || last_token == SPACES)
3618                 {
3619                     wchar_t *pwText = to_wide_string(yytext);
3620                     yylval.str = new std::wstring(pwText);
3621                     FREE(pwText);
3622                     return scan_throw(STR);
3623                 }
3624                 else
3625                 {
3626                     BEGIN(INITIAL);
3627                     return scan_throw(ASSIGN);
3628                 }
3629             }
3630             YY_BREAK
3631         case 140:
3632             YY_RULE_SETUP
3633             {
3634                 if (last_token == STR || last_token == SPACES)
3635                 {
3636                     wchar_t *pwText = to_wide_string(yytext);
3637                     yylval.str = new std::wstring(pwText);
3638                     FREE(pwText);
3639                     return scan_throw(STR);
3640                 }
3641                 else
3642                 {
3643                     BEGIN(INITIAL);
3644                     return scan_throw(LPAREN);
3645                 }
3646             }
3647             YY_BREAK
3648         case 141:
3649             YY_RULE_SETUP
3650             {
3651                 if (last_token == STR || last_token == SPACES)
3652                 {
3653                     wchar_t *pwText = to_wide_string(yytext);
3654                     yylval.str = new std::wstring(pwText);
3655                     FREE(pwText);
3656                     return scan_throw(STR);
3657                 }
3658                 else
3659                 {
3660                     BEGIN(INITIAL);
3661                     return scan_throw(LT);
3662                 }
3663             }
3664             YY_BREAK
3665         case 142:
3666             YY_RULE_SETUP
3667             {
3668                 if (last_token == STR || last_token == SPACES)
3669                 {
3670                     wchar_t *pwText = to_wide_string(yytext);
3671                     yylval.str = new std::wstring(pwText);
3672                     FREE(pwText);
3673                     return scan_throw(STR);
3674                 }
3675                 else
3676                 {
3677                     BEGIN(INITIAL);
3678                     return scan_throw(GT);
3679                 }
3680             }
3681             YY_BREAK
3682         case 143:
3683             YY_RULE_SETUP
3684             {
3685                 if (last_token == STR || last_token == SPACES)
3686                 {
3687                     wchar_t *pwText = to_wide_string(yytext);
3688                     yylval.str = new std::wstring(pwText);
3689                     FREE(pwText);
3690                     return scan_throw(STR);
3691                 }
3692                 else
3693                 {
3694                     BEGIN(INITIAL);
3695                     return scan_throw(NOT);
3696                 }
3697             }
3698             YY_BREAK
3699         case 144:
3700             YY_RULE_SETUP
3701             {
3702                 wchar_t *pwText = to_wide_string(yytext);
3703                 yylval.str = new std::wstring(pwText);
3704                 FREE(pwText);
3705                 return scan_throw(STR);
3706             }
3707             YY_BREAK
3708         case YY_STATE_EOF(SHELLMODE):
3709         {
3710             BEGIN(INITIAL);
3711         }
3712         YY_BREAK
3713
3714         case 145:
3715             YY_RULE_SETUP
3716             ECHO;
3717             YY_BREAK
3718         case YY_STATE_EOF(INITIAL):
3719         case YY_STATE_EOF(BEGINID):
3720             yyterminate();
3721
3722         case YY_END_OF_BUFFER:
3723         {
3724             /* Amount of text matched not including the EOB char. */
3725             int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
3726
3727             /* Undo the effects of YY_DO_BEFORE_ACTION. */
3728             *yy_cp = (yy_hold_char);
3729             YY_RESTORE_YY_MORE_OFFSET
3730
3731             if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
3732             {
3733                 /* We're scanning a new file or input source.  It's
3734                  * possible that this happened because the user
3735                  * just pointed yyin at a new source and called
3736                  * yylex().  If so, then we have to assure
3737                  * consistency between YY_CURRENT_BUFFER and our
3738                  * globals.  Here is the right place to do so, because
3739                  * this is the first action (other than possibly a
3740                  * back-up) that will match for the new input source.
3741                  */
3742                 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3743                 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
3744                 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
3745             }
3746
3747             /* Note that here we test for yy_c_buf_p "<=" to the position
3748              * of the first EOB in the buffer, since yy_c_buf_p will
3749              * already have been incremented past the NUL character
3750              * (since all states make transitions on EOB to the
3751              * end-of-buffer state).  Contrast this with the test
3752              * in input().
3753              */
3754             if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3755             {
3756                 /* This was really a NUL. */
3757                 yy_state_type yy_next_state;
3758
3759                 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
3760
3761                 yy_current_state = yy_get_previous_state(  );
3762
3763                 /* Okay, we're now positioned to make the NUL
3764                  * transition.  We couldn't have
3765                  * yy_get_previous_state() go ahead and do it
3766                  * for us because it doesn't know how to deal
3767                  * with the possibility of jamming (and we don't
3768                  * want to build jamming into it because then it
3769                  * will run more slowly).
3770                  */
3771
3772                 yy_next_state = yy_try_NUL_trans( yy_current_state );
3773
3774                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3775
3776                 if ( yy_next_state )
3777                 {
3778                     /* Consume the NUL. */
3779                     yy_cp = ++(yy_c_buf_p);
3780                     yy_current_state = yy_next_state;
3781                     goto yy_match;
3782                 }
3783
3784                 else
3785                 {
3786                     yy_cp = (yy_c_buf_p);
3787                     goto yy_find_action;
3788                 }
3789             }
3790
3791             else switch ( yy_get_next_buffer(  ) )
3792                 {
3793                     case EOB_ACT_END_OF_FILE:
3794                     {
3795                         (yy_did_buffer_switch_on_eof) = 0;
3796
3797                         if ( yywrap( ) )
3798                         {
3799                             /* Note: because we've taken care in
3800                              * yy_get_next_buffer() to have set up
3801                              * yytext, we can now set up
3802                              * yy_c_buf_p so that if some total
3803                              * hoser (like flex itself) wants to
3804                              * call the scanner after we return the
3805                              * YY_NULL, it'll still work - another
3806                              * YY_NULL will get returned.
3807                              */
3808                             (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
3809
3810                             yy_act = YY_STATE_EOF(YY_START);
3811                             goto do_action;
3812                         }
3813
3814                         else
3815                         {
3816                             if ( ! (yy_did_buffer_switch_on_eof) )
3817                             {
3818                                 YY_NEW_FILE;
3819                             }
3820                         }
3821                         break;
3822                     }
3823
3824                     case EOB_ACT_CONTINUE_SCAN:
3825                         (yy_c_buf_p) =
3826                             (yytext_ptr) + yy_amount_of_matched_text;
3827
3828                         yy_current_state = yy_get_previous_state(  );
3829
3830                         yy_cp = (yy_c_buf_p);
3831                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3832                         goto yy_match;
3833
3834                     case EOB_ACT_LAST_MATCH:
3835                         (yy_c_buf_p) =
3836                             &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3837
3838                         yy_current_state = yy_get_previous_state(  );
3839
3840                         yy_cp = (yy_c_buf_p);
3841                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3842                         goto yy_find_action;
3843                 }
3844             break;
3845         }
3846
3847         default:
3848             YY_FATAL_ERROR(
3849                 "fatal flex scanner internal error--no action found" );
3850     } /* end of action switch */
3851 } /* end of scanning one token */
3852 } /* end of yylex */
3853
3854 /* yy_get_next_buffer - try to read in a new buffer
3855  *
3856  * Returns a code representing an action:
3857  *      EOB_ACT_LAST_MATCH -
3858  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3859  *      EOB_ACT_END_OF_FILE - end of file
3860  */
3861 static int yy_get_next_buffer (void)
3862 {
3863 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
3864 register char *source = (yytext_ptr);
3865 register int number_to_move, i;
3866 int ret_val;
3867
3868 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
3869     YY_FATAL_ERROR(
3870         "fatal flex scanner internal error--end of buffer missed" );
3871
3872 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
3873 {
3874     /* Don't try to fill the buffer, so this is an EOF. */
3875     if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
3876     {
3877         /* We matched a single character, the EOB, so
3878          * treat this as a final EOF.
3879          */
3880         return EOB_ACT_END_OF_FILE;
3881     }
3882
3883     else
3884     {
3885         /* We matched some text prior to the EOB, first
3886          * process it.
3887          */
3888         return EOB_ACT_LAST_MATCH;
3889     }
3890 }
3891
3892 /* Try to read more data. */
3893
3894 /* First move last chars to start of buffer. */
3895 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
3896
3897 for ( i = 0; i < number_to_move; ++i )
3898 {
3899     *(dest++) = *(source++);
3900 }
3901
3902 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3903     /* don't do the read, it's not guaranteed to return an EOF,
3904      * just force an EOF
3905      */
3906 {
3907     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3908 }
3909
3910 else
3911 {
3912     int num_to_read =
3913         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3914
3915     while ( num_to_read <= 0 )
3916     {
3917         /* Not enough room in the buffer - grow it. */
3918
3919         YY_FATAL_ERROR(
3920             "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
3921
3922     }
3923
3924     if ( num_to_read > YY_READ_BUF_SIZE )
3925     {
3926         num_to_read = YY_READ_BUF_SIZE;
3927     }
3928
3929     /* Read in more data. */
3930     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3931               (yy_n_chars), (size_t) num_to_read );
3932
3933     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3934 }
3935
3936 if ( (yy_n_chars) == 0 )
3937 {
3938     if ( number_to_move == YY_MORE_ADJ )
3939     {
3940         ret_val = EOB_ACT_END_OF_FILE;
3941         yyrestart(yyin  );
3942     }
3943
3944     else
3945     {
3946         ret_val = EOB_ACT_LAST_MATCH;
3947         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3948             YY_BUFFER_EOF_PENDING;
3949     }
3950 }
3951
3952 else
3953 {
3954     ret_val = EOB_ACT_CONTINUE_SCAN;
3955 }
3956
3957 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size)
3958 {
3959     /* Extend the array by 50%, plus the number we really need. */
3960     yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3961     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size  );
3962     if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3963     {
3964         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3965     }
3966 }
3967
3968 (yy_n_chars) += number_to_move;
3969 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3970 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3971
3972 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3973
3974 return ret_val;
3975 }
3976
3977 /* yy_get_previous_state - get the state just before the EOB char was reached */
3978
3979 static yy_state_type yy_get_previous_state (void)
3980 {
3981 register yy_state_type yy_current_state;
3982 register char *yy_cp;
3983
3984 yy_current_state = (yy_start);
3985 yy_current_state += YY_AT_BOL();
3986
3987 (yy_state_ptr) = (yy_state_buf);
3988 *(yy_state_ptr)++ = yy_current_state;
3989
3990 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3991 {
3992     register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3993     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3994     {
3995         yy_current_state = (int) yy_def[yy_current_state];
3996         if ( yy_current_state >= 815 )
3997         {
3998             yy_c = yy_meta[(unsigned int) yy_c];
3999         }
4000     }
4001     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4002     *(yy_state_ptr)++ = yy_current_state;
4003 }
4004
4005 return yy_current_state;
4006 }
4007
4008 /* yy_try_NUL_trans - try to make a transition on the NUL character
4009  *
4010  * synopsis
4011  *      next_state = yy_try_NUL_trans( current_state );
4012  */
4013 static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
4014 {
4015 register int yy_is_jam;
4016
4017 register YY_CHAR yy_c = 1;
4018 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4019 {
4020     yy_current_state = (int) yy_def[yy_current_state];
4021     if ( yy_current_state >= 815 )
4022     {
4023         yy_c = yy_meta[(unsigned int) yy_c];
4024     }
4025 }
4026 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4027 yy_is_jam = (yy_current_state == 814);
4028 if ( ! yy_is_jam )
4029 {
4030     *(yy_state_ptr)++ = yy_current_state;
4031 }
4032
4033 return yy_is_jam ? 0 : yy_current_state;
4034 }
4035
4036 static void yyunput (int c, register char * yy_bp )
4037 {
4038 register char *yy_cp;
4039
4040 yy_cp = (yy_c_buf_p);
4041
4042 /* undo effects of setting up yytext */
4043 *yy_cp = (yy_hold_char);
4044
4045 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4046 {
4047     /* need to shift things up to make room */
4048     /* +2 for EOB chars. */
4049     register int number_to_move = (yy_n_chars) + 2;
4050     register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
4051                               YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
4052     register char *source =
4053         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
4054
4055     while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4056     {
4057         *--dest = *--source;
4058     }
4059
4060     yy_cp += (int) (dest - source);
4061     yy_bp += (int) (dest - source);
4062     YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
4063         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
4064
4065     if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4066     {
4067         YY_FATAL_ERROR( "flex scanner push-back overflow" );
4068     }
4069 }
4070
4071 *--yy_cp = (char) c;
4072
4073 (yytext_ptr) = yy_bp;
4074 (yy_hold_char) = *yy_cp;
4075 (yy_c_buf_p) = yy_cp;
4076 }
4077
4078 #ifndef YY_NO_INPUT
4079 #ifdef __cplusplus
4080 static int yyinput (void)
4081 #else
4082 static int input  (void)
4083 #endif
4084
4085 {
4086     int c;
4087
4088     *(yy_c_buf_p) = (yy_hold_char);
4089
4090     if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
4091     {
4092         /* yy_c_buf_p now points to the character we want to return.
4093          * If this occurs *before* the EOB characters, then it's a
4094          * valid NUL; if not, then we've hit the end of the buffer.
4095          */
4096         if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4097             /* This was really a NUL. */
4098         {
4099             *(yy_c_buf_p) = '\0';
4100         }
4101
4102         else
4103         {
4104             /* need more input */
4105             int offset = (yy_c_buf_p) - (yytext_ptr);
4106             ++(yy_c_buf_p);
4107
4108             switch ( yy_get_next_buffer(  ) )
4109             {
4110                 case EOB_ACT_LAST_MATCH:
4111                     /* This happens because yy_g_n_b()
4112                      * sees that we've accumulated a
4113                      * token and flags that we need to
4114                      * try matching the token before
4115                      * proceeding.  But for input(),
4116                      * there's no matching to consider.
4117                      * So convert the EOB_ACT_LAST_MATCH
4118                      * to EOB_ACT_END_OF_FILE.
4119                      */
4120
4121                     /* Reset buffer status. */
4122                     yyrestart(yyin );
4123
4124                     /*FALLTHROUGH*/
4125
4126                 case EOB_ACT_END_OF_FILE:
4127                 {
4128                     if ( yywrap( ) )
4129                     {
4130                         return EOF;
4131                     }
4132
4133                     if ( ! (yy_did_buffer_switch_on_eof) )
4134                     {
4135                         YY_NEW_FILE;
4136                     }
4137 #ifdef __cplusplus
4138                     return yyinput();
4139 #else
4140                     return input();
4141 #endif
4142                 }
4143
4144                 case EOB_ACT_CONTINUE_SCAN:
4145                     (yy_c_buf_p) = (yytext_ptr) + offset;
4146                     break;
4147             }
4148         }
4149     }
4150
4151     c = *(unsigned char *) (yy_c_buf_p);        /* cast for 8-bit char's */
4152     *(yy_c_buf_p) = '\0';       /* preserve yytext */
4153     (yy_hold_char) = *++(yy_c_buf_p);
4154
4155     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
4156
4157     return c;
4158 }
4159 #endif  /* ifndef YY_NO_INPUT */
4160
4161 /** Immediately switch to a different input stream.
4162  * @param input_file A readable stream.
4163  *
4164  * @note This function does not reset the start condition to @c INITIAL .
4165  */
4166 void yyrestart  (FILE * input_file )
4167 {
4168
4169     if ( ! YY_CURRENT_BUFFER )
4170     {
4171         yyensure_buffer_stack ();
4172         YY_CURRENT_BUFFER_LVALUE =
4173             yy_create_buffer(yyin, YY_BUF_SIZE );
4174     }
4175
4176     yy_init_buffer(YY_CURRENT_BUFFER, input_file );
4177     yy_load_buffer_state( );
4178 }
4179
4180 /** Switch to a different input buffer.
4181  * @param new_buffer The new input buffer.
4182  *
4183  */
4184 void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
4185 {
4186
4187     /* TODO. We should be able to replace this entire function body
4188      * with
4189      *          yypop_buffer_state();
4190      *          yypush_buffer_state(new_buffer);
4191      */
4192     yyensure_buffer_stack ();
4193     if ( YY_CURRENT_BUFFER == new_buffer )
4194     {
4195         return;
4196     }
4197
4198     if ( YY_CURRENT_BUFFER )
4199     {
4200         /* Flush out information for old buffer. */
4201         *(yy_c_buf_p) = (yy_hold_char);
4202         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4203         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4204     }
4205
4206     YY_CURRENT_BUFFER_LVALUE = new_buffer;
4207     yy_load_buffer_state( );
4208
4209     /* We don't actually know whether we did this switch during
4210      * EOF (yywrap()) processing, but the only time this flag
4211      * is looked at is after yywrap() is called, so it's safe
4212      * to go ahead and always set it.
4213      */
4214     (yy_did_buffer_switch_on_eof) = 1;
4215 }
4216
4217 static void yy_load_buffer_state  (void)
4218 {
4219     (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4220     (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
4221     yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
4222     (yy_hold_char) = *(yy_c_buf_p);
4223 }
4224
4225 /** Allocate and initialize an input buffer state.
4226  * @param file A readable stream.
4227  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
4228  *
4229  * @return the allocated buffer state.
4230  */
4231 YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
4232 {
4233     YY_BUFFER_STATE b;
4234
4235     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
4236     if ( ! b )
4237     {
4238         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4239     }
4240
4241     b->yy_buf_size = size;
4242
4243     /* yy_ch_buf has to be 2 characters longer than the size given because
4244      * we need to put in 2 end-of-buffer characters.
4245      */
4246     b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
4247     if ( ! b->yy_ch_buf )
4248     {
4249         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4250     }
4251
4252     b->yy_is_our_buffer = 1;
4253
4254     yy_init_buffer(b, file );
4255
4256     return b;
4257 }
4258
4259 /** Destroy the buffer.
4260  * @param b a buffer created with yy_create_buffer()
4261  *
4262  */
4263 void yy_delete_buffer (YY_BUFFER_STATE  b )
4264 {
4265
4266     if ( ! b )
4267     {
4268         return;
4269     }
4270
4271     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
4272     {
4273         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
4274     }
4275
4276     if ( b->yy_is_our_buffer )
4277     {
4278         yyfree((void *) b->yy_ch_buf  );
4279     }
4280
4281     yyfree((void *) b  );
4282 }
4283
4284 #ifndef __cplusplus
4285 extern int isatty (int );
4286 #endif /* __cplusplus */
4287
4288 /* Initializes or reinitializes a buffer.
4289  * This function is sometimes called more than once on the same buffer,
4290  * such as during a yyrestart() or at EOF.
4291  */
4292 static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
4293
4294 {
4295 int oerrno = errno;
4296
4297 yy_flush_buffer(b );
4298
4299 b->yy_input_file = file;
4300 b->yy_fill_buffer = 1;
4301
4302 /* If b is the current buffer, then yy_init_buffer was _probably_
4303  * called from yyrestart() or through yy_get_next_buffer.
4304  * In that case, we don't want to reset the lineno or column.
4305  */
4306 if (b != YY_CURRENT_BUFFER)
4307 {
4308     b->yy_bs_lineno = 1;
4309     b->yy_bs_column = 0;
4310 }
4311
4312 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
4313
4314 errno = oerrno;
4315 }
4316
4317 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
4318  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
4319  *
4320  */
4321 void yy_flush_buffer (YY_BUFFER_STATE  b )
4322 {
4323 if ( ! b )
4324 {
4325     return;
4326 }
4327
4328 b->yy_n_chars = 0;
4329
4330 /* We always need two end-of-buffer characters.  The first causes
4331  * a transition to the end-of-buffer state.  The second causes
4332  * a jam in that state.
4333  */
4334 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
4335 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
4336
4337 b->yy_buf_pos = &b->yy_ch_buf[0];
4338
4339 b->yy_at_bol = 1;
4340 b->yy_buffer_status = YY_BUFFER_NEW;
4341
4342 if ( b == YY_CURRENT_BUFFER )
4343 {
4344     yy_load_buffer_state( );
4345 }
4346 }
4347
4348 /** Pushes the new state onto the stack. The new state becomes
4349  *  the current state. This function will allocate the stack
4350  *  if necessary.
4351  *  @param new_buffer The new state.
4352  *
4353  */
4354 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
4355 {
4356 if (new_buffer == NULL)
4357 {
4358     return;
4359 }
4360
4361 yyensure_buffer_stack();
4362
4363 /* This block is copied from yy_switch_to_buffer. */
4364 if ( YY_CURRENT_BUFFER )
4365 {
4366     /* Flush out information for old buffer. */
4367     *(yy_c_buf_p) = (yy_hold_char);
4368     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4369     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4370 }
4371
4372 /* Only push if top exists. Otherwise, replace top. */
4373 if (YY_CURRENT_BUFFER)
4374 {
4375     (yy_buffer_stack_top)++;
4376 }
4377 YY_CURRENT_BUFFER_LVALUE = new_buffer;
4378
4379 /* copied from yy_switch_to_buffer. */
4380 yy_load_buffer_state( );
4381 (yy_did_buffer_switch_on_eof) = 1;
4382 }
4383
4384 /** Removes and deletes the top of the stack, if present.
4385  *  The next element becomes the new top.
4386  *
4387  */
4388 void yypop_buffer_state (void)
4389 {
4390 if (!YY_CURRENT_BUFFER)
4391 {
4392     return;
4393 }
4394
4395 yy_delete_buffer(YY_CURRENT_BUFFER );
4396 YY_CURRENT_BUFFER_LVALUE = NULL;
4397 if ((yy_buffer_stack_top) > 0)
4398 {
4399     --(yy_buffer_stack_top);
4400 }
4401
4402 if (YY_CURRENT_BUFFER)
4403 {
4404     yy_load_buffer_state( );
4405     (yy_did_buffer_switch_on_eof) = 1;
4406 }
4407 }
4408
4409 /* Allocates the stack if it does not exist.
4410  *  Guarantees space for at least one push.
4411  */
4412 static void yyensure_buffer_stack (void)
4413 {
4414 int num_to_alloc;
4415
4416 if (!(yy_buffer_stack))
4417 {
4418
4419     /* First allocation is just for 2 elements, since we don't know if this
4420      * scanner will even need a stack. We use 2 instead of 1 to avoid an
4421      * immediate realloc on the next call.
4422      */
4423     num_to_alloc = 1;
4424     (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
4425                         (num_to_alloc * sizeof(struct yy_buffer_state*)
4426                         );
4427     if ( ! (yy_buffer_stack) )
4428     {
4429         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4430     }
4431
4432     memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4433
4434     (yy_buffer_stack_max) = num_to_alloc;
4435     (yy_buffer_stack_top) = 0;
4436     return;
4437 }
4438
4439 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1)
4440 {
4441
4442     /* Increase the buffer to prepare for a possible push. */
4443     int grow_size = 8 /* arbitrary grow size */;
4444
4445     num_to_alloc = (yy_buffer_stack_max) + grow_size;
4446     (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
4447                         ((yy_buffer_stack),
4448                          num_to_alloc * sizeof(struct yy_buffer_state*)
4449                         );
4450     if ( ! (yy_buffer_stack) )
4451     {
4452         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4453     }
4454
4455     /* zero only the new slots.*/
4456     memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
4457     (yy_buffer_stack_max) = num_to_alloc;
4458 }
4459 }
4460
4461 /** Setup the input buffer state to scan directly from a user-specified character buffer.
4462  * @param base the character buffer
4463  * @param size the size in bytes of the character buffer
4464  *
4465  * @return the newly allocated buffer state object.
4466  */
4467 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
4468 {
4469 YY_BUFFER_STATE b;
4470
4471 if ( size < 2 ||
4472         base[size - 2] != YY_END_OF_BUFFER_CHAR ||
4473         base[size - 1] != YY_END_OF_BUFFER_CHAR )
4474     /* They forgot to leave room for the EOB's. */
4475 {
4476     return 0;
4477 }
4478
4479 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
4480 if ( ! b )
4481 {
4482     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
4483 }
4484
4485 b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
4486 b->yy_buf_pos = b->yy_ch_buf = base;
4487 b->yy_is_our_buffer = 0;
4488 b->yy_input_file = 0;
4489 b->yy_n_chars = b->yy_buf_size;
4490 b->yy_is_interactive = 0;
4491 b->yy_at_bol = 1;
4492 b->yy_fill_buffer = 0;
4493 b->yy_buffer_status = YY_BUFFER_NEW;
4494
4495 yy_switch_to_buffer(b  );
4496
4497 return b;
4498 }
4499
4500 /** Setup the input buffer state to scan a string. The next call to yylex() will
4501  * scan from a @e copy of @a str.
4502  * @param yystr a NUL-terminated string to scan
4503  *
4504  * @return the newly allocated buffer state object.
4505  * @note If you want to scan bytes that may contain NUL values, then use
4506  *       yy_scan_bytes() instead.
4507  */
4508 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
4509 {
4510
4511 return yy_scan_bytes(yystr, strlen(yystr) );
4512 }
4513
4514 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
4515  * scan from a @e copy of @a bytes.
4516  * @param yybytes the byte buffer to scan
4517  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
4518  *
4519  * @return the newly allocated buffer state object.
4520  */
4521 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
4522 {
4523 YY_BUFFER_STATE b;
4524 char *buf;
4525 yy_size_t n;
4526 int i;
4527
4528 /* Get memory for full buffer, including space for trailing EOB's. */
4529 n = _yybytes_len + 2;
4530 buf = (char *) yyalloc(n  );
4531 if ( ! buf )
4532 {
4533     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
4534 }
4535
4536 for ( i = 0; i < _yybytes_len; ++i )
4537 {
4538     buf[i] = yybytes[i];
4539 }
4540
4541 buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR;
4542
4543 b = yy_scan_buffer(buf, n );
4544 if ( ! b )
4545 {
4546     YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
4547 }
4548
4549 /* It's okay to grow etc. this buffer, and we should throw it
4550  * away when we're done.
4551  */
4552 b->yy_is_our_buffer = 1;
4553
4554 return b;
4555 }
4556
4557 static void yy_push_state (int  new_state )
4558 {
4559 if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
4560 {
4561     yy_size_t new_size;
4562
4563     (yy_start_stack_depth) += YY_START_STACK_INCR;
4564     new_size = (yy_start_stack_depth) * sizeof( int );
4565
4566     if ( ! (yy_start_stack) )
4567     {
4568         (yy_start_stack) = (int *) yyalloc(new_size  );
4569     }
4570
4571     else
4572     {
4573         (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack), new_size  );
4574     }
4575
4576     if ( ! (yy_start_stack) )
4577     {
4578         YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
4579     }
4580 }
4581
4582 (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
4583
4584 BEGIN(new_state);
4585 }
4586
4587 static void yy_pop_state  (void)
4588 {
4589 if ( --(yy_start_stack_ptr) < 0 )
4590 {
4591     YY_FATAL_ERROR( "start-condition stack underflow" );
4592 }
4593
4594 BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
4595 }
4596
4597 static int yy_top_state  (void)
4598 {
4599 return (yy_start_stack)[(yy_start_stack_ptr) - 1];
4600 }
4601
4602 #ifndef YY_EXIT_FAILURE
4603 #define YY_EXIT_FAILURE 2
4604 #endif
4605
4606 static void yy_fatal_error (yyconst char* msg )
4607 {
4608 (void) fprintf( stderr, "%s\n", msg );
4609 exit( YY_EXIT_FAILURE );
4610 }
4611
4612 /* Redefine yyless() so it works in section 3 code. */
4613
4614 #undef yyless
4615 #define yyless(n) \
4616         do \
4617                 { \
4618                 /* Undo effects of setting up yytext. */ \
4619         int yyless_macro_arg = (n); \
4620         YY_LESS_LINENO(yyless_macro_arg);\
4621                 yytext[yyleng] = (yy_hold_char); \
4622                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
4623                 (yy_hold_char) = *(yy_c_buf_p); \
4624                 *(yy_c_buf_p) = '\0'; \
4625                 yyleng = yyless_macro_arg; \
4626                 } \
4627         while ( 0 )
4628
4629 /* Accessor  methods (get/set functions) to struct members. */
4630
4631 /** Get the current line number.
4632  *
4633  */
4634 int yyget_lineno  (void)
4635 {
4636
4637 return yylineno;
4638 }
4639
4640 /** Get the input stream.
4641  *
4642  */
4643 FILE *yyget_in  (void)
4644 {
4645 return yyin;
4646 }
4647
4648 /** Get the output stream.
4649  *
4650  */
4651 FILE *yyget_out  (void)
4652 {
4653 return yyout;
4654 }
4655
4656 /** Get the length of the current token.
4657  *
4658  */
4659 int yyget_leng  (void)
4660 {
4661 return yyleng;
4662 }
4663
4664 /** Get the current token.
4665  *
4666  */
4667
4668 char *yyget_text  (void)
4669 {
4670 return yytext;
4671 }
4672
4673 /** Set the current line number.
4674  * @param line_number
4675  *
4676  */
4677 void yyset_lineno (int  line_number )
4678 {
4679
4680 yylineno = line_number;
4681 }
4682
4683 /** Set the input stream. This does not discard the current
4684  * input buffer.
4685  * @param in_str A readable stream.
4686  *
4687  * @see yy_switch_to_buffer
4688  */
4689 void yyset_in (FILE *  in_str )
4690 {
4691 yyin = in_str ;
4692 }
4693
4694 void yyset_out (FILE *  out_str )
4695 {
4696 yyout = out_str ;
4697 }
4698
4699 int yyget_debug  (void)
4700 {
4701 return yy_flex_debug;
4702 }
4703
4704 void yyset_debug (int  bdebug )
4705 {
4706 yy_flex_debug = bdebug ;
4707 }
4708
4709 static int yy_init_globals (void)
4710 {
4711 /* Initialization is the same as for the non-reentrant scanner.
4712 * This function is called from yylex_destroy(), so don't allocate here.
4713 */
4714
4715 (yy_buffer_stack) = 0;
4716 (yy_buffer_stack_top) = 0;
4717 (yy_buffer_stack_max) = 0;
4718 (yy_c_buf_p) = (char *) 0;
4719 (yy_init) = 0;
4720 (yy_start) = 0;
4721
4722 (yy_start_stack_ptr) = 0;
4723 (yy_start_stack_depth) = 0;
4724 (yy_start_stack) =  NULL;
4725
4726 (yy_state_buf) = 0;
4727 (yy_state_ptr) = 0;
4728 (yy_full_match) = 0;
4729 (yy_lp) = 0;
4730
4731 /* Defined in main.c */
4732 #ifdef YY_STDINIT
4733 yyin = stdin;
4734 yyout = stdout;
4735 #else
4736 yyin = (FILE *) 0;
4737 yyout = (FILE *) 0;
4738 #endif
4739
4740 /* For future reference: Set errno on error, since we are called by
4741  * yylex_init()
4742  */
4743 return 0;
4744 }
4745
4746 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
4747 int yylex_destroy  (void)
4748 {
4749
4750 /* Pop the buffer stack, destroying each element. */
4751 while (YY_CURRENT_BUFFER)
4752 {
4753     yy_delete_buffer(YY_CURRENT_BUFFER  );
4754     YY_CURRENT_BUFFER_LVALUE = NULL;
4755     yypop_buffer_state();
4756 }
4757
4758 /* Destroy the stack itself. */
4759 yyfree((yy_buffer_stack) );
4760 (yy_buffer_stack) = NULL;
4761
4762 /* Destroy the start condition stack. */
4763 yyfree((yy_start_stack)  );
4764 (yy_start_stack) = NULL;
4765
4766 yyfree ( (yy_state_buf) );
4767 (yy_state_buf)  = NULL;
4768
4769 /* Reset the globals. This is important in a non-reentrant scanner so the next time
4770  * yylex() is called, initialization will occur. */
4771 yy_init_globals( );
4772
4773 return 0;
4774 }
4775
4776 /*
4777  * Internal utility routines.
4778  */
4779
4780 #ifndef yytext_ptr
4781 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
4782 {
4783 register int i;
4784 for ( i = 0; i < n; ++i )
4785 {
4786     s1[i] = s2[i];
4787 }
4788 }
4789 #endif
4790
4791 #ifdef YY_NEED_STRLEN
4792 static int yy_flex_strlen (yyconst char * s )
4793 {
4794 register int n;
4795 for ( n = 0; s[n]; ++n )
4796     ;
4797
4798 return n;
4799 }
4800 #endif
4801
4802 void *yyalloc (yy_size_t  size )
4803 {
4804 return (void *) malloc( size );
4805 }
4806
4807 void *yyrealloc  (void * ptr, yy_size_t  size )
4808 {
4809 /* The cast to (char *) in the following accommodates both
4810  * implementations that use char* generic pointers, and those
4811  * that use void* generic pointers.  It works with the latter
4812  * because both ANSI C and C++ allow castless assignment from
4813  * any pointer type to void*, and deal with argument conversions
4814  * as though doing an assignment.
4815  */
4816 return (void *) realloc( (char *) ptr, size );
4817 }
4818
4819 void yyfree (void * ptr )
4820 {
4821 free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
4822 }
4823
4824 #define YYTABLES_NAME "yytables"
4825
4826 int scan_throw(int token)
4827 {
4828 last_token = token;
4829 #ifdef DEV
4830 std::cout << "--> [DEBUG] TOKEN : " << token << " - " << token_to_string(token) << std::endl;
4831 #endif
4832 return token;
4833 }
4834
4835 int get_last_token()
4836 {
4837 return last_token;
4838 }
4839
4840 void scan_step()
4841 {
4842 yylloc.first_line = yylloc.last_line;
4843 yylloc.first_column = yylloc.last_column;
4844 }
4845
4846 /*
4847 ** convert floating numbers to C standard
4848 ** 1.2d-3 -> 1.2e-3
4849 ** 1.2D-3 -> 1.2e-3
4850 */
4851 void scan_exponent_convert(char *in)
4852 {
4853 for (; *in != 'd' && *in != 'D'; ++in);
4854 *in = 'e';
4855 }
4856
4857 #ifdef _MSC_VER
4858 int isatty (int desc)
4859 {
4860 return 0;
4861 }
4862 #endif
4863
4864 #ifdef DEV
4865 std::string token_to_string(int token)
4866 {
4867 std::string str;
4868 switch (token)
4869 {
4870     case AND :
4871         str = "AND";
4872         break;
4873     case ASSIGN :
4874         str = "ASSIGN";
4875         break;
4876     case BOOLFALSE :
4877         str = "BOOLFALSE";
4878         break;
4879     case BOOLTRUE :
4880         str = "BOOLTRUE";
4881         break;
4882     case BREAK :
4883         str = "BREAK";
4884         break;
4885     case CASE :
4886         str = "CASE";
4887         break;
4888     case CATCH :
4889         str = "CATCH";
4890         break;
4891     case COLON :
4892         str = "COLON";
4893         break;
4894     case COMMA :
4895         str = "COMMA";
4896         break;
4897     case COMMENT :
4898         str = "COMMENT";
4899         break;
4900     case CONTINUE :
4901         str = "CONTINUE";
4902         break;
4903     case CONTROLLDIVIDE :
4904         str = "CONTROLLDIVIDE";
4905         break;
4906     case CONTROLRDIVIDE :
4907         str = "CONTROLRDIVIDE";
4908         break;
4909     case CONTROLTIMES :
4910         str = "CONTROLTIMES";
4911         break;
4912     case DO :
4913         str = "DO";
4914         break;
4915     case DOLLAR :
4916         str = "DOLLAR";
4917         break;
4918     case DOT :
4919         str = "DOT";
4920         break;
4921     case DOTLDIVIDE :
4922         str = "DOTLDIVIDE";
4923         break;
4924     case DOTPOWER :
4925         str = "DOTPOWER";
4926         break;
4927     case DOTQUOTE :
4928         str = "DOTQUOTE";
4929         break;
4930     case DOTRDIVIDE :
4931         str = "DOTRDIVIDE";
4932         break;
4933     case DOTS :
4934         str = "DOTS";
4935         break;
4936     case DOTTIMES :
4937         str = "DOTTIMES";
4938         break;
4939     case ELSE :
4940         str = "ELSE";
4941         break;
4942     case ELSEIF :
4943         str = "ELSEIF";
4944         break;
4945     case END :
4946         str = "END";
4947         break;
4948     case ENDFUNCTION :
4949         str = "ENDFUNCTION";
4950         break;
4951     case EOL :
4952         str = "EOL";
4953         break;
4954     case EQ :
4955         str = "EQ";
4956         break;
4957     case FLEX_ERROR :
4958         str = "FLEX_ERROR";
4959         break;
4960     case FOR :
4961         str = "FOR";
4962         break;
4963     case FUNCTION :
4964         str = "FUNCTION";
4965         break;
4966     case GE :
4967         str = "GE";
4968         break;
4969     case GT :
4970         str = "GT";
4971         break;
4972     case ID :
4973         str = "ID";
4974         break;
4975     case IF :
4976         str = "IF";
4977         break;
4978     case KRONLDIVIDE :
4979         str = "KRONLDIVIDE";
4980         break;
4981     case KRONRDIVIDE :
4982         str = "KRONRDIVIDE";
4983         break;
4984     case KRONTIMES :
4985         str = "KRONTIMES";
4986         break;
4987     case LBRACE :
4988         str = "LBRACE";
4989         break;
4990     case LBRACK :
4991         str = "LBRACK";
4992         break;
4993     case LDIVIDE :
4994         str = "LDIVIDE";
4995         break;
4996     case LE :
4997         str = "LE";
4998         break;
4999     case LPAREN :
5000         str = "LPAREN";
5001         break;
5002     case LT :
5003         str = "LT";
5004         break;
5005     case MINUS :
5006         str = "MINUS";
5007         break;
5008     case NE :
5009         str = "NE";
5010         break;
5011     case NOT :
5012         str = "NOT";
5013         break;
5014     case NUM :
5015         str = "NUM";
5016         break;
5017     case OR :
5018         str = "OR";
5019         break;
5020     case OROR :
5021         str = "OROR";
5022         break;
5023     case OTHERWISE :
5024         str = "OTHERWISE";
5025         break;
5026     case PLUS :
5027         str = "PLUS";
5028         break;
5029     case POWER :
5030         str = "POWER";
5031         break;
5032     case QUOTE :
5033         str = "QUOTE";
5034         break;
5035     case RBRACE :
5036         str = "RBRACE";
5037         break;
5038     case RBRACK :
5039         str = "RBRACK";
5040         break;
5041     case RDIVIDE :
5042         str = "RDIVIDE";
5043         break;
5044     case RETURN :
5045         str = "RETURN";
5046         break;
5047     case RPAREN :
5048         str = "RPAREN";
5049         break;
5050     case SELECT :
5051         str = "SELECT";
5052         break;
5053     case SEMI :
5054         str = "SEMI";
5055         break;
5056     case SPACES :
5057         str = "SPACES";
5058         break;
5059     case STR :
5060         str = "STR";
5061         break;
5062     case SWITCH :
5063         str = "SWITCH";
5064         break;
5065     case THEN :
5066         str = "THEN";
5067         break;
5068     case TIMES :
5069         str = "TIMES";
5070         break;
5071     case TRY :
5072         str = "TRY";
5073         break;
5074     case VARFLOAT :
5075         str = "VARFLOAT";
5076         break;
5077     case VARINT :
5078         str = "VARINT";
5079         break;
5080     case WHILE :
5081         str = "WHILE";
5082         break;
5083     default :
5084         str = "UNKNOWN";
5085         break;
5086 }
5087 return str;
5088
5089 }
5090 #endif
5091