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
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 #if defined _MSC_VER
727 // signed/unsigned mismatch
728 #pragma warning(disable:4365)
729 // macro re-definition: flex conditonally defines INT32_MAX et al. and thus
730 // they are set before library headers get to define them
731 #pragma warning(disable:4005)
732 #endif
733 
734 #define PARSER assembler_parser
735 #define YYSTYPE unsigned
736 #undef ECHO
737 #define ECHO
738 
739 #include "assembler_parser.h"
740 
741 #include <util/pragma_wsign_compare.def>
742 #include <util/pragma_wnull_conversion.def>
743 #include <util/pragma_wdeprecated_register.def>
744 
745 /*** macros for easier rule definition **********************************/
746 #line 746 "assembler_lex.yy.cpp"
747 
748 #line 64 "scanner.l"
750 {
752  BEGIN(0);
753 }
754 #line 754 "assembler_lex.yy.cpp"
755 #line 755 "assembler_lex.yy.cpp"
756 
757 #define INITIAL 0
758 #define GRAMMAR 1
759 #define LINE_COMMENT 2
760 
761 #ifndef YY_NO_UNISTD_H
762 /* Special case for "unistd.h", since it is non-ANSI. We include it way
763  * down here because we want the user's section 1 to have been scanned first.
764  * The user has a chance to override it with an option.
765  */
766 #include <unistd.h>
767 #endif
768 
769 #ifndef YY_EXTRA_TYPE
770 #define YY_EXTRA_TYPE void *
771 #endif
772 
773 static int yy_init_globals ( void );
774 
775 /* Accessor methods to globals.
776  These are made visible to non-reentrant scanners for convenience. */
777 
778 int yylex_destroy ( void );
779 
780 int yyget_debug ( void );
781 
782 void yyset_debug ( int debug_flag );
783 
785 
786 void yyset_extra ( YY_EXTRA_TYPE user_defined );
787 
788 FILE *yyget_in ( void );
789 
790 void yyset_in ( FILE * _in_str );
791 
792 FILE *yyget_out ( void );
793 
794 void yyset_out ( FILE * _out_str );
795 
796  int yyget_leng ( void );
797 
798 char *yyget_text ( void );
799 
800 int yyget_lineno ( void );
801 
802 void yyset_lineno ( int _line_number );
803 
804 /* Macros after this point can all be overridden by user definitions in
805  * section 1.
806  */
807 
808 #ifndef YY_SKIP_YYWRAP
809 #ifdef __cplusplus
810 extern "C" int yywrap ( void );
811 #else
812 extern int yywrap ( void );
813 #endif
814 #endif
815 
816 #ifndef YY_NO_UNPUT
817 
818 #endif
819 
820 #ifndef yytext_ptr
821 static void yy_flex_strncpy ( char *, const char *, int );
822 #endif
823 
824 #ifdef YY_NEED_STRLEN
825 static int yy_flex_strlen ( const char * );
826 #endif
827 
828 #ifndef YY_NO_INPUT
829 #ifdef __cplusplus
830 static int yyinput ( void );
831 #else
832 static int input ( void );
833 #endif
834 
835 #endif
836 
837 /* Amount of stuff to slurp up with each read. */
838 #ifndef YY_READ_BUF_SIZE
839 #ifdef __ia64__
840 /* On IA-64, the buffer size is 16k, not 8k */
841 #define YY_READ_BUF_SIZE 16384
842 #else
843 #define YY_READ_BUF_SIZE 8192
844 #endif /* __ia64__ */
845 #endif
846 
847 /* Copy whatever the last rule matched to the standard output. */
848 #ifndef ECHO
849 /* This used to be an fputs(), but since the string might contain NUL's,
850  * we now use fwrite().
851  */
852 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
853 #endif
854 
855 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
856  * is returned in "result".
857  */
858 #ifndef YY_INPUT
859 #define YY_INPUT(buf,result,max_size) \
860  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
861  { \
862  int c = '*'; \
863  int n; \
864  for ( n = 0; n < max_size && \
865  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
866  buf[n] = (char) c; \
867  if ( c == '\n' ) \
868  buf[n++] = (char) c; \
869  if ( c == EOF && ferror( yyin ) ) \
870  YY_FATAL_ERROR( "input in flex scanner failed" ); \
871  result = n; \
872  } \
873  else \
874  { \
875  errno=0; \
876  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
877  { \
878  if( errno != EINTR) \
879  { \
880  YY_FATAL_ERROR( "input in flex scanner failed" ); \
881  break; \
882  } \
883  errno=0; \
884  clearerr(yyin); \
885  } \
886  }\
887 \
888 
889 #endif
890 
891 /* No semi-colon after return; correct usage is to write "yyterminate();" -
892  * we don't want an extra ';' after the "return" because that will cause
893  * some compilers to complain about unreachable statements.
894  */
895 #ifndef yyterminate
896 #define yyterminate() return YY_NULL
897 #endif
898 
899 /* Number of entries by which start-condition stack grows. */
900 #ifndef YY_START_STACK_INCR
901 #define YY_START_STACK_INCR 25
902 #endif
903 
904 /* Report a fatal error. */
905 #ifndef YY_FATAL_ERROR
906 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
907 #endif
908 
909 /* end tables serialization structures and prototypes */
910 
911 /* Default declaration of generated scanner - a define so the user can
912  * easily add parameters.
913  */
914 #ifndef YY_DECL
915 #define YY_DECL_IS_OURS 1
916 
917 extern int yylex (void);
918 
919 #define YY_DECL int yylex (void)
920 #endif /* !YY_DECL */
921 
922 /* Code executed at the beginning of each rule, after yytext and yyleng
923  * have been set up.
924  */
925 #ifndef YY_USER_ACTION
926 #define YY_USER_ACTION
927 #endif
928 
929 /* Code executed at the end of each rule. */
930 #ifndef YY_BREAK
931 #define YY_BREAK /*LINTED*/break;
932 #endif
933 
934 #define YY_RULE_SETUP \
935  YY_USER_ACTION
936 
940 {
941  yy_state_type yy_current_state;
942  char *yy_cp, *yy_bp;
943  int yy_act;
944 
945  if ( !(yy_init) )
946  {
947  (yy_init) = 1;
948 
949 #ifdef YY_USER_INIT
950  YY_USER_INIT;
951 #endif
952 
953  if ( ! (yy_start) )
954  (yy_start) = 1; /* first start state */
955 
956  if ( ! yyin )
957  yyin = stdin;
958 
959  if ( ! yyout )
960  yyout = stdout;
961 
962  if ( ! YY_CURRENT_BUFFER ) {
966  }
967 
969  }
970 
971  {
972 #line 71 "scanner.l"
973 
974 
975 #line 975 "assembler_lex.yy.cpp"
976 
977  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
978  {
979  yy_cp = (yy_c_buf_p);
980 
981  /* Support of yytext. */
982  *yy_cp = (yy_hold_char);
983 
984  /* yy_bp points to the position in yy_ch_buf of the start of
985  * the current run.
986  */
987  yy_bp = yy_cp;
988 
989  yy_current_state = (yy_start);
990 yy_match:
991  do
992  {
993  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
994  if ( yy_accept[yy_current_state] )
995  {
996  (yy_last_accepting_state) = yy_current_state;
997  (yy_last_accepting_cpos) = yy_cp;
998  }
999  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1000  {
1001  yy_current_state = (int) yy_def[yy_current_state];
1002  if ( yy_current_state >= 33 )
1003  yy_c = yy_meta[yy_c];
1004  }
1005  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1006  ++yy_cp;
1007  }
1008  while ( yy_current_state != 32 );
1009  yy_cp = (yy_last_accepting_cpos);
1010  yy_current_state = (yy_last_accepting_state);
1011 
1012 yy_find_action:
1013  yy_act = yy_accept[yy_current_state];
1014 
1016 
1017 do_action: /* This label is used only to access EOF actions. */
1018 
1019  switch ( yy_act )
1020  { /* beginning of action switch */
1021  case 0: /* must back up */
1022  /* undo the effects of YY_DO_BEFORE_ACTION */
1023  *yy_cp = (yy_hold_char);
1024  yy_cp = (yy_last_accepting_cpos);
1025  yy_current_state = (yy_last_accepting_state);
1026  goto yy_find_action;
1027 
1028 case 1:
1029 /* rule 1 can match eol */
1031 #line 73 "scanner.l"
1032 { BEGIN(GRAMMAR);
1033  yyless(0); /* start again with this character */
1034  }
1035  YY_BREAK
1036 case 2:
1038 #line 77 "scanner.l"
1039 { PARSER.new_instruction(); BEGIN(LINE_COMMENT); } /* begin comment state */
1040  YY_BREAK
1041 
1042 case 3:
1043 /* rule 3 can match eol */
1045 #line 80 "scanner.l"
1046 { BEGIN(GRAMMAR); } /* end comment state, back GRAMMAR */
1047  YY_BREAK
1048 case 4:
1050 #line 81 "scanner.l"
1051 { } /* all characters within comments are ignored */
1052  YY_BREAK
1053 
1054 case 5:
1055 /* rule 5 can match eol */
1057 #line 84 "scanner.l"
1058 { PARSER.new_instruction(); }
1059  YY_BREAK
1060 case 6:
1062 #line 85 "scanner.l"
1063 { PARSER.new_instruction(); }
1064  YY_BREAK
1065 case 7:
1067 #line 86 "scanner.l"
1068 { } /* skipped */
1069  YY_BREAK
1070 /*** keywords ***/
1071 
1072 case 8:
1074 #line 91 "scanner.l"
1075 { }
1076  YY_BREAK
1077 
1078 /*** rest ***/
1079 
1080 case 9:
1082 #line 97 "scanner.l"
1083 { /* ignore */ }
1084  YY_BREAK
1085 case 10:
1087 #line 98 "scanner.l"
1088 { irept identifier(ID_symbol);
1089  identifier.set(ID_identifier, yytext);
1090  PARSER.add_token(identifier);
1091  }
1092  YY_BREAK
1093 case 11:
1095 #line 103 "scanner.l"
1096 { PARSER.add_token(irept(ID_shr)); }
1097  YY_BREAK
1098 case 12:
1100 #line 104 "scanner.l"
1101 { PARSER.add_token(irept(ID_shl)); }
1102  YY_BREAK
1103 case 13:
1105 #line 105 "scanner.l"
1106 { std::string s;
1107  s+=yytext[0];
1108  PARSER.add_token(irept(s));
1109  }
1110  YY_BREAK
1111 
1112 case YY_STATE_EOF(INITIAL):
1113 case YY_STATE_EOF(GRAMMAR):
1115 #line 111 "scanner.l"
1116 { yyterminate(); /* done! */ }
1117  YY_BREAK
1118 case 14:
1120 #line 113 "scanner.l"
1121 ECHO;
1122  YY_BREAK
1123 #line 1123 "assembler_lex.yy.cpp"
1124 
1125  case YY_END_OF_BUFFER:
1126  {
1127  /* Amount of text matched not including the EOB char. */
1128  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1129 
1130  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1131  *yy_cp = (yy_hold_char);
1133 
1134  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1135  {
1136  /* We're scanning a new file or input source. It's
1137  * possible that this happened because the user
1138  * just pointed yyin at a new source and called
1139  * yylex(). If so, then we have to assure
1140  * consistency between YY_CURRENT_BUFFER and our
1141  * globals. Here is the right place to do so, because
1142  * this is the first action (other than possibly a
1143  * back-up) that will match for the new input source.
1144  */
1145  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1146  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1147  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1148  }
1149 
1150  /* Note that here we test for yy_c_buf_p "<=" to the position
1151  * of the first EOB in the buffer, since yy_c_buf_p will
1152  * already have been incremented past the NUL character
1153  * (since all states make transitions on EOB to the
1154  * end-of-buffer state). Contrast this with the test
1155  * in input().
1156  */
1157  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1158  { /* This was really a NUL. */
1159  yy_state_type yy_next_state;
1160 
1161  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1162 
1163  yy_current_state = yy_get_previous_state( );
1164 
1165  /* Okay, we're now positioned to make the NUL
1166  * transition. We couldn't have
1167  * yy_get_previous_state() go ahead and do it
1168  * for us because it doesn't know how to deal
1169  * with the possibility of jamming (and we don't
1170  * want to build jamming into it because then it
1171  * will run more slowly).
1172  */
1173 
1174  yy_next_state = yy_try_NUL_trans( yy_current_state );
1175 
1176  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1177 
1178  if ( yy_next_state )
1179  {
1180  /* Consume the NUL. */
1181  yy_cp = ++(yy_c_buf_p);
1182  yy_current_state = yy_next_state;
1183  goto yy_match;
1184  }
1185 
1186  else
1187  {
1188  yy_cp = (yy_last_accepting_cpos);
1189  yy_current_state = (yy_last_accepting_state);
1190  goto yy_find_action;
1191  }
1192  }
1193 
1194  else switch ( yy_get_next_buffer( ) )
1195  {
1196  case EOB_ACT_END_OF_FILE:
1197  {
1199 
1200  if ( yywrap( ) )
1201  {
1202  /* Note: because we've taken care in
1203  * yy_get_next_buffer() to have set up
1204  * yytext, we can now set up
1205  * yy_c_buf_p so that if some total
1206  * hoser (like flex itself) wants to
1207  * call the scanner after we return the
1208  * YY_NULL, it'll still work - another
1209  * YY_NULL will get returned.
1210  */
1212 
1213  yy_act = YY_STATE_EOF(YY_START);
1214  goto do_action;
1215  }
1216 
1217  else
1218  {
1219  if ( ! (yy_did_buffer_switch_on_eof) )
1220  YY_NEW_FILE;
1221  }
1222  break;
1223  }
1224 
1225  case EOB_ACT_CONTINUE_SCAN:
1226  (yy_c_buf_p) =
1227  (yytext_ptr) + yy_amount_of_matched_text;
1228 
1229  yy_current_state = yy_get_previous_state( );
1230 
1231  yy_cp = (yy_c_buf_p);
1232  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1233  goto yy_match;
1234 
1235  case EOB_ACT_LAST_MATCH:
1236  (yy_c_buf_p) =
1237  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1238 
1239  yy_current_state = yy_get_previous_state( );
1240 
1241  yy_cp = (yy_c_buf_p);
1242  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1243  goto yy_find_action;
1244  }
1245  break;
1246  }
1247 
1248  default:
1250  "fatal flex scanner internal error--no action found" );
1251  } /* end of action switch */
1252  } /* end of scanning one token */
1253  } /* end of user's declarations */
1254 } /* end of yylex */
1255 
1256 /* yy_get_next_buffer - try to read in a new buffer
1257  *
1258  * Returns a code representing an action:
1259  * EOB_ACT_LAST_MATCH -
1260  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1261  * EOB_ACT_END_OF_FILE - end of file
1262  */
1263 static int yy_get_next_buffer (void)
1264 {
1265  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1266  char *source = (yytext_ptr);
1267  int number_to_move, i;
1268  int ret_val;
1269 
1270  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1272  "fatal flex scanner internal error--end of buffer missed" );
1273 
1274  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1275  { /* Don't try to fill the buffer, so this is an EOF. */
1276  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1277  {
1278  /* We matched a single character, the EOB, so
1279  * treat this as a final EOF.
1280  */
1281  return EOB_ACT_END_OF_FILE;
1282  }
1283 
1284  else
1285  {
1286  /* We matched some text prior to the EOB, first
1287  * process it.
1288  */
1289  return EOB_ACT_LAST_MATCH;
1290  }
1291  }
1292 
1293  /* Try to read more data. */
1294 
1295  /* First move last chars to start of buffer. */
1296  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1297 
1298  for ( i = 0; i < number_to_move; ++i )
1299  *(dest++) = *(source++);
1300 
1301  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1302  /* don't do the read, it's not guaranteed to return an EOF,
1303  * just force an EOF
1304  */
1305  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1306 
1307  else
1308  {
1309  int num_to_read =
1310  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1311 
1312  while ( num_to_read <= 0 )
1313  { /* Not enough room in the buffer - grow it. */
1314 
1315  /* just a shorter name for the current buffer */
1317 
1318  int yy_c_buf_p_offset =
1319  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1320 
1321  if ( b->yy_is_our_buffer )
1322  {
1323  int new_size = b->yy_buf_size * 2;
1324 
1325  if ( new_size <= 0 )
1326  b->yy_buf_size += b->yy_buf_size / 8;
1327  else
1328  b->yy_buf_size *= 2;
1329 
1330  b->yy_ch_buf = (char *)
1331  /* Include room in for 2 EOB chars. */
1332  yyrealloc( (void *) b->yy_ch_buf,
1333  (yy_size_t) (b->yy_buf_size + 2) );
1334  }
1335  else
1336  /* Can't grow it, we don't own it. */
1337  b->yy_ch_buf = NULL;
1338 
1339  if ( ! b->yy_ch_buf )
1341  "fatal error - scanner input buffer overflow" );
1342 
1343  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1344 
1345  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1346  number_to_move - 1;
1347 
1348  }
1349 
1350  if ( num_to_read > YY_READ_BUF_SIZE )
1351  num_to_read = YY_READ_BUF_SIZE;
1352 
1353  /* Read in more data. */
1354  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1355  (yy_n_chars), num_to_read );
1356 
1357  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1358  }
1359 
1360  if ( (yy_n_chars) == 0 )
1361  {
1362  if ( number_to_move == YY_MORE_ADJ )
1363  {
1364  ret_val = EOB_ACT_END_OF_FILE;
1365  yyrestart( yyin );
1366  }
1367 
1368  else
1369  {
1370  ret_val = EOB_ACT_LAST_MATCH;
1371  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1373  }
1374  }
1375 
1376  else
1377  ret_val = EOB_ACT_CONTINUE_SCAN;
1378 
1379  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1380  /* Extend the array by 50%, plus the number we really need. */
1381  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1382  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1383  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1384  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1385  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1386  /* "- 2" to take care of EOB's */
1387  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1388  }
1389 
1390  (yy_n_chars) += number_to_move;
1393 
1394  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1395 
1396  return ret_val;
1397 }
1398 
1399 /* yy_get_previous_state - get the state just before the EOB char was reached */
1400 
1402 {
1403  yy_state_type yy_current_state;
1404  char *yy_cp;
1405 
1406  yy_current_state = (yy_start);
1407 
1408  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1409  {
1410  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1411  if ( yy_accept[yy_current_state] )
1412  {
1413  (yy_last_accepting_state) = yy_current_state;
1414  (yy_last_accepting_cpos) = yy_cp;
1415  }
1416  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1417  {
1418  yy_current_state = (int) yy_def[yy_current_state];
1419  if ( yy_current_state >= 33 )
1420  yy_c = yy_meta[yy_c];
1421  }
1422  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1423  }
1424 
1425  return yy_current_state;
1426 }
1427 
1428 /* yy_try_NUL_trans - try to make a transition on the NUL character
1429  *
1430  * synopsis
1431  * next_state = yy_try_NUL_trans( current_state );
1432  */
1433  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1434 {
1435  int yy_is_jam;
1436  char *yy_cp = (yy_c_buf_p);
1437 
1438  YY_CHAR yy_c = 1;
1439  if ( yy_accept[yy_current_state] )
1440  {
1441  (yy_last_accepting_state) = yy_current_state;
1442  (yy_last_accepting_cpos) = yy_cp;
1443  }
1444  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1445  {
1446  yy_current_state = (int) yy_def[yy_current_state];
1447  if ( yy_current_state >= 33 )
1448  yy_c = yy_meta[yy_c];
1449  }
1450  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1451  yy_is_jam = (yy_current_state == 32);
1452 
1453  return yy_is_jam ? 0 : yy_current_state;
1454 }
1455 
1456 #ifndef YY_NO_UNPUT
1457 
1458 #endif
1459 
1460 #ifndef YY_NO_INPUT
1461 #ifdef __cplusplus
1462  static int yyinput (void)
1463 #else
1464  static int input (void)
1465 #endif
1466 
1467 {
1468  int c;
1469 
1470  *(yy_c_buf_p) = (yy_hold_char);
1471 
1472  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1473  {
1474  /* yy_c_buf_p now points to the character we want to return.
1475  * If this occurs *before* the EOB characters, then it's a
1476  * valid NUL; if not, then we've hit the end of the buffer.
1477  */
1478  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1479  /* This was really a NUL. */
1480  *(yy_c_buf_p) = '\0';
1481 
1482  else
1483  { /* need more input */
1484  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1485  ++(yy_c_buf_p);
1486 
1487  switch ( yy_get_next_buffer( ) )
1488  {
1489  case EOB_ACT_LAST_MATCH:
1490  /* This happens because yy_g_n_b()
1491  * sees that we've accumulated a
1492  * token and flags that we need to
1493  * try matching the token before
1494  * proceeding. But for input(),
1495  * there's no matching to consider.
1496  * So convert the EOB_ACT_LAST_MATCH
1497  * to EOB_ACT_END_OF_FILE.
1498  */
1499 
1500  /* Reset buffer status. */
1501  yyrestart( yyin );
1502 
1503  /*FALLTHROUGH*/
1504 
1505  case EOB_ACT_END_OF_FILE:
1506  {
1507  if ( yywrap( ) )
1508  return 0;
1509 
1510  if ( ! (yy_did_buffer_switch_on_eof) )
1511  YY_NEW_FILE;
1512 #ifdef __cplusplus
1513  return yyinput();
1514 #else
1515  return input();
1516 #endif
1517  }
1518 
1519  case EOB_ACT_CONTINUE_SCAN:
1520  (yy_c_buf_p) = (yytext_ptr) + offset;
1521  break;
1522  }
1523  }
1524  }
1525 
1526  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1527  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1528  (yy_hold_char) = *++(yy_c_buf_p);
1529 
1530  return c;
1531 }
1532 #endif /* ifndef YY_NO_INPUT */
1533 
1539  void yyrestart (FILE * input_file )
1540 {
1541 
1542  if ( ! YY_CURRENT_BUFFER ){
1546  }
1547 
1548  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1550 }
1551 
1557 {
1558 
1559  /* TODO. We should be able to replace this entire function body
1560  * with
1561  * yypop_buffer_state();
1562  * yypush_buffer_state(new_buffer);
1563  */
1565  if ( YY_CURRENT_BUFFER == new_buffer )
1566  return;
1567 
1568  if ( YY_CURRENT_BUFFER )
1569  {
1570  /* Flush out information for old buffer. */
1571  *(yy_c_buf_p) = (yy_hold_char);
1572  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1573  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1574  }
1575 
1576  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1578 
1579  /* We don't actually know whether we did this switch during
1580  * EOF (yywrap()) processing, but the only time this flag
1581  * is looked at is after yywrap() is called, so it's safe
1582  * to go ahead and always set it.
1583  */
1585 }
1586 
1587 static void yy_load_buffer_state (void)
1588 {
1589  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1590  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1591  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1592  (yy_hold_char) = *(yy_c_buf_p);
1593 }
1594 
1602 {
1603  YY_BUFFER_STATE b;
1604 
1605  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1606  if ( ! b )
1607  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1608 
1609  b->yy_buf_size = size;
1610 
1611  /* yy_ch_buf has to be 2 characters longer than the size given because
1612  * we need to put in 2 end-of-buffer characters.
1613  */
1614  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1615  if ( ! b->yy_ch_buf )
1616  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1617 
1618  b->yy_is_our_buffer = 1;
1619 
1620  yy_init_buffer( b, file );
1621 
1622  return b;
1623 }
1624 
1630 {
1631 
1632  if ( ! b )
1633  return;
1634 
1635  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1637 
1638  if ( b->yy_is_our_buffer )
1639  yyfree( (void *) b->yy_ch_buf );
1640 
1641  yyfree( (void *) b );
1642 }
1643 
1644 /* Initializes or reinitializes a buffer.
1645  * This function is sometimes called more than once on the same buffer,
1646  * such as during a yyrestart() or at EOF.
1647  */
1648  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1649 
1650 {
1651  int oerrno = errno;
1652 
1653  yy_flush_buffer( b );
1654 
1655  b->yy_input_file = file;
1656  b->yy_fill_buffer = 1;
1657 
1658  /* If b is the current buffer, then yy_init_buffer was _probably_
1659  * called from yyrestart() or through yy_get_next_buffer.
1660  * In that case, we don't want to reset the lineno or column.
1661  */
1662  if (b != YY_CURRENT_BUFFER){
1663  b->yy_bs_lineno = 1;
1664  b->yy_bs_column = 0;
1665  }
1666 
1667  b->yy_is_interactive = 0;
1668 
1669  errno = oerrno;
1670 }
1671 
1677 {
1678  if ( ! b )
1679  return;
1680 
1681  b->yy_n_chars = 0;
1682 
1683  /* We always need two end-of-buffer characters. The first causes
1684  * a transition to the end-of-buffer state. The second causes
1685  * a jam in that state.
1686  */
1689 
1690  b->yy_buf_pos = &b->yy_ch_buf[0];
1691 
1692  b->yy_at_bol = 1;
1694 
1695  if ( b == YY_CURRENT_BUFFER )
1697 }
1698 
1706 {
1707  if (new_buffer == NULL)
1708  return;
1709 
1711 
1712  /* This block is copied from yy_switch_to_buffer. */
1713  if ( YY_CURRENT_BUFFER )
1714  {
1715  /* Flush out information for old buffer. */
1716  *(yy_c_buf_p) = (yy_hold_char);
1717  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1718  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1719  }
1720 
1721  /* Only push if top exists. Otherwise, replace top. */
1722  if (YY_CURRENT_BUFFER)
1723  (yy_buffer_stack_top)++;
1724  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1725 
1726  /* copied from yy_switch_to_buffer. */
1729 }
1730 
1736 {
1737  if (!YY_CURRENT_BUFFER)
1738  return;
1739 
1741  YY_CURRENT_BUFFER_LVALUE = NULL;
1742  if ((yy_buffer_stack_top) > 0)
1743  --(yy_buffer_stack_top);
1744 
1745  if (YY_CURRENT_BUFFER) {
1748  }
1749 }
1750 
1751 /* Allocates the stack if it does not exist.
1752  * Guarantees space for at least one push.
1753  */
1754 static void yyensure_buffer_stack (void)
1755 {
1756  yy_size_t num_to_alloc;
1757 
1758  if (!(yy_buffer_stack)) {
1759 
1760  /* First allocation is just for 2 elements, since we don't know if this
1761  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1762  * immediate realloc on the next call.
1763  */
1764  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1766  (num_to_alloc * sizeof(struct yy_buffer_state*)
1767  );
1768  if ( ! (yy_buffer_stack) )
1769  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1770 
1771  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1772 
1773  (yy_buffer_stack_max) = num_to_alloc;
1774  (yy_buffer_stack_top) = 0;
1775  return;
1776  }
1777 
1778  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1779 
1780  /* Increase the buffer to prepare for a possible push. */
1781  yy_size_t grow_size = 8 /* arbitrary grow size */;
1782 
1783  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1785  ((yy_buffer_stack),
1786  num_to_alloc * sizeof(struct yy_buffer_state*)
1787  );
1788  if ( ! (yy_buffer_stack) )
1789  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1790 
1791  /* zero only the new slots.*/
1792  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1793  (yy_buffer_stack_max) = num_to_alloc;
1794  }
1795 }
1796 
1804 {
1805  YY_BUFFER_STATE b;
1806 
1807  if ( size < 2 ||
1808  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1809  base[size-1] != YY_END_OF_BUFFER_CHAR )
1810  /* They forgot to leave room for the EOB's. */
1811  return NULL;
1812 
1813  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1814  if ( ! b )
1815  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1816 
1817  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1818  b->yy_buf_pos = b->yy_ch_buf = base;
1819  b->yy_is_our_buffer = 0;
1820  b->yy_input_file = NULL;
1821  b->yy_n_chars = b->yy_buf_size;
1822  b->yy_is_interactive = 0;
1823  b->yy_at_bol = 1;
1824  b->yy_fill_buffer = 0;
1826 
1827  yy_switch_to_buffer( b );
1828 
1829  return b;
1830 }
1831 
1840 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1841 {
1842 
1843  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1844 }
1845 
1853 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1854 {
1855  YY_BUFFER_STATE b;
1856  char *buf;
1857  yy_size_t n;
1858  int i;
1859 
1860  /* Get memory for full buffer, including space for trailing EOB's. */
1861  n = (yy_size_t) (_yybytes_len + 2);
1862  buf = (char *) yyalloc( n );
1863  if ( ! buf )
1864  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1865 
1866  for ( i = 0; i < _yybytes_len; ++i )
1867  buf[i] = yybytes[i];
1868 
1869  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1870 
1871  b = yy_scan_buffer( buf, n );
1872  if ( ! b )
1873  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1874 
1875  /* It's okay to grow etc. this buffer, and we should throw it
1876  * away when we're done.
1877  */
1878  b->yy_is_our_buffer = 1;
1879 
1880  return b;
1881 }
1882 
1883 #ifndef YY_EXIT_FAILURE
1884 #define YY_EXIT_FAILURE 2
1885 #endif
1886 
1887 static void yynoreturn yy_fatal_error (const char* msg )
1888 {
1889  fprintf( stderr, "%s\n", msg );
1890  exit( YY_EXIT_FAILURE );
1891 }
1892 
1893 /* Redefine yyless() so it works in section 3 code. */
1894 
1895 #undef yyless
1896 #define yyless(n) \
1897  do \
1898  { \
1899  /* Undo effects of setting up yytext. */ \
1900  int yyless_macro_arg = (n); \
1901  YY_LESS_LINENO(yyless_macro_arg);\
1902  yytext[yyleng] = (yy_hold_char); \
1903  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1904  (yy_hold_char) = *(yy_c_buf_p); \
1905  *(yy_c_buf_p) = '\0'; \
1906  yyleng = yyless_macro_arg; \
1907  } \
1908  while ( 0 )
1909 
1910 /* Accessor methods (get/set functions) to struct members. */
1911 
1915 int yyget_lineno (void)
1916 {
1917 
1918  return yylineno;
1919 }
1920 
1924 FILE *yyget_in (void)
1925 {
1926  return yyin;
1927 }
1928 
1932 FILE *yyget_out (void)
1933 {
1934  return yyout;
1935 }
1936 
1940 int yyget_leng (void)
1941 {
1942  return yyleng;
1943 }
1944 
1949 char *yyget_text (void)
1950 {
1951  return yytext;
1952 }
1953 
1958 void yyset_lineno (int _line_number )
1959 {
1960 
1961  yylineno = _line_number;
1962 }
1963 
1970 void yyset_in (FILE * _in_str )
1971 {
1972  yyin = _in_str ;
1973 }
1974 
1975 void yyset_out (FILE * _out_str )
1976 {
1977  yyout = _out_str ;
1978 }
1979 
1980 int yyget_debug (void)
1981 {
1982  return yy_flex_debug;
1983 }
1984 
1985 void yyset_debug (int _bdebug )
1986 {
1987  yy_flex_debug = _bdebug ;
1988 }
1989 
1990 static int yy_init_globals (void)
1991 {
1992  /* Initialization is the same as for the non-reentrant scanner.
1993  * This function is called from yylex_destroy(), so don't allocate here.
1994  */
1995 
1996  (yy_buffer_stack) = NULL;
1997  (yy_buffer_stack_top) = 0;
1998  (yy_buffer_stack_max) = 0;
1999  (yy_c_buf_p) = NULL;
2000  (yy_init) = 0;
2001  (yy_start) = 0;
2002 
2003 /* Defined in main.c */
2004 #ifdef YY_STDINIT
2005  yyin = stdin;
2006  yyout = stdout;
2007 #else
2008  yyin = NULL;
2009  yyout = NULL;
2010 #endif
2011 
2012  /* For future reference: Set errno on error, since we are called by
2013  * yylex_init()
2014  */
2015  return 0;
2016 }
2017 
2018 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2019 int yylex_destroy (void)
2020 {
2021 
2022  /* Pop the buffer stack, destroying each element. */
2023  while(YY_CURRENT_BUFFER){
2025  YY_CURRENT_BUFFER_LVALUE = NULL;
2027  }
2028 
2029  /* Destroy the stack itself. */
2030  yyfree((yy_buffer_stack) );
2031  (yy_buffer_stack) = NULL;
2032 
2033  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2034  * yylex() is called, initialization will occur. */
2035  yy_init_globals( );
2036 
2037  return 0;
2038 }
2039 
2040 /*
2041  * Internal utility routines.
2042  */
2043 
2044 #ifndef yytext_ptr
2045 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2046 {
2047 
2048  int i;
2049  for ( i = 0; i < n; ++i )
2050  s1[i] = s2[i];
2051 }
2052 #endif
2053 
2054 #ifdef YY_NEED_STRLEN
2055 static int yy_flex_strlen (const char * s )
2056 {
2057  int n;
2058  for ( n = 0; s[n]; ++n )
2059  ;
2060 
2061  return n;
2062 }
2063 #endif
2064 
2065 void *yyalloc (yy_size_t size )
2066 {
2067  return malloc(size);
2068 }
2069 
2070 void *yyrealloc (void * ptr, yy_size_t size )
2071 {
2072 
2073  /* The cast to (char *) in the following accommodates both
2074  * implementations that use char* generic pointers, and those
2075  * that use void* generic pointers. It works with the latter
2076  * because both ANSI C and C++ allow castless assignment from
2077  * any pointer type to void*, and deal with argument conversions
2078  * as though doing an assignment.
2079  */
2080  return realloc(ptr, size);
2081 }
2082 
2083 void yyfree (void * ptr )
2084 {
2085  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2086 }
2087 
2088 #define YYTABLES_NAME "yytables"
2090 #line 113 "scanner.l"
2091 
2092 
2093 int yywrap() { return 1; }
2094 
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:859
yy_trans_info
Definition: ansi_c_lex.yy.cpp:619
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:896
yyless
#define yyless(n)
Definition: assembler_lex.yy.cpp:1896
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:749
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:757
yy_buffer_state
Definition: ansi_c_lex.yy.cpp:446
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:919
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: assembler_lex.yy.cpp:934
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:759
ECHO
#define ECHO
Definition: assembler_lex.yy.cpp:737
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:843
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:1263
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:1884
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:906
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:1990
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:758
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:931
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:442
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:1401
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:734
irept
There are a large number of kinds of tree structured or tree-like data in CPROVER.
Definition: irep.h:394
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:1433
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:1887
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: assembler_lex.yy.cpp:770
yyrealloc
#define yyrealloc
Definition: assembler_lex.yy.cpp:31