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