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