Line data Source code
1 : #line 2 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/LexTarget/l10ntools/source/srclex.cxx"
2 :
3 : #line 4 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/LexTarget/l10ntools/source/srclex.cxx"
4 :
5 : #define YY_INT_ALIGNED short int
6 :
7 : /* A lexical scanner generated by flex */
8 :
9 : #define FLEX_SCANNER
10 : #define YY_FLEX_MAJOR_VERSION 2
11 : #define YY_FLEX_MINOR_VERSION 5
12 : #define YY_FLEX_SUBMINOR_VERSION 37
13 : #if YY_FLEX_SUBMINOR_VERSION > 0
14 : #define FLEX_BETA
15 : #endif
16 :
17 : /* First, we deal with platform-specific or compiler-specific issues. */
18 :
19 : /* begin standard C headers. */
20 : #include <stdio.h>
21 : #include <string.h>
22 : #include <errno.h>
23 : #include <stdlib.h>
24 :
25 : /* end standard C headers. */
26 :
27 : /* flex integer type definitions */
28 :
29 : #ifndef FLEXINT_H
30 : #define FLEXINT_H
31 :
32 : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
33 :
34 : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
35 :
36 : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37 : * if you want the limit (max/min) macros for int types.
38 : */
39 : #ifndef __STDC_LIMIT_MACROS
40 : #define __STDC_LIMIT_MACROS 1
41 : #endif
42 :
43 : #include <inttypes.h>
44 : typedef int8_t flex_int8_t;
45 : typedef uint8_t flex_uint8_t;
46 : typedef int16_t flex_int16_t;
47 : typedef uint16_t flex_uint16_t;
48 : typedef int32_t flex_int32_t;
49 : typedef uint32_t flex_uint32_t;
50 : #else
51 : typedef signed char flex_int8_t;
52 : typedef short int flex_int16_t;
53 : typedef int flex_int32_t;
54 : typedef unsigned char flex_uint8_t;
55 : typedef unsigned short int flex_uint16_t;
56 : typedef unsigned int flex_uint32_t;
57 :
58 : /* Limits of integral types. */
59 : #ifndef INT8_MIN
60 : #define INT8_MIN (-128)
61 : #endif
62 : #ifndef INT16_MIN
63 : #define INT16_MIN (-32767-1)
64 : #endif
65 : #ifndef INT32_MIN
66 : #define INT32_MIN (-2147483647-1)
67 : #endif
68 : #ifndef INT8_MAX
69 : #define INT8_MAX (127)
70 : #endif
71 : #ifndef INT16_MAX
72 : #define INT16_MAX (32767)
73 : #endif
74 : #ifndef INT32_MAX
75 : #define INT32_MAX (2147483647)
76 : #endif
77 : #ifndef UINT8_MAX
78 : #define UINT8_MAX (255U)
79 : #endif
80 : #ifndef UINT16_MAX
81 : #define UINT16_MAX (65535U)
82 : #endif
83 : #ifndef UINT32_MAX
84 : #define UINT32_MAX (4294967295U)
85 : #endif
86 :
87 : #endif /* ! C99 */
88 :
89 : #endif /* ! FLEXINT_H */
90 :
91 : #ifdef __cplusplus
92 :
93 : /* The "const" storage-class-modifier is valid. */
94 : #define YY_USE_CONST
95 :
96 : #else /* ! __cplusplus */
97 :
98 : /* C99 requires __STDC__ to be defined as 1. */
99 : #if defined (__STDC__)
100 :
101 : #define YY_USE_CONST
102 :
103 : #endif /* defined (__STDC__) */
104 : #endif /* ! __cplusplus */
105 :
106 : #ifdef YY_USE_CONST
107 : #define yyconst const
108 : #else
109 : #define yyconst
110 : #endif
111 :
112 : /* Returned upon end-of-file. */
113 : #define YY_NULL 0
114 :
115 : /* Promotes a possibly negative, possibly signed char to an unsigned
116 : * integer for use as an array index. If the signed char is negative,
117 : * we want to instead treat it as an 8-bit unsigned char, hence the
118 : * double cast.
119 : */
120 : #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
121 :
122 : /* Enter a start condition. This macro really ought to take a parameter,
123 : * but we do it the disgusting crufty way forced on us by the ()-less
124 : * definition of BEGIN.
125 : */
126 : #define BEGIN (yy_start) = 1 + 2 *
127 :
128 : /* Translate the current start state into a value that can be later handed
129 : * to BEGIN to return to the state. The YYSTATE alias is for lex
130 : * compatibility.
131 : */
132 : #define YY_START (((yy_start) - 1) / 2)
133 : #define YYSTATE YY_START
134 :
135 : /* Action number for EOF rule of a given start state. */
136 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
137 :
138 : /* Special action meaning "start processing a new file". */
139 : #define YY_NEW_FILE yyrestart(yyin )
140 :
141 : #define YY_END_OF_BUFFER_CHAR 0
142 :
143 : /* Size of default input buffer. */
144 : #ifndef YY_BUF_SIZE
145 : #define YY_BUF_SIZE 16384
146 : #endif
147 :
148 : /* The state buf must be large enough to hold one state per character in the main buffer.
149 : */
150 : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
151 :
152 : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
153 : #define YY_TYPEDEF_YY_BUFFER_STATE
154 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
155 : #endif
156 :
157 : #ifndef YY_TYPEDEF_YY_SIZE_T
158 : #define YY_TYPEDEF_YY_SIZE_T
159 : typedef size_t yy_size_t;
160 : #endif
161 :
162 : extern yy_size_t yyleng;
163 :
164 : extern FILE *yyin, *yyout;
165 :
166 : #define EOB_ACT_CONTINUE_SCAN 0
167 : #define EOB_ACT_END_OF_FILE 1
168 : #define EOB_ACT_LAST_MATCH 2
169 :
170 : /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
171 : * access to the local variable yy_act. Since yyless() is a macro, it would break
172 : * existing scanners that call yyless() from OUTSIDE yylex.
173 : * One obvious solution it to make yy_act a global. I tried that, and saw
174 : * a 5% performance hit in a non-yylineno scanner, because yy_act is
175 : * normally declared as a register variable-- so it is not worth it.
176 : */
177 : #define YY_LESS_LINENO(n) \
178 : do { \
179 : int yyl;\
180 : for ( yyl = n; yyl < yyleng; ++yyl )\
181 : if ( yytext[yyl] == '\n' )\
182 : --yylineno;\
183 : }while(0)
184 :
185 : /* Return all but the first "n" matched characters back to the input stream. */
186 : #define yyless(n) \
187 : do \
188 : { \
189 : /* Undo effects of setting up yytext. */ \
190 : int yyless_macro_arg = (n); \
191 : YY_LESS_LINENO(yyless_macro_arg);\
192 : *yy_cp = (yy_hold_char); \
193 : YY_RESTORE_YY_MORE_OFFSET \
194 : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
196 : } \
197 : while ( 0 )
198 :
199 : #define unput(c) yyunput( c, (yytext_ptr) )
200 :
201 : #ifndef YY_STRUCT_YY_BUFFER_STATE
202 : #define YY_STRUCT_YY_BUFFER_STATE
203 : struct yy_buffer_state
204 : {
205 : FILE *yy_input_file;
206 :
207 : char *yy_ch_buf; /* input buffer */
208 : char *yy_buf_pos; /* current position in input buffer */
209 :
210 : /* Size of input buffer in bytes, not including room for EOB
211 : * characters.
212 : */
213 : yy_size_t yy_buf_size;
214 :
215 : /* Number of characters read into yy_ch_buf, not including EOB
216 : * characters.
217 : */
218 : yy_size_t yy_n_chars;
219 :
220 : /* Whether we "own" the buffer - i.e., we know we created it,
221 : * and can realloc() it to grow it, and should free() it to
222 : * delete it.
223 : */
224 : int yy_is_our_buffer;
225 :
226 : /* Whether this is an "interactive" input source; if so, and
227 : * if we're using stdio for input, then we want to use getc()
228 : * instead of fread(), to make sure we stop fetching input after
229 : * each newline.
230 : */
231 : int yy_is_interactive;
232 :
233 : /* Whether we're considered to be at the beginning of a line.
234 : * If so, '^' rules will be active on the next match, otherwise
235 : * not.
236 : */
237 : int yy_at_bol;
238 :
239 : int yy_bs_lineno; /**< The line count. */
240 : int yy_bs_column; /**< The column count. */
241 :
242 : /* Whether to try to fill the input buffer when we reach the
243 : * end of it.
244 : */
245 : int yy_fill_buffer;
246 :
247 : int yy_buffer_status;
248 :
249 : #define YY_BUFFER_NEW 0
250 : #define YY_BUFFER_NORMAL 1
251 : /* When an EOF's been seen but there's still some text to process
252 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
253 : * shouldn't try reading from the input source any more. We might
254 : * still have a bunch of tokens to match, though, because of
255 : * possible backing-up.
256 : *
257 : * When we actually see the EOF, we change the status to "new"
258 : * (via yyrestart()), so that the user can continue scanning by
259 : * just pointing yyin at a new input file.
260 : */
261 : #define YY_BUFFER_EOF_PENDING 2
262 :
263 : };
264 : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
265 :
266 : /* Stack of input buffers. */
267 : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
268 : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
269 : static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
270 :
271 : /* We provide macros for accessing buffer states in case in the
272 : * future we want to put the buffer states in a more general
273 : * "scanner state".
274 : *
275 : * Returns the top of the stack, or NULL.
276 : */
277 : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
278 : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
279 : : NULL)
280 :
281 : /* Same as previous macro, but useful when we know that the buffer stack is not
282 : * NULL or when we need an lvalue. For internal use only.
283 : */
284 : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
285 :
286 : /* yy_hold_char holds the character lost when yytext is formed. */
287 : static char yy_hold_char;
288 : static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
289 : yy_size_t yyleng;
290 :
291 : /* Points to current character in buffer. */
292 : static char *yy_c_buf_p = (char *) 0;
293 : static int yy_init = 0; /* whether we need to initialize */
294 : static int yy_start = 0; /* start state number */
295 :
296 : /* Flag which is used to allow yywrap()'s to do buffer switches
297 : * instead of setting up a fresh yyin. A bit of a hack ...
298 : */
299 : static int yy_did_buffer_switch_on_eof;
300 :
301 : void yyrestart (FILE *input_file );
302 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
303 : YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
304 : void yy_delete_buffer (YY_BUFFER_STATE b );
305 : void yy_flush_buffer (YY_BUFFER_STATE b );
306 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
307 : void yypop_buffer_state (void );
308 :
309 : static void yyensure_buffer_stack (void );
310 : static void yy_load_buffer_state (void );
311 : static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
312 :
313 : #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
314 :
315 : YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
316 : YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
317 : YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
318 :
319 : void *yyalloc (yy_size_t );
320 : void *yyrealloc (void *,yy_size_t );
321 : void yyfree (void * );
322 :
323 : #define yy_new_buffer yy_create_buffer
324 :
325 : #define yy_set_interactive(is_interactive) \
326 : { \
327 : if ( ! YY_CURRENT_BUFFER ){ \
328 : yyensure_buffer_stack (); \
329 : YY_CURRENT_BUFFER_LVALUE = \
330 : yy_create_buffer(yyin,YY_BUF_SIZE ); \
331 : } \
332 : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
333 : }
334 :
335 : #define yy_set_bol(at_bol) \
336 : { \
337 : if ( ! YY_CURRENT_BUFFER ){\
338 : yyensure_buffer_stack (); \
339 : YY_CURRENT_BUFFER_LVALUE = \
340 : yy_create_buffer(yyin,YY_BUF_SIZE ); \
341 : } \
342 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
343 : }
344 :
345 : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
346 :
347 : /* Begin user sect3 */
348 :
349 : typedef unsigned char YY_CHAR;
350 :
351 : FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
352 :
353 : typedef int yy_state_type;
354 :
355 : extern int yylineno;
356 :
357 : int yylineno = 1;
358 :
359 : extern char *yytext;
360 : #define yytext_ptr yytext
361 :
362 : static yy_state_type yy_get_previous_state (void );
363 : static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
364 : static int yy_get_next_buffer (void );
365 : static void yy_fatal_error (yyconst char msg[] );
366 :
367 : /* Done after the current pattern has been matched and before the
368 : * corresponding action - sets up yytext.
369 : */
370 : #define YY_DO_BEFORE_ACTION \
371 : (yytext_ptr) = yy_bp; \
372 : yyleng = (size_t) (yy_cp - yy_bp); \
373 : (yy_hold_char) = *yy_cp; \
374 : *yy_cp = '\0'; \
375 : (yy_c_buf_p) = yy_cp;
376 :
377 : #define YY_NUM_RULES 41
378 : #define YY_END_OF_BUFFER 42
379 : /* This struct is not used in this scanner,
380 : but its presence is necessary. */
381 : struct yy_trans_info
382 : {
383 : flex_int32_t yy_verify;
384 : flex_int32_t yy_nxt;
385 : };
386 : static yyconst flex_int16_t yy_acclist[383] =
387 : { 0,
388 : 42, 39, 41, 3, 39, 41, 10, 41, 39, 41,
389 : 39, 41, 39, 41, 39, 41, 7, 39, 41, 8,
390 : 39, 41, 9, 39, 41, 39, 41, 39, 41, 39,
391 : 41, 39, 41, 37, 39, 41, 25, 39, 41, 39,
392 : 41, 3, 39, 41, 2, 10, 41, 39, 41, 39,
393 : 41, 39, 41, 39, 41, 39, 41, 39, 41, 3,
394 : 24, 11, 6, 38, 29, 30, 25, 25, 26, 3,
395 : 2, 21, 24, 34, 6, 29, 30, 29, 30, 29,
396 : 30, 29, 30, 28, 29, 30, 29, 30, 29, 30,
397 : 29, 30, 29, 30, 29, 30, 38, 26, 21, 21,
398 :
399 : 34, 28, 40, 29, 30, 22, 29, 30, 29, 30,
400 : 28, 29, 30, 29, 30, 28, 29, 30, 28, 29,
401 : 30, 28, 29, 30, 29, 30, 29, 30, 29, 30,
402 : 29, 30, 29, 30, 31, 29, 30, 34, 18, 20,
403 : 18, 18, 18,16398,16398,16398, 18, 20, 21, 18,
404 : 40, 22, 28, 28, 28, 28, 31, 22, 29, 30,
405 : 22, 29, 30, 22, 22, 29, 30, 22, 29, 30,
406 : 22, 23, 29, 30, 29, 30, 29, 29, 30, 29,
407 : 30, 28, 29, 30, 29, 30, 29, 30, 18, 40,
408 : 16399,16400, 8206,16398,16398, 22, 22, 22, 22, 22,
409 :
410 : 23, 28, 23, 22, 22, 29, 30, 23, 22, 29,
411 : 30, 22, 29, 30, 22, 29, 30, 22, 29, 30,
412 : 22, 23, 29, 30, 29, 29, 29, 29, 30, 29,
413 : 30, 29, 30, 23, 29, 30, 28, 29, 30, 29,
414 : 30, 18, 20, 18,16399, 8207,16400, 8208,16401,16398,
415 : 16398, 5, 22, 22, 22, 22, 22, 22, 23, 28,
416 : 23, 22, 29, 30, 29, 29, 30, 29, 30, 29,
417 : 30, 29, 30, 23, 29, 30, 28, 29, 30, 29,
418 : 30, 19, 18,16401, 8209,16397,16398,16398, 1, 5,
419 : 22, 28, 29, 29, 30, 29, 30, 8205, 8206,16398,
420 :
421 : 4, 1, 29, 30, 12, 8206, 4, 36, 36, 35,
422 : 36, 29, 30, 29, 30, 29, 30, 29, 30, 29,
423 : 30, 29, 30, 29, 30, 33, 29, 30, 29, 30,
424 : 29, 30, 29, 30, 32, 18, 18, 33, 29, 30,
425 : 18, 29, 30, 18, 18, 32, 29, 30, 29, 30,
426 : 32, 32, 29, 30, 32, 18, 18, 29, 30, 29,
427 : 30, 18, 32, 32, 32, 29, 30, 32, 18, 29,
428 : 30, 18, 32, 27, 29, 30, 27, 29, 30, 27,
429 : 29, 30
430 : } ;
431 :
432 : static yyconst flex_int16_t yy_accept[476] =
433 : { 0,
434 : 1, 1, 1, 2, 4, 7, 9, 11, 13, 15,
435 : 17, 20, 23, 26, 28, 30, 32, 34, 37, 40,
436 : 42, 45, 48, 50, 52, 54, 56, 58, 60, 61,
437 : 61, 61, 61, 61, 61, 62, 62, 63, 64, 64,
438 : 64, 64, 65, 67, 67, 67, 67, 67, 67, 67,
439 : 67, 67, 68, 68, 69, 69, 70, 71, 72, 72,
440 : 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
441 : 72, 73, 73, 73, 73, 73, 73, 73, 73, 73,
442 : 73, 73, 74, 74, 75, 75, 76, 76, 76, 78,
443 : 80, 80, 82, 84, 87, 89, 91, 93, 95, 97,
444 :
445 : 97, 97, 97, 97, 97, 97, 98, 98, 98, 98,
446 : 98, 98, 98, 99, 99, 99, 99, 99, 99, 99,
447 : 99, 99, 99, 99, 99, 99, 100, 101, 101, 101,
448 : 101, 101, 101, 101, 102, 102, 102, 102, 103, 103,
449 : 103, 103, 103, 103, 104, 104, 104, 104, 104, 104,
450 : 104, 106, 109, 111, 114, 116, 119, 122, 125, 127,
451 : 129, 131, 131, 133, 133, 136, 138, 138, 138, 138,
452 : 138, 139, 140, 140, 140, 140, 141, 142, 142, 143,
453 : 144, 144, 144, 144, 144, 144, 144, 144, 144, 145,
454 : 146, 147, 147, 147, 147, 148, 148, 150, 151, 151,
455 :
456 : 151, 151, 151, 151, 152, 152, 153, 154, 155, 156,
457 : 157, 157, 157, 157, 157, 157, 157, 158, 158, 161,
458 : 164, 165, 168, 171, 175, 177, 178, 180, 182, 185,
459 : 187, 187, 187, 189, 189, 189, 189, 189, 189, 189,
460 : 189, 190, 190, 190, 190, 190, 191, 192, 193, 193,
461 : 194, 195, 196, 196, 196, 196, 196, 196, 196, 196,
462 : 197, 198, 199, 200, 202, 203, 203, 203, 203, 203,
463 : 203, 203, 203, 204, 204, 205, 208, 208, 208, 209,
464 : 212, 215, 218, 221, 225, 226, 227, 228, 230, 232,
465 : 234, 237, 240, 242, 242, 242, 242, 242, 242, 242,
466 :
467 : 243, 243, 243, 243, 243, 244, 245, 245, 245, 246,
468 : 247, 248, 249, 250, 251, 252, 252, 252, 253, 253,
469 : 253, 254, 255, 256, 257, 258, 260, 261, 261, 261,
470 : 261, 261, 261, 261, 262, 262, 265, 266, 268, 270,
471 : 272, 274, 277, 280, 282, 282, 282, 283, 283, 283,
472 : 284, 284, 284, 285, 286, 288, 289, 289, 290, 291,
473 : 291, 291, 292, 293, 293, 294, 296, 298, 298, 298,
474 : 298, 300, 301, 302, 303, 303, 303, 303, 305, 305,
475 : 305, 307, 308, 308, 308, 309, 310, 312, 314, 314,
476 : 314, 316, 316, 316, 316, 318, 318, 320, 320, 320,
477 :
478 : 320, 320, 322, 322, 324, 327, 327, 327, 327, 327,
479 : 327, 329, 329, 329, 331, 331, 333, 336, 336, 336,
480 : 337, 338, 338, 338, 339, 341, 341, 341, 341, 341,
481 : 342, 344, 345, 346, 346, 346, 347, 349, 349, 352,
482 : 353, 356, 356, 356, 357, 357, 357, 357, 357, 358,
483 : 360, 362, 363, 363, 364, 365, 365, 366, 369, 369,
484 : 369, 370, 370, 370, 372, 373, 374, 374, 374, 374,
485 : 377, 377, 380, 383, 383
486 : } ;
487 :
488 : static yyconst flex_int32_t yy_ec[256] =
489 : { 0,
490 : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
491 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
492 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
493 : 1, 2, 1, 4, 5, 1, 1, 1, 1, 6,
494 : 7, 8, 1, 1, 9, 1, 10, 11, 11, 11,
495 : 11, 11, 11, 11, 11, 11, 11, 1, 12, 13,
496 : 14, 15, 1, 1, 16, 17, 17, 17, 18, 19,
497 : 17, 17, 20, 17, 17, 21, 22, 23, 24, 25,
498 : 17, 17, 26, 27, 28, 17, 17, 17, 17, 17,
499 : 29, 30, 31, 1, 32, 1, 33, 17, 34, 35,
500 :
501 : 36, 37, 38, 17, 39, 17, 17, 40, 41, 42,
502 : 17, 43, 17, 44, 45, 46, 47, 17, 17, 17,
503 : 17, 17, 48, 1, 49, 1, 1, 1, 1, 1,
504 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
505 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
506 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
507 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
508 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
509 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
510 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
511 :
512 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
513 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
514 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
515 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
516 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
517 : 1, 1, 1, 1, 1
518 : } ;
519 :
520 : static yyconst flex_int32_t yy_meta[50] =
521 : { 0,
522 : 1, 2, 3, 4, 5, 1, 1, 1, 6, 1,
523 : 2, 7, 1, 8, 1, 2, 2, 2, 2, 2,
524 : 2, 2, 2, 2, 2, 2, 2, 2, 9, 10,
525 : 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526 : 2, 2, 2, 2, 2, 2, 2, 11, 1
527 : } ;
528 :
529 : static yyconst flex_int16_t yy_base[541] =
530 : { 0,
531 : 0, 49, 1568, 2733, 97, 2733, 1563, 1512, 95, 105,
532 : 2733, 102, 2733, 110, 141, 105, 96, 2733, 124, 108,
533 : 127, 2733, 121, 172, 219, 121, 107, 266, 145, 1541,
534 : 1509, 174, 195, 1536, 157, 1503, 2733, 0, 178, 144,
535 : 203, 2733, 314, 1536, 161, 1532, 1530, 223, 1528, 167,
536 : 190, 183, 1520, 2733, 216, 189, 236, 2733, 207, 362,
537 : 1519, 93, 99, 1477, 1478, 258, 242, 1515, 256, 409,
538 : 225, 185, 192, 262, 1513, 269, 280, 366, 1494, 230,
539 : 296, 370, 379, 271, 1456, 0, 283, 299, 0, 0,
540 : 376, 1488, 1481, 456, 384, 386, 397, 398, 402, 1488,
541 :
542 : 387, 1475, 402, 423, 440, 1467, 504, 380, 389, 1445,
543 : 432, 277, 2733, 470, 254, 1413, 270, 1413, 1409, 1406,
544 : 552, 473, 447, 400, 214, 449, 2733, 425, 403, 426,
545 : 478, 511, 487, 459, 526, 494, 1436, 537, 540, 554,
546 : 1428, 463, 523, 466, 1385, 557, 1419, 566, 571, 574,
547 : 1418, 614, 1418, 1409, 1394, 1383, 1363, 0, 520, 577,
548 : 453, 543, 581, 490, 0, 583, 549, 595, 586, 588,
549 : 591, 628, 603, 644, 1390, 2733, 657, 647, 1389, 705,
550 : 608, 595, 589, 662, 630, 1351, 1345, 1340, 1371, 159,
551 : 543, 1333, 1333, 1328, 753, 668, 623, 727, 675, 639,
552 :
553 : 608, 629, 679, 684, 1342, 801, 740, 746, 1311, 2733,
554 : 634, 687, 1297, 1327, 850, 701, 2733, 719, 111, 899,
555 : 757, 948, 0, 693, 1326, 561, 1297, 997, 1278, 760,
556 : 698, 689, 771, 724, 791, 775, 1285, 1270, 786, 823,
557 : 1011, 872, 741, 418, 795, 1274, 1271, 1263, 1207, 2733,
558 : 744, 730, 1195, 1188, 1190, 883, 867, 782, 680, 814,
559 : 1059, 1108, 0, 823, 914, 833, 919, 1168, 1157, 864,
560 : 1206, 0, 1195, 930, 2733, 0, 1176, 933, 2733, 837,
561 : 1255, 0, 0, 839, 0, 836, 1169, 1304, 1353, 0,
562 : 1173, 1135, 957, 987, 893, 1124, 776, 1116, 972, 1027,
563 :
564 : 983, 1081, 1030, 1102, 1101, 1084, 232, 783, 1082, 2733,
565 : 1079, 2733, 1052, 1044, 887, 1003, 986, 0, 651, 844,
566 : 0, 888, 1402, 0, 0, 935, 1046, 962, 970, 963,
567 : 1451, 0, 0, 923, 0, 0, 907, 890, 1500, 0,
568 : 0, 787, 757, 1122, 968, 871, 2733, 932, 1141, 1078,
569 : 942, 689, 761, 2733, 665, 645, 484, 0, 0, 1014,
570 : 715, 0, 1138, 451, 444, 0, 1171, 1126, 520, 825,
571 : 2733, 437, 0, 0, 991, 1011, 1549, 1173, 694, 1220,
572 : 2733, 0, 815, 1224, 345, 1598, 341, 1221, 1269, 1188,
573 : 1646, 311, 1273, 1612, 1270, 1318, 1049, 841, 287, 1523,
574 :
575 : 1694, 0, 1097, 1100, 1367, 264, 1075, 1641, 988, 1742,
576 : 1313, 1572, 1790, 1195, 1191, 1128, 1383, 261, 1123, 1663,
577 : 1839, 1147, 1244, 1416, 1228, 974, 1248, 1238, 1887, 1934,
578 : 1432, 1717, 1982, 1292, 1324, 1465, 1288, 992, 1481, 876,
579 : 1335, 1320, 1373, 1737, 1425, 1022, 1375, 1468, 2030, 1516,
580 : 0, 1861, 1764, 1563, 1423, 1133, 1041, 1472, 1474, 1539,
581 : 1767, 1588, 1294, 207, 1814, 1484, 1631, 1342, 1347, 205,
582 : 1397, 186, 133, 2733, 2077, 2082, 2092, 2100, 2108, 2112,
583 : 2122, 2133, 2144, 2155, 2165, 2171, 2182, 2192, 2203, 2213,
584 : 2216, 2222, 2233, 2244, 2255, 2265, 2276, 2287, 2298, 2309,
585 :
586 : 2320, 2331, 2342, 2353, 2364, 2374, 2381, 2392, 2403, 2414,
587 : 2425, 2436, 2447, 2458, 2469, 2480, 2491, 2502, 2513, 2524,
588 : 2535, 2546, 2557, 2568, 2579, 2590, 2601, 2612, 2623, 135,
589 : 2634, 2645, 2656, 2666, 2671, 2677, 2688, 2699, 2710, 2721
590 : } ;
591 :
592 : static yyconst flex_int16_t yy_def[541] =
593 : { 0,
594 : 474, 474, 474, 474, 475, 474, 476, 474, 474, 477,
595 : 474, 474, 474, 478, 478, 15, 15, 474, 474, 474,
596 : 479, 474, 474, 480, 480, 25, 25, 481, 475, 482,
597 : 474, 475, 475, 476, 483, 474, 474, 484, 474, 474,
598 : 477, 474, 474, 485, 474, 486, 474, 487, 15, 15,
599 : 15, 474, 488, 474, 474, 474, 479, 474, 474, 479,
600 : 60, 474, 474, 474, 474, 487, 474, 25, 474, 481,
601 : 474, 25, 25, 474, 482, 489, 474, 490, 491, 483,
602 : 483, 483, 483, 483, 474, 484, 474, 490, 492, 43,
603 : 490, 493, 492, 43, 94, 94, 94, 492, 492, 485,
604 :
605 : 485, 486, 494, 487, 487, 495, 496, 15, 15, 488,
606 : 488, 474, 474, 474, 474, 474, 497, 474, 474, 474,
607 : 487, 487, 474, 474, 474, 474, 474, 25, 25, 489,
608 : 489, 489, 489, 489, 490, 490, 498, 490, 490, 490,
609 : 491, 491, 483, 483, 474, 490, 499, 490, 490, 474,
610 : 493, 500, 501, 94, 502, 94, 492, 492, 94, 94,
611 : 492, 474, 492, 474, 492, 492, 474, 474, 494, 494,
612 : 494, 487, 474, 487, 495, 474, 487, 474, 495, 496,
613 : 180, 15, 15, 488, 488, 474, 474, 474, 497, 497,
614 : 497, 474, 474, 474, 487, 474, 474, 487, 474, 474,
615 :
616 : 25, 25, 489, 489, 498, 503, 490, 490, 474, 474,
617 : 474, 474, 474, 499, 504, 474, 474, 474, 505, 500,
618 : 506, 507, 220, 505, 501, 508, 502, 509, 94, 94,
619 : 474, 474, 492, 474, 490, 474, 510, 474, 511, 474,
620 : 487, 487, 15, 15, 488, 488, 512, 513, 474, 474,
621 : 497, 497, 474, 474, 474, 474, 474, 25, 25, 514,
622 : 503, 515, 261, 514, 490, 474, 490, 474, 504, 506,
623 : 516, 269, 499, 474, 474, 220, 517, 506, 474, 518,
624 : 507, 281, 281, 518, 508, 508, 508, 509, 519, 288,
625 : 502, 94, 94, 490, 474, 510, 474, 520, 511, 511,
626 :
627 : 474, 511, 521, 520, 520, 487, 15, 15, 512, 474,
628 : 513, 474, 522, 523, 497, 474, 474, 524, 25, 25,
629 : 261, 525, 515, 323, 323, 525, 490, 490, 474, 517,
630 : 516, 331, 331, 517, 331, 281, 526, 527, 519, 339,
631 : 339, 527, 94, 94, 474, 474, 474, 474, 511, 521,
632 : 15, 15, 522, 474, 523, 528, 474, 529, 524, 25,
633 : 25, 323, 490, 530, 526, 339, 94, 474, 15, 15,
634 : 474, 528, 531, 529, 25, 25, 532, 94, 15, 15,
635 : 474, 531, 25, 25, 533, 532, 533, 94, 15, 487,
636 : 94, 534, 25, 487, 94, 487, 391, 15, 535, 487,
637 :
638 : 536, 391, 490, 537, 537, 534, 534, 487, 25, 487,
639 : 94, 487, 538, 391, 490, 537, 537, 535, 535, 487,
640 : 536, 421, 490, 474, 537, 474, 474, 474, 487, 487,
641 : 94, 487, 538, 433, 490, 474, 537, 474, 537, 474,
642 : 537, 474, 474, 487, 487, 474, 474, 490, 487, 94,
643 : 539, 487, 487, 474, 474, 474, 474, 537, 474, 490,
644 : 487, 490, 474, 539, 487, 474, 490, 474, 474, 540,
645 : 474, 540, 540, 0, 474, 474, 474, 474, 474, 474,
646 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
647 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
648 :
649 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
650 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
651 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
652 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474
653 : } ;
654 :
655 : static yyconst flex_int16_t yy_nxt[2783] =
656 : { 0,
657 : 4, 5, 6, 7, 8, 4, 4, 4, 4, 9,
658 : 10, 11, 12, 4, 13, 14, 14, 14, 14, 14,
659 : 15, 14, 14, 14, 14, 16, 14, 17, 4, 18,
660 : 4, 10, 14, 14, 14, 14, 14, 14, 14, 14,
661 : 14, 14, 14, 14, 14, 14, 14, 19, 20, 4,
662 : 21, 22, 7, 23, 4, 4, 4, 4, 9, 10,
663 : 11, 12, 4, 13, 24, 24, 24, 24, 24, 25,
664 : 24, 24, 24, 24, 26, 24, 27, 4, 18, 4,
665 : 28, 24, 24, 24, 24, 24, 24, 24, 24, 24,
666 : 24, 24, 24, 24, 24, 24, 19, 20, 29, 474,
667 :
668 : 30, 31, 37, 45, 38, 46, 39, 40, 474, 55,
669 : 474, 48, 40, 275, 276, 51, 42, 33, 43, 56,
670 : 41, 42, 47, 43, 474, 52, 73, 53, 57, 58,
671 : 30, 59, 115, 44, 116, 117, 377, 32, 44, 473,
672 : 118, 41, 48, 40, 46, 87, 29, 61, 30, 31,
673 : 50, 41, 42, 54, 43, 36, 62, 88, 81, 63,
674 : 82, 250, 45, 64, 46, 33, 72, 65, 83, 44,
675 : 474, 84, 41, 66, 67, 77, 40, 474, 474, 39,
676 : 40, 47, 41, 42, 52, 43, 53, 78, 474, 42,
677 : 112, 43, 473, 474, 251, 474, 77, 40, 46, 474,
678 :
679 : 44, 69, 79, 70, 39, 40, 44, 109, 78, 129,
680 : 108, 473, 54, 470, 42, 200, 43, 55, 113, 71,
681 : 66, 67, 46, 79, 105, 40, 126, 56, 128, 41,
682 : 42, 44, 43, 82, 106, 474, 43, 57, 58, 30,
683 : 59, 36, 62, 123, 84, 63, 32, 44, 69, 64,
684 : 70, 107, 351, 65, 127, 88, 61, 124, 125, 121,
685 : 67, 71, 418, 74, 67, 406, 71, 74, 67, 106,
686 : 131, 43, 132, 42, 82, 43, 41, 42, 112, 43,
687 : 133, 77, 40, 134, 87, 84, 107, 122, 418, 71,
688 : 44, 69, 186, 78, 44, 69, 88, 81, 187, 82,
689 :
690 : 146, 136, 147, 71, 190, 71, 113, 83, 79, 71,
691 : 84, 191, 406, 71, 89, 90, 91, 92, 89, 89,
692 : 89, 89, 89, 93, 94, 89, 89, 89, 89, 95,
693 : 95, 95, 95, 95, 96, 97, 95, 95, 95, 95,
694 : 95, 95, 89, 98, 89, 95, 95, 95, 95, 95,
695 : 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,
696 : 95, 99, 89, 114, 67, 474, 474, 135, 136, 137,
697 : 387, 81, 32, 82, 387, 78, 138, 148, 149, 147,
698 : 143, 83, 82, 474, 84, 159, 140, 159, 167, 92,
699 : 79, 69, 474, 84, 95, 89, 95, 89, 159, 161,
700 :
701 : 162, 124, 125, 163, 164, 170, 474, 95, 89, 71,
702 : 74, 67, 160, 89, 165, 89, 171, 168, 182, 41,
703 : 42, 474, 43, 150, 172, 173, 89, 144, 474, 132,
704 : 183, 166, 174, 184, 175, 111, 474, 44, 69, 381,
705 : 134, 177, 178, 185, 202, 99, 226, 71, 123, 174,
706 : 126, 106, 364, 43, 161, 162, 71, 154, 149, 155,
707 : 88, 308, 132, 201, 211, 89, 156, 157, 107, 82,
708 : 176, 114, 67, 134, 198, 199, 95, 95, 127, 131,
709 : 84, 132, 174, 78, 175, 158, 474, 176, 203, 133,
710 : 132, 232, 134, 212, 71, 149, 149, 147, 79, 69,
711 :
712 : 99, 134, 217, 89, 104, 180, 173, 104, 104, 104,
713 : 104, 104, 131, 174, 132, 175, 104, 71, 104, 373,
714 : 197, 159, 133, 474, 143, 134, 82, 135, 136, 137,
715 : 95, 89, 104, 104, 104, 204, 138, 84, 207, 149,
716 : 147, 149, 149, 147, 231, 250, 140, 208, 209, 89,
717 : 167, 176, 104, 195, 196, 149, 149, 137, 146, 136,
718 : 147, 174, 286, 106, 379, 43, 210, 148, 149, 147,
719 : 287, 144, 149, 149, 147, 216, 164, 252, 159, 168,
720 : 107, 122, 163, 164, 233, 164, 217, 95, 89, 170,
721 : 150, 170, 474, 165, 170, 165, 234, 40, 474, 197,
722 :
723 : 171, 230, 171, 218, 236, 171, 89, 237, 235, 241,
724 : 166, 474, 238, 150, 219, 220, 221, 222, 219, 219,
725 : 219, 219, 219, 219, 126, 224, 219, 219, 219, 172,
726 : 173, 245, 474, 111, 244, 211, 243, 174, 242, 175,
727 : 200, 474, 219, 219, 219, 172, 173, 250, 240, 258,
728 : 176, 237, 127, 239, 474, 175, 238, 474, 177, 178,
729 : 88, 219, 219, 184, 212, 111, 174, 371, 106, 256,
730 : 43, 360, 237, 185, 259, 176, 257, 238, 246, 237,
731 : 203, 88, 132, 474, 238, 107, 71, 132, 266, 40,
732 : 232, 176, 474, 134, 176, 275, 276, 474, 134, 231,
733 :
734 : 267, 217, 216, 164, 176, 104, 180, 173, 104, 104,
735 : 104, 104, 104, 217, 174, 197, 175, 104, 474, 104,
736 : 274, 164, 197, 320, 370, 234, 40, 204, 198, 199,
737 : 218, 217, 250, 104, 104, 104, 174, 235, 175, 389,
738 : 474, 207, 149, 147, 474, 150, 250, 207, 149, 147,
739 : 376, 209, 176, 104, 195, 196, 265, 209, 270, 270,
740 : 277, 159, 174, 354, 106, 315, 43, 95, 279, 210,
741 : 95, 89, 233, 164, 197, 210, 236, 346, 307, 237,
742 : 314, 107, 122, 165, 238, 474, 474, 300, 301, 89,
743 : 366, 293, 294, 91, 137, 302, 245, 303, 111, 304,
744 :
745 : 197, 260, 261, 221, 262, 260, 260, 260, 260, 260,
746 : 260, 140, 264, 260, 260, 260, 275, 321, 474, 319,
747 : 295, 352, 176, 347, 240, 275, 321, 237, 474, 260,
748 : 260, 260, 238, 305, 266, 40, 88, 286, 150, 275,
749 : 336, 275, 336, 246, 474, 287, 267, 474, 260, 260,
750 : 214, 269, 270, 271, 214, 214, 214, 214, 214, 214,
751 : 393, 273, 214, 214, 214, 270, 270, 277, 257, 380,
752 : 176, 237, 346, 306, 178, 279, 238, 457, 214, 214,
753 : 214, 174, 361, 175, 256, 235, 50, 237, 217, 250,
754 : 275, 362, 238, 366, 345, 162, 88, 214, 214, 219,
755 :
756 : 220, 221, 222, 219, 219, 219, 219, 219, 219, 226,
757 : 224, 219, 219, 219, 197, 207, 149, 147, 347, 176,
758 : 328, 136, 137, 356, 327, 209, 335, 219, 219, 219,
759 : 197, 274, 164, 368, 270, 270, 277, 275, 362, 140,
760 : 150, 238, 217, 210, 279, 474, 219, 219, 280, 281,
761 : 221, 282, 280, 280, 280, 280, 280, 280, 159, 284,
762 : 280, 280, 280, 328, 136, 137, 335, 95, 89, 345,
763 : 162, 364, 344, 300, 301, 446, 280, 280, 280, 176,
764 : 369, 349, 140, 303, 236, 304, 89, 237, 294, 91,
765 : 137, 474, 238, 456, 474, 280, 280, 227, 288, 270,
766 :
767 : 289, 227, 227, 227, 227, 227, 227, 140, 291, 227,
768 : 227, 227, 241, 173, 474, 150, 295, 474, 358, 305,
769 : 174, 424, 175, 446, 474, 227, 227, 227, 300, 301,
770 : 176, 350, 348, 72, 150, 383, 349, 357, 303, 436,
771 : 304, 242, 457, 304, 227, 227, 250, 207, 149, 147,
772 : 414, 415, 375, 217, 354, 384, 363, 209, 176, 260,
773 : 261, 221, 262, 260, 260, 260, 260, 260, 260, 424,
774 : 264, 260, 260, 260, 305, 210, 427, 304, 416, 350,
775 : 348, 312, 300, 301, 310, 306, 178, 260, 260, 260,
776 : 302, 304, 303, 174, 304, 175, 417, 235, 423, 149,
777 :
778 : 147, 425, 426, 348, 348, 428, 260, 260, 322, 323,
779 : 221, 324, 322, 322, 322, 322, 322, 322, 348, 326,
780 : 322, 322, 322, 159, 442, 304, 297, 368, 305, 437,
781 : 438, 176, 95, 89, 456, 238, 322, 322, 322, 207,
782 : 149, 147, 300, 301, 424, 343, 367, 405, 444, 209,
783 : 302, 89, 303, 443, 304, 322, 322, 214, 269, 270,
784 : 271, 214, 214, 214, 214, 214, 214, 210, 273, 214,
785 : 214, 214, 159, 176, 159, 417, 228, 445, 337, 335,
786 : 436, 95, 89, 95, 89, 214, 214, 214, 305, 400,
787 : 40, 388, 435, 149, 147, 378, 414, 415, 215, 106,
788 :
789 : 89, 391, 89, 329, 214, 214, 330, 331, 270, 332,
790 : 330, 330, 330, 330, 330, 330, 401, 334, 330, 330,
791 : 330, 390, 159, 474, 416, 394, 318, 474, 317, 425,
792 : 426, 95, 89, 391, 330, 330, 330, 391, 436, 447,
793 : 40, 316, 417, 313, 395, 423, 149, 147, 392, 427,
794 : 89, 448, 392, 330, 330, 280, 281, 221, 282, 280,
795 : 280, 280, 280, 280, 280, 312, 284, 280, 280, 280,
796 : 396, 159, 474, 310, 408, 405, 474, 111, 428, 298,
797 : 95, 89, 397, 280, 280, 280, 397, 297, 292, 437,
798 : 438, 424, 411, 452, 398, 469, 426, 399, 409, 89,
799 :
800 : 228, 399, 280, 280, 227, 288, 270, 289, 227, 227,
801 : 227, 227, 227, 227, 159, 291, 227, 227, 227, 412,
802 : 40, 442, 453, 95, 89, 435, 149, 147, 226, 106,
803 : 215, 397, 227, 227, 227, 417, 458, 440, 268, 431,
804 : 210, 424, 89, 471, 438, 206, 413, 165, 469, 426,
805 : 443, 227, 227, 338, 339, 270, 340, 338, 338, 338,
806 : 338, 338, 338, 255, 342, 338, 338, 338, 163, 164,
807 : 254, 436, 253, 250, 459, 40, 447, 40, 249, 165,
808 : 248, 338, 338, 338, 439, 440, 460, 247, 448, 436,
809 : 179, 179, 158, 229, 424, 165, 166, 228, 471, 438,
810 :
811 : 338, 338, 322, 323, 221, 324, 322, 322, 322, 322,
812 : 322, 322, 441, 326, 322, 322, 322, 216, 164, 95,
813 : 226, 152, 215, 213, 466, 440, 461, 178, 217, 141,
814 : 322, 322, 322, 450, 174, 217, 175, 451, 448, 206,
815 : 194, 193, 95, 89, 436, 218, 192, 188, 111, 322,
816 : 322, 330, 331, 270, 332, 330, 330, 330, 330, 330,
817 : 330, 89, 334, 330, 330, 330, 454, 440, 179, 462,
818 : 403, 137, 176, 458, 440, 459, 40, 217, 103, 330,
819 : 330, 330, 439, 440, 165, 466, 440, 460, 140, 100,
820 : 153, 152, 145, 165, 455, 141, 217, 463, 330, 330,
821 :
822 : 338, 339, 270, 340, 338, 338, 338, 338, 338, 338,
823 : 441, 342, 338, 338, 338, 424, 76, 450, 474, 120,
824 : 119, 451, 46, 111, 420, 178, 95, 89, 338, 338,
825 : 338, 474, 174, 46, 106, 103, 391, 100, 85, 35,
826 : 467, 415, 137, 36, 76, 89, 36, 338, 338, 385,
827 : 385, 401, 385, 385, 385, 385, 385, 385, 385, 140,
828 : 385, 385, 385, 385, 454, 440, 35, 474, 468, 474,
829 : 176, 474, 474, 432, 178, 217, 474, 385, 387, 385,
830 : 474, 174, 474, 106, 474, 397, 436, 474, 474, 462,
831 : 403, 137, 455, 474, 474, 474, 385, 385, 385, 385,
832 :
833 : 413, 385, 385, 385, 385, 385, 385, 385, 140, 385,
834 : 385, 385, 385, 410, 67, 474, 474, 463, 474, 176,
835 : 474, 474, 474, 106, 474, 391, 385, 387, 385, 474,
836 : 474, 474, 467, 415, 137, 424, 474, 474, 474, 474,
837 : 401, 122, 429, 67, 474, 385, 385, 402, 403, 92,
838 : 474, 140, 106, 474, 397, 93, 94, 89, 474, 71,
839 : 468, 474, 474, 474, 420, 178, 96, 97, 474, 413,
840 : 122, 474, 174, 474, 106, 404, 391, 474, 436, 474,
841 : 474, 474, 474, 474, 474, 474, 474, 474, 71, 474,
842 : 474, 401, 474, 405, 104, 421, 173, 104, 104, 104,
843 :
844 : 104, 104, 474, 174, 474, 175, 104, 474, 104, 474,
845 : 176, 474, 474, 474, 474, 474, 474, 474, 432, 178,
846 : 474, 474, 104, 104, 104, 474, 174, 474, 106, 474,
847 : 397, 474, 474, 474, 474, 474, 474, 474, 444, 173,
848 : 474, 176, 104, 430, 196, 413, 174, 474, 175, 474,
849 : 474, 174, 474, 106, 474, 391, 474, 474, 474, 474,
850 : 474, 474, 474, 474, 176, 465, 178, 445, 461, 178,
851 : 401, 122, 474, 174, 474, 175, 174, 460, 175, 474,
852 : 448, 474, 474, 474, 176, 474, 474, 474, 474, 197,
853 : 104, 433, 173, 104, 104, 104, 104, 104, 474, 174,
854 :
855 : 474, 175, 104, 474, 104, 474, 474, 474, 474, 474,
856 : 474, 176, 474, 474, 176, 465, 178, 474, 104, 104,
857 : 104, 474, 474, 174, 474, 175, 474, 460, 474, 474,
858 : 474, 474, 474, 474, 474, 474, 474, 176, 104, 104,
859 : 421, 173, 104, 104, 104, 104, 104, 474, 174, 474,
860 : 175, 104, 474, 104, 474, 474, 474, 474, 474, 474,
861 : 474, 176, 452, 173, 474, 474, 474, 104, 104, 104,
862 : 174, 474, 175, 474, 474, 474, 474, 474, 474, 474,
863 : 474, 474, 474, 474, 474, 474, 176, 104, 449, 196,
864 : 474, 453, 474, 474, 474, 474, 174, 474, 106, 474,
865 :
866 : 397, 474, 474, 474, 474, 474, 474, 474, 176, 474,
867 : 474, 474, 474, 474, 474, 413, 122, 474, 474, 474,
868 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
869 : 474, 474, 474, 474, 197, 430, 196, 474, 474, 474,
870 : 474, 474, 474, 174, 474, 106, 474, 391, 474, 474,
871 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
872 : 474, 474, 401, 122, 474, 474, 474, 474, 474, 474,
873 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
874 : 474, 197, 104, 433, 173, 104, 104, 104, 104, 104,
875 : 474, 174, 474, 175, 104, 474, 104, 474, 474, 474,
876 :
877 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
878 : 104, 104, 104, 474, 474, 474, 474, 474, 474, 474,
879 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 176,
880 : 104, 449, 196, 474, 474, 474, 474, 474, 474, 174,
881 : 474, 106, 474, 397, 474, 474, 474, 474, 474, 474,
882 : 474, 474, 474, 474, 474, 474, 474, 474, 413, 122,
883 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
884 : 474, 474, 474, 474, 474, 474, 474, 197, 32, 474,
885 : 32, 32, 34, 34, 474, 34, 34, 34, 34, 34,
886 : 34, 34, 34, 41, 41, 474, 474, 474, 41, 41,
887 :
888 : 41, 49, 49, 474, 474, 474, 49, 49, 49, 60,
889 : 60, 60, 60, 68, 68, 474, 474, 474, 68, 68,
890 : 68, 68, 68, 70, 70, 474, 474, 474, 70, 70,
891 : 70, 70, 70, 75, 75, 474, 75, 75, 75, 75,
892 : 75, 75, 75, 75, 80, 80, 474, 80, 80, 80,
893 : 80, 80, 80, 80, 80, 86, 86, 474, 86, 86,
894 : 86, 86, 86, 86, 86, 86, 101, 474, 474, 474,
895 : 101, 102, 102, 474, 102, 102, 102, 102, 102, 102,
896 : 102, 102, 104, 104, 104, 104, 104, 104, 104, 104,
897 : 104, 104, 110, 110, 474, 110, 110, 110, 110, 110,
898 :
899 : 110, 110, 110, 130, 130, 474, 130, 130, 130, 130,
900 : 130, 130, 130, 130, 139, 139, 139, 142, 474, 474,
901 : 474, 142, 89, 89, 474, 89, 89, 89, 89, 89,
902 : 89, 89, 89, 151, 151, 474, 151, 151, 151, 151,
903 : 151, 151, 151, 151, 169, 169, 474, 169, 169, 169,
904 : 169, 169, 169, 169, 169, 175, 175, 474, 175, 175,
905 : 175, 175, 474, 175, 175, 181, 181, 181, 181, 181,
906 : 181, 181, 474, 181, 181, 181, 189, 189, 474, 189,
907 : 189, 189, 189, 189, 189, 189, 189, 205, 205, 474,
908 : 205, 205, 205, 205, 205, 205, 205, 205, 214, 214,
909 :
910 : 474, 214, 214, 214, 214, 214, 214, 214, 214, 223,
911 : 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
912 : 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
913 : 225, 227, 227, 474, 227, 227, 227, 227, 227, 227,
914 : 227, 227, 263, 263, 263, 263, 263, 263, 263, 263,
915 : 263, 263, 263, 272, 272, 272, 272, 272, 272, 272,
916 : 272, 272, 272, 272, 219, 219, 219, 219, 219, 219,
917 : 219, 219, 219, 219, 219, 278, 278, 278, 474, 474,
918 : 278, 283, 283, 283, 283, 283, 283, 283, 283, 283,
919 : 283, 283, 285, 285, 474, 285, 285, 285, 285, 285,
920 :
921 : 285, 285, 285, 290, 290, 290, 290, 290, 290, 290,
922 : 290, 290, 290, 290, 296, 296, 296, 296, 296, 296,
923 : 296, 296, 296, 296, 296, 299, 299, 299, 299, 299,
924 : 299, 299, 299, 299, 299, 299, 309, 309, 309, 309,
925 : 309, 309, 309, 309, 309, 309, 309, 311, 311, 311,
926 : 311, 311, 311, 311, 311, 311, 311, 311, 260, 260,
927 : 260, 260, 260, 260, 260, 260, 260, 260, 260, 325,
928 : 325, 325, 325, 325, 325, 325, 325, 325, 325, 325,
929 : 333, 333, 333, 333, 333, 333, 333, 333, 333, 333,
930 : 333, 330, 330, 474, 330, 330, 330, 330, 330, 330,
931 :
932 : 330, 330, 280, 280, 280, 280, 280, 280, 280, 280,
933 : 280, 280, 280, 341, 341, 341, 341, 341, 341, 341,
934 : 341, 341, 341, 341, 304, 304, 304, 304, 304, 304,
935 : 304, 304, 304, 304, 304, 303, 303, 303, 303, 303,
936 : 303, 303, 303, 303, 303, 303, 353, 353, 353, 353,
937 : 353, 353, 353, 353, 353, 353, 353, 355, 355, 355,
938 : 355, 355, 355, 355, 355, 355, 355, 355, 359, 359,
939 : 474, 359, 359, 359, 359, 359, 359, 359, 359, 322,
940 : 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
941 : 365, 365, 365, 365, 365, 365, 365, 365, 365, 365,
942 :
943 : 365, 338, 338, 474, 338, 338, 338, 338, 338, 338,
944 : 338, 338, 372, 372, 372, 372, 372, 372, 372, 372,
945 : 372, 372, 372, 374, 374, 474, 374, 374, 374, 374,
946 : 374, 374, 374, 374, 382, 382, 474, 382, 382, 382,
947 : 382, 382, 382, 382, 382, 386, 386, 474, 386, 386,
948 : 386, 386, 386, 386, 386, 386, 385, 385, 474, 385,
949 : 385, 385, 385, 385, 385, 385, 385, 407, 474, 474,
950 : 474, 407, 419, 474, 474, 474, 419, 422, 422, 422,
951 : 422, 422, 422, 422, 474, 422, 422, 422, 89, 89,
952 : 89, 89, 89, 89, 89, 89, 89, 89, 89, 434,
953 :
954 : 434, 434, 434, 434, 434, 434, 474, 434, 434, 434,
955 : 464, 464, 474, 464, 464, 464, 464, 464, 464, 464,
956 : 464, 472, 472, 474, 472, 472, 472, 472, 472, 472,
957 : 472, 472, 3, 474, 474, 474, 474, 474, 474, 474,
958 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
959 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
960 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
961 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
962 : 474, 474
963 : } ;
964 :
965 : static yyconst flex_int16_t yy_chk[2783] =
966 : { 0,
967 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
968 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
969 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
970 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
971 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
972 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
973 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
974 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
975 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
976 : 2, 2, 2, 2, 2, 2, 2, 2, 5, 17,
977 :
978 : 5, 5, 9, 12, 9, 12, 10, 10, 16, 20,
979 : 27, 14, 14, 219, 219, 17, 10, 5, 10, 20,
980 : 14, 14, 12, 14, 26, 19, 27, 19, 21, 21,
981 : 21, 21, 62, 10, 62, 63, 530, 21, 14, 473,
982 : 63, 14, 15, 15, 15, 40, 29, 21, 29, 29,
983 : 16, 15, 15, 19, 15, 23, 23, 40, 35, 23,
984 : 35, 190, 45, 23, 45, 29, 26, 23, 35, 15,
985 : 50, 35, 15, 24, 24, 32, 32, 32, 32, 39,
986 : 39, 45, 24, 24, 52, 24, 52, 32, 72, 39,
987 : 56, 39, 472, 51, 190, 73, 33, 33, 33, 33,
988 :
989 : 24, 24, 32, 24, 41, 41, 39, 51, 33, 73,
990 : 50, 470, 52, 464, 41, 125, 41, 55, 56, 24,
991 : 25, 25, 25, 33, 48, 48, 71, 55, 72, 25,
992 : 25, 41, 25, 80, 48, 307, 48, 57, 57, 57,
993 : 57, 59, 59, 67, 80, 59, 57, 25, 25, 59,
994 : 25, 48, 307, 59, 71, 67, 57, 69, 69, 66,
995 : 66, 125, 418, 74, 74, 406, 25, 28, 28, 66,
996 : 76, 66, 76, 74, 84, 74, 28, 28, 112, 28,
997 : 76, 77, 77, 76, 87, 84, 66, 66, 399, 67,
998 : 74, 74, 115, 77, 28, 28, 87, 81, 115, 81,
999 :
1000 : 88, 88, 88, 69, 117, 66, 112, 81, 77, 74,
1001 : 81, 117, 392, 28, 43, 43, 43, 43, 43, 43,
1002 : 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1003 : 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1004 : 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1005 : 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1006 : 43, 43, 43, 60, 60, 60, 60, 78, 78, 78,
1007 : 387, 82, 60, 82, 385, 60, 78, 91, 91, 91,
1008 : 83, 82, 83, 108, 82, 95, 78, 96, 101, 96,
1009 : 60, 60, 109, 83, 95, 95, 96, 96, 97, 98,
1010 :
1011 : 98, 124, 124, 99, 99, 103, 129, 97, 97, 60,
1012 : 70, 70, 97, 95, 99, 96, 103, 101, 108, 70,
1013 : 70, 244, 70, 91, 104, 104, 97, 83, 128, 130,
1014 : 109, 99, 104, 111, 104, 111, 104, 70, 70, 372,
1015 : 130, 105, 105, 111, 129, 98, 365, 124, 123, 105,
1016 : 126, 105, 364, 105, 161, 161, 70, 94, 94, 94,
1017 : 123, 244, 134, 128, 142, 94, 94, 94, 105, 144,
1018 : 104, 114, 114, 134, 122, 122, 94, 94, 126, 131,
1019 : 144, 131, 122, 114, 122, 94, 122, 105, 133, 131,
1020 : 133, 164, 131, 142, 123, 136, 136, 136, 114, 114,
1021 :
1022 : 161, 133, 164, 94, 107, 107, 107, 107, 107, 107,
1023 : 107, 107, 132, 107, 132, 107, 107, 114, 107, 357,
1024 : 122, 159, 132, 369, 143, 132, 143, 135, 135, 135,
1025 : 159, 159, 107, 107, 107, 133, 135, 143, 138, 138,
1026 : 138, 139, 139, 139, 162, 191, 135, 138, 138, 159,
1027 : 167, 107, 107, 121, 121, 140, 140, 140, 146, 146,
1028 : 146, 121, 226, 121, 369, 121, 138, 148, 148, 148,
1029 : 226, 143, 149, 149, 149, 150, 150, 191, 160, 167,
1030 : 121, 121, 163, 163, 166, 166, 150, 160, 160, 169,
1031 : 162, 170, 183, 163, 171, 166, 168, 168, 182, 121,
1032 :
1033 : 169, 160, 170, 150, 173, 171, 160, 173, 168, 181,
1034 : 163, 201, 173, 148, 152, 152, 152, 152, 152, 152,
1035 : 152, 152, 152, 152, 197, 152, 152, 152, 152, 172,
1036 : 172, 185, 202, 185, 183, 211, 182, 172, 181, 172,
1037 : 200, 172, 152, 152, 152, 174, 174, 356, 178, 201,
1038 : 173, 178, 197, 174, 319, 174, 178, 174, 177, 177,
1039 : 178, 152, 152, 184, 211, 184, 177, 355, 177, 196,
1040 : 177, 319, 196, 184, 202, 172, 199, 196, 185, 199,
1041 : 203, 196, 203, 259, 199, 177, 200, 204, 212, 212,
1042 : 232, 174, 352, 203, 178, 224, 224, 379, 204, 231,
1043 :
1044 : 212, 232, 216, 216, 177, 180, 180, 180, 180, 180,
1045 : 180, 180, 180, 216, 180, 196, 180, 180, 361, 180,
1046 : 218, 218, 199, 259, 352, 234, 234, 203, 198, 198,
1047 : 216, 218, 252, 180, 180, 180, 198, 234, 198, 379,
1048 : 198, 207, 207, 207, 243, 231, 251, 208, 208, 208,
1049 : 361, 207, 180, 180, 195, 195, 208, 208, 221, 221,
1050 : 221, 230, 195, 353, 195, 252, 195, 343, 221, 207,
1051 : 230, 230, 233, 233, 198, 208, 236, 297, 243, 236,
1052 : 251, 195, 195, 233, 236, 258, 308, 239, 239, 230,
1053 : 342, 230, 235, 235, 235, 239, 245, 239, 245, 239,
1054 :
1055 : 195, 206, 206, 206, 206, 206, 206, 206, 206, 206,
1056 : 206, 235, 206, 206, 206, 206, 260, 260, 383, 258,
1057 : 235, 308, 236, 297, 240, 264, 264, 240, 370, 206,
1058 : 206, 206, 240, 239, 266, 266, 240, 286, 235, 280,
1059 : 280, 284, 284, 245, 398, 286, 266, 320, 206, 206,
1060 : 215, 215, 215, 215, 215, 215, 215, 215, 215, 215,
1061 : 383, 215, 215, 215, 215, 270, 270, 270, 257, 370,
1062 : 240, 257, 346, 242, 242, 270, 257, 440, 215, 215,
1063 : 215, 242, 320, 242, 256, 242, 398, 256, 440, 315,
1064 : 322, 322, 256, 338, 295, 295, 256, 215, 215, 220,
1065 :
1066 : 220, 220, 220, 220, 220, 220, 220, 220, 220, 337,
1067 : 220, 220, 220, 220, 257, 265, 265, 265, 346, 242,
1068 : 267, 267, 267, 315, 265, 265, 334, 220, 220, 220,
1069 : 256, 274, 274, 348, 278, 278, 278, 326, 326, 267,
1070 : 295, 348, 274, 265, 278, 351, 220, 220, 222, 222,
1071 : 222, 222, 222, 222, 222, 222, 222, 222, 293, 222,
1072 : 222, 222, 222, 328, 328, 328, 330, 293, 293, 345,
1073 : 345, 329, 293, 299, 299, 426, 222, 222, 222, 348,
1074 : 351, 299, 328, 299, 301, 299, 293, 301, 294, 294,
1075 : 294, 409, 301, 438, 375, 222, 222, 228, 228, 228,
1076 :
1077 : 228, 228, 228, 228, 228, 228, 228, 294, 228, 228,
1078 : 228, 228, 241, 241, 376, 345, 294, 360, 317, 299,
1079 : 241, 426, 241, 446, 241, 228, 228, 228, 300, 300,
1080 : 301, 303, 303, 409, 294, 375, 300, 316, 300, 438,
1081 : 300, 241, 457, 303, 228, 228, 314, 327, 327, 327,
1082 : 397, 397, 360, 457, 313, 376, 327, 327, 241, 261,
1083 : 261, 261, 261, 261, 261, 261, 261, 261, 261, 446,
1084 : 261, 261, 261, 261, 300, 327, 407, 303, 397, 350,
1085 : 350, 311, 302, 302, 309, 306, 306, 261, 261, 261,
1086 : 302, 350, 302, 306, 302, 306, 397, 306, 403, 403,
1087 :
1088 : 403, 404, 404, 305, 304, 407, 261, 261, 262, 262,
1089 : 262, 262, 262, 262, 262, 262, 262, 262, 298, 262,
1090 : 262, 262, 262, 344, 419, 350, 296, 368, 302, 416,
1091 : 416, 306, 344, 344, 456, 368, 262, 262, 262, 363,
1092 : 363, 363, 349, 349, 403, 292, 344, 404, 422, 363,
1093 : 349, 344, 349, 419, 349, 262, 262, 269, 269, 269,
1094 : 269, 269, 269, 269, 269, 269, 269, 363, 269, 269,
1095 : 269, 269, 367, 368, 378, 416, 291, 422, 287, 277,
1096 : 456, 367, 367, 378, 378, 269, 269, 269, 349, 390,
1097 : 390, 378, 415, 415, 415, 367, 414, 414, 273, 390,
1098 :
1099 : 367, 390, 378, 268, 269, 269, 271, 271, 271, 271,
1100 : 271, 271, 271, 271, 271, 271, 390, 271, 271, 271,
1101 : 271, 380, 388, 380, 414, 384, 255, 384, 254, 425,
1102 : 425, 388, 388, 380, 271, 271, 271, 384, 415, 428,
1103 : 428, 253, 414, 249, 388, 423, 423, 423, 380, 427,
1104 : 388, 428, 384, 271, 271, 281, 281, 281, 281, 281,
1105 : 281, 281, 281, 281, 281, 248, 281, 281, 281, 281,
1106 : 389, 395, 389, 247, 393, 425, 393, 246, 427, 238,
1107 : 395, 395, 389, 281, 281, 281, 393, 237, 229, 437,
1108 : 437, 423, 395, 434, 389, 463, 463, 389, 393, 395,
1109 :
1110 : 227, 393, 281, 281, 288, 288, 288, 288, 288, 288,
1111 : 288, 288, 288, 288, 411, 288, 288, 288, 288, 396,
1112 : 396, 442, 434, 411, 411, 435, 435, 435, 225, 396,
1113 : 214, 396, 288, 288, 288, 437, 441, 441, 213, 411,
1114 : 209, 463, 411, 468, 468, 205, 396, 441, 469, 469,
1115 : 442, 288, 288, 289, 289, 289, 289, 289, 289, 289,
1116 : 289, 289, 289, 194, 289, 289, 289, 289, 405, 405,
1117 : 193, 435, 192, 189, 443, 443, 447, 447, 188, 405,
1118 : 187, 289, 289, 289, 417, 417, 443, 186, 447, 468,
1119 : 179, 175, 157, 156, 469, 417, 405, 155, 471, 471,
1120 :
1121 : 289, 289, 323, 323, 323, 323, 323, 323, 323, 323,
1122 : 323, 323, 417, 323, 323, 323, 323, 424, 424, 154,
1123 : 153, 151, 147, 145, 455, 455, 445, 445, 424, 141,
1124 : 323, 323, 323, 431, 445, 455, 445, 431, 445, 137,
1125 : 120, 119, 431, 431, 471, 424, 118, 116, 110, 323,
1126 : 323, 331, 331, 331, 331, 331, 331, 331, 331, 331,
1127 : 331, 431, 331, 331, 331, 331, 436, 436, 106, 448,
1128 : 448, 448, 445, 458, 458, 459, 459, 436, 102, 331,
1129 : 331, 331, 439, 439, 458, 466, 466, 459, 448, 100,
1130 : 93, 92, 85, 439, 436, 79, 466, 448, 331, 331,
1131 :
1132 : 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
1133 : 439, 339, 339, 339, 339, 448, 75, 450, 68, 65,
1134 : 64, 450, 61, 53, 400, 400, 450, 450, 339, 339,
1135 : 339, 49, 400, 47, 400, 46, 400, 44, 36, 34,
1136 : 460, 460, 460, 31, 30, 450, 8, 339, 339, 377,
1137 : 377, 400, 377, 377, 377, 377, 377, 377, 377, 460,
1138 : 377, 377, 377, 377, 454, 454, 7, 3, 460, 0,
1139 : 400, 0, 0, 412, 412, 454, 0, 377, 377, 377,
1140 : 0, 412, 0, 412, 0, 412, 460, 0, 0, 462,
1141 : 462, 462, 454, 0, 0, 0, 377, 377, 386, 386,
1142 :
1143 : 412, 386, 386, 386, 386, 386, 386, 386, 462, 386,
1144 : 386, 386, 386, 394, 394, 0, 0, 462, 0, 412,
1145 : 0, 0, 0, 394, 0, 394, 386, 386, 386, 0,
1146 : 0, 0, 467, 467, 467, 462, 0, 0, 0, 0,
1147 : 394, 394, 408, 408, 0, 386, 386, 391, 391, 391,
1148 : 0, 467, 408, 0, 408, 391, 391, 391, 0, 394,
1149 : 467, 0, 0, 0, 420, 420, 391, 391, 0, 408,
1150 : 408, 0, 420, 0, 420, 391, 420, 0, 467, 0,
1151 : 0, 0, 0, 0, 0, 0, 0, 0, 408, 0,
1152 : 0, 420, 0, 391, 401, 401, 401, 401, 401, 401,
1153 :
1154 : 401, 401, 0, 401, 0, 401, 401, 0, 401, 0,
1155 : 420, 0, 0, 0, 0, 0, 0, 0, 432, 432,
1156 : 0, 0, 401, 401, 401, 0, 432, 0, 432, 0,
1157 : 432, 0, 0, 0, 0, 0, 0, 0, 444, 444,
1158 : 0, 401, 401, 410, 410, 432, 444, 0, 444, 0,
1159 : 444, 410, 0, 410, 0, 410, 0, 0, 0, 0,
1160 : 0, 0, 0, 0, 432, 453, 453, 444, 461, 461,
1161 : 410, 410, 0, 453, 0, 453, 461, 453, 461, 0,
1162 : 461, 0, 0, 0, 444, 0, 0, 0, 0, 410,
1163 : 413, 413, 413, 413, 413, 413, 413, 413, 0, 413,
1164 :
1165 : 0, 413, 413, 0, 413, 0, 0, 0, 0, 0,
1166 : 0, 453, 0, 0, 461, 465, 465, 0, 413, 413,
1167 : 413, 0, 0, 465, 0, 465, 0, 465, 0, 0,
1168 : 0, 0, 0, 0, 0, 0, 0, 413, 413, 421,
1169 : 421, 421, 421, 421, 421, 421, 421, 0, 421, 0,
1170 : 421, 421, 0, 421, 0, 0, 0, 0, 0, 0,
1171 : 0, 465, 452, 452, 0, 0, 0, 421, 421, 421,
1172 : 452, 0, 452, 0, 452, 0, 0, 0, 0, 0,
1173 : 0, 0, 0, 0, 0, 0, 421, 421, 429, 429,
1174 : 0, 452, 0, 0, 0, 0, 429, 0, 429, 0,
1175 :
1176 : 429, 0, 0, 0, 0, 0, 0, 0, 452, 0,
1177 : 0, 0, 0, 0, 0, 429, 429, 0, 0, 0,
1178 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1179 : 0, 0, 0, 0, 429, 430, 430, 0, 0, 0,
1180 : 0, 0, 0, 430, 0, 430, 0, 430, 0, 0,
1181 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1182 : 0, 0, 430, 430, 0, 0, 0, 0, 0, 0,
1183 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1184 : 0, 430, 433, 433, 433, 433, 433, 433, 433, 433,
1185 : 0, 433, 0, 433, 433, 0, 433, 0, 0, 0,
1186 :
1187 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1188 : 433, 433, 433, 0, 0, 0, 0, 0, 0, 0,
1189 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 433,
1190 : 433, 449, 449, 0, 0, 0, 0, 0, 0, 449,
1191 : 0, 449, 0, 449, 0, 0, 0, 0, 0, 0,
1192 : 0, 0, 0, 0, 0, 0, 0, 0, 449, 449,
1193 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1194 : 0, 0, 0, 0, 0, 0, 0, 449, 475, 0,
1195 : 475, 475, 476, 476, 0, 476, 476, 476, 476, 476,
1196 : 476, 476, 476, 477, 477, 0, 0, 0, 477, 477,
1197 :
1198 : 477, 478, 478, 0, 0, 0, 478, 478, 478, 479,
1199 : 479, 479, 479, 480, 480, 0, 0, 0, 480, 480,
1200 : 480, 480, 480, 481, 481, 0, 0, 0, 481, 481,
1201 : 481, 481, 481, 482, 482, 0, 482, 482, 482, 482,
1202 : 482, 482, 482, 482, 483, 483, 0, 483, 483, 483,
1203 : 483, 483, 483, 483, 483, 484, 484, 0, 484, 484,
1204 : 484, 484, 484, 484, 484, 484, 485, 0, 0, 0,
1205 : 485, 486, 486, 0, 486, 486, 486, 486, 486, 486,
1206 : 486, 486, 487, 487, 487, 487, 487, 487, 487, 487,
1207 : 487, 487, 488, 488, 0, 488, 488, 488, 488, 488,
1208 :
1209 : 488, 488, 488, 489, 489, 0, 489, 489, 489, 489,
1210 : 489, 489, 489, 489, 490, 490, 490, 491, 0, 0,
1211 : 0, 491, 492, 492, 0, 492, 492, 492, 492, 492,
1212 : 492, 492, 492, 493, 493, 0, 493, 493, 493, 493,
1213 : 493, 493, 493, 493, 494, 494, 0, 494, 494, 494,
1214 : 494, 494, 494, 494, 494, 495, 495, 0, 495, 495,
1215 : 495, 495, 0, 495, 495, 496, 496, 496, 496, 496,
1216 : 496, 496, 0, 496, 496, 496, 497, 497, 0, 497,
1217 : 497, 497, 497, 497, 497, 497, 497, 498, 498, 0,
1218 : 498, 498, 498, 498, 498, 498, 498, 498, 499, 499,
1219 :
1220 : 0, 499, 499, 499, 499, 499, 499, 499, 499, 500,
1221 : 500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
1222 : 501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
1223 : 501, 502, 502, 0, 502, 502, 502, 502, 502, 502,
1224 : 502, 502, 503, 503, 503, 503, 503, 503, 503, 503,
1225 : 503, 503, 503, 504, 504, 504, 504, 504, 504, 504,
1226 : 504, 504, 504, 504, 505, 505, 505, 505, 505, 505,
1227 : 505, 505, 505, 505, 505, 506, 506, 506, 0, 0,
1228 : 506, 507, 507, 507, 507, 507, 507, 507, 507, 507,
1229 : 507, 507, 508, 508, 0, 508, 508, 508, 508, 508,
1230 :
1231 : 508, 508, 508, 509, 509, 509, 509, 509, 509, 509,
1232 : 509, 509, 509, 509, 510, 510, 510, 510, 510, 510,
1233 : 510, 510, 510, 510, 510, 511, 511, 511, 511, 511,
1234 : 511, 511, 511, 511, 511, 511, 512, 512, 512, 512,
1235 : 512, 512, 512, 512, 512, 512, 512, 513, 513, 513,
1236 : 513, 513, 513, 513, 513, 513, 513, 513, 514, 514,
1237 : 514, 514, 514, 514, 514, 514, 514, 514, 514, 515,
1238 : 515, 515, 515, 515, 515, 515, 515, 515, 515, 515,
1239 : 516, 516, 516, 516, 516, 516, 516, 516, 516, 516,
1240 : 516, 517, 517, 0, 517, 517, 517, 517, 517, 517,
1241 :
1242 : 517, 517, 518, 518, 518, 518, 518, 518, 518, 518,
1243 : 518, 518, 518, 519, 519, 519, 519, 519, 519, 519,
1244 : 519, 519, 519, 519, 520, 520, 520, 520, 520, 520,
1245 : 520, 520, 520, 520, 520, 521, 521, 521, 521, 521,
1246 : 521, 521, 521, 521, 521, 521, 522, 522, 522, 522,
1247 : 522, 522, 522, 522, 522, 522, 522, 523, 523, 523,
1248 : 523, 523, 523, 523, 523, 523, 523, 523, 524, 524,
1249 : 0, 524, 524, 524, 524, 524, 524, 524, 524, 525,
1250 : 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
1251 : 526, 526, 526, 526, 526, 526, 526, 526, 526, 526,
1252 :
1253 : 526, 527, 527, 0, 527, 527, 527, 527, 527, 527,
1254 : 527, 527, 528, 528, 528, 528, 528, 528, 528, 528,
1255 : 528, 528, 528, 529, 529, 0, 529, 529, 529, 529,
1256 : 529, 529, 529, 529, 531, 531, 0, 531, 531, 531,
1257 : 531, 531, 531, 531, 531, 532, 532, 0, 532, 532,
1258 : 532, 532, 532, 532, 532, 532, 533, 533, 0, 533,
1259 : 533, 533, 533, 533, 533, 533, 533, 534, 0, 0,
1260 : 0, 534, 535, 0, 0, 0, 535, 536, 536, 536,
1261 : 536, 536, 536, 536, 0, 536, 536, 536, 537, 537,
1262 : 537, 537, 537, 537, 537, 537, 537, 537, 537, 538,
1263 :
1264 : 538, 538, 538, 538, 538, 538, 0, 538, 538, 538,
1265 : 539, 539, 0, 539, 539, 539, 539, 539, 539, 539,
1266 : 539, 540, 540, 0, 540, 540, 540, 540, 540, 540,
1267 : 540, 540, 474, 474, 474, 474, 474, 474, 474, 474,
1268 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
1269 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
1270 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
1271 : 474, 474, 474, 474, 474, 474, 474, 474, 474, 474,
1272 : 474, 474
1273 : } ;
1274 :
1275 : /* Table of booleans, true if rule could match eol. */
1276 : static yyconst flex_int32_t yy_rule_can_match_eol[42] =
1277 : { 0,
1278 : 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1279 : 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
1280 : 0, 0, };
1281 :
1282 : extern int yy_flex_debug;
1283 : int yy_flex_debug = 0;
1284 :
1285 : static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
1286 : static char *yy_full_match;
1287 : static int yy_lp;
1288 : static int yy_looking_for_trail_begin = 0;
1289 : static int yy_full_lp;
1290 : static int *yy_full_state;
1291 : #define YY_TRAILING_MASK 0x2000
1292 : #define YY_TRAILING_HEAD_MASK 0x4000
1293 : #define REJECT \
1294 : { \
1295 : *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1296 : yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1297 : (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
1298 : (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
1299 : yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
1300 : ++(yy_lp); \
1301 : goto find_rule; \
1302 : }
1303 :
1304 : #define yymore() yymore_used_but_not_detected
1305 : #define YY_MORE_ADJ 0
1306 : #define YY_RESTORE_YY_MORE_OFFSET
1307 : char *yytext;
1308 : #line 1 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1309 : #line 3 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1310 : /*
1311 : * This file is part of the LibreOffice project.
1312 : *
1313 : * This Source Code Form is subject to the terms of the Mozilla Public
1314 : * License, v. 2.0. If a copy of the MPL was not distributed with this
1315 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
1316 : *
1317 : * This file incorporates work covered by the following license notice:
1318 : *
1319 : * Licensed to the Apache Software Foundation (ASF) under one or more
1320 : * contributor license agreements. See the NOTICE file distributed
1321 : * with this work for additional information regarding copyright
1322 : * ownership. The ASF licenses this file to you under the Apache
1323 : * License, Version 2.0 (the "License"); you may not use this file
1324 : * except in compliance with the License. You may obtain a copy of
1325 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
1326 : */
1327 :
1328 : /*
1329 : * lexer for parsing resource source files (*.src)
1330 : */
1331 :
1332 : #include "sal/config.h"
1333 :
1334 : /* enlarge token buffer to tokenize whole strings */
1335 : #undef YYLMAX
1336 : #define YYLMAX 64000
1337 :
1338 : /* to enable debug output define LEXDEBUG */
1339 : #define LEXDEBUG 1
1340 : #ifdef LEXDEBUG
1341 : #define OUTPUT fprintf
1342 : #else
1343 : #define OUTPUT(Par1,Par2);
1344 : #endif
1345 :
1346 : /* table of possible token ids */
1347 : #include "tokens.h"
1348 : #include <stdlib.h>
1349 : #include <stdio.h>
1350 :
1351 : #include "sal/main.h"
1352 :
1353 : #if HAVE_GCC_PRAGMA_DIAGNOSTIC_MODIFY
1354 : #pragma GCC diagnostic ignored "-Wunused-function"
1355 : #pragma GCC diagnostic ignored "-Wunused-label"
1356 : #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
1357 : #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
1358 : #endif
1359 : #elif defined __SUNPRO_CC
1360 : #pragma disable_warn
1361 : #elif defined _MSC_VER
1362 : #pragma warning(push, 1)
1363 : #endif
1364 : #define YY_NO_UNISTD_H
1365 :
1366 : /* external functions (C++ code, declared as extern "C" */
1367 : extern "C" int WorkOnTokenSet( int, char* );
1368 : extern "C" FILE * init(int, char **);
1369 : extern "C" int SetError();
1370 : extern "C" int GetError();
1371 : extern "C" void Close();
1372 :
1373 : /* forwards */
1374 : void YYWarning();
1375 : #line 1376 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/LexTarget/l10ntools/source/srclex.cxx"
1376 :
1377 : #define INITIAL 0
1378 :
1379 : #ifndef YY_NO_UNISTD_H
1380 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
1381 : * down here because we want the user's section 1 to have been scanned first.
1382 : * The user has a chance to override it with an option.
1383 : */
1384 : #include <unistd.h>
1385 : #endif
1386 :
1387 : #ifndef YY_EXTRA_TYPE
1388 : #define YY_EXTRA_TYPE void *
1389 : #endif
1390 :
1391 : static int yy_init_globals (void );
1392 :
1393 : /* Accessor methods to globals.
1394 : These are made visible to non-reentrant scanners for convenience. */
1395 :
1396 : int yylex_destroy (void );
1397 :
1398 : int yyget_debug (void );
1399 :
1400 : void yyset_debug (int debug_flag );
1401 :
1402 : YY_EXTRA_TYPE yyget_extra (void );
1403 :
1404 : void yyset_extra (YY_EXTRA_TYPE user_defined );
1405 :
1406 : FILE *yyget_in (void );
1407 :
1408 : void yyset_in (FILE * in_str );
1409 :
1410 : FILE *yyget_out (void );
1411 :
1412 : void yyset_out (FILE * out_str );
1413 :
1414 : yy_size_t yyget_leng (void );
1415 :
1416 : char *yyget_text (void );
1417 :
1418 : int yyget_lineno (void );
1419 :
1420 : void yyset_lineno (int line_number );
1421 :
1422 : /* Macros after this point can all be overridden by user definitions in
1423 : * section 1.
1424 : */
1425 :
1426 : #ifndef YY_SKIP_YYWRAP
1427 : #ifdef __cplusplus
1428 : extern "C" int yywrap (void );
1429 : #else
1430 : extern int yywrap (void );
1431 : #endif
1432 : #endif
1433 :
1434 : static void yyunput (int c,char *buf_ptr );
1435 :
1436 : #ifndef yytext_ptr
1437 : static void yy_flex_strncpy (char *,yyconst char *,int );
1438 : #endif
1439 :
1440 : #ifdef YY_NEED_STRLEN
1441 : static int yy_flex_strlen (yyconst char * );
1442 : #endif
1443 :
1444 : #ifndef YY_NO_INPUT
1445 :
1446 : #ifdef __cplusplus
1447 : static int yyinput (void );
1448 : #else
1449 : static int input (void );
1450 : #endif
1451 :
1452 : #endif
1453 :
1454 : /* Amount of stuff to slurp up with each read. */
1455 : #ifndef YY_READ_BUF_SIZE
1456 : #define YY_READ_BUF_SIZE 8192
1457 : #endif
1458 :
1459 : /* Copy whatever the last rule matched to the standard output. */
1460 : #ifndef ECHO
1461 : /* This used to be an fputs(), but since the string might contain NUL's,
1462 : * we now use fwrite().
1463 : */
1464 : #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1465 : #endif
1466 :
1467 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1468 : * is returned in "result".
1469 : */
1470 : #ifndef YY_INPUT
1471 : #define YY_INPUT(buf,result,max_size) \
1472 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1473 : { \
1474 : int c = '*'; \
1475 : size_t n; \
1476 : for ( n = 0; n < max_size && \
1477 : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1478 : buf[n] = (char) c; \
1479 : if ( c == '\n' ) \
1480 : buf[n++] = (char) c; \
1481 : if ( c == EOF && ferror( yyin ) ) \
1482 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
1483 : result = n; \
1484 : } \
1485 : else \
1486 : { \
1487 : errno=0; \
1488 : while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1489 : { \
1490 : if( errno != EINTR) \
1491 : { \
1492 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
1493 : break; \
1494 : } \
1495 : errno=0; \
1496 : clearerr(yyin); \
1497 : } \
1498 : }\
1499 : \
1500 :
1501 : #endif
1502 :
1503 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
1504 : * we don't want an extra ';' after the "return" because that will cause
1505 : * some compilers to complain about unreachable statements.
1506 : */
1507 : #ifndef yyterminate
1508 : #define yyterminate() return YY_NULL
1509 : #endif
1510 :
1511 : /* Number of entries by which start-condition stack grows. */
1512 : #ifndef YY_START_STACK_INCR
1513 : #define YY_START_STACK_INCR 25
1514 : #endif
1515 :
1516 : /* Report a fatal error. */
1517 : #ifndef YY_FATAL_ERROR
1518 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1519 : #endif
1520 :
1521 : /* end tables serialization structures and prototypes */
1522 :
1523 : /* Default declaration of generated scanner - a define so the user can
1524 : * easily add parameters.
1525 : */
1526 : #ifndef YY_DECL
1527 : #define YY_DECL_IS_OURS 1
1528 :
1529 : extern int yylex (void);
1530 :
1531 : #define YY_DECL int yylex (void)
1532 : #endif /* !YY_DECL */
1533 :
1534 : /* Code executed at the beginning of each rule, after yytext and yyleng
1535 : * have been set up.
1536 : */
1537 : #ifndef YY_USER_ACTION
1538 : #define YY_USER_ACTION
1539 : #endif
1540 :
1541 : /* Code executed at the end of each rule. */
1542 : #ifndef YY_BREAK
1543 : #define YY_BREAK break;
1544 : #endif
1545 :
1546 : #define YY_RULE_SETUP \
1547 : if ( yyleng > 0 ) \
1548 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1549 : (yytext[yyleng - 1] == '\n'); \
1550 : YY_USER_ACTION
1551 :
1552 : /** The main scanner function which does all the work.
1553 : */
1554 13 : YY_DECL
1555 : {
1556 : register yy_state_type yy_current_state;
1557 : register char *yy_cp, *yy_bp;
1558 : register int yy_act;
1559 :
1560 : #line 77 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1561 :
1562 :
1563 : #line 1564 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/LexTarget/l10ntools/source/srclex.cxx"
1564 :
1565 13 : if ( !(yy_init) )
1566 : {
1567 13 : (yy_init) = 1;
1568 :
1569 : #ifdef YY_USER_INIT
1570 : YY_USER_INIT;
1571 : #endif
1572 :
1573 : /* Create the reject buffer large enough to save one state per allowed character. */
1574 13 : if ( ! (yy_state_buf) )
1575 13 : (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE );
1576 13 : if ( ! (yy_state_buf) )
1577 0 : YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1578 :
1579 13 : if ( ! (yy_start) )
1580 13 : (yy_start) = 1; /* first start state */
1581 :
1582 13 : if ( ! yyin )
1583 0 : yyin = stdin;
1584 :
1585 13 : if ( ! yyout )
1586 13 : yyout = stdout;
1587 :
1588 13 : if ( ! YY_CURRENT_BUFFER ) {
1589 13 : yyensure_buffer_stack ();
1590 13 : YY_CURRENT_BUFFER_LVALUE =
1591 13 : yy_create_buffer(yyin,YY_BUF_SIZE );
1592 : }
1593 :
1594 13 : yy_load_buffer_state( );
1595 : }
1596 :
1597 : while ( 1 ) /* loops until end-of-file is reached */
1598 : {
1599 19690 : yy_cp = (yy_c_buf_p);
1600 :
1601 : /* Support of yytext. */
1602 19690 : *yy_cp = (yy_hold_char);
1603 :
1604 : /* yy_bp points to the position in yy_ch_buf of the start of
1605 : * the current run.
1606 : */
1607 19690 : yy_bp = yy_cp;
1608 :
1609 19690 : yy_current_state = (yy_start);
1610 19690 : yy_current_state += YY_AT_BOL();
1611 :
1612 19690 : (yy_state_ptr) = (yy_state_buf);
1613 19690 : *(yy_state_ptr)++ = yy_current_state;
1614 :
1615 : yy_match:
1616 367400 : do
1617 : {
1618 367400 : register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1619 991620 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1620 : {
1621 256820 : yy_current_state = (int) yy_def[yy_current_state];
1622 256820 : if ( yy_current_state >= 475 )
1623 175632 : yy_c = yy_meta[(unsigned int) yy_c];
1624 : }
1625 367400 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1626 367400 : *(yy_state_ptr)++ = yy_current_state;
1627 367400 : ++yy_cp;
1628 : }
1629 : while ( yy_current_state != 474 );
1630 :
1631 : yy_find_action:
1632 19730 : yy_current_state = *--(yy_state_ptr);
1633 19730 : (yy_lp) = yy_accept[yy_current_state];
1634 : find_rule: /* we branch to this label when backing up */
1635 : for ( ; ; ) /* until we find what rule we matched */
1636 : {
1637 230798 : if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1638 : {
1639 19854 : yy_act = yy_acclist[(yy_lp)];
1640 19854 : if ( yy_act & YY_TRAILING_HEAD_MASK ||
1641 : (yy_looking_for_trail_begin) )
1642 : {
1643 124 : if ( yy_act == (yy_looking_for_trail_begin) )
1644 : {
1645 124 : (yy_looking_for_trail_begin) = 0;
1646 124 : yy_act &= ~YY_TRAILING_HEAD_MASK;
1647 124 : break;
1648 : }
1649 : }
1650 19730 : else if ( yy_act & YY_TRAILING_MASK )
1651 : {
1652 124 : (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
1653 124 : (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
1654 : }
1655 : else
1656 : {
1657 19606 : (yy_full_match) = yy_cp;
1658 19606 : (yy_full_state) = (yy_state_ptr);
1659 19606 : (yy_full_lp) = (yy_lp);
1660 19606 : break;
1661 : }
1662 124 : ++(yy_lp);
1663 124 : goto find_rule;
1664 : }
1665 210944 : --yy_cp;
1666 210944 : yy_current_state = *--(yy_state_ptr);
1667 210944 : (yy_lp) = yy_accept[yy_current_state];
1668 : }
1669 :
1670 19730 : YY_DO_BEFORE_ACTION;
1671 :
1672 19730 : if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1673 : {
1674 : int yyl;
1675 84068 : for ( yyl = 0; yyl < yyleng; ++yyl )
1676 77878 : if ( yytext[yyl] == '\n' )
1677 :
1678 5120 : yylineno++;
1679 : ;
1680 : }
1681 :
1682 : do_action: /* This label is used only to access EOF actions. */
1683 :
1684 19743 : switch ( yy_act )
1685 : { /* beginning of action switch */
1686 : case 1:
1687 0 : YY_RULE_SETUP
1688 : #line 79 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1689 : {
1690 : WorkOnTokenSet( PRAGMA, yytext );
1691 : }
1692 : YY_BREAK
1693 : case 2:
1694 : /* rule 2 can match eol */
1695 : YY_RULE_SETUP
1696 : #line 83 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1697 : {
1698 : WorkOnTokenSet( EMPTYLINE, yytext );
1699 : }
1700 : YY_BREAK
1701 : case 3:
1702 : #line 88 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1703 : case 4:
1704 : #line 89 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1705 : case 5:
1706 : #line 90 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1707 : case 6:
1708 : #line 91 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1709 : case 7:
1710 : #line 92 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1711 : case 8:
1712 : #line 93 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1713 : case 9:
1714 : #line 94 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1715 : case 10:
1716 : /* rule 10 can match eol */
1717 : YY_RULE_SETUP
1718 : #line 94 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1719 : {
1720 : WorkOnTokenSet( IGNOREDTOKENS, yytext );
1721 : }
1722 : YY_BREAK
1723 : case 11:
1724 : YY_RULE_SETUP
1725 : #line 97 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1726 : {
1727 : char c1 = 0;
1728 : int c2 = yyinput();
1729 : char pChar[2];
1730 : pChar[1] = 0x00;
1731 : pChar[0] = c2;
1732 :
1733 : WorkOnTokenSet( COMMENT, yytext );
1734 : WorkOnTokenSet( COMMENT, pChar );
1735 : for(;;) {
1736 : if ( c2 == EOF )
1737 : break;
1738 : if ( c1 == '*' && c2 == '/' )
1739 : break;
1740 : c1 = c2;
1741 : c2 = yyinput();
1742 : pChar[0] = c2;
1743 : WorkOnTokenSet( COMMENT, pChar );
1744 : }
1745 : }
1746 : YY_BREAK
1747 : case 12:
1748 : *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1749 : (yy_c_buf_p) = yy_cp -= 1;
1750 : YY_DO_BEFORE_ACTION; /* set up yytext again */
1751 : YY_RULE_SETUP
1752 : #line 118 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1753 : case 13:
1754 : #line 119 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1755 : case 14:
1756 : #line 120 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1757 : case 15:
1758 : #line 121 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1759 : case 16:
1760 : #line 122 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1761 : case 17:
1762 : #line 123 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1763 : {
1764 : WorkOnTokenSet( CONDITION, yytext );
1765 : }
1766 : YY_BREAK
1767 : case 18:
1768 : YY_RULE_SETUP
1769 : #line 127 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1770 : {
1771 : /* defined Res */
1772 : WorkOnTokenSet( DEFINEDRES, yytext );
1773 : }
1774 : YY_BREAK
1775 : case 19:
1776 : /* rule 19 can match eol */
1777 : #line 133 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1778 : case 20:
1779 : /* rule 20 can match eol */
1780 : YY_RULE_SETUP
1781 : #line 133 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1782 : {
1783 : /* RESOURCE // String TTT_XX ... */
1784 : WorkOnTokenSet( RESOURCE, yytext );
1785 : }
1786 : YY_BREAK
1787 : case 21:
1788 : /* rule 21 can match eol */
1789 : YY_RULE_SETUP
1790 : #line 138 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1791 : {
1792 : /* SMALRESOURCE // String ... */
1793 : WorkOnTokenSet( SMALRESOURCE, yytext );
1794 : }
1795 : YY_BREAK
1796 : case 22:
1797 : /* rule 22 can match eol */
1798 : YY_RULE_SETUP
1799 : #line 143 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1800 : {
1801 : /* TEXTLINE // TextTyp = "A Text" */
1802 : WorkOnTokenSet( TEXTLINE, yytext );
1803 : }
1804 : YY_BREAK
1805 : case 23:
1806 : /* rule 23 can match eol */
1807 : YY_RULE_SETUP
1808 : #line 148 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1809 : {
1810 : /* LONGTEXTLINE // TextTyp = "A Text" HHH_XXX "A Text" ZZZ_TTT ... */
1811 : WorkOnTokenSet( LONGTEXTLINE, yytext );
1812 : }
1813 : YY_BREAK
1814 : case 24:
1815 : YY_RULE_SETUP
1816 : #line 153 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1817 : {
1818 : /* TEXT // "A Text" */
1819 : WorkOnTokenSet( TEXT, yytext );
1820 : }
1821 : YY_BREAK
1822 : case 25:
1823 : YY_RULE_SETUP
1824 : #line 158 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1825 : {
1826 : /* LEVELUP */
1827 : WorkOnTokenSet( LEVELUP, yytext );
1828 : }
1829 : YY_BREAK
1830 : case 26:
1831 : YY_RULE_SETUP
1832 : #line 163 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1833 : {
1834 : /* LEVELDOWN */
1835 : WorkOnTokenSet( LEVELDOWN, yytext );
1836 : }
1837 : YY_BREAK
1838 : case 27:
1839 : YY_RULE_SETUP
1840 : #line 168 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1841 : {
1842 : /* APPFONTMAPPING Typ = MAP_APPFONT( ... ) */
1843 : WorkOnTokenSet( APPFONTMAPPING, yytext );
1844 : }
1845 : YY_BREAK
1846 : case 28:
1847 : YY_RULE_SETUP
1848 : #line 173 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1849 : {
1850 : /* TEXTREFID // TextTyp = 12345 */
1851 : WorkOnTokenSet( TEXTREFID, yytext );
1852 : }
1853 : YY_BREAK
1854 : case 29:
1855 : /* rule 29 can match eol */
1856 : #line 179 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1857 : case 30:
1858 : /* rule 30 can match eol */
1859 : YY_RULE_SETUP
1860 : #line 179 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1861 : {
1862 : /* ASSIGNMENT Typ = ... */
1863 : WorkOnTokenSet( ASSIGNMENT, yytext );
1864 : }
1865 : YY_BREAK
1866 : case 31:
1867 : /* rule 31 can match eol */
1868 : YY_RULE_SETUP
1869 : #line 186 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1870 : {
1871 : /* LISTASSIGNMENT Typ [ ... ] = ... */
1872 : WorkOnTokenSet( LISTASSIGNMENT, yytext );
1873 : }
1874 : YY_BREAK
1875 : case 32:
1876 : /* rule 32 can match eol */
1877 : YY_RULE_SETUP
1878 : #line 191 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1879 : {
1880 : /* LISTASSIGNMENT Typ [ ... ] = ... */
1881 : WorkOnTokenSet( LISTASSIGNMENT, yytext );
1882 : }
1883 : YY_BREAK
1884 : case 33:
1885 : /* rule 33 can match eol */
1886 : YY_RULE_SETUP
1887 : #line 196 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1888 : {
1889 : /* UIENTRIES */
1890 : WorkOnTokenSet( UIENTRIES, yytext );
1891 : }
1892 : YY_BREAK
1893 : case 34:
1894 : YY_RULE_SETUP
1895 : #line 201 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1896 : {
1897 : /* LISTTEXT */
1898 : WorkOnTokenSet( LISTTEXT, yytext );
1899 : }
1900 : YY_BREAK
1901 : case 35:
1902 : YY_RULE_SETUP
1903 : #line 206 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1904 : {
1905 : /* RSCDEFINE #define ... */
1906 : WorkOnTokenSet( RSCDEFINE, yytext );
1907 : }
1908 : YY_BREAK
1909 : case 36:
1910 : YY_RULE_SETUP
1911 : #line 211 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1912 : {
1913 : /* #define ... */
1914 : WorkOnTokenSet( NORMDEFINE, yytext );
1915 : }
1916 : YY_BREAK
1917 : case 37:
1918 : YY_RULE_SETUP
1919 : #line 216 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1920 : {
1921 : /* RSCDEFINELEND */
1922 : WorkOnTokenSet( RSCDEFINELEND, yytext );
1923 : }
1924 : YY_BREAK
1925 : case 38:
1926 : YY_RULE_SETUP
1927 : #line 221 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1928 : {
1929 : /* allowed other tokens like "49 ;" or "SFX_... ;" */
1930 : WorkOnTokenSet( ANYTOKEN, yytext );
1931 : }
1932 : YY_BREAK
1933 : case 39:
1934 : YY_RULE_SETUP
1935 : #line 226 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1936 : {
1937 : WorkOnTokenSet( UNKNOWNCHAR, yytext );
1938 : /* YYWarning( "Unknown Char" ); */
1939 : }
1940 : YY_BREAK
1941 : case 40:
1942 : YY_RULE_SETUP
1943 : #line 231 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1944 : {
1945 : /* _LISTTEXT */
1946 : WorkOnTokenSet( _LISTTEXT, yytext );
1947 : }
1948 : YY_BREAK
1949 : case 41:
1950 : YY_RULE_SETUP
1951 : #line 236 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
1952 : ECHO;
1953 : YY_BREAK
1954 : #line 1955 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/LexTarget/l10ntools/source/srclex.cxx"
1955 : case YY_STATE_EOF(INITIAL):
1956 26 : yyterminate();
1957 :
1958 : case YY_END_OF_BUFFER:
1959 : {
1960 : /* Amount of text matched not including the EOB char. */
1961 53 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1962 :
1963 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1964 53 : *yy_cp = (yy_hold_char);
1965 : YY_RESTORE_YY_MORE_OFFSET
1966 :
1967 53 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1968 : {
1969 : /* We're scanning a new file or input source. It's
1970 : * possible that this happened because the user
1971 : * just pointed yyin at a new source and called
1972 : * yylex(). If so, then we have to assure
1973 : * consistency between YY_CURRENT_BUFFER and our
1974 : * globals. Here is the right place to do so, because
1975 : * this is the first action (other than possibly a
1976 : * back-up) that will match for the new input source.
1977 : */
1978 13 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1979 13 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1980 13 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1981 : }
1982 :
1983 : /* Note that here we test for yy_c_buf_p "<=" to the position
1984 : * of the first EOB in the buffer, since yy_c_buf_p will
1985 : * already have been incremented past the NUL character
1986 : * (since all states make transitions on EOB to the
1987 : * end-of-buffer state). Contrast this with the test
1988 : * in input().
1989 : */
1990 53 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1991 : { /* This was really a NUL. */
1992 : yy_state_type yy_next_state;
1993 :
1994 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1995 :
1996 0 : yy_current_state = yy_get_previous_state( );
1997 :
1998 : /* Okay, we're now positioned to make the NUL
1999 : * transition. We couldn't have
2000 : * yy_get_previous_state() go ahead and do it
2001 : * for us because it doesn't know how to deal
2002 : * with the possibility of jamming (and we don't
2003 : * want to build jamming into it because then it
2004 : * will run more slowly).
2005 : */
2006 :
2007 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
2008 :
2009 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2010 :
2011 0 : if ( yy_next_state )
2012 : {
2013 : /* Consume the NUL. */
2014 0 : yy_cp = ++(yy_c_buf_p);
2015 0 : yy_current_state = yy_next_state;
2016 0 : goto yy_match;
2017 : }
2018 :
2019 : else
2020 : {
2021 0 : yy_cp = (yy_c_buf_p);
2022 0 : goto yy_find_action;
2023 : }
2024 : }
2025 :
2026 53 : else switch ( yy_get_next_buffer( ) )
2027 : {
2028 : case EOB_ACT_END_OF_FILE:
2029 : {
2030 13 : (yy_did_buffer_switch_on_eof) = 0;
2031 :
2032 13 : if ( yywrap( ) )
2033 : {
2034 : /* Note: because we've taken care in
2035 : * yy_get_next_buffer() to have set up
2036 : * yytext, we can now set up
2037 : * yy_c_buf_p so that if some total
2038 : * hoser (like flex itself) wants to
2039 : * call the scanner after we return the
2040 : * YY_NULL, it'll still work - another
2041 : * YY_NULL will get returned.
2042 : */
2043 13 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2044 :
2045 13 : yy_act = YY_STATE_EOF(YY_START);
2046 13 : goto do_action;
2047 : }
2048 :
2049 : else
2050 : {
2051 0 : if ( ! (yy_did_buffer_switch_on_eof) )
2052 0 : YY_NEW_FILE;
2053 : }
2054 0 : break;
2055 : }
2056 :
2057 : case EOB_ACT_CONTINUE_SCAN:
2058 : (yy_c_buf_p) =
2059 27 : (yytext_ptr) + yy_amount_of_matched_text;
2060 :
2061 27 : yy_current_state = yy_get_previous_state( );
2062 :
2063 27 : yy_cp = (yy_c_buf_p);
2064 27 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2065 27 : goto yy_match;
2066 :
2067 : case EOB_ACT_LAST_MATCH:
2068 : (yy_c_buf_p) =
2069 13 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2070 :
2071 13 : yy_current_state = yy_get_previous_state( );
2072 :
2073 13 : yy_cp = (yy_c_buf_p);
2074 13 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2075 13 : goto yy_find_action;
2076 : }
2077 0 : break;
2078 : }
2079 :
2080 : default:
2081 : YY_FATAL_ERROR(
2082 0 : "fatal flex scanner internal error--no action found" );
2083 : } /* end of action switch */
2084 230621 : } /* end of scanning one token */
2085 : } /* end of yylex */
2086 :
2087 : /* yy_get_next_buffer - try to read in a new buffer
2088 : *
2089 : * Returns a code representing an action:
2090 : * EOB_ACT_LAST_MATCH -
2091 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2092 : * EOB_ACT_END_OF_FILE - end of file
2093 : */
2094 53 : static int yy_get_next_buffer (void)
2095 : {
2096 53 : register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2097 53 : register char *source = (yytext_ptr);
2098 : register int number_to_move, i;
2099 : int ret_val;
2100 :
2101 53 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2102 : YY_FATAL_ERROR(
2103 0 : "fatal flex scanner internal error--end of buffer missed" );
2104 :
2105 53 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2106 : { /* Don't try to fill the buffer, so this is an EOF. */
2107 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2108 : {
2109 : /* We matched a single character, the EOB, so
2110 : * treat this as a final EOF.
2111 : */
2112 0 : return EOB_ACT_END_OF_FILE;
2113 : }
2114 :
2115 : else
2116 : {
2117 : /* We matched some text prior to the EOB, first
2118 : * process it.
2119 : */
2120 0 : return EOB_ACT_LAST_MATCH;
2121 : }
2122 : }
2123 :
2124 : /* Try to read more data. */
2125 :
2126 : /* First move last chars to start of buffer. */
2127 53 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2128 :
2129 414 : for ( i = 0; i < number_to_move; ++i )
2130 361 : *(dest++) = *(source++);
2131 :
2132 53 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2133 : /* don't do the read, it's not guaranteed to return an EOF,
2134 : * just force an EOF
2135 : */
2136 13 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2137 :
2138 : else
2139 : {
2140 : yy_size_t num_to_read =
2141 40 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2142 :
2143 80 : while ( num_to_read <= 0 )
2144 : { /* Not enough room in the buffer - grow it. */
2145 :
2146 : YY_FATAL_ERROR(
2147 0 : "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2148 :
2149 : }
2150 :
2151 40 : if ( num_to_read > YY_READ_BUF_SIZE )
2152 40 : num_to_read = YY_READ_BUF_SIZE;
2153 :
2154 : /* Read in more data. */
2155 40 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2156 : (yy_n_chars), num_to_read );
2157 :
2158 40 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2159 : }
2160 :
2161 53 : if ( (yy_n_chars) == 0 )
2162 : {
2163 26 : if ( number_to_move == YY_MORE_ADJ )
2164 : {
2165 13 : ret_val = EOB_ACT_END_OF_FILE;
2166 13 : yyrestart(yyin );
2167 : }
2168 :
2169 : else
2170 : {
2171 13 : ret_val = EOB_ACT_LAST_MATCH;
2172 13 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2173 13 : YY_BUFFER_EOF_PENDING;
2174 : }
2175 : }
2176 :
2177 : else
2178 27 : ret_val = EOB_ACT_CONTINUE_SCAN;
2179 :
2180 53 : if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2181 : /* Extend the array by 50%, plus the number we really need. */
2182 0 : yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2183 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
2184 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2185 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2186 : }
2187 :
2188 53 : (yy_n_chars) += number_to_move;
2189 53 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2190 53 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2191 :
2192 53 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2193 :
2194 53 : return ret_val;
2195 : }
2196 :
2197 : /* yy_get_previous_state - get the state just before the EOB char was reached */
2198 :
2199 40 : static yy_state_type yy_get_previous_state (void)
2200 : {
2201 : register yy_state_type yy_current_state;
2202 : register char *yy_cp;
2203 :
2204 40 : yy_current_state = (yy_start);
2205 40 : yy_current_state += YY_AT_BOL();
2206 :
2207 40 : (yy_state_ptr) = (yy_state_buf);
2208 40 : *(yy_state_ptr)++ = yy_current_state;
2209 :
2210 401 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2211 : {
2212 361 : register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2213 883 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2214 : {
2215 161 : yy_current_state = (int) yy_def[yy_current_state];
2216 161 : if ( yy_current_state >= 475 )
2217 140 : yy_c = yy_meta[(unsigned int) yy_c];
2218 : }
2219 361 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2220 361 : *(yy_state_ptr)++ = yy_current_state;
2221 : }
2222 :
2223 40 : return yy_current_state;
2224 : }
2225 :
2226 : /* yy_try_NUL_trans - try to make a transition on the NUL character
2227 : *
2228 : * synopsis
2229 : * next_state = yy_try_NUL_trans( current_state );
2230 : */
2231 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2232 : {
2233 : register int yy_is_jam;
2234 :
2235 0 : register YY_CHAR yy_c = 1;
2236 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2237 : {
2238 0 : yy_current_state = (int) yy_def[yy_current_state];
2239 0 : if ( yy_current_state >= 475 )
2240 0 : yy_c = yy_meta[(unsigned int) yy_c];
2241 : }
2242 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2243 0 : yy_is_jam = (yy_current_state == 474);
2244 0 : if ( ! yy_is_jam )
2245 0 : *(yy_state_ptr)++ = yy_current_state;
2246 :
2247 0 : return yy_is_jam ? 0 : yy_current_state;
2248 : }
2249 :
2250 0 : static void yyunput (int c, register char * yy_bp )
2251 : {
2252 : register char *yy_cp;
2253 :
2254 0 : yy_cp = (yy_c_buf_p);
2255 :
2256 : /* undo effects of setting up yytext */
2257 0 : *yy_cp = (yy_hold_char);
2258 :
2259 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2260 : { /* need to shift things up to make room */
2261 : /* +2 for EOB chars. */
2262 0 : register yy_size_t number_to_move = (yy_n_chars) + 2;
2263 0 : register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2264 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2265 : register char *source =
2266 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2267 :
2268 0 : while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2269 0 : *--dest = *--source;
2270 :
2271 0 : yy_cp += (int) (dest - source);
2272 0 : yy_bp += (int) (dest - source);
2273 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2274 0 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2275 :
2276 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2277 0 : YY_FATAL_ERROR( "flex scanner push-back overflow" );
2278 : }
2279 :
2280 0 : *--yy_cp = (char) c;
2281 :
2282 0 : if ( c == '\n' ){
2283 0 : --yylineno;
2284 : }
2285 :
2286 0 : (yytext_ptr) = yy_bp;
2287 0 : (yy_hold_char) = *yy_cp;
2288 0 : (yy_c_buf_p) = yy_cp;
2289 0 : }
2290 :
2291 : #ifndef YY_NO_INPUT
2292 : #ifdef __cplusplus
2293 12801 : static int yyinput (void)
2294 : #else
2295 : static int input (void)
2296 : #endif
2297 :
2298 : {
2299 : int c;
2300 :
2301 12801 : *(yy_c_buf_p) = (yy_hold_char);
2302 :
2303 12801 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2304 : {
2305 : /* yy_c_buf_p now points to the character we want to return.
2306 : * If this occurs *before* the EOB characters, then it's a
2307 : * valid NUL; if not, then we've hit the end of the buffer.
2308 : */
2309 0 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2310 : /* This was really a NUL. */
2311 0 : *(yy_c_buf_p) = '\0';
2312 :
2313 : else
2314 : { /* need more input */
2315 0 : yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2316 0 : ++(yy_c_buf_p);
2317 :
2318 0 : switch ( yy_get_next_buffer( ) )
2319 : {
2320 : case EOB_ACT_LAST_MATCH:
2321 : /* This happens because yy_g_n_b()
2322 : * sees that we've accumulated a
2323 : * token and flags that we need to
2324 : * try matching the token before
2325 : * proceeding. But for input(),
2326 : * there's no matching to consider.
2327 : * So convert the EOB_ACT_LAST_MATCH
2328 : * to EOB_ACT_END_OF_FILE.
2329 : */
2330 :
2331 : /* Reset buffer status. */
2332 0 : yyrestart(yyin );
2333 :
2334 : /*FALLTHROUGH*/
2335 :
2336 : case EOB_ACT_END_OF_FILE:
2337 : {
2338 0 : if ( yywrap( ) )
2339 0 : return EOF;
2340 :
2341 0 : if ( ! (yy_did_buffer_switch_on_eof) )
2342 0 : YY_NEW_FILE;
2343 : #ifdef __cplusplus
2344 0 : return yyinput();
2345 : #else
2346 : return input();
2347 : #endif
2348 : }
2349 :
2350 : case EOB_ACT_CONTINUE_SCAN:
2351 0 : (yy_c_buf_p) = (yytext_ptr) + offset;
2352 0 : break;
2353 : }
2354 : }
2355 : }
2356 :
2357 12801 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2358 12801 : *(yy_c_buf_p) = '\0'; /* preserve yytext */
2359 12801 : (yy_hold_char) = *++(yy_c_buf_p);
2360 :
2361 12801 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2362 12801 : if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
2363 :
2364 214 : yylineno++;
2365 : ;
2366 :
2367 12801 : return c;
2368 : }
2369 : #endif /* ifndef YY_NO_INPUT */
2370 :
2371 : /** Immediately switch to a different input stream.
2372 : * @param input_file A readable stream.
2373 : *
2374 : * @note This function does not reset the start condition to @c INITIAL .
2375 : */
2376 13 : void yyrestart (FILE * input_file )
2377 : {
2378 :
2379 13 : if ( ! YY_CURRENT_BUFFER ){
2380 0 : yyensure_buffer_stack ();
2381 0 : YY_CURRENT_BUFFER_LVALUE =
2382 0 : yy_create_buffer(yyin,YY_BUF_SIZE );
2383 : }
2384 :
2385 13 : yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2386 13 : yy_load_buffer_state( );
2387 13 : }
2388 :
2389 : /** Switch to a different input buffer.
2390 : * @param new_buffer The new input buffer.
2391 : *
2392 : */
2393 0 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2394 : {
2395 :
2396 : /* TODO. We should be able to replace this entire function body
2397 : * with
2398 : * yypop_buffer_state();
2399 : * yypush_buffer_state(new_buffer);
2400 : */
2401 0 : yyensure_buffer_stack ();
2402 0 : if ( YY_CURRENT_BUFFER == new_buffer )
2403 0 : return;
2404 :
2405 0 : if ( YY_CURRENT_BUFFER )
2406 : {
2407 : /* Flush out information for old buffer. */
2408 0 : *(yy_c_buf_p) = (yy_hold_char);
2409 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2410 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2411 : }
2412 :
2413 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
2414 0 : yy_load_buffer_state( );
2415 :
2416 : /* We don't actually know whether we did this switch during
2417 : * EOF (yywrap()) processing, but the only time this flag
2418 : * is looked at is after yywrap() is called, so it's safe
2419 : * to go ahead and always set it.
2420 : */
2421 0 : (yy_did_buffer_switch_on_eof) = 1;
2422 : }
2423 :
2424 39 : static void yy_load_buffer_state (void)
2425 : {
2426 39 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2427 39 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2428 39 : yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2429 39 : (yy_hold_char) = *(yy_c_buf_p);
2430 39 : }
2431 :
2432 : /** Allocate and initialize an input buffer state.
2433 : * @param file A readable stream.
2434 : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2435 : *
2436 : * @return the allocated buffer state.
2437 : */
2438 13 : YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
2439 : {
2440 : YY_BUFFER_STATE b;
2441 :
2442 13 : b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
2443 13 : if ( ! b )
2444 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2445 :
2446 13 : b->yy_buf_size = size;
2447 :
2448 : /* yy_ch_buf has to be 2 characters longer than the size given because
2449 : * we need to put in 2 end-of-buffer characters.
2450 : */
2451 13 : b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
2452 13 : if ( ! b->yy_ch_buf )
2453 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2454 :
2455 13 : b->yy_is_our_buffer = 1;
2456 :
2457 13 : yy_init_buffer(b,file );
2458 :
2459 13 : return b;
2460 : }
2461 :
2462 : /** Destroy the buffer.
2463 : * @param b a buffer created with yy_create_buffer()
2464 : *
2465 : */
2466 0 : void yy_delete_buffer (YY_BUFFER_STATE b )
2467 : {
2468 :
2469 0 : if ( ! b )
2470 0 : return;
2471 :
2472 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2473 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2474 :
2475 0 : if ( b->yy_is_our_buffer )
2476 0 : yyfree((void *) b->yy_ch_buf );
2477 :
2478 0 : yyfree((void *) b );
2479 : }
2480 :
2481 : /* Initializes or reinitializes a buffer.
2482 : * This function is sometimes called more than once on the same buffer,
2483 : * such as during a yyrestart() or at EOF.
2484 : */
2485 26 : static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
2486 :
2487 : {
2488 26 : int oerrno = errno;
2489 :
2490 26 : yy_flush_buffer(b );
2491 :
2492 26 : b->yy_input_file = file;
2493 26 : b->yy_fill_buffer = 1;
2494 :
2495 : /* If b is the current buffer, then yy_init_buffer was _probably_
2496 : * called from yyrestart() or through yy_get_next_buffer.
2497 : * In that case, we don't want to reset the lineno or column.
2498 : */
2499 26 : if (b != YY_CURRENT_BUFFER){
2500 13 : b->yy_bs_lineno = 1;
2501 13 : b->yy_bs_column = 0;
2502 : }
2503 :
2504 26 : b->yy_is_interactive = 0;
2505 :
2506 26 : errno = oerrno;
2507 26 : }
2508 :
2509 : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2510 : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2511 : *
2512 : */
2513 26 : void yy_flush_buffer (YY_BUFFER_STATE b )
2514 : {
2515 26 : if ( ! b )
2516 26 : return;
2517 :
2518 26 : b->yy_n_chars = 0;
2519 :
2520 : /* We always need two end-of-buffer characters. The first causes
2521 : * a transition to the end-of-buffer state. The second causes
2522 : * a jam in that state.
2523 : */
2524 26 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2525 26 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2526 :
2527 26 : b->yy_buf_pos = &b->yy_ch_buf[0];
2528 :
2529 26 : b->yy_at_bol = 1;
2530 26 : b->yy_buffer_status = YY_BUFFER_NEW;
2531 :
2532 26 : if ( b == YY_CURRENT_BUFFER )
2533 13 : yy_load_buffer_state( );
2534 : }
2535 :
2536 : /** Pushes the new state onto the stack. The new state becomes
2537 : * the current state. This function will allocate the stack
2538 : * if necessary.
2539 : * @param new_buffer The new state.
2540 : *
2541 : */
2542 0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2543 : {
2544 0 : if (new_buffer == NULL)
2545 0 : return;
2546 :
2547 0 : yyensure_buffer_stack();
2548 :
2549 : /* This block is copied from yy_switch_to_buffer. */
2550 0 : if ( YY_CURRENT_BUFFER )
2551 : {
2552 : /* Flush out information for old buffer. */
2553 0 : *(yy_c_buf_p) = (yy_hold_char);
2554 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2555 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2556 : }
2557 :
2558 : /* Only push if top exists. Otherwise, replace top. */
2559 0 : if (YY_CURRENT_BUFFER)
2560 0 : (yy_buffer_stack_top)++;
2561 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
2562 :
2563 : /* copied from yy_switch_to_buffer. */
2564 0 : yy_load_buffer_state( );
2565 0 : (yy_did_buffer_switch_on_eof) = 1;
2566 : }
2567 :
2568 : /** Removes and deletes the top of the stack, if present.
2569 : * The next element becomes the new top.
2570 : *
2571 : */
2572 0 : void yypop_buffer_state (void)
2573 : {
2574 0 : if (!YY_CURRENT_BUFFER)
2575 0 : return;
2576 :
2577 0 : yy_delete_buffer(YY_CURRENT_BUFFER );
2578 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2579 0 : if ((yy_buffer_stack_top) > 0)
2580 0 : --(yy_buffer_stack_top);
2581 :
2582 0 : if (YY_CURRENT_BUFFER) {
2583 0 : yy_load_buffer_state( );
2584 0 : (yy_did_buffer_switch_on_eof) = 1;
2585 : }
2586 : }
2587 :
2588 : /* Allocates the stack if it does not exist.
2589 : * Guarantees space for at least one push.
2590 : */
2591 13 : static void yyensure_buffer_stack (void)
2592 : {
2593 : yy_size_t num_to_alloc;
2594 :
2595 13 : if (!(yy_buffer_stack)) {
2596 :
2597 : /* First allocation is just for 2 elements, since we don't know if this
2598 : * scanner will even need a stack. We use 2 instead of 1 to avoid an
2599 : * immediate realloc on the next call.
2600 : */
2601 13 : num_to_alloc = 1;
2602 : (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2603 : (num_to_alloc * sizeof(struct yy_buffer_state*)
2604 13 : );
2605 13 : if ( ! (yy_buffer_stack) )
2606 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2607 :
2608 13 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2609 :
2610 13 : (yy_buffer_stack_max) = num_to_alloc;
2611 13 : (yy_buffer_stack_top) = 0;
2612 26 : return;
2613 : }
2614 :
2615 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2616 :
2617 : /* Increase the buffer to prepare for a possible push. */
2618 0 : int grow_size = 8 /* arbitrary grow size */;
2619 :
2620 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
2621 : (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2622 : ((yy_buffer_stack),
2623 : num_to_alloc * sizeof(struct yy_buffer_state*)
2624 0 : );
2625 0 : if ( ! (yy_buffer_stack) )
2626 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2627 :
2628 : /* zero only the new slots.*/
2629 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2630 0 : (yy_buffer_stack_max) = num_to_alloc;
2631 : }
2632 : }
2633 :
2634 : /** Setup the input buffer state to scan directly from a user-specified character buffer.
2635 : * @param base the character buffer
2636 : * @param size the size in bytes of the character buffer
2637 : *
2638 : * @return the newly allocated buffer state object.
2639 : */
2640 0 : YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
2641 : {
2642 : YY_BUFFER_STATE b;
2643 :
2644 0 : if ( size < 2 ||
2645 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
2646 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
2647 : /* They forgot to leave room for the EOB's. */
2648 0 : return 0;
2649 :
2650 0 : b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
2651 0 : if ( ! b )
2652 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2653 :
2654 0 : b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2655 0 : b->yy_buf_pos = b->yy_ch_buf = base;
2656 0 : b->yy_is_our_buffer = 0;
2657 0 : b->yy_input_file = 0;
2658 0 : b->yy_n_chars = b->yy_buf_size;
2659 0 : b->yy_is_interactive = 0;
2660 0 : b->yy_at_bol = 1;
2661 0 : b->yy_fill_buffer = 0;
2662 0 : b->yy_buffer_status = YY_BUFFER_NEW;
2663 :
2664 0 : yy_switch_to_buffer(b );
2665 :
2666 0 : return b;
2667 : }
2668 :
2669 : /** Setup the input buffer state to scan a string. The next call to yylex() will
2670 : * scan from a @e copy of @a str.
2671 : * @param yystr a NUL-terminated string to scan
2672 : *
2673 : * @return the newly allocated buffer state object.
2674 : * @note If you want to scan bytes that may contain NUL values, then use
2675 : * yy_scan_bytes() instead.
2676 : */
2677 0 : YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2678 : {
2679 :
2680 0 : return yy_scan_bytes(yystr,strlen(yystr) );
2681 : }
2682 :
2683 : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2684 : * scan from a @e copy of @a bytes.
2685 : * @param yybytes the byte buffer to scan
2686 : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2687 : *
2688 : * @return the newly allocated buffer state object.
2689 : */
2690 0 : YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2691 : {
2692 : YY_BUFFER_STATE b;
2693 : char *buf;
2694 : yy_size_t n;
2695 : int i;
2696 :
2697 : /* Get memory for full buffer, including space for trailing EOB's. */
2698 0 : n = _yybytes_len + 2;
2699 0 : buf = (char *) yyalloc(n );
2700 0 : if ( ! buf )
2701 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2702 :
2703 0 : for ( i = 0; i < _yybytes_len; ++i )
2704 0 : buf[i] = yybytes[i];
2705 :
2706 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2707 :
2708 0 : b = yy_scan_buffer(buf,n );
2709 0 : if ( ! b )
2710 0 : YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2711 :
2712 : /* It's okay to grow etc. this buffer, and we should throw it
2713 : * away when we're done.
2714 : */
2715 0 : b->yy_is_our_buffer = 1;
2716 :
2717 0 : return b;
2718 : }
2719 :
2720 : #ifndef YY_EXIT_FAILURE
2721 : #define YY_EXIT_FAILURE 2
2722 : #endif
2723 :
2724 0 : static void yy_fatal_error (yyconst char* msg )
2725 : {
2726 0 : (void) fprintf( stderr, "%s\n", msg );
2727 0 : exit( YY_EXIT_FAILURE );
2728 : }
2729 :
2730 : /* Redefine yyless() so it works in section 3 code. */
2731 :
2732 : #undef yyless
2733 : #define yyless(n) \
2734 : do \
2735 : { \
2736 : /* Undo effects of setting up yytext. */ \
2737 : int yyless_macro_arg = (n); \
2738 : YY_LESS_LINENO(yyless_macro_arg);\
2739 : yytext[yyleng] = (yy_hold_char); \
2740 : (yy_c_buf_p) = yytext + yyless_macro_arg; \
2741 : (yy_hold_char) = *(yy_c_buf_p); \
2742 : *(yy_c_buf_p) = '\0'; \
2743 : yyleng = yyless_macro_arg; \
2744 : } \
2745 : while ( 0 )
2746 :
2747 : /* Accessor methods (get/set functions) to struct members. */
2748 :
2749 : /** Get the current line number.
2750 : *
2751 : */
2752 0 : int yyget_lineno (void)
2753 : {
2754 :
2755 0 : return yylineno;
2756 : }
2757 :
2758 : /** Get the input stream.
2759 : *
2760 : */
2761 0 : FILE *yyget_in (void)
2762 : {
2763 0 : return yyin;
2764 : }
2765 :
2766 : /** Get the output stream.
2767 : *
2768 : */
2769 0 : FILE *yyget_out (void)
2770 : {
2771 0 : return yyout;
2772 : }
2773 :
2774 : /** Get the length of the current token.
2775 : *
2776 : */
2777 0 : yy_size_t yyget_leng (void)
2778 : {
2779 0 : return yyleng;
2780 : }
2781 :
2782 : /** Get the current token.
2783 : *
2784 : */
2785 :
2786 0 : char *yyget_text (void)
2787 : {
2788 0 : return yytext;
2789 : }
2790 :
2791 : /** Set the current line number.
2792 : * @param line_number
2793 : *
2794 : */
2795 0 : void yyset_lineno (int line_number )
2796 : {
2797 :
2798 0 : yylineno = line_number;
2799 0 : }
2800 :
2801 : /** Set the input stream. This does not discard the current
2802 : * input buffer.
2803 : * @param in_str A readable stream.
2804 : *
2805 : * @see yy_switch_to_buffer
2806 : */
2807 0 : void yyset_in (FILE * in_str )
2808 : {
2809 0 : yyin = in_str ;
2810 0 : }
2811 :
2812 0 : void yyset_out (FILE * out_str )
2813 : {
2814 0 : yyout = out_str ;
2815 0 : }
2816 :
2817 0 : int yyget_debug (void)
2818 : {
2819 0 : return yy_flex_debug;
2820 : }
2821 :
2822 0 : void yyset_debug (int bdebug )
2823 : {
2824 0 : yy_flex_debug = bdebug ;
2825 0 : }
2826 :
2827 0 : static int yy_init_globals (void)
2828 : {
2829 : /* Initialization is the same as for the non-reentrant scanner.
2830 : * This function is called from yylex_destroy(), so don't allocate here.
2831 : */
2832 :
2833 : /* We do not touch yylineno unless the option is enabled. */
2834 0 : yylineno = 1;
2835 :
2836 0 : (yy_buffer_stack) = 0;
2837 0 : (yy_buffer_stack_top) = 0;
2838 0 : (yy_buffer_stack_max) = 0;
2839 0 : (yy_c_buf_p) = (char *) 0;
2840 0 : (yy_init) = 0;
2841 0 : (yy_start) = 0;
2842 :
2843 0 : (yy_state_buf) = 0;
2844 0 : (yy_state_ptr) = 0;
2845 0 : (yy_full_match) = 0;
2846 0 : (yy_lp) = 0;
2847 :
2848 : /* Defined in main.c */
2849 : #ifdef YY_STDINIT
2850 : yyin = stdin;
2851 : yyout = stdout;
2852 : #else
2853 0 : yyin = (FILE *) 0;
2854 0 : yyout = (FILE *) 0;
2855 : #endif
2856 :
2857 : /* For future reference: Set errno on error, since we are called by
2858 : * yylex_init()
2859 : */
2860 0 : return 0;
2861 : }
2862 :
2863 : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2864 0 : int yylex_destroy (void)
2865 : {
2866 :
2867 : /* Pop the buffer stack, destroying each element. */
2868 0 : while(YY_CURRENT_BUFFER){
2869 0 : yy_delete_buffer(YY_CURRENT_BUFFER );
2870 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2871 0 : yypop_buffer_state();
2872 : }
2873 :
2874 : /* Destroy the stack itself. */
2875 0 : yyfree((yy_buffer_stack) );
2876 0 : (yy_buffer_stack) = NULL;
2877 :
2878 0 : yyfree ( (yy_state_buf) );
2879 0 : (yy_state_buf) = NULL;
2880 :
2881 : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2882 : * yylex() is called, initialization will occur. */
2883 0 : yy_init_globals( );
2884 :
2885 0 : return 0;
2886 : }
2887 :
2888 : /*
2889 : * Internal utility routines.
2890 : */
2891 :
2892 : #ifndef yytext_ptr
2893 : static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2894 : {
2895 : register int i;
2896 : for ( i = 0; i < n; ++i )
2897 : s1[i] = s2[i];
2898 : }
2899 : #endif
2900 :
2901 : #ifdef YY_NEED_STRLEN
2902 : static int yy_flex_strlen (yyconst char * s )
2903 : {
2904 : register int n;
2905 : for ( n = 0; s[n]; ++n )
2906 : ;
2907 :
2908 : return n;
2909 : }
2910 : #endif
2911 :
2912 52 : void *yyalloc (yy_size_t size )
2913 : {
2914 52 : return (void *) malloc( size );
2915 : }
2916 :
2917 0 : void *yyrealloc (void * ptr, yy_size_t size )
2918 : {
2919 : /* The cast to (char *) in the following accommodates both
2920 : * implementations that use char* generic pointers, and those
2921 : * that use void* generic pointers. It works with the latter
2922 : * because both ANSI C and C++ allow castless assignment from
2923 : * any pointer type to void*, and deal with argument conversions
2924 : * as though doing an assignment.
2925 : */
2926 0 : return (void *) realloc( (char *) ptr, size );
2927 : }
2928 :
2929 0 : void yyfree (void * ptr )
2930 : {
2931 0 : free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2932 0 : }
2933 :
2934 : #define YYTABLES_NAME "yytables"
2935 :
2936 : #line 236 "/usr/local/src/libreoffice/l10ntools/source/srclex.l"
2937 :
2938 :
2939 :
2940 : /*****************************************************************************/
2941 : int yywrap(void)
2942 : /*****************************************************************************/
2943 : {
2944 : return 1;
2945 : }
2946 :
2947 : /*****************************************************************************/
2948 : void YYWarning( const char *s )
2949 : /*****************************************************************************/
2950 : {
2951 : /* write warning to stderr */
2952 : fprintf( stderr, "Warning: \"%s\" in line %d: \"%s\"\n", s, yylineno, yytext );
2953 : }
2954 :
2955 : /*****************************************************************************/
2956 : void yyerror( const char *s )
2957 : /*****************************************************************************/
2958 : {
2959 : /* write error to stderr */
2960 : fprintf( stderr, "Error: \"%s\" in line %d: \"%s\"\n", s, yylineno, yytext );
2961 : SetError();
2962 : }
2963 :
2964 : SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv) {
2965 : int e;
2966 : yyin = init(argc, argv);
2967 : yylex();
2968 : e = GetError();
2969 : Close();
2970 : return EXIT_SUCCESS;
2971 : }
2972 :
|
