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