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