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