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