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