?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CMake Nightly Date Stamp
[kiteware-cmake.git] / Source / LexerParser / cmCTestResourceGroupsLexer.cxx
blobf1d351a574d3f86e1740440f45a011e3c7bc538f
1 #include "cmStandardLexer.h"
2
3 #define FLEXINT_H 1
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 6
11 #define YY_FLEX_SUBMINOR_VERSION 4
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 #ifdef yy_create_buffer
17 #define cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED
18 #else
19 #define yy_create_buffer cmCTestResourceGroups_yy_create_buffer
20 #endif
21
22 #ifdef yy_delete_buffer
23 #define cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED
24 #else
25 #define yy_delete_buffer cmCTestResourceGroups_yy_delete_buffer
26 #endif
27
28 #ifdef yy_scan_buffer
29 #define cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED
30 #else
31 #define yy_scan_buffer cmCTestResourceGroups_yy_scan_buffer
32 #endif
33
34 #ifdef yy_scan_string
35 #define cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED
36 #else
37 #define yy_scan_string cmCTestResourceGroups_yy_scan_string
38 #endif
39
40 #ifdef yy_scan_bytes
41 #define cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED
42 #else
43 #define yy_scan_bytes cmCTestResourceGroups_yy_scan_bytes
44 #endif
45
46 #ifdef yy_init_buffer
47 #define cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED
48 #else
49 #define yy_init_buffer cmCTestResourceGroups_yy_init_buffer
50 #endif
51
52 #ifdef yy_flush_buffer
53 #define cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED
54 #else
55 #define yy_flush_buffer cmCTestResourceGroups_yy_flush_buffer
56 #endif
57
58 #ifdef yy_load_buffer_state
59 #define cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED
60 #else
61 #define yy_load_buffer_state cmCTestResourceGroups_yy_load_buffer_state
62 #endif
63
64 #ifdef yy_switch_to_buffer
65 #define cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED
66 #else
67 #define yy_switch_to_buffer cmCTestResourceGroups_yy_switch_to_buffer
68 #endif
69
70 #ifdef yypush_buffer_state
71 #define cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED
72 #else
73 #define yypush_buffer_state cmCTestResourceGroups_yypush_buffer_state
74 #endif
75
76 #ifdef yypop_buffer_state
77 #define cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED
78 #else
79 #define yypop_buffer_state cmCTestResourceGroups_yypop_buffer_state
80 #endif
81
82 #ifdef yyensure_buffer_stack
83 #define cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED
84 #else
85 #define yyensure_buffer_stack cmCTestResourceGroups_yyensure_buffer_stack
86 #endif
87
88 #ifdef yylex
89 #define cmCTestResourceGroups_yylex_ALREADY_DEFINED
90 #else
91 #define yylex cmCTestResourceGroups_yylex
92 #endif
93
94 #ifdef yyrestart
95 #define cmCTestResourceGroups_yyrestart_ALREADY_DEFINED
96 #else
97 #define yyrestart cmCTestResourceGroups_yyrestart
98 #endif
99
100 #ifdef yylex_init
101 #define cmCTestResourceGroups_yylex_init_ALREADY_DEFINED
102 #else
103 #define yylex_init cmCTestResourceGroups_yylex_init
104 #endif
105
106 #ifdef yylex_init_extra
107 #define cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED
108 #else
109 #define yylex_init_extra cmCTestResourceGroups_yylex_init_extra
110 #endif
111
112 #ifdef yylex_destroy
113 #define cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED
114 #else
115 #define yylex_destroy cmCTestResourceGroups_yylex_destroy
116 #endif
117
118 #ifdef yyget_debug
119 #define cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED
120 #else
121 #define yyget_debug cmCTestResourceGroups_yyget_debug
122 #endif
123
124 #ifdef yyset_debug
125 #define cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED
126 #else
127 #define yyset_debug cmCTestResourceGroups_yyset_debug
128 #endif
129
130 #ifdef yyget_extra
131 #define cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED
132 #else
133 #define yyget_extra cmCTestResourceGroups_yyget_extra
134 #endif
135
136 #ifdef yyset_extra
137 #define cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED
138 #else
139 #define yyset_extra cmCTestResourceGroups_yyset_extra
140 #endif
141
142 #ifdef yyget_in
143 #define cmCTestResourceGroups_yyget_in_ALREADY_DEFINED
144 #else
145 #define yyget_in cmCTestResourceGroups_yyget_in
146 #endif
147
148 #ifdef yyset_in
149 #define cmCTestResourceGroups_yyset_in_ALREADY_DEFINED
150 #else
151 #define yyset_in cmCTestResourceGroups_yyset_in
152 #endif
153
154 #ifdef yyget_out
155 #define cmCTestResourceGroups_yyget_out_ALREADY_DEFINED
156 #else
157 #define yyget_out cmCTestResourceGroups_yyget_out
158 #endif
159
160 #ifdef yyset_out
161 #define cmCTestResourceGroups_yyset_out_ALREADY_DEFINED
162 #else
163 #define yyset_out cmCTestResourceGroups_yyset_out
164 #endif
165
166 #ifdef yyget_leng
167 #define cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED
168 #else
169 #define yyget_leng cmCTestResourceGroups_yyget_leng
170 #endif
171
172 #ifdef yyget_text
173 #define cmCTestResourceGroups_yyget_text_ALREADY_DEFINED
174 #else
175 #define yyget_text cmCTestResourceGroups_yyget_text
176 #endif
177
178 #ifdef yyget_lineno
179 #define cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED
180 #else
181 #define yyget_lineno cmCTestResourceGroups_yyget_lineno
182 #endif
183
184 #ifdef yyset_lineno
185 #define cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED
186 #else
187 #define yyset_lineno cmCTestResourceGroups_yyset_lineno
188 #endif
189
190 #ifdef yyget_column
191 #define cmCTestResourceGroups_yyget_column_ALREADY_DEFINED
192 #else
193 #define yyget_column cmCTestResourceGroups_yyget_column
194 #endif
195
196 #ifdef yyset_column
197 #define cmCTestResourceGroups_yyset_column_ALREADY_DEFINED
198 #else
199 #define yyset_column cmCTestResourceGroups_yyset_column
200 #endif
201
202 #ifdef yywrap
203 #define cmCTestResourceGroups_yywrap_ALREADY_DEFINED
204 #else
205 #define yywrap cmCTestResourceGroups_yywrap
206 #endif
207
208 #ifdef yyalloc
209 #define cmCTestResourceGroups_yyalloc_ALREADY_DEFINED
210 #else
211 #define yyalloc cmCTestResourceGroups_yyalloc
212 #endif
213
214 #ifdef yyrealloc
215 #define cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED
216 #else
217 #define yyrealloc cmCTestResourceGroups_yyrealloc
218 #endif
219
220 #ifdef yyfree
221 #define cmCTestResourceGroups_yyfree_ALREADY_DEFINED
222 #else
223 #define yyfree cmCTestResourceGroups_yyfree
224 #endif
225
226 /* First, we deal with platform-specific or compiler-specific issues. */
227
228 /* begin standard C headers. */
229 #include <stdio.h>
230 #include <string.h>
231 #include <errno.h>
232 #include <stdlib.h>
233
234 /* end standard C headers. */
235
236 /* flex integer type definitions */
237
238 #ifndef FLEXINT_H
239 #define FLEXINT_H
240
241 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
242
243 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
244
245 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
246 * if you want the limit (max/min) macros for int types.
247 */
248 #ifndef __STDC_LIMIT_MACROS
249 #define __STDC_LIMIT_MACROS 1
250 #endif
251
252 #include <inttypes.h>
253 typedef int8_t flex_int8_t;
254 typedef uint8_t flex_uint8_t;
255 typedef int16_t flex_int16_t;
256 typedef uint16_t flex_uint16_t;
257 typedef int32_t flex_int32_t;
258 typedef uint32_t flex_uint32_t;
259 #else
260 typedef signed char flex_int8_t;
261 typedef short int flex_int16_t;
262 typedef int flex_int32_t;
263 typedef unsigned char flex_uint8_t;
264 typedef unsigned short int flex_uint16_t;
265 typedef unsigned int flex_uint32_t;
266
267 /* Limits of integral types. */
268 #ifndef INT8_MIN
269 #define INT8_MIN (-128)
270 #endif
271 #ifndef INT16_MIN
272 #define INT16_MIN (-32767-1)
273 #endif
274 #ifndef INT32_MIN
275 #define INT32_MIN (-2147483647-1)
276 #endif
277 #ifndef INT8_MAX
278 #define INT8_MAX (127)
279 #endif
280 #ifndef INT16_MAX
281 #define INT16_MAX (32767)
282 #endif
283 #ifndef INT32_MAX
284 #define INT32_MAX (2147483647)
285 #endif
286 #ifndef UINT8_MAX
287 #define UINT8_MAX (255U)
288 #endif
289 #ifndef UINT16_MAX
290 #define UINT16_MAX (65535U)
291 #endif
292 #ifndef UINT32_MAX
293 #define UINT32_MAX (4294967295U)
294 #endif
295
296 #ifndef SIZE_MAX
297 #define SIZE_MAX (~(size_t)0)
298 #endif
299
300 #endif /* ! C99 */
301
302 #endif /* ! FLEXINT_H */
303
304 /* begin standard C++ headers. */
305
306 /* TODO: this is always defined, so inline it */
307 #define yyconst const
308
309 #if defined(__GNUC__) && __GNUC__ >= 3
310 #define yynoreturn __attribute__((__noreturn__))
311 #else
312 #define yynoreturn
313 #endif
314
315 /* Returned upon end-of-file. */
316 #define YY_NULL 0
317
318 /* Promotes a possibly negative, possibly signed char to an
319 * integer in range [0..255] for use as an array index.
320 */
321 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
322
323 /* An opaque pointer. */
324 #ifndef YY_TYPEDEF_YY_SCANNER_T
325 #define YY_TYPEDEF_YY_SCANNER_T
326 typedef void* yyscan_t;
327 #endif
328
329 /* For convenience, these vars (plus the bison vars far below)
330 are macros in the reentrant scanner. */
331 #define yyin yyg->yyin_r
332 #define yyout yyg->yyout_r
333 #define yyextra yyg->yyextra_r
334 #define yyleng yyg->yyleng_r
335 #define yytext yyg->yytext_r
336 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
337 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
338 #define yy_flex_debug yyg->yy_flex_debug_r
339
340 /* Enter a start condition. This macro really ought to take a parameter,
341 * but we do it the disgusting crufty way forced on us by the ()-less
342 * definition of BEGIN.
343 */
344 #define BEGIN yyg->yy_start = 1 + 2 *
345 /* Translate the current start state into a value that can be later handed
346 * to BEGIN to return to the state. The YYSTATE alias is for lex
347 * compatibility.
348 */
349 #define YY_START ((yyg->yy_start - 1) / 2)
350 #define YYSTATE YY_START
351 /* Action number for EOF rule of a given start state. */
352 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
353 /* Special action meaning "start processing a new file". */
354 #define YY_NEW_FILE yyrestart( yyin , yyscanner )
355 #define YY_END_OF_BUFFER_CHAR 0
356
357 /* Size of default input buffer. */
358 #ifndef YY_BUF_SIZE
359 #ifdef __ia64__
360 /* On IA-64, the buffer size is 16k, not 8k.
361 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
362 * Ditto for the __ia64__ case accordingly.
363 */
364 #define YY_BUF_SIZE 32768
365 #else
366 #define YY_BUF_SIZE 16384
367 #endif /* __ia64__ */
368 #endif
369
370 /* The state buf must be large enough to hold one state per character in the main buffer.
371 */
372 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
373
374 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
375 #define YY_TYPEDEF_YY_BUFFER_STATE
376 typedef struct yy_buffer_state *YY_BUFFER_STATE;
377 #endif
378
379 #ifndef YY_TYPEDEF_YY_SIZE_T
380 #define YY_TYPEDEF_YY_SIZE_T
381 typedef size_t yy_size_t;
382 #endif
383
384 #define EOB_ACT_CONTINUE_SCAN 0
385 #define EOB_ACT_END_OF_FILE 1
386 #define EOB_ACT_LAST_MATCH 2
387
388 #define YY_LESS_LINENO(n)
389 #define YY_LINENO_REWIND_TO(ptr)
390
391 /* Return all but the first "n" matched characters back to the input stream. */
392 #define yyless(n) \
393 do \
394 { \
395 /* Undo effects of setting up yytext. */ \
396 int yyless_macro_arg = (n); \
397 YY_LESS_LINENO(yyless_macro_arg);\
398 *yy_cp = yyg->yy_hold_char; \
399 YY_RESTORE_YY_MORE_OFFSET \
400 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
401 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
402 } \
403 while ( 0 )
404 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
405
406 #ifndef YY_STRUCT_YY_BUFFER_STATE
407 #define YY_STRUCT_YY_BUFFER_STATE
408 struct yy_buffer_state
409 {
410 FILE *yy_input_file;
411
412 char *yy_ch_buf; /* input buffer */
413 char *yy_buf_pos; /* current position in input buffer */
414
415 /* Size of input buffer in bytes, not including room for EOB
416 * characters.
417 */
418 int yy_buf_size;
419
420 /* Number of characters read into yy_ch_buf, not including EOB
421 * characters.
422 */
423 int yy_n_chars;
424
425 /* Whether we "own" the buffer - i.e., we know we created it,
426 * and can realloc() it to grow it, and should free() it to
427 * delete it.
428 */
429 int yy_is_our_buffer;
430
431 /* Whether this is an "interactive" input source; if so, and
432 * if we're using stdio for input, then we want to use getc()
433 * instead of fread(), to make sure we stop fetching input after
434 * each newline.
435 */
436 int yy_is_interactive;
437
438 /* Whether we're considered to be at the beginning of a line.
439 * If so, '^' rules will be active on the next match, otherwise
440 * not.
441 */
442 int yy_at_bol;
443
444 int yy_bs_lineno; /**< The line count. */
445 int yy_bs_column; /**< The column count. */
446
447 /* Whether to try to fill the input buffer when we reach the
448 * end of it.
449 */
450 int yy_fill_buffer;
451
452 int yy_buffer_status;
453
454 #define YY_BUFFER_NEW 0
455 #define YY_BUFFER_NORMAL 1
456 /* When an EOF's been seen but there's still some text to process
457 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
458 * shouldn't try reading from the input source any more. We might
459 * still have a bunch of tokens to match, though, because of
460 * possible backing-up.
461 *
462 * When we actually see the EOF, we change the status to "new"
463 * (via yyrestart()), so that the user can continue scanning by
464 * just pointing yyin at a new input file.
465 */
466 #define YY_BUFFER_EOF_PENDING 2
467
468 };
469 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
470
471 /* We provide macros for accessing buffer states in case in the
472 * future we want to put the buffer states in a more general
473 * "scanner state".
474 *
475 * Returns the top of the stack, or NULL.
476 */
477 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
478 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
479 : NULL)
480 /* Same as previous macro, but useful when we know that the buffer stack is not
481 * NULL or when we need an lvalue. For internal use only.
482 */
483 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
484
485 void yyrestart ( FILE *input_file , yyscan_t yyscanner );
486 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
487 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
488 void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
489 void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
490 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
491 void yypop_buffer_state ( yyscan_t yyscanner );
492
493 static void yyensure_buffer_stack ( yyscan_t yyscanner );
494 static void yy_load_buffer_state ( yyscan_t yyscanner );
495 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
496 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
497
498 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
499 YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
500 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
501
502 void *yyalloc ( yy_size_t , yyscan_t yyscanner );
503 void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
504 void yyfree ( void * , yyscan_t yyscanner );
505
506 #define yy_new_buffer yy_create_buffer
507 #define yy_set_interactive(is_interactive) \
508 { \
509 if ( ! YY_CURRENT_BUFFER ){ \
510 yyensure_buffer_stack (yyscanner); \
511 YY_CURRENT_BUFFER_LVALUE = \
512 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
513 } \
514 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
515 }
516 #define yy_set_bol(at_bol) \
517 { \
518 if ( ! YY_CURRENT_BUFFER ){\
519 yyensure_buffer_stack (yyscanner); \
520 YY_CURRENT_BUFFER_LVALUE = \
521 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
522 } \
523 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
524 }
525 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
526
527 /* Begin user sect3 */
528
529 #define cmCTestResourceGroups_yywrap(yyscanner) (/*CONSTCOND*/1)
530 #define YY_SKIP_YYWRAP
531 typedef flex_uint8_t YY_CHAR;
532
533 typedef int yy_state_type;
534
535 #define yytext_ptr yytext_r
536
537 static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
538 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
539 static int yy_get_next_buffer ( yyscan_t yyscanner );
540 static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
541
542 /* Done after the current pattern has been matched and before the
543 * corresponding action - sets up yytext.
544 */
545 #define YY_DO_BEFORE_ACTION \
546 yyg->yytext_ptr = yy_bp; \
547 yyleng = (int) (yy_cp - yy_bp); \
548 yyg->yy_hold_char = *yy_cp; \
549 *yy_cp = '\0'; \
550 yyg->yy_c_buf_p = yy_cp;
551 #define YY_NUM_RULES 8
552 #define YY_END_OF_BUFFER 9
553 /* This struct is not used in this scanner,
554 but its presence is necessary. */
555 struct yy_trans_info
556 {
557 flex_int32_t yy_verify;
558 flex_int32_t yy_nxt;
559 };
560 static const flex_int16_t yy_accept[29] =
561 { 0,
562 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
563 0, 0, 9, 7, 2, 5, 7, 4, 6, 3,
564 2, 5, 0, 1, 4, 6, 3, 0
565 } ;
566
567 static const YY_CHAR yy_ec[256] =
568 { 0,
569 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
570 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
571 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
572 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
573 1, 1, 1, 3, 1, 1, 1, 4, 4, 4,
574 4, 4, 4, 4, 4, 4, 4, 5, 6, 1,
575 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
576 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
577 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
578 1, 1, 1, 1, 7, 1, 7, 7, 7, 7,
579
580 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
581 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
582 7, 7, 1, 1, 1, 1, 1, 1, 1, 1,
583 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
584 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
585 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
586 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
587 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
588 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
589 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
590
591 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
592 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
593 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
594 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
595 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
596 1, 1, 1, 1, 1
597 } ;
598
599 static const YY_CHAR yy_meta[8] =
600 { 0,
601 1, 1, 1, 2, 2, 1, 2
602 } ;
603
604 static const flex_int16_t yy_base[30] =
605 { 0,
606 0, 0, 0, 0, 7, 0, 31, 12, 17, 0,
607 0, 0, 34, 36, 29, 26, 26, 27, 23, 24,
608 23, 20, 20, 36, 21, 16, 13, 36, 14
609 } ;
610
611 static const flex_int16_t yy_def[30] =
612 { 0,
613 28, 1, 1, 1, 28, 5, 1, 5, 5, 9,
614 5, 5, 28, 28, 28, 28, 29, 28, 28, 28,
615 28, 28, 29, 28, 28, 28, 28, 0, 28
616 } ;
617
618 static const flex_int16_t yy_nxt[44] =
619 { 0,
620 14, 14, 14, 15, 14, 16, 17, 14, 14, 18,
621 14, 14, 19, 14, 14, 23, 27, 16, 17, 14,
622 20, 26, 14, 25, 24, 22, 21, 27, 26, 25,
623 24, 22, 21, 28, 14, 13, 28, 28, 28, 28,
624 28, 28, 28
625 } ;
626
627 static const flex_int16_t yy_chk[44] =
628 { 0,
629 1, 1, 1, 1, 1, 1, 1, 5, 5, 5,
630 5, 5, 5, 5, 8, 29, 27, 8, 8, 9,
631 9, 26, 9, 25, 23, 22, 21, 20, 19, 18,
632 17, 16, 15, 13, 7, 28, 28, 28, 28, 28,
633 28, 28, 28
634 } ;
635
636 /* The intent behind this definition is that it'll catch
637 * any uses of REJECT which flex missed.
638 */
639 #define REJECT reject_used_but_not_detected
640 #define yymore() yymore_used_but_not_detected
641 #define YY_MORE_ADJ 0
642 #define YY_RESTORE_YY_MORE_OFFSET
643 /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
644 file Copyright.txt or https://cmake.org/licensing for details. */
645 /*
646
647 This file must be translated to C++ and modified to build everywhere.
648
649 Run flex >= 2.6 like this:
650
651 flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestResourceGroupsLexer.h -ocmCTestResourceGroupsLexer.cxx cmCTestResourceGroupsLexer.in.l
652
653 Modify cmCTestResourceGroupsLexer.cxx:
654 - remove trailing whitespace: sed -i 's/\s*$//' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx
655 - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx
656 - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestResourceGroupsLexer.cxx
657
658 */
659
660 /* IWYU pragma: no_forward_declare yyguts_t */
661
662 #ifndef __clang_analyzer__ /* Suppress clang-analyzer warnings */
663
664 #include "cmCTestResourceGroupsLexerHelper.h"
665
666 #include <string>
667
668 #include <cstddef>
669
670 #ifndef _WIN32
671 # include <termios.h>
672 #endif
673
674 /*--------------------------------------------------------------------------*/
675
676 #define INITIAL 0
677 #define RESOURCE_GROUPS_START 1
678 #define RESOURCE_GROUPS_END 2
679 #define RESOURCE_START 3
680 #define RESOURCE_COUNT 4
681 #define RESOURCE_END 5
682
683 #ifndef YY_EXTRA_TYPE
684 #define YY_EXTRA_TYPE void *
685 #endif
686
687 /* Holds the entire state of the reentrant scanner. */
688 struct yyguts_t
689 {
690
691 /* User-defined. Not touched by flex. */
692 YY_EXTRA_TYPE yyextra_r;
693
694 /* The rest are the same as the globals declared in the non-reentrant scanner. */
695 FILE *yyin_r, *yyout_r;
696 size_t yy_buffer_stack_top; /**< index of top of stack. */
697 size_t yy_buffer_stack_max; /**< capacity of stack. */
698 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
699 char yy_hold_char;
700 int yy_n_chars;
701 int yyleng_r;
702 char *yy_c_buf_p;
703 int yy_init;
704 int yy_start;
705 int yy_did_buffer_switch_on_eof;
706 int yy_start_stack_ptr;
707 int yy_start_stack_depth;
708 int *yy_start_stack;
709 yy_state_type yy_last_accepting_state;
710 char* yy_last_accepting_cpos;
711
712 int yylineno_r;
713 int yy_flex_debug_r;
714
715 char *yytext_r;
716 int yy_more_flag;
717 int yy_more_len;
718
719 }; /* end struct yyguts_t */
720
721 static int yy_init_globals ( yyscan_t yyscanner );
722
723 int yylex_init (yyscan_t* scanner);
724
725 int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
726
727 /* Accessor methods to globals.
728 These are made visible to non-reentrant scanners for convenience. */
729
730 int yylex_destroy ( yyscan_t yyscanner );
731
732 int yyget_debug ( yyscan_t yyscanner );
733
734 void yyset_debug ( int debug_flag , yyscan_t yyscanner );
735
736 YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
737
738 void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
739
740 FILE *yyget_in ( yyscan_t yyscanner );
741
742 void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
743
744 FILE *yyget_out ( yyscan_t yyscanner );
745
746 void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
747
748 int yyget_leng ( yyscan_t yyscanner );
749
750 char *yyget_text ( yyscan_t yyscanner );
751
752 int yyget_lineno ( yyscan_t yyscanner );
753
754 void yyset_lineno ( int _line_number , yyscan_t yyscanner );
755
756 int yyget_column ( yyscan_t yyscanner );
757
758 void yyset_column ( int _column_no , yyscan_t yyscanner );
759
760 /* Macros after this point can all be overridden by user definitions in
761 * section 1.
762 */
763
764 #ifndef YY_SKIP_YYWRAP
765 #ifdef __cplusplus
766 extern "C" int yywrap ( yyscan_t yyscanner );
767 #else
768 extern int yywrap ( yyscan_t yyscanner );
769 #endif
770 #endif
771
772 #ifndef YY_NO_UNPUT
773
774 static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner);
775
776 #endif
777
778 #ifndef yytext_ptr
779 static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
780 #endif
781
782 #ifdef YY_NEED_STRLEN
783 static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
784 #endif
785
786 #ifndef YY_NO_INPUT
787 #ifdef __cplusplus
788 static int yyinput ( yyscan_t yyscanner );
789 #else
790 static int input ( yyscan_t yyscanner );
791 #endif
792
793 #endif
794
795 /* Amount of stuff to slurp up with each read. */
796 #ifndef YY_READ_BUF_SIZE
797 #ifdef __ia64__
798 /* On IA-64, the buffer size is 16k, not 8k */
799 #define YY_READ_BUF_SIZE 16384
800 #else
801 #define YY_READ_BUF_SIZE 8192
802 #endif /* __ia64__ */
803 #endif
804
805 /* Copy whatever the last rule matched to the standard output. */
806 #ifndef ECHO
807 /* This used to be an fputs(), but since the string might contain NUL's,
808 * we now use fwrite().
809 */
810 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
811 #endif
812
813 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
814 * is returned in "result".
815 */
816 #ifndef YY_INPUT
817 #define YY_INPUT(buf,result,max_size) \
818 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
819 { \
820 int c = '*'; \
821 int n; \
822 for ( n = 0; n < max_size && \
823 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
824 buf[n] = (char) c; \
825 if ( c == '\n' ) \
826 buf[n++] = (char) c; \
827 if ( c == EOF && ferror( yyin ) ) \
828 YY_FATAL_ERROR( "input in flex scanner failed" ); \
829 result = n; \
830 } \
831 else \
832 { \
833 errno=0; \
834 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
835 { \
836 if( errno != EINTR) \
837 { \
838 YY_FATAL_ERROR( "input in flex scanner failed" ); \
839 break; \
840 } \
841 errno=0; \
842 clearerr(yyin); \
843 } \
844 }\
845 \
846
847 #endif
848
849 /* No semi-colon after return; correct usage is to write "yyterminate();" -
850 * we don't want an extra ';' after the "return" because that will cause
851 * some compilers to complain about unreachable statements.
852 */
853 #ifndef yyterminate
854 #define yyterminate() return YY_NULL
855 #endif
856
857 /* Number of entries by which start-condition stack grows. */
858 #ifndef YY_START_STACK_INCR
859 #define YY_START_STACK_INCR 25
860 #endif
861
862 /* Report a fatal error. */
863 #ifndef YY_FATAL_ERROR
864 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
865 #endif
866
867 /* end tables serialization structures and prototypes */
868
869 /* Default declaration of generated scanner - a define so the user can
870 * easily add parameters.
871 */
872 #ifndef YY_DECL
873 #define YY_DECL_IS_OURS 1
874
875 extern int yylex (yyscan_t yyscanner);
876
877 #define YY_DECL int yylex (yyscan_t yyscanner)
878 #endif /* !YY_DECL */
879
880 /* Code executed at the beginning of each rule, after yytext and yyleng
881 * have been set up.
882 */
883 #ifndef YY_USER_ACTION
884 #define YY_USER_ACTION
885 #endif
886
887 /* Code executed at the end of each rule. */
888 #ifndef YY_BREAK
889 #define YY_BREAK /*LINTED*/break;
890 #endif
891
892 #define YY_RULE_SETUP \
893 YY_USER_ACTION
894
895 /** The main scanner function which does all the work.
896 */
897 YY_DECL
898 {
899 yy_state_type yy_current_state;
900 char *yy_cp, *yy_bp;
901 int yy_act;
902 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
903
904 if ( !yyg->yy_init )
905 {
906 yyg->yy_init = 1;
907
908 #ifdef YY_USER_INIT
909 YY_USER_INIT;
910 #endif
911
912 if ( ! yyg->yy_start )
913 yyg->yy_start = 1; /* first start state */
914
915 if ( ! yyin )
916 yyin = stdin;
917
918 if ( ! yyout )
919 yyout = stdout;
920
921 if ( ! YY_CURRENT_BUFFER ) {
922 yyensure_buffer_stack (yyscanner);
923 YY_CURRENT_BUFFER_LVALUE =
924 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
925 }
926
927 yy_load_buffer_state( yyscanner );
928 }
929
930 {
931
932 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
933 {
934 yy_cp = yyg->yy_c_buf_p;
935
936 /* Support of yytext. */
937 *yy_cp = yyg->yy_hold_char;
938
939 /* yy_bp points to the position in yy_ch_buf of the start of
940 * the current run.
941 */
942 yy_bp = yy_cp;
943
944 yy_current_state = yyg->yy_start;
945 yy_match:
946 do
947 {
948 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
949 if ( yy_accept[yy_current_state] )
950 {
951 yyg->yy_last_accepting_state = yy_current_state;
952 yyg->yy_last_accepting_cpos = yy_cp;
953 }
954 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
955 {
956 yy_current_state = (int) yy_def[yy_current_state];
957 if ( yy_current_state >= 29 )
958 yy_c = yy_meta[yy_c];
959 }
960 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
961 ++yy_cp;
962 }
963 while ( yy_base[yy_current_state] != 36 );
964
965 yy_find_action:
966 yy_act = yy_accept[yy_current_state];
967 if ( yy_act == 0 )
968 { /* have to back up */
969 yy_cp = yyg->yy_last_accepting_cpos;
970 yy_current_state = yyg->yy_last_accepting_state;
971 yy_act = yy_accept[yy_current_state];
972 }
973
974 YY_DO_BEFORE_ACTION;
975
976 do_action: /* This label is used only to access EOF actions. */
977
978 switch ( yy_act )
979 { /* beginning of action switch */
980 case 0: /* must back up */
981 /* undo the effects of YY_DO_BEFORE_ACTION */
982 *yy_cp = yyg->yy_hold_char;
983 yy_cp = yyg->yy_last_accepting_cpos;
984 yy_current_state = yyg->yy_last_accepting_state;
985 goto yy_find_action;
986
987 case 1:
988 YY_RULE_SETUP
989 {
990 BEGIN(RESOURCE_COUNT);
991 yyextra->SetResourceType(std::string(yytext, yyleng - 1));
992 }
993 YY_BREAK
994 case 2:
995 YY_RULE_SETUP
996 {
997 BEGIN(RESOURCE_GROUPS_END);
998 std::size_t len = yyleng;
999 yyextra->SetProcessCount(std::stoll(yytext, &len, 10));
1000 }
1001 YY_BREAK
1002 case 3:
1003 YY_RULE_SETUP
1004 {
1005 BEGIN(RESOURCE_END);
1006 std::size_t len = yyleng;
1007 yyextra->SetNeededSlots(std::stoll(yytext, &len, 10));
1008 yyextra->WriteRequirement();
1009 }
1010 YY_BREAK
1011 case 4:
1012 YY_RULE_SETUP
1013 {
1014 BEGIN(RESOURCE_START);
1015 }
1016 YY_BREAK
1017 case 5:
1018 YY_RULE_SETUP
1019 {
1020 BEGIN(RESOURCE_GROUPS_START);
1021 }
1022 YY_BREAK
1023 case 6:
1024 YY_RULE_SETUP
1025 {
1026 BEGIN(RESOURCE_GROUPS_START);
1027 yyextra->WriteProcess();
1028 }
1029 YY_BREAK
1030 case YY_STATE_EOF(RESOURCE_START):
1031 case YY_STATE_EOF(RESOURCE_GROUPS_END):
1032 case YY_STATE_EOF(RESOURCE_END):
1033 {
1034 yyextra->WriteProcess();
1035 return 0;
1036 }
1037 YY_BREAK
1038 case YY_STATE_EOF(INITIAL):
1039 case YY_STATE_EOF(RESOURCE_GROUPS_START):
1040 {
1041 return 0;
1042 }
1043 YY_BREAK
1044 case YY_STATE_EOF(RESOURCE_COUNT):
1045 {
1046 return 1;
1047 }
1048 YY_BREAK
1049 case 7:
1050 /* rule 7 can match eol */
1051 YY_RULE_SETUP
1052 {
1053 return 1;
1054 }
1055 YY_BREAK
1056 case 8:
1057 YY_RULE_SETUP
1058 YY_FATAL_ERROR( "flex scanner jammed" );
1059 YY_BREAK
1060
1061 case YY_END_OF_BUFFER:
1062 {
1063 /* Amount of text matched not including the EOB char. */
1064 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1065
1066 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1067 *yy_cp = yyg->yy_hold_char;
1068 YY_RESTORE_YY_MORE_OFFSET
1069
1070 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1071 {
1072 /* We're scanning a new file or input source. It's
1073 * possible that this happened because the user
1074 * just pointed yyin at a new source and called
1075 * yylex(). If so, then we have to assure
1076 * consistency between YY_CURRENT_BUFFER and our
1077 * globals. Here is the right place to do so, because
1078 * this is the first action (other than possibly a
1079 * back-up) that will match for the new input source.
1080 */
1081 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1082 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1083 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1084 }
1085
1086 /* Note that here we test for yy_c_buf_p "<=" to the position
1087 * of the first EOB in the buffer, since yy_c_buf_p will
1088 * already have been incremented past the NUL character
1089 * (since all states make transitions on EOB to the
1090 * end-of-buffer state). Contrast this with the test
1091 * in input().
1092 */
1093 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1094 { /* This was really a NUL. */
1095 yy_state_type yy_next_state;
1096
1097 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1098
1099 yy_current_state = yy_get_previous_state( yyscanner );
1100
1101 /* Okay, we're now positioned to make the NUL
1102 * transition. We couldn't have
1103 * yy_get_previous_state() go ahead and do it
1104 * for us because it doesn't know how to deal
1105 * with the possibility of jamming (and we don't
1106 * want to build jamming into it because then it
1107 * will run more slowly).
1108 */
1109
1110 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1111
1112 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1113
1114 if ( yy_next_state )
1115 {
1116 /* Consume the NUL. */
1117 yy_cp = ++yyg->yy_c_buf_p;
1118 yy_current_state = yy_next_state;
1119 goto yy_match;
1120 }
1121
1122 else
1123 {
1124 yy_cp = yyg->yy_c_buf_p;
1125 goto yy_find_action;
1126 }
1127 }
1128
1129 else switch ( yy_get_next_buffer( yyscanner ) )
1130 {
1131 case EOB_ACT_END_OF_FILE:
1132 {
1133 yyg->yy_did_buffer_switch_on_eof = 0;
1134
1135 if ( yywrap( yyscanner ) )
1136 {
1137 /* Note: because we've taken care in
1138 * yy_get_next_buffer() to have set up
1139 * yytext, we can now set up
1140 * yy_c_buf_p so that if some total
1141 * hoser (like flex itself) wants to
1142 * call the scanner after we return the
1143 * YY_NULL, it'll still work - another
1144 * YY_NULL will get returned.
1145 */
1146 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1147
1148 yy_act = YY_STATE_EOF(YY_START);
1149 goto do_action;
1150 }
1151
1152 else
1153 {
1154 if ( ! yyg->yy_did_buffer_switch_on_eof )
1155 YY_NEW_FILE;
1156 }
1157 break;
1158 }
1159
1160 case EOB_ACT_CONTINUE_SCAN:
1161 yyg->yy_c_buf_p =
1162 yyg->yytext_ptr + yy_amount_of_matched_text;
1163
1164 yy_current_state = yy_get_previous_state( yyscanner );
1165
1166 yy_cp = yyg->yy_c_buf_p;
1167 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1168 goto yy_match;
1169
1170 case EOB_ACT_LAST_MATCH:
1171 yyg->yy_c_buf_p =
1172 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1173
1174 yy_current_state = yy_get_previous_state( yyscanner );
1175
1176 yy_cp = yyg->yy_c_buf_p;
1177 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1178 goto yy_find_action;
1179 }
1180 break;
1181 }
1182
1183 default:
1184 YY_FATAL_ERROR(
1185 "fatal flex scanner internal error--no action found" );
1186 } /* end of action switch */
1187 } /* end of scanning one token */
1188 } /* end of user's declarations */
1189 } /* end of yylex */
1190
1191 /* yy_get_next_buffer - try to read in a new buffer
1192 *
1193 * Returns a code representing an action:
1194 * EOB_ACT_LAST_MATCH -
1195 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1196 * EOB_ACT_END_OF_FILE - end of file
1197 */
1198 static int yy_get_next_buffer (yyscan_t yyscanner)
1199 {
1200 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1201 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1202 char *source = yyg->yytext_ptr;
1203 int number_to_move, i;
1204 int ret_val;
1205
1206 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1207 YY_FATAL_ERROR(
1208 "fatal flex scanner internal error--end of buffer missed" );
1209
1210 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1211 { /* Don't try to fill the buffer, so this is an EOF. */
1212 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1213 {
1214 /* We matched a single character, the EOB, so
1215 * treat this as a final EOF.
1216 */
1217 return EOB_ACT_END_OF_FILE;
1218 }
1219
1220 else
1221 {
1222 /* We matched some text prior to the EOB, first
1223 * process it.
1224 */
1225 return EOB_ACT_LAST_MATCH;
1226 }
1227 }
1228
1229 /* Try to read more data. */
1230
1231 /* First move last chars to start of buffer. */
1232 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1233
1234 for ( i = 0; i < number_to_move; ++i )
1235 *(dest++) = *(source++);
1236
1237 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1238 /* don't do the read, it's not guaranteed to return an EOF,
1239 * just force an EOF
1240 */
1241 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1242
1243 else
1244 {
1245 int num_to_read =
1246 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1247
1248 while ( num_to_read <= 0 )
1249 { /* Not enough room in the buffer - grow it. */
1250
1251 /* just a shorter name for the current buffer */
1252 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1253
1254 int yy_c_buf_p_offset =
1255 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1256
1257 if ( b->yy_is_our_buffer )
1258 {
1259 int new_size = b->yy_buf_size * 2;
1260
1261 if ( new_size <= 0 )
1262 b->yy_buf_size += b->yy_buf_size / 8;
1263 else
1264 b->yy_buf_size *= 2;
1265
1266 b->yy_ch_buf = (char *)
1267 /* Include room in for 2 EOB chars. */
1268 yyrealloc( (void *) b->yy_ch_buf,
1269 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1270 }
1271 else
1272 /* Can't grow it, we don't own it. */
1273 b->yy_ch_buf = NULL;
1274
1275 if ( ! b->yy_ch_buf )
1276 YY_FATAL_ERROR(
1277 "fatal error - scanner input buffer overflow" );
1278
1279 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1280
1281 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1282 number_to_move - 1;
1283
1284 }
1285
1286 if ( num_to_read > YY_READ_BUF_SIZE )
1287 num_to_read = YY_READ_BUF_SIZE;
1288
1289 /* Read in more data. */
1290 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1291 yyg->yy_n_chars, num_to_read );
1292
1293 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1294 }
1295
1296 if ( yyg->yy_n_chars == 0 )
1297 {
1298 if ( number_to_move == YY_MORE_ADJ )
1299 {
1300 ret_val = EOB_ACT_END_OF_FILE;
1301 yyrestart( yyin , yyscanner);
1302 }
1303
1304 else
1305 {
1306 ret_val = EOB_ACT_LAST_MATCH;
1307 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1308 YY_BUFFER_EOF_PENDING;
1309 }
1310 }
1311
1312 else
1313 ret_val = EOB_ACT_CONTINUE_SCAN;
1314
1315 if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1316 /* Extend the array by 50%, plus the number we really need. */
1317 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1318 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1319 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1320 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1321 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1322 /* "- 2" to take care of EOB's */
1323 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1324 }
1325
1326 yyg->yy_n_chars += number_to_move;
1327 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1328 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1329
1330 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1331
1332 return ret_val;
1333 }
1334
1335 /* yy_get_previous_state - get the state just before the EOB char was reached */
1336
1337 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1338 {
1339 yy_state_type yy_current_state;
1340 char *yy_cp;
1341 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1342
1343 yy_current_state = yyg->yy_start;
1344
1345 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1346 {
1347 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1348 if ( yy_accept[yy_current_state] )
1349 {
1350 yyg->yy_last_accepting_state = yy_current_state;
1351 yyg->yy_last_accepting_cpos = yy_cp;
1352 }
1353 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1354 {
1355 yy_current_state = (int) yy_def[yy_current_state];
1356 if ( yy_current_state >= 29 )
1357 yy_c = yy_meta[yy_c];
1358 }
1359 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1360 }
1361
1362 return yy_current_state;
1363 }
1364
1365 /* yy_try_NUL_trans - try to make a transition on the NUL character
1366 *
1367 * synopsis
1368 * next_state = yy_try_NUL_trans( current_state );
1369 */
1370 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1371 {
1372 int yy_is_jam;
1373 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1374 char *yy_cp = yyg->yy_c_buf_p;
1375
1376 YY_CHAR yy_c = 1;
1377 if ( yy_accept[yy_current_state] )
1378 {
1379 yyg->yy_last_accepting_state = yy_current_state;
1380 yyg->yy_last_accepting_cpos = yy_cp;
1381 }
1382 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1383 {
1384 yy_current_state = (int) yy_def[yy_current_state];
1385 if ( yy_current_state >= 29 )
1386 yy_c = yy_meta[yy_c];
1387 }
1388 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1389 yy_is_jam = (yy_current_state == 28);
1390
1391 (void)yyg;
1392 return yy_is_jam ? 0 : yy_current_state;
1393 }
1394
1395 #ifndef YY_NO_UNPUT
1396
1397 static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
1398 {
1399 char *yy_cp;
1400 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1401
1402 yy_cp = yyg->yy_c_buf_p;
1403
1404 /* undo effects of setting up yytext */
1405 *yy_cp = yyg->yy_hold_char;
1406
1407 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1408 { /* need to shift things up to make room */
1409 /* +2 for EOB chars. */
1410 int number_to_move = yyg->yy_n_chars + 2;
1411 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1412 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1413 char *source =
1414 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1415
1416 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1417 *--dest = *--source;
1418
1419 yy_cp += (int) (dest - source);
1420 yy_bp += (int) (dest - source);
1421 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1422 yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1423
1424 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1425 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1426 }
1427
1428 *--yy_cp = (char) c;
1429
1430 yyg->yytext_ptr = yy_bp;
1431 yyg->yy_hold_char = *yy_cp;
1432 yyg->yy_c_buf_p = yy_cp;
1433 }
1434
1435 #endif
1436
1437 #ifndef YY_NO_INPUT
1438 #ifdef __cplusplus
1439 static int yyinput (yyscan_t yyscanner)
1440 #else
1441 static int input (yyscan_t yyscanner)
1442 #endif
1443
1444 {
1445 int c;
1446 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1447
1448 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1449
1450 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1451 {
1452 /* yy_c_buf_p now points to the character we want to return.
1453 * If this occurs *before* the EOB characters, then it's a
1454 * valid NUL; if not, then we've hit the end of the buffer.
1455 */
1456 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1457 /* This was really a NUL. */
1458 *yyg->yy_c_buf_p = '\0';
1459
1460 else
1461 { /* need more input */
1462 int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
1463 ++yyg->yy_c_buf_p;
1464
1465 switch ( yy_get_next_buffer( yyscanner ) )
1466 {
1467 case EOB_ACT_LAST_MATCH:
1468 /* This happens because yy_g_n_b()
1469 * sees that we've accumulated a
1470 * token and flags that we need to
1471 * try matching the token before
1472 * proceeding. But for input(),
1473 * there's no matching to consider.
1474 * So convert the EOB_ACT_LAST_MATCH
1475 * to EOB_ACT_END_OF_FILE.
1476 */
1477
1478 /* Reset buffer status. */
1479 yyrestart( yyin , yyscanner);
1480
1481 /*FALLTHROUGH*/
1482
1483 case EOB_ACT_END_OF_FILE:
1484 {
1485 if ( yywrap( yyscanner ) )
1486 return 0;
1487
1488 if ( ! yyg->yy_did_buffer_switch_on_eof )
1489 YY_NEW_FILE;
1490 #ifdef __cplusplus
1491 return yyinput(yyscanner);
1492 #else
1493 return input(yyscanner);
1494 #endif
1495 }
1496
1497 case EOB_ACT_CONTINUE_SCAN:
1498 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1499 break;
1500 }
1501 }
1502 }
1503
1504 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1505 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
1506 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1507
1508 return c;
1509 }
1510 #endif /* ifndef YY_NO_INPUT */
1511
1512 /** Immediately switch to a different input stream.
1513 * @param input_file A readable stream.
1514 * @param yyscanner The scanner object.
1515 * @note This function does not reset the start condition to @c INITIAL .
1516 */
1517 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1518 {
1519 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1520
1521 if ( ! YY_CURRENT_BUFFER ){
1522 yyensure_buffer_stack (yyscanner);
1523 YY_CURRENT_BUFFER_LVALUE =
1524 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1525 }
1526
1527 yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
1528 yy_load_buffer_state( yyscanner );
1529 }
1530
1531 /** Switch to a different input buffer.
1532 * @param new_buffer The new input buffer.
1533 * @param yyscanner The scanner object.
1534 */
1535 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1536 {
1537 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1538
1539 /* TODO. We should be able to replace this entire function body
1540 * with
1541 * yypop_buffer_state();
1542 * yypush_buffer_state(new_buffer);
1543 */
1544 yyensure_buffer_stack (yyscanner);
1545 if ( YY_CURRENT_BUFFER == new_buffer )
1546 return;
1547
1548 if ( YY_CURRENT_BUFFER )
1549 {
1550 /* Flush out information for old buffer. */
1551 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1552 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1553 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1554 }
1555
1556 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1557 yy_load_buffer_state( yyscanner );
1558
1559 /* We don't actually know whether we did this switch during
1560 * EOF (yywrap()) processing, but the only time this flag
1561 * is looked at is after yywrap() is called, so it's safe
1562 * to go ahead and always set it.
1563 */
1564 yyg->yy_did_buffer_switch_on_eof = 1;
1565 }
1566
1567 static void yy_load_buffer_state (yyscan_t yyscanner)
1568 {
1569 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1570 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1571 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1572 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1573 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1574 }
1575
1576 /** Allocate and initialize an input buffer state.
1577 * @param file A readable stream.
1578 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1579 * @param yyscanner The scanner object.
1580 * @return the allocated buffer state.
1581 */
1582 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
1583 {
1584 YY_BUFFER_STATE b;
1585
1586 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
1587 if ( ! b )
1588 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1589
1590 b->yy_buf_size = size;
1591
1592 /* yy_ch_buf has to be 2 characters longer than the size given because
1593 * we need to put in 2 end-of-buffer characters.
1594 */
1595 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1596 if ( ! b->yy_ch_buf )
1597 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1598
1599 b->yy_is_our_buffer = 1;
1600
1601 yy_init_buffer( b, file , yyscanner);
1602
1603 return b;
1604 }
1605
1606 /** Destroy the buffer.
1607 * @param b a buffer created with yy_create_buffer()
1608 * @param yyscanner The scanner object.
1609 */
1610 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1611 {
1612 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1613
1614 if ( ! b )
1615 return;
1616
1617 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1618 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1619
1620 if ( b->yy_is_our_buffer )
1621 yyfree( (void *) b->yy_ch_buf , yyscanner );
1622
1623 yyfree( (void *) b , yyscanner );
1624 }
1625
1626 /* Initializes or reinitializes a buffer.
1627 * This function is sometimes called more than once on the same buffer,
1628 * such as during a yyrestart() or at EOF.
1629 */
1630 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1631
1632 {
1633 int oerrno = errno;
1634 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1635
1636 yy_flush_buffer( b , yyscanner);
1637
1638 b->yy_input_file = file;
1639 b->yy_fill_buffer = 1;
1640
1641 /* If b is the current buffer, then yy_init_buffer was _probably_
1642 * called from yyrestart() or through yy_get_next_buffer.
1643 * In that case, we don't want to reset the lineno or column.
1644 */
1645 if (b != YY_CURRENT_BUFFER){
1646 b->yy_bs_lineno = 1;
1647 b->yy_bs_column = 0;
1648 }
1649
1650 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1651
1652 errno = oerrno;
1653 }
1654
1655 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1656 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1657 * @param yyscanner The scanner object.
1658 */
1659 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1660 {
1661 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1662 if ( ! b )
1663 return;
1664
1665 b->yy_n_chars = 0;
1666
1667 /* We always need two end-of-buffer characters. The first causes
1668 * a transition to the end-of-buffer state. The second causes
1669 * a jam in that state.
1670 */
1671 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1672 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1673
1674 b->yy_buf_pos = &b->yy_ch_buf[0];
1675
1676 b->yy_at_bol = 1;
1677 b->yy_buffer_status = YY_BUFFER_NEW;
1678
1679 if ( b == YY_CURRENT_BUFFER )
1680 yy_load_buffer_state( yyscanner );
1681 }
1682
1683 /** Pushes the new state onto the stack. The new state becomes
1684 * the current state. This function will allocate the stack
1685 * if necessary.
1686 * @param new_buffer The new state.
1687 * @param yyscanner The scanner object.
1688 */
1689 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1690 {
1691 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1692 if (new_buffer == NULL)
1693 return;
1694
1695 yyensure_buffer_stack(yyscanner);
1696
1697 /* This block is copied from yy_switch_to_buffer. */
1698 if ( YY_CURRENT_BUFFER )
1699 {
1700 /* Flush out information for old buffer. */
1701 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1702 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1703 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1704 }
1705
1706 /* Only push if top exists. Otherwise, replace top. */
1707 if (YY_CURRENT_BUFFER)
1708 yyg->yy_buffer_stack_top++;
1709 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1710
1711 /* copied from yy_switch_to_buffer. */
1712 yy_load_buffer_state( yyscanner );
1713 yyg->yy_did_buffer_switch_on_eof = 1;
1714 }
1715
1716 /** Removes and deletes the top of the stack, if present.
1717 * The next element becomes the new top.
1718 * @param yyscanner The scanner object.
1719 */
1720 void yypop_buffer_state (yyscan_t yyscanner)
1721 {
1722 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1723 if (!YY_CURRENT_BUFFER)
1724 return;
1725
1726 yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
1727 YY_CURRENT_BUFFER_LVALUE = NULL;
1728 if (yyg->yy_buffer_stack_top > 0)
1729 --yyg->yy_buffer_stack_top;
1730
1731 if (YY_CURRENT_BUFFER) {
1732 yy_load_buffer_state( yyscanner );
1733 yyg->yy_did_buffer_switch_on_eof = 1;
1734 }
1735 }
1736
1737 /* Allocates the stack if it does not exist.
1738 * Guarantees space for at least one push.
1739 */
1740 static void yyensure_buffer_stack (yyscan_t yyscanner)
1741 {
1742 yy_size_t num_to_alloc;
1743 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1744
1745 if (!yyg->yy_buffer_stack) {
1746
1747 /* First allocation is just for 2 elements, since we don't know if this
1748 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1749 * immediate realloc on the next call.
1750 */
1751 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1752 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
1753 (num_to_alloc * sizeof(struct yy_buffer_state*)
1754 , yyscanner);
1755 if ( ! yyg->yy_buffer_stack )
1756 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1757
1758 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1759
1760 yyg->yy_buffer_stack_max = num_to_alloc;
1761 yyg->yy_buffer_stack_top = 0;
1762 return;
1763 }
1764
1765 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1766
1767 /* Increase the buffer to prepare for a possible push. */
1768 yy_size_t grow_size = 8 /* arbitrary grow size */;
1769
1770 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1771 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
1772 (yyg->yy_buffer_stack,
1773 num_to_alloc * sizeof(struct yy_buffer_state*)
1774 , yyscanner);
1775 if ( ! yyg->yy_buffer_stack )
1776 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1777
1778 /* zero only the new slots.*/
1779 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1780 yyg->yy_buffer_stack_max = num_to_alloc;
1781 }
1782 }
1783
1784 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1785 * @param base the character buffer
1786 * @param size the size in bytes of the character buffer
1787 * @param yyscanner The scanner object.
1788 * @return the newly allocated buffer state object.
1789 */
1790 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
1791 {
1792 YY_BUFFER_STATE b;
1793
1794 if ( size < 2 ||
1795 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1796 base[size-1] != YY_END_OF_BUFFER_CHAR )
1797 /* They forgot to leave room for the EOB's. */
1798 return NULL;
1799
1800 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
1801 if ( ! b )
1802 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1803
1804 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1805 b->yy_buf_pos = b->yy_ch_buf = base;
1806 b->yy_is_our_buffer = 0;
1807 b->yy_input_file = NULL;
1808 b->yy_n_chars = b->yy_buf_size;
1809 b->yy_is_interactive = 0;
1810 b->yy_at_bol = 1;
1811 b->yy_fill_buffer = 0;
1812 b->yy_buffer_status = YY_BUFFER_NEW;
1813
1814 yy_switch_to_buffer( b , yyscanner );
1815
1816 return b;
1817 }
1818
1819 /** Setup the input buffer state to scan a string. The next call to yylex() will
1820 * scan from a @e copy of @a str.
1821 * @param yystr a NUL-terminated string to scan
1822 * @param yyscanner The scanner object.
1823 * @return the newly allocated buffer state object.
1824 * @note If you want to scan bytes that may contain NUL values, then use
1825 * yy_scan_bytes() instead.
1826 */
1827 YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
1828 {
1829
1830 return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
1831 }
1832
1833 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1834 * scan from a @e copy of @a bytes.
1835 * @param yybytes the byte buffer to scan
1836 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1837 * @param yyscanner The scanner object.
1838 * @return the newly allocated buffer state object.
1839 */
1840 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
1841 {
1842 YY_BUFFER_STATE b;
1843 char *buf;
1844 yy_size_t n;
1845 int i;
1846
1847 /* Get memory for full buffer, including space for trailing EOB's. */
1848 n = (yy_size_t) (_yybytes_len + 2);
1849 buf = (char *) yyalloc( n , yyscanner );
1850 if ( ! buf )
1851 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1852
1853 for ( i = 0; i < _yybytes_len; ++i )
1854 buf[i] = yybytes[i];
1855
1856 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1857
1858 b = yy_scan_buffer( buf, n , yyscanner);
1859 if ( ! b )
1860 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1861
1862 /* It's okay to grow etc. this buffer, and we should throw it
1863 * away when we're done.
1864 */
1865 b->yy_is_our_buffer = 1;
1866
1867 return b;
1868 }
1869
1870 #ifndef YY_EXIT_FAILURE
1871 #define YY_EXIT_FAILURE 2
1872 #endif
1873
1874 static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
1875 {
1876 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1877 (void)yyg;
1878 fprintf( stderr, "%s\n", msg );
1879 exit( YY_EXIT_FAILURE );
1880 }
1881
1882 /* Redefine yyless() so it works in section 3 code. */
1883
1884 #undef yyless
1885 #define yyless(n) \
1886 do \
1887 { \
1888 /* Undo effects of setting up yytext. */ \
1889 int yyless_macro_arg = (n); \
1890 YY_LESS_LINENO(yyless_macro_arg);\
1891 yytext[yyleng] = yyg->yy_hold_char; \
1892 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1893 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1894 *yyg->yy_c_buf_p = '\0'; \
1895 yyleng = yyless_macro_arg; \
1896 } \
1897 while ( 0 )
1898
1899 /* Accessor methods (get/set functions) to struct members. */
1900
1901 /** Get the user-defined data for this scanner.
1902 * @param yyscanner The scanner object.
1903 */
1904 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1905 {
1906 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1907 return yyextra;
1908 }
1909
1910 /** Get the current line number.
1911 * @param yyscanner The scanner object.
1912 */
1913 int yyget_lineno (yyscan_t yyscanner)
1914 {
1915 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1916
1917 if (! YY_CURRENT_BUFFER)
1918 return 0;
1919
1920 return yylineno;
1921 }
1922
1923 /** Get the current column number.
1924 * @param yyscanner The scanner object.
1925 */
1926 int yyget_column (yyscan_t yyscanner)
1927 {
1928 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1929
1930 if (! YY_CURRENT_BUFFER)
1931 return 0;
1932
1933 return yycolumn;
1934 }
1935
1936 /** Get the input stream.
1937 * @param yyscanner The scanner object.
1938 */
1939 FILE *yyget_in (yyscan_t yyscanner)
1940 {
1941 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1942 return yyin;
1943 }
1944
1945 /** Get the output stream.
1946 * @param yyscanner The scanner object.
1947 */
1948 FILE *yyget_out (yyscan_t yyscanner)
1949 {
1950 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1951 return yyout;
1952 }
1953
1954 /** Get the length of the current token.
1955 * @param yyscanner The scanner object.
1956 */
1957 int yyget_leng (yyscan_t yyscanner)
1958 {
1959 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1960 return yyleng;
1961 }
1962
1963 /** Get the current token.
1964 * @param yyscanner The scanner object.
1965 */
1966
1967 char *yyget_text (yyscan_t yyscanner)
1968 {
1969 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1970 return yytext;
1971 }
1972
1973 /** Set the user-defined data. This data is never touched by the scanner.
1974 * @param user_defined The data to be associated with this scanner.
1975 * @param yyscanner The scanner object.
1976 */
1977 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1978 {
1979 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1980 yyextra = user_defined ;
1981 }
1982
1983 /** Set the current line number.
1984 * @param _line_number line number
1985 * @param yyscanner The scanner object.
1986 */
1987 void yyset_lineno (int _line_number , yyscan_t yyscanner)
1988 {
1989 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1990
1991 /* lineno is only valid if an input buffer exists. */
1992 if (! YY_CURRENT_BUFFER )
1993 YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
1994
1995 yylineno = _line_number;
1996 }
1997
1998 /** Set the current column.
1999 * @param _column_no column number
2000 * @param yyscanner The scanner object.
2001 */
2002 void yyset_column (int _column_no , yyscan_t yyscanner)
2003 {
2004 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2005
2006 /* column is only valid if an input buffer exists. */
2007 if (! YY_CURRENT_BUFFER )
2008 YY_FATAL_ERROR( "yyset_column called with no buffer" );
2009
2010 yycolumn = _column_no;
2011 }
2012
2013 /** Set the input stream. This does not discard the current
2014 * input buffer.
2015 * @param _in_str A readable stream.
2016 * @param yyscanner The scanner object.
2017 * @see yy_switch_to_buffer
2018 */
2019 void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2020 {
2021 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2022 yyin = _in_str ;
2023 }
2024
2025 void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2026 {
2027 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2028 yyout = _out_str ;
2029 }
2030
2031 int yyget_debug (yyscan_t yyscanner)
2032 {
2033 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2034 return yy_flex_debug;
2035 }
2036
2037 void yyset_debug (int _bdebug , yyscan_t yyscanner)
2038 {
2039 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2040 yy_flex_debug = _bdebug ;
2041 }
2042
2043 /* Accessor methods for yylval and yylloc */
2044
2045 /* User-visible API */
2046
2047 /* yylex_init is special because it creates the scanner itself, so it is
2048 * the ONLY reentrant function that doesn't take the scanner as the last argument.
2049 * That's why we explicitly handle the declaration, instead of using our macros.
2050 */
2051 int yylex_init(yyscan_t* ptr_yy_globals)
2052 {
2053 if (ptr_yy_globals == NULL){
2054 errno = EINVAL;
2055 return 1;
2056 }
2057
2058 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2059
2060 if (*ptr_yy_globals == NULL){
2061 errno = ENOMEM;
2062 return 1;
2063 }
2064
2065 /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2066 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2067
2068 return yy_init_globals ( *ptr_yy_globals );
2069 }
2070
2071 /* yylex_init_extra has the same functionality as yylex_init, but follows the
2072 * convention of taking the scanner as the last argument. Note however, that
2073 * this is a *pointer* to a scanner, as it will be allocated by this call (and
2074 * is the reason, too, why this function also must handle its own declaration).
2075 * The user defined value in the first argument will be available to yyalloc in
2076 * the yyextra field.
2077 */
2078 int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2079 {
2080 struct yyguts_t dummy_yyguts;
2081
2082 yyset_extra (yy_user_defined, &dummy_yyguts);
2083
2084 if (ptr_yy_globals == NULL){
2085 errno = EINVAL;
2086 return 1;
2087 }
2088
2089 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2090
2091 if (*ptr_yy_globals == NULL){
2092 errno = ENOMEM;
2093 return 1;
2094 }
2095
2096 /* By setting to 0xAA, we expose bugs in
2097 yy_init_globals. Leave at 0x00 for releases. */
2098 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2099
2100 yyset_extra (yy_user_defined, *ptr_yy_globals);
2101
2102 return yy_init_globals ( *ptr_yy_globals );
2103 }
2104
2105 static int yy_init_globals (yyscan_t yyscanner)
2106 {
2107 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2108 /* Initialization is the same as for the non-reentrant scanner.
2109 * This function is called from yylex_destroy(), so don't allocate here.
2110 */
2111
2112 yyg->yy_buffer_stack = NULL;
2113 yyg->yy_buffer_stack_top = 0;
2114 yyg->yy_buffer_stack_max = 0;
2115 yyg->yy_c_buf_p = NULL;
2116 yyg->yy_init = 0;
2117 yyg->yy_start = 0;
2118
2119 yyg->yy_start_stack_ptr = 0;
2120 yyg->yy_start_stack_depth = 0;
2121 yyg->yy_start_stack = NULL;
2122
2123 /* Defined in main.c */
2124 #ifdef YY_STDINIT
2125 yyin = stdin;
2126 yyout = stdout;
2127 #else
2128 yyin = NULL;
2129 yyout = NULL;
2130 #endif
2131
2132 /* For future reference: Set errno on error, since we are called by
2133 * yylex_init()
2134 */
2135 return 0;
2136 }
2137
2138 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2139 int yylex_destroy (yyscan_t yyscanner)
2140 {
2141 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2142
2143 /* Pop the buffer stack, destroying each element. */
2144 while(YY_CURRENT_BUFFER){
2145 yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2146 YY_CURRENT_BUFFER_LVALUE = NULL;
2147 yypop_buffer_state(yyscanner);
2148 }
2149
2150 /* Destroy the stack itself. */
2151 yyfree(yyg->yy_buffer_stack , yyscanner);
2152 yyg->yy_buffer_stack = NULL;
2153
2154 /* Destroy the start condition stack. */
2155 yyfree( yyg->yy_start_stack , yyscanner );
2156 yyg->yy_start_stack = NULL;
2157
2158 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2159 * yylex() is called, initialization will occur. */
2160 yy_init_globals( yyscanner);
2161
2162 /* Destroy the main struct (reentrant only). */
2163 yyfree ( yyscanner , yyscanner );
2164 yyscanner = NULL;
2165 return 0;
2166 }
2167
2168 /*
2169 * Internal utility routines.
2170 */
2171
2172 #ifndef yytext_ptr
2173 static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
2174 {
2175 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2176 (void)yyg;
2177
2178 int i;
2179 for ( i = 0; i < n; ++i )
2180 s1[i] = s2[i];
2181 }
2182 #endif
2183
2184 #ifdef YY_NEED_STRLEN
2185 static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
2186 {
2187 int n;
2188 for ( n = 0; s[n]; ++n )
2189 ;
2190
2191 return n;
2192 }
2193 #endif
2194
2195 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2196 {
2197 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2198 (void)yyg;
2199 return malloc(size);
2200 }
2201
2202 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2203 {
2204 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2205 (void)yyg;
2206
2207 /* The cast to (char *) in the following accommodates both
2208 * implementations that use char* generic pointers, and those
2209 * that use void* generic pointers. It works with the latter
2210 * because both ANSI C and C++ allow castless assignment from
2211 * any pointer type to void*, and deal with argument conversions
2212 * as though doing an assignment.
2213 */
2214 return realloc(ptr, size);
2215 }
2216
2217 void yyfree (void * ptr , yyscan_t yyscanner)
2218 {
2219 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2220 (void)yyg;
2221 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2222 }
2223
2224 #define YYTABLES_NAME "yytables"
2225
2226 /*--------------------------------------------------------------------------*/
2227
2228 #endif /* __clang_analyzer__ */
CMake is an open-source, cross-platform family of tools designed to build, test and package software