home *** CD-ROM | disk | FTP | other *** search
/ Large Pack of OldSkool DOS MOD Trackers / goattracker_2.73.zip / src / asm / lexyy.c < prev    next >
Encoding:
C/C++ Source or Header  |  2014-07-23  |  56.3 KB  |  2,324 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12. #include <unistd.h>
  13.  
  14.  
  15. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  16. #ifdef c_plusplus
  17. #ifndef __cplusplus
  18. #define __cplusplus
  19. #endif
  20. #endif
  21.  
  22.  
  23. #ifdef __cplusplus
  24.  
  25. #include <stdlib.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         YY_RESTORE_YY_MORE_OFFSET \
  130.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  131.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  132.         } \
  133.     while ( 0 )
  134.  
  135. #define unput(c) yyunput( c, yytext_ptr )
  136.  
  137. /* The following is because we cannot portably get our hands on size_t
  138.  * (without autoconf's help, which isn't available because we want
  139.  * flex-generated scanners to compile on their own).
  140.  */
  141. typedef unsigned int yy_size_t;
  142.  
  143.  
  144. struct yy_buffer_state
  145.     {
  146.     FILE *yy_input_file;
  147.  
  148.     char *yy_ch_buf;        /* input buffer */
  149.     char *yy_buf_pos;        /* current position in input buffer */
  150.  
  151.     /* Size of input buffer in bytes, not including room for EOB
  152.      * characters.
  153.      */
  154.     yy_size_t yy_buf_size;
  155.  
  156.     /* Number of characters read into yy_ch_buf, not including EOB
  157.      * characters.
  158.      */
  159.     int yy_n_chars;
  160.  
  161.     /* Whether we "own" the buffer - i.e., we know we created it,
  162.      * and can realloc() it to grow it, and should free() it to
  163.      * delete it.
  164.      */
  165.     int yy_is_our_buffer;
  166.  
  167.     /* Whether this is an "interactive" input source; if so, and
  168.      * if we're using stdio for input, then we want to use getc()
  169.      * instead of fread(), to make sure we stop fetching input after
  170.      * each newline.
  171.      */
  172.     int yy_is_interactive;
  173.  
  174.     /* Whether we're considered to be at the beginning of a line.
  175.      * If so, '^' rules will be active on the next match, otherwise
  176.      * not.
  177.      */
  178.     int yy_at_bol;
  179.  
  180.     /* Whether to try to fill the input buffer when we reach the
  181.      * end of it.
  182.      */
  183.     int yy_fill_buffer;
  184.  
  185.     int yy_buffer_status;
  186. #define YY_BUFFER_NEW 0
  187. #define YY_BUFFER_NORMAL 1
  188.     /* When an EOF's been seen but there's still some text to process
  189.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  190.      * shouldn't try reading from the input source any more.  We might
  191.      * still have a bunch of tokens to match, though, because of
  192.      * possible backing-up.
  193.      *
  194.      * When we actually see the EOF, we change the status to "new"
  195.      * (via yyrestart()), so that the user can continue scanning by
  196.      * just pointing yyin at a new input file.
  197.      */
  198. #define YY_BUFFER_EOF_PENDING 2
  199.     };
  200.  
  201. static YY_BUFFER_STATE yy_current_buffer = 0;
  202.  
  203. /* We provide macros for accessing buffer states in case in the
  204.  * future we want to put the buffer states in a more general
  205.  * "scanner state".
  206.  */
  207. #define YY_CURRENT_BUFFER yy_current_buffer
  208.  
  209.  
  210. /* yy_hold_char holds the character lost when yytext is formed. */
  211. static char yy_hold_char;
  212.  
  213. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  214.  
  215.  
  216. int yyleng;
  217.  
  218. /* Points to current character in buffer. */
  219. static char *yy_c_buf_p = (char *) 0;
  220. static int yy_init = 1;        /* whether we need to initialize */
  221. static int yy_start = 0;    /* start state number */
  222.  
  223. /* Flag which is used to allow yywrap()'s to do buffer switches
  224.  * instead of setting up a fresh yyin.  A bit of a hack ...
  225.  */
  226. static int yy_did_buffer_switch_on_eof;
  227.  
  228.  
  229. void yyrestart YY_PROTO(( FILE *input_file ));
  230.  
  231. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  232. void yy_load_buffer_state YY_PROTO(( void ));
  233. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  234. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  235. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  236. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  237. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  238.  
  239. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  240. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
  241. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  242.  
  243. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  244. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  245. static void yy_flex_free YY_PROTO(( void * ));
  246.  
  247. #define yy_new_buffer yy_create_buffer
  248.  
  249. #define yy_set_interactive(is_interactive) \
  250.     { \
  251.     if ( ! yy_current_buffer ) \
  252.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  253.     yy_current_buffer->yy_is_interactive = is_interactive; \
  254.     }
  255.  
  256. #define yy_set_bol(at_bol) \
  257.     { \
  258.     if ( ! yy_current_buffer ) \
  259.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  260.     yy_current_buffer->yy_at_bol = at_bol; \
  261.     }
  262.  
  263. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  264.  
  265.  
  266. #define yywrap() 1
  267. #define YY_SKIP_YYWRAP
  268. typedef unsigned char YY_CHAR;
  269. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  270. typedef int yy_state_type;
  271. extern char *yytext;
  272. #define yytext_ptr yytext
  273.  
  274. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  275. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  276. static int yy_get_next_buffer YY_PROTO(( void ));
  277. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  278.  
  279. /* Done after the current pattern has been matched and before the
  280.  * corresponding action - sets up yytext.
  281.  */
  282. #define YY_DO_BEFORE_ACTION \
  283.     yytext_ptr = yy_bp; \
  284.     yyleng = (int) (yy_cp - yy_bp); \
  285.     yy_hold_char = *yy_cp; \
  286.     *yy_cp = '\0'; \
  287.     yy_c_buf_p = yy_cp;
  288.  
  289. #define YY_NUM_RULES 111
  290. #define YY_END_OF_BUFFER 112
  291. static yyconst short int yy_accept[256] =
  292.     {   0,
  293.         0,    0,    0,    0,    0,    0,  107,  107,    0,    0,
  294.         0,    0,  112,   93,   92,   91,   93,   74,   16,   81,
  295.        93,   86,   93,   77,   78,   84,   82,   79,   83,   93,
  296.        85,   68,   80,   17,   70,   87,   71,   90,   90,   90,
  297.        90,   90,   90,   90,   90,   90,   90,   90,   90,   90,
  298.        90,   90,   88,   89,   93,   99,   98,   99,   99,  106,
  299.       105,  106,  106,  107,  107,  107,  109,  111,  110,  111,
  300.       102,  101,   91,   73,   69,   75,    0,    0,    0,    0,
  301.         0,    0,    0,    0,   68,   72,   90,   90,   90,   90,
  302.        90,   90,   90,   90,   90,   90,   90,   90,   90,   90,
  303.  
  304.        90,   90,   90,   90,   90,   90,   90,   90,   90,   90,
  305.        90,   90,   90,   90,   90,   90,   90,   90,   90,   76,
  306.        98,    0,    0,  105,    0,    0,  107,  107,  110,  102,
  307.       101,    0,    0,    0,    0,    0,    0,    0,    1,    0,
  308.         0,    0,    0,    0,   27,   24,   65,   52,   53,   50,
  309.        55,   51,   54,   56,   57,   45,   39,   29,   30,   31,
  310.        63,   59,   61,   26,   62,   58,   60,   49,   48,   18,
  311.        19,   20,   64,   40,   25,   34,   36,   35,   37,   67,
  312.        66,   47,   28,   46,   38,   21,   22,   23,   44,   42,
  313.        32,   43,   33,   41,    0,    0,   94,    0,  103,    0,
  314.  
  315.         0,    0,    0,    0,    0,    0,    0,    0,    0,    8,
  316.        13,    0,    0,    0,    0,    0,    0,   15,    0,   10,
  317.         2,    3,    0,    0,    0,    0,    0,    0,   14,   95,
  318.        96,    0,    0,    0,    0,    4,    9,    0,    0,    0,
  319.         6,   97,  104,    0,    0,   11,    0,    0,    0,    7,
  320.         5,   12,    0,  100,    0
  321.     } ;
  322.  
  323. static yyconst int yy_ec[256] =
  324.     {   0,
  325.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  326.         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
  327.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  328.         1,    2,    5,    6,    7,    8,    9,   10,    1,   11,
  329.        12,   13,   14,   15,   16,   17,   18,   19,   19,   19,
  330.        19,   19,   19,   19,   19,   19,   19,   20,   21,   22,
  331.        23,   24,    1,    1,   26,   27,   28,   29,   30,   31,
  332.        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
  333.        42,   43,   44,   45,   46,   47,   48,   49,   50,   36,
  334.         1,    1,    1,    1,   25,    1,   26,   27,   28,   29,
  335.  
  336.        30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
  337.        40,   41,   42,   43,   44,   45,   46,   47,   48,   49,
  338.        50,   36,    1,   51,    1,    1,    1,    1,    1,    1,
  339.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  341.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  344.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  345.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  346.  
  347.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  350.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  352.         1,    1,    1,    1,    1
  353.     } ;
  354.  
  355. static yyconst int yy_meta[52] =
  356.     {   0,
  357.         1,    1,    1,    1,    1,    2,    1,    1,    1,    1,
  358.         1,    1,    1,    1,    1,    1,    3,    1,    4,    1,
  359.         1,    1,    1,    1,    5,    4,    4,    4,    4,    4,
  360.         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
  361.         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
  362.         1
  363.     } ;
  364.  
  365. static yyconst short int yy_base[265] =
  366.     {   0,
  367.         0,    0,   49,   51,   53,   55,   57,   61,   70,   72,
  368.       275,  274,  290,  293,  293,  293,  286,  265,  293,  293,
  369.         0,  293,  277,  293,  293,  293,  293,  293,  293,   50,
  370.       293,  267,  293,  293,  293,  262,  293,   42,   61,   66,
  371.       254,  243,    0,  243,   57,   53,  241,  237,   50,   65,
  372.        79,   68,    0,    0,  228,  293,  293,  275,   62,  293,
  373.       293,  274,   81,    0,    0,  273,  293,  293,  293,  272,
  374.         0,   96,  293,  293,    0,  293,  224,  243,   86,   88,
  375.       246,  228,  240,  229,  249,  293,    0,  239,  237,  228,
  376.        34,  222,  229,  232,  224,   41,   88,  219,   71,  100,
  377.  
  378.       216,  102,  217,  214,  105,  213,  214,  228,  106,  107,
  379.        97,  209,  224,  107,  110,   88,  202,  113,  224,  293,
  380.       293,  105,  218,  293,  209,  216,    0,    0,  293,    0,
  381.       229,  206,  199,  212,  209,  109,  212,  197,  293,  211,
  382.       210,  205,  192,  192,    0,    0,    0,    0,    0,    0,
  383.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  384.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  385.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  386.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  387.         0,    0,    0,    0,  112,  205,  293,  204,  293,  203,
  388.  
  389.       201,  196,  189,  197,  197,  192,  185,  131,  181,  293,
  390.       293,  194,  191,  191,  186,  185,  180,  293,  178,  293,
  391.       293,  293,  183,  165,  144,  131,  136,  135,  293,  293,
  392.       293,  143,  142,  146,  141,  293,  293,  131,  140,  124,
  393.       293,  293,  293,  138,  136,  293,  134,  134,  119,  293,
  394.       293,  293,  121,  293,  293,  179,  184,  189,  194,  199,
  395.       141,  201,  206,  211
  396.     } ;
  397.  
  398. static yyconst short int yy_def[265] =
  399.     {   0,
  400.       255,    1,  256,  256,  257,  257,  258,  258,  259,  259,
  401.       260,  260,  255,  255,  255,  255,  255,  255,  255,  255,
  402.       261,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  403.       255,  255,  255,  255,  255,  255,  255,  262,  262,  262,
  404.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  405.       262,  262,  262,  262,  255,  255,  255,  255,  255,  255,
  406.       255,  255,  255,  263,  263,  263,  255,  255,  255,  255,
  407.       264,  255,  255,  255,  261,  255,  255,  255,  255,  255,
  408.       255,  255,  255,  255,  255,  255,  262,  262,  262,  262,
  409.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  410.  
  411.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  412.       262,  262,  262,  262,  262,  262,  262,  262,  262,  255,
  413.       255,  255,  255,  255,  255,  255,  263,  263,  255,  264,
  414.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  415.       255,  255,  255,  255,  262,  262,  262,  262,  262,  262,
  416.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  417.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  418.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  419.       262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
  420.       262,  262,  262,  262,  255,  255,  255,  255,  255,  255,
  421.  
  422.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  423.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  424.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  425.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  426.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  427.       255,  255,  255,  255,    0,  255,  255,  255,  255,  255,
  428.       255,  255,  255,  255
  429.     } ;
  430.  
  431. static yyconst short int yy_nxt[345] =
  432.     {   0,
  433.        14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
  434.        24,   25,   26,   27,   28,   29,   30,   31,   32,   33,
  435.        34,   35,   36,   37,   14,   38,   39,   40,   41,   42,
  436.        43,   43,   43,   44,   45,   43,   46,   43,   47,   48,
  437.        49,   43,   50,   51,   52,   43,   43,   43,   53,   54,
  438.        55,   57,   58,   57,   58,   61,   62,   61,   62,   65,
  439.        66,  148,   67,   65,   66,   59,   67,   59,  154,   63,
  440.        88,   63,   69,   70,   69,   70,   77,  149,   78,   79,
  441.        89,  105,  109,   80,  155,   90,  110,   81,   91,   82,
  442.        92,  122,   83,  116,  103,  123,  106,   84,   93,   94,
  443.  
  444.       104,   95,   97,   98,  111,  113,   99,   96,  114,  112,
  445.       125,  117,  131,  135,  126,  156,  118,  119,  139,  159,
  446.       160,  157,  136,  115,  137,  132,  140,  161,  138,  165,
  447.       170,  176,  178,  180,  184,  186,  189,  190,  192,  181,
  448.       185,  195,  204,  196,   75,  213,  177,  179,  162,  163,
  449.       166,  167,  205,  171,  172,  214,  193,  225,  187,  188,
  450.       254,  253,  252,  251,  250,  249,  248,  226,  247,  246,
  451.       245,  244,  243,  242,  241,  240,  239,  238,  227,   56,
  452.        56,   56,   56,   56,   60,   60,   60,   60,   60,   64,
  453.        64,   64,   64,   64,   68,   68,   68,   68,   68,   71,
  454.  
  455.        71,   71,   71,   71,   87,   87,  127,  237,  127,  127,
  456.       127,  130,  130,  236,  130,  130,  235,  234,  233,  232,
  457.       231,  230,  229,  228,  224,  223,  222,  221,  220,  219,
  458.       218,  217,  216,  215,  212,  211,  210,  209,  208,  207,
  459.       206,  203,  202,  201,  200,  131,  199,  198,  197,  194,
  460.       191,  183,  182,  175,  174,  173,  169,  168,  164,  158,
  461.       153,  152,  151,  150,  147,  146,  145,   85,  144,  143,
  462.       142,  141,  134,  133,  129,  128,  124,  121,  120,  108,
  463.       107,  102,  101,  100,   86,   85,   76,   74,   73,  255,
  464.        72,   72,   13,  255,  255,  255,  255,  255,  255,  255,
  465.  
  466.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  467.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  468.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  469.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  470.       255,  255,  255,  255
  471.     } ;
  472.  
  473. static yyconst short int yy_chk[345] =
  474.     {   0,
  475.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  476.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  477.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  478.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  479.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  480.         1,    3,    3,    4,    4,    5,    5,    6,    6,    7,
  481.         7,   91,    7,    8,    8,    3,    8,    4,   96,    5,
  482.        38,    6,    9,    9,   10,   10,   30,   91,   30,   30,
  483.        38,   46,   49,   30,   96,   38,   49,   30,   39,   30,
  484.        39,   59,   30,   52,   45,   59,   46,   30,   39,   39,
  485.  
  486.        45,   39,   40,   40,   50,   51,   40,   39,   51,   50,
  487.        63,   52,   72,   79,   63,   97,   52,   52,   80,   99,
  488.        99,   97,   79,   51,   79,   72,   80,  100,   79,  102,
  489.       105,  109,  110,  111,  114,  115,  116,  116,  118,  111,
  490.       114,  122,  136,  122,  261,  195,  109,  110,  100,  100,
  491.       102,  102,  136,  105,  105,  195,  118,  208,  115,  115,
  492.       253,  249,  248,  247,  245,  244,  240,  208,  239,  238,
  493.       235,  234,  233,  232,  228,  227,  226,  225,  208,  256,
  494.       256,  256,  256,  256,  257,  257,  257,  257,  257,  258,
  495.       258,  258,  258,  258,  259,  259,  259,  259,  259,  260,
  496.  
  497.       260,  260,  260,  260,  262,  262,  263,  224,  263,  263,
  498.       263,  264,  264,  223,  264,  264,  219,  217,  216,  215,
  499.       214,  213,  212,  209,  207,  206,  205,  204,  203,  202,
  500.       201,  200,  198,  196,  144,  143,  142,  141,  140,  138,
  501.       137,  135,  134,  133,  132,  131,  126,  125,  123,  119,
  502.       117,  113,  112,  108,  107,  106,  104,  103,  101,   98,
  503.        95,   94,   93,   92,   90,   89,   88,   85,   84,   83,
  504.        82,   81,   78,   77,   70,   66,   62,   58,   55,   48,
  505.        47,   44,   42,   41,   36,   32,   23,   18,   17,   13,
  506.        12,   11,  255,  255,  255,  255,  255,  255,  255,  255,
  507.  
  508.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  509.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  510.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  511.       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
  512.       255,  255,  255,  255
  513.     } ;
  514.  
  515. static yy_state_type yy_last_accepting_state;
  516. static char *yy_last_accepting_cpos;
  517.  
  518. /* The intent behind this definition is that it'll catch
  519.  * any uses of REJECT which flex missed.
  520.  */
  521. #define REJECT reject_used_but_not_detected
  522. #define yymore() yymore_used_but_not_detected
  523. #define YY_MORE_ADJ 0
  524. #define YY_RESTORE_YY_MORE_OFFSET
  525. char *yytext;
  526. // #line 1 "asm.yy"
  527. #define INITIAL 0
  528. /* scanner for a simple assembler */
  529. // #line 3 "asm.yy"
  530. #include <stdio.h>
  531. #include <string.h>
  532. #include "int.h"
  533. #include "membuf.h"
  534. #include "parse.h"
  535. #include "asmtab.h"
  536.  
  537.  
  538.  
  539. #define MAX_SRC_BUFFER_DEPTH 10
  540. static YY_BUFFER_STATE src_buffers[MAX_SRC_BUFFER_DEPTH];
  541. static int src_buffer_depth = 0;
  542.  
  543. static char *strdupped_get(char *text);
  544. static int strdupped_cmp(const void *a, const void *b);
  545. static void strdupped_free(void *a);
  546.  
  547. int num_lines = 1;
  548. int push_state_skip = 0;
  549. int push_state_init = 0;
  550. int push_state_macro = 0;
  551. struct vec strdupped[1];
  552.  
  553. #define SKIP 1
  554. #define SKIP_ALL 2
  555. #define QUOTED_STRING 3
  556. #define SKIP_LINE 4
  557. #define MACROO 5
  558.  
  559. #define YY_STACK_USED 1
  560. // #line 558 "lex.yy.c"
  561.  
  562. /* Macros after this point can all be overridden by user definitions in
  563.  * section 1.
  564.  */
  565.  
  566. #ifndef YY_SKIP_YYWRAP
  567. #ifdef __cplusplus
  568. extern "C" int yywrap YY_PROTO(( void ));
  569. #else
  570. extern int yywrap YY_PROTO(( void ));
  571. #endif
  572. #endif
  573.  
  574. #ifndef YY_NO_UNPUT
  575. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  576. #endif
  577.  
  578. #ifndef yytext_ptr
  579. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  580. #endif
  581.  
  582. #ifdef YY_NEED_STRLEN
  583. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  584. #endif
  585.  
  586. #ifndef YY_NO_INPUT
  587. #ifdef __cplusplus
  588. static int yyinput YY_PROTO(( void ));
  589. #else
  590. static int input YY_PROTO(( void ));
  591. #endif
  592. #endif
  593.  
  594. #if YY_STACK_USED
  595. static int yy_start_stack_ptr = 0;
  596. static int yy_start_stack_depth = 0;
  597. static int *yy_start_stack = 0;
  598. #ifndef YY_NO_PUSH_STATE
  599. static void yy_push_state YY_PROTO(( int new_state ));
  600. #endif
  601. #ifndef YY_NO_POP_STATE
  602. static void yy_pop_state YY_PROTO(( void ));
  603. #endif
  604. #ifndef YY_NO_TOP_STATE
  605. static int yy_top_state YY_PROTO(( void ));
  606. #endif
  607.  
  608. #else
  609. #define YY_NO_PUSH_STATE 1
  610. #define YY_NO_POP_STATE 1
  611. #define YY_NO_TOP_STATE 1
  612. #endif
  613.  
  614. #ifdef YY_MALLOC_DECL
  615. YY_MALLOC_DECL
  616. #else
  617. #if __STDC__
  618. #ifndef __cplusplus
  619. #include <stdlib.h>
  620. #endif
  621. #else
  622. /* Just try to get by without declaring the routines.  This will fail
  623.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  624.  * or sizeof(void*) != sizeof(int).
  625.  */
  626. #endif
  627. #endif
  628.  
  629. /* Amount of stuff to slurp up with each read. */
  630. #ifndef YY_READ_BUF_SIZE
  631. #define YY_READ_BUF_SIZE 8192
  632. #endif
  633.  
  634. /* Copy whatever the last rule matched to the standard output. */
  635.  
  636. #ifndef ECHO
  637. /* This used to be an fputs(), but since the string might contain NUL's,
  638.  * we now use fwrite().
  639.  */
  640. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  641. #endif
  642.  
  643. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  644.  * is returned in "result".
  645.  */
  646. #ifndef YY_INPUT
  647. #define YY_INPUT(buf,result,max_size) \
  648.     if ( yy_current_buffer->yy_is_interactive ) \
  649.         { \
  650.         int c = '*', n; \
  651.         for ( n = 0; n < max_size && \
  652.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  653.             buf[n] = (char) c; \
  654.         if ( c == '\n' ) \
  655.             buf[n++] = (char) c; \
  656.         if ( c == EOF && ferror( yyin ) ) \
  657.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  658.         result = n; \
  659.         } \
  660.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  661.           && ferror( yyin ) ) \
  662.         YY_FATAL_ERROR( "input in flex scanner failed" );
  663. #endif
  664.  
  665. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  666.  * we don't want an extra ';' after the "return" because that will cause
  667.  * some compilers to complain about unreachable statements.
  668.  */
  669. #ifndef yyterminate
  670. #define yyterminate() return YY_NULL
  671. #endif
  672.  
  673. /* Number of entries by which start-condition stack grows. */
  674. #ifndef YY_START_STACK_INCR
  675. #define YY_START_STACK_INCR 25
  676. #endif
  677.  
  678. /* Report a fatal error. */
  679. #ifndef YY_FATAL_ERROR
  680. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  681. #endif
  682.  
  683. /* Default declaration of generated scanner - a define so the user can
  684.  * easily add parameters.
  685.  */
  686. #ifndef YY_DECL
  687. #define YY_DECL int yylex YY_PROTO(( void ))
  688. #endif
  689.  
  690. /* Code executed at the beginning of each rule, after yytext and yyleng
  691.  * have been set up.
  692.  */
  693. #ifndef YY_USER_ACTION
  694. #define YY_USER_ACTION
  695. #endif
  696.  
  697. /* Code executed at the end of each rule. */
  698. #ifndef YY_BREAK
  699. #define YY_BREAK break;
  700. #endif
  701.  
  702. #define YY_RULE_SETUP \
  703.     YY_USER_ACTION
  704.  
  705. YY_DECL
  706.     {
  707.     register yy_state_type yy_current_state;
  708.     register char *yy_cp = NULL, *yy_bp = NULL;
  709.     register int yy_act;
  710.  
  711. // #line 32 "asm.yy"
  712.  
  713.  
  714.     if(push_state_init)
  715.     {push_state_init = 0; yy_push_state(INITIAL); }
  716.     if(push_state_skip)
  717.     {push_state_skip = 0; yy_push_state(SKIP); }
  718.     if(push_state_macro)
  719.     {push_state_macro = 0; yy_push_state(MACROO); }
  720.  
  721. // #line 719 "lex.yy.c"
  722.  
  723.     if ( yy_init )
  724.         {
  725.         yy_init = 0;
  726.  
  727. #ifdef YY_USER_INIT
  728.         YY_USER_INIT;
  729. #endif
  730.  
  731.         if ( ! yy_start )
  732.             yy_start = 1;    /* first start state */
  733.  
  734.         if ( ! yyin )
  735.             yyin = stdin;
  736.  
  737.         if ( ! yyout )
  738.             yyout = stdout;
  739.  
  740.         if ( ! yy_current_buffer )
  741.             yy_current_buffer =
  742.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  743.  
  744.         yy_load_buffer_state();
  745.         }
  746.  
  747.     while ( 1 )        /* loops until end-of-file is reached */
  748.         {
  749.         yy_cp = yy_c_buf_p;
  750.  
  751.         /* Support of yytext. */
  752.         *yy_cp = yy_hold_char;
  753.  
  754.         /* yy_bp points to the position in yy_ch_buf of the start of
  755.          * the current run.
  756.          */
  757.         yy_bp = yy_cp;
  758.  
  759.         yy_current_state = yy_start;
  760. yy_match:
  761.         do
  762.             {
  763.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  764.             if ( yy_accept[yy_current_state] )
  765.                 {
  766.                 yy_last_accepting_state = yy_current_state;
  767.                 yy_last_accepting_cpos = yy_cp;
  768.                 }
  769.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  770.                 {
  771.                 yy_current_state = (int) yy_def[yy_current_state];
  772.                 if ( yy_current_state >= 256 )
  773.                     yy_c = yy_meta[(unsigned int) yy_c];
  774.                 }
  775.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  776.             ++yy_cp;
  777.             }
  778.         while ( yy_current_state != 255 );
  779.         yy_cp = yy_last_accepting_cpos;
  780.         yy_current_state = yy_last_accepting_state;
  781.  
  782. yy_find_action:
  783.         yy_act = yy_accept[yy_current_state];
  784.  
  785.         YY_DO_BEFORE_ACTION;
  786.  
  787.  
  788. do_action:    /* This label is used only to access EOF actions. */
  789.  
  790.  
  791.         switch ( yy_act )
  792.     { /* beginning of action switch */
  793.             case 0: /* must back up */
  794.             /* undo the effects of YY_DO_BEFORE_ACTION */
  795.             *yy_cp = yy_hold_char;
  796.             yy_cp = yy_last_accepting_cpos;
  797.             yy_current_state = yy_last_accepting_state;
  798.             goto yy_find_action;
  799.  
  800. case 1:
  801. YY_RULE_SETUP
  802. // #line 41 "asm.yy"
  803. return IF;
  804.     YY_BREAK
  805. case 2:
  806. YY_RULE_SETUP
  807. // #line 42 "asm.yy"
  808. BEGIN(SKIP_ALL);
  809.     YY_BREAK
  810. case 3:
  811. YY_RULE_SETUP
  812. // #line 43 "asm.yy"
  813. BEGIN(SKIP);
  814.     YY_BREAK
  815. case 4:
  816. YY_RULE_SETUP
  817. // #line 44 "asm.yy"
  818. yy_pop_state();
  819.     YY_BREAK
  820. case 5:
  821. YY_RULE_SETUP
  822. // #line 46 "asm.yy"
  823. return INCLUDE;
  824.     YY_BREAK
  825. case 6:
  826. YY_RULE_SETUP
  827. // #line 47 "asm.yy"
  828. return MACRO;
  829.     YY_BREAK
  830. case 7:
  831. YY_RULE_SETUP
  832. // #line 49 "asm.yy"
  833. return DEFINED;
  834.     YY_BREAK
  835. case 8:
  836. YY_RULE_SETUP
  837. // #line 50 "asm.yy"
  838. return ORG;
  839.     YY_BREAK
  840. case 9:
  841. YY_RULE_SETUP
  842. // #line 51 "asm.yy"
  843. return ASMERROR;
  844.     YY_BREAK
  845. case 10:
  846. YY_RULE_SETUP
  847. // #line 52 "asm.yy"
  848. return ECHO;
  849.     YY_BREAK
  850. case 11:
  851. YY_RULE_SETUP
  852. // #line 53 "asm.yy"
  853. return INCBIN;
  854.     YY_BREAK
  855. case 12:
  856. YY_RULE_SETUP
  857. // #line 54 "asm.yy"
  858. return INCWORD;
  859.     YY_BREAK
  860. case 13:
  861. YY_RULE_SETUP
  862. // #line 55 "asm.yy"
  863. return RES;
  864.     YY_BREAK
  865. case 14:
  866. YY_RULE_SETUP
  867. // #line 56 "asm.yy"
  868. return WORD;
  869.     YY_BREAK
  870. case 15:
  871. YY_RULE_SETUP
  872. // #line 57 "asm.yy"
  873. return BYTE;
  874.     YY_BREAK
  875. case 16:
  876. YY_RULE_SETUP
  877. // #line 59 "asm.yy"
  878. BEGIN(QUOTED_STRING);
  879.     YY_BREAK
  880. case 17:
  881. YY_RULE_SETUP
  882. // #line 60 "asm.yy"
  883. BEGIN(SKIP_LINE);
  884.     YY_BREAK
  885. case 18:
  886. YY_RULE_SETUP
  887. // #line 62 "asm.yy"
  888. return LDA;
  889.     YY_BREAK
  890. case 19:
  891. YY_RULE_SETUP
  892. // #line 63 "asm.yy"
  893. return LDX;
  894.     YY_BREAK
  895. case 20:
  896. YY_RULE_SETUP
  897. // #line 64 "asm.yy"
  898. return LDY;
  899.     YY_BREAK
  900. case 21:
  901. YY_RULE_SETUP
  902. // #line 65 "asm.yy"
  903. return STA;
  904.     YY_BREAK
  905. case 22:
  906. YY_RULE_SETUP
  907. // #line 66 "asm.yy"
  908. return STX;
  909.     YY_BREAK
  910. case 23:
  911. YY_RULE_SETUP
  912. // #line 67 "asm.yy"
  913. return STY;
  914.     YY_BREAK
  915. case 24:
  916. YY_RULE_SETUP
  917. // #line 68 "asm.yy"
  918. return AND;
  919.     YY_BREAK
  920. case 25:
  921. YY_RULE_SETUP
  922. // #line 69 "asm.yy"
  923. return ORA;
  924.     YY_BREAK
  925. case 26:
  926. YY_RULE_SETUP
  927. // #line 70 "asm.yy"
  928. return EOR;
  929.     YY_BREAK
  930. case 27:
  931. YY_RULE_SETUP
  932. // #line 71 "asm.yy"
  933. return ADC;
  934.     YY_BREAK
  935. case 28:
  936. YY_RULE_SETUP
  937. // #line 72 "asm.yy"
  938. return SBC;
  939.     YY_BREAK
  940. case 29:
  941. YY_RULE_SETUP
  942. // #line 73 "asm.yy"
  943. return CMP;
  944.     YY_BREAK
  945. case 30:
  946. YY_RULE_SETUP
  947. // #line 74 "asm.yy"
  948. return CPX;
  949.     YY_BREAK
  950. case 31:
  951. YY_RULE_SETUP
  952. // #line 75 "asm.yy"
  953. return CPY;
  954.     YY_BREAK
  955. case 32:
  956. YY_RULE_SETUP
  957. // #line 77 "asm.yy"
  958. return TSX;
  959.     YY_BREAK
  960. case 33:
  961. YY_RULE_SETUP
  962. // #line 78 "asm.yy"
  963. return TXS;
  964.     YY_BREAK
  965. case 34:
  966. YY_RULE_SETUP
  967. // #line 79 "asm.yy"
  968. return PHA;
  969.     YY_BREAK
  970. case 35:
  971. YY_RULE_SETUP
  972. // #line 80 "asm.yy"
  973. return PLA;
  974.     YY_BREAK
  975. case 36:
  976. YY_RULE_SETUP
  977. // #line 81 "asm.yy"
  978. return PHP;
  979.     YY_BREAK
  980. case 37:
  981. YY_RULE_SETUP
  982. // #line 82 "asm.yy"
  983. return PLP;
  984.     YY_BREAK
  985. case 38:
  986. YY_RULE_SETUP
  987. // #line 83 "asm.yy"
  988. return SEI;
  989.     YY_BREAK
  990. case 39:
  991. YY_RULE_SETUP
  992. // #line 84 "asm.yy"
  993. return CLI;
  994.     YY_BREAK
  995. case 40:
  996. YY_RULE_SETUP
  997. // #line 85 "asm.yy"
  998. return NOP;
  999.     YY_BREAK
  1000. case 41:
  1001. YY_RULE_SETUP
  1002. // #line 86 "asm.yy"
  1003. return TYA;
  1004.     YY_BREAK
  1005. case 42:
  1006. YY_RULE_SETUP
  1007. // #line 87 "asm.yy"
  1008. return TAY;
  1009.     YY_BREAK
  1010. case 43:
  1011. YY_RULE_SETUP
  1012. // #line 88 "asm.yy"
  1013. return TXA;
  1014.     YY_BREAK
  1015. case 44:
  1016. YY_RULE_SETUP
  1017. // #line 89 "asm.yy"
  1018. return TAX;
  1019.     YY_BREAK
  1020. case 45:
  1021. YY_RULE_SETUP
  1022. // #line 90 "asm.yy"
  1023. return CLC;
  1024.     YY_BREAK
  1025. case 46:
  1026. YY_RULE_SETUP
  1027. // #line 91 "asm.yy"
  1028. return SEC;
  1029.     YY_BREAK
  1030. case 47:
  1031. YY_RULE_SETUP
  1032. // #line 92 "asm.yy"
  1033. return RTS;
  1034.     YY_BREAK
  1035. case 48:
  1036. YY_RULE_SETUP
  1037. // #line 94 "asm.yy"
  1038. return JSR;
  1039.     YY_BREAK
  1040. case 49:
  1041. YY_RULE_SETUP
  1042. // #line 95 "asm.yy"
  1043. return JMP;
  1044.     YY_BREAK
  1045. case 50:
  1046. YY_RULE_SETUP
  1047. // #line 96 "asm.yy"
  1048. return BEQ;
  1049.     YY_BREAK
  1050. case 51:
  1051. YY_RULE_SETUP
  1052. // #line 97 "asm.yy"
  1053. return BNE;
  1054.     YY_BREAK
  1055. case 52:
  1056. YY_RULE_SETUP
  1057. // #line 98 "asm.yy"
  1058. return BCC;
  1059.     YY_BREAK
  1060. case 53:
  1061. YY_RULE_SETUP
  1062. // #line 99 "asm.yy"
  1063. return BCS;
  1064.     YY_BREAK
  1065. case 54:
  1066. YY_RULE_SETUP
  1067. // #line 100 "asm.yy"
  1068. return BPL;
  1069.     YY_BREAK
  1070. case 55:
  1071. YY_RULE_SETUP
  1072. // #line 101 "asm.yy"
  1073. return BMI;
  1074.     YY_BREAK
  1075. case 56:
  1076. YY_RULE_SETUP
  1077. // #line 102 "asm.yy"
  1078. return BVC;
  1079.     YY_BREAK
  1080. case 57:
  1081. YY_RULE_SETUP
  1082. // #line 103 "asm.yy"
  1083. return BCS;
  1084.     YY_BREAK
  1085. case 58:
  1086. YY_RULE_SETUP
  1087. // #line 104 "asm.yy"
  1088. return INX;
  1089.     YY_BREAK
  1090. case 59:
  1091. YY_RULE_SETUP
  1092. // #line 105 "asm.yy"
  1093. return DEX;
  1094.     YY_BREAK
  1095. case 60:
  1096. YY_RULE_SETUP
  1097. // #line 106 "asm.yy"
  1098. return INY;
  1099.     YY_BREAK
  1100. case 61:
  1101. YY_RULE_SETUP
  1102. // #line 107 "asm.yy"
  1103. return DEY;
  1104.     YY_BREAK
  1105. case 62:
  1106. YY_RULE_SETUP
  1107. // #line 108 "asm.yy"
  1108. return INC;
  1109.     YY_BREAK
  1110. case 63:
  1111. YY_RULE_SETUP
  1112. // #line 109 "asm.yy"
  1113. return DEC;
  1114.     YY_BREAK
  1115. case 64:
  1116. YY_RULE_SETUP
  1117. // #line 110 "asm.yy"
  1118. return LSR;
  1119.     YY_BREAK
  1120. case 65:
  1121. YY_RULE_SETUP
  1122. // #line 111 "asm.yy"
  1123. return ASL;
  1124.     YY_BREAK
  1125. case 66:
  1126. YY_RULE_SETUP
  1127. // #line 112 "asm.yy"
  1128. return ROR;
  1129.     YY_BREAK
  1130. case 67:
  1131. YY_RULE_SETUP
  1132. // #line 113 "asm.yy"
  1133. return ROL;
  1134.     YY_BREAK
  1135. case 68:
  1136. YY_RULE_SETUP
  1137. // #line 115 "asm.yy"
  1138. { yylval.num = atoi(yytext); return NUMBER; }
  1139.     YY_BREAK
  1140. case 69:
  1141. YY_RULE_SETUP
  1142. // #line 117 "asm.yy"
  1143. { yylval.num = strtol(yytext + 1, NULL, 16); return NUMBER; }
  1144.     YY_BREAK
  1145. case 70:
  1146. YY_RULE_SETUP
  1147. // #line 119 "asm.yy"
  1148. return LT;
  1149.     YY_BREAK
  1150. case 71:
  1151. YY_RULE_SETUP
  1152. // #line 120 "asm.yy"
  1153. return GT;
  1154.     YY_BREAK
  1155. case 72:
  1156. YY_RULE_SETUP
  1157. // #line 121 "asm.yy"
  1158. return EQ;
  1159.     YY_BREAK
  1160. case 73:
  1161. YY_RULE_SETUP
  1162. // #line 122 "asm.yy"
  1163. return NEQ;
  1164.     YY_BREAK
  1165. case 74:
  1166. YY_RULE_SETUP
  1167. // #line 123 "asm.yy"
  1168. return LNOT;
  1169.     YY_BREAK
  1170. case 75:
  1171. YY_RULE_SETUP
  1172. // #line 124 "asm.yy"
  1173. return LAND;
  1174.     YY_BREAK
  1175. case 76:
  1176. YY_RULE_SETUP
  1177. // #line 125 "asm.yy"
  1178. return LOR;
  1179.     YY_BREAK
  1180. case 77:
  1181. YY_RULE_SETUP
  1182. // #line 127 "asm.yy"
  1183. return LPAREN;
  1184.     YY_BREAK
  1185. case 78:
  1186. YY_RULE_SETUP
  1187. // #line 128 "asm.yy"
  1188. return RPAREN;
  1189.     YY_BREAK
  1190. case 79:
  1191. YY_RULE_SETUP
  1192. // #line 129 "asm.yy"
  1193. return COMMA;
  1194.     YY_BREAK
  1195. case 80:
  1196. YY_RULE_SETUP
  1197. // #line 130 "asm.yy"
  1198. return COLON;
  1199.     YY_BREAK
  1200. case 81:
  1201. YY_RULE_SETUP
  1202. // #line 131 "asm.yy"
  1203. return HASH;
  1204.     YY_BREAK
  1205. case 82:
  1206. YY_RULE_SETUP
  1207. // #line 132 "asm.yy"
  1208. return PLUS;
  1209.     YY_BREAK
  1210. case 83:
  1211. YY_RULE_SETUP
  1212. // #line 133 "asm.yy"
  1213. return MINUS;
  1214.     YY_BREAK
  1215. case 84:
  1216. YY_RULE_SETUP
  1217. // #line 134 "asm.yy"
  1218. return MULT;
  1219.     YY_BREAK
  1220. case 85:
  1221. YY_RULE_SETUP
  1222. // #line 135 "asm.yy"
  1223. return DIV;
  1224.     YY_BREAK
  1225. case 86:
  1226. YY_RULE_SETUP
  1227. // #line 136 "asm.yy"
  1228. return MOD;
  1229.     YY_BREAK
  1230. case 87:
  1231. YY_RULE_SETUP
  1232. // #line 138 "asm.yy"
  1233. return ASSIGN;
  1234.     YY_BREAK
  1235. case 88:
  1236. YY_RULE_SETUP
  1237. // #line 140 "asm.yy"
  1238. return X;
  1239.     YY_BREAK
  1240. case 89:
  1241. YY_RULE_SETUP
  1242. // #line 141 "asm.yy"
  1243. return Y;
  1244.     YY_BREAK
  1245. case 90:
  1246. YY_RULE_SETUP
  1247. // #line 143 "asm.yy"
  1248. { yylval.str = strdupped_get(yytext); return SYMBOL; }
  1249.     YY_BREAK
  1250. case 91:
  1251. YY_RULE_SETUP
  1252. // #line 145 "asm.yy"
  1253. ++num_lines;
  1254.     YY_BREAK
  1255. case 92:
  1256. YY_RULE_SETUP
  1257. // #line 147 "asm.yy"
  1258. /* eat whitespace */
  1259.     YY_BREAK
  1260. case 93:
  1261. YY_RULE_SETUP
  1262. // #line 149 "asm.yy"
  1263. printf("unknown character found %s\n", yytext);
  1264.     YY_BREAK
  1265. case 94:
  1266. YY_RULE_SETUP
  1267. // #line 151 "asm.yy"
  1268. yy_push_state(SKIP_ALL);
  1269.     YY_BREAK
  1270. case 95:
  1271. YY_RULE_SETUP
  1272. // #line 152 "asm.yy"
  1273. { yy_pop_state(); return IF; }
  1274.     YY_BREAK
  1275. case 96:
  1276. YY_RULE_SETUP
  1277. // #line 153 "asm.yy"
  1278. BEGIN(INITIAL);
  1279.     YY_BREAK
  1280. case 97:
  1281. YY_RULE_SETUP
  1282. // #line 154 "asm.yy"
  1283. yy_pop_state();
  1284.     YY_BREAK
  1285. case 98:
  1286. YY_RULE_SETUP
  1287. // #line 155 "asm.yy"
  1288. ++num_lines;
  1289.     YY_BREAK
  1290. case 99:
  1291. YY_RULE_SETUP
  1292. // #line 156 "asm.yy"
  1293.  
  1294.     YY_BREAK
  1295. case 100:
  1296. YY_RULE_SETUP
  1297. // #line 158 "asm.yy"
  1298. yy_pop_state();
  1299.     YY_BREAK
  1300. case 101:
  1301. YY_RULE_SETUP
  1302. // #line 159 "asm.yy"
  1303. { yylval.str = yytext; return MACRO_STRING; }
  1304.     YY_BREAK
  1305. case 102:
  1306. YY_RULE_SETUP
  1307. // #line 160 "asm.yy"
  1308. { yylval.str = yytext; return MACRO_STRING; }
  1309.     YY_BREAK
  1310. case 103:
  1311. YY_RULE_SETUP
  1312. // #line 162 "asm.yy"
  1313. yy_push_state(SKIP_ALL);
  1314.     YY_BREAK
  1315. case 104:
  1316. YY_RULE_SETUP
  1317. // #line 163 "asm.yy"
  1318. yy_pop_state();
  1319.     YY_BREAK
  1320. case 105:
  1321. YY_RULE_SETUP
  1322. // #line 164 "asm.yy"
  1323. ++num_lines;
  1324.     YY_BREAK
  1325. case 106:
  1326. YY_RULE_SETUP
  1327. // #line 165 "asm.yy"
  1328.  
  1329.     YY_BREAK
  1330. case 107:
  1331. YY_RULE_SETUP
  1332. // #line 167 "asm.yy"
  1333. {
  1334.     yylval.str = strdupped_get(yytext);
  1335.     return STRING;
  1336. }
  1337.     YY_BREAK
  1338. case 108:
  1339. YY_RULE_SETUP
  1340. // #line 171 "asm.yy"
  1341. ++num_lines;
  1342.     YY_BREAK
  1343. case 109:
  1344. YY_RULE_SETUP
  1345. // #line 172 "asm.yy"
  1346. BEGIN(INITIAL);
  1347.     YY_BREAK
  1348. case 110:
  1349. YY_RULE_SETUP
  1350. // #line 174 "asm.yy"
  1351. { ++num_lines; BEGIN(INITIAL); }
  1352.     YY_BREAK
  1353. case YY_STATE_EOF(INITIAL):
  1354. case YY_STATE_EOF(SKIP):
  1355. case YY_STATE_EOF(SKIP_ALL):
  1356. case YY_STATE_EOF(QUOTED_STRING):
  1357. case YY_STATE_EOF(SKIP_LINE):
  1358. case YY_STATE_EOF(MACROO):
  1359. // #line 176 "asm.yy"
  1360. {
  1361.         if(--src_buffer_depth == 0)
  1362.         {
  1363.             yyterminate();
  1364.         }
  1365.         else
  1366.         {
  1367.         yy_delete_buffer(YY_CURRENT_BUFFER);
  1368.         yy_switch_to_buffer(src_buffers[src_buffer_depth]);
  1369.         }
  1370.     }
  1371.     YY_BREAK
  1372. case 111:
  1373. YY_RULE_SETUP
  1374. // #line 188 "asm.yy"
  1375. ECHO;
  1376.     YY_BREAK
  1377. // #line 1375 "lex.yy.c"
  1378.  
  1379.     case YY_END_OF_BUFFER:
  1380.         {
  1381.         /* Amount of text matched not including the EOB char. */
  1382.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1383.  
  1384.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1385.         *yy_cp = yy_hold_char;
  1386.         YY_RESTORE_YY_MORE_OFFSET
  1387.  
  1388.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1389.             {
  1390.             /* We're scanning a new file or input source.  It's
  1391.              * possible that this happened because the user
  1392.              * just pointed yyin at a new source and called
  1393.              * yylex().  If so, then we have to assure
  1394.              * consistency between yy_current_buffer and our
  1395.              * globals.  Here is the right place to do so, because
  1396.              * this is the first action (other than possibly a
  1397.              * back-up) that will match for the new input source.
  1398.              */
  1399.             yy_n_chars = yy_current_buffer->yy_n_chars;
  1400.             yy_current_buffer->yy_input_file = yyin;
  1401.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1402.             }
  1403.  
  1404.         /* Note that here we test for yy_c_buf_p "<=" to the position
  1405.          * of the first EOB in the buffer, since yy_c_buf_p will
  1406.          * already have been incremented past the NUL character
  1407.          * (since all states make transitions on EOB to the
  1408.          * end-of-buffer state).  Contrast this with the test
  1409.          * in input().
  1410.          */
  1411.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1412.             { /* This was really a NUL. */
  1413.             yy_state_type yy_next_state;
  1414.  
  1415.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1416.  
  1417.             yy_current_state = yy_get_previous_state();
  1418.  
  1419.             /* Okay, we're now positioned to make the NUL
  1420.              * transition.  We couldn't have
  1421.              * yy_get_previous_state() go ahead and do it
  1422.              * for us because it doesn't know how to deal
  1423.              * with the possibility of jamming (and we don't
  1424.              * want to build jamming into it because then it
  1425.              * will run more slowly).
  1426.              */
  1427.  
  1428.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  1429.  
  1430.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  1431.  
  1432.             if ( yy_next_state )
  1433.                 {
  1434.                 /* Consume the NUL. */
  1435.                 yy_cp = ++yy_c_buf_p;
  1436.                 yy_current_state = yy_next_state;
  1437.                 goto yy_match;
  1438.                 }
  1439.  
  1440.             else
  1441.                 {
  1442.                 yy_cp = yy_last_accepting_cpos;
  1443.                 yy_current_state = yy_last_accepting_state;
  1444.                 goto yy_find_action;
  1445.                 }
  1446.             }
  1447.  
  1448.         else switch ( yy_get_next_buffer() )
  1449.             {
  1450.             case EOB_ACT_END_OF_FILE:
  1451.                 {
  1452.                 yy_did_buffer_switch_on_eof = 0;
  1453.  
  1454.                 if ( yywrap() )
  1455.                     {
  1456.                     /* Note: because we've taken care in
  1457.                      * yy_get_next_buffer() to have set up
  1458.                      * yytext, we can now set up
  1459.                      * yy_c_buf_p so that if some total
  1460.                      * hoser (like flex itself) wants to
  1461.                      * call the scanner after we return the
  1462.                      * YY_NULL, it'll still work - another
  1463.                      * YY_NULL will get returned.
  1464.                      */
  1465.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1466.  
  1467.                     yy_act = YY_STATE_EOF(YY_START);
  1468.                     goto do_action;
  1469.                     }
  1470.  
  1471.                 else
  1472.                     {
  1473.                     if ( ! yy_did_buffer_switch_on_eof )
  1474.                         YY_NEW_FILE;
  1475.                     }
  1476.                 break;
  1477.                 }
  1478.  
  1479.             case EOB_ACT_CONTINUE_SCAN:
  1480.                 yy_c_buf_p =
  1481.                     yytext_ptr + yy_amount_of_matched_text;
  1482.  
  1483.                 yy_current_state = yy_get_previous_state();
  1484.  
  1485.                 yy_cp = yy_c_buf_p;
  1486.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1487.                 goto yy_match;
  1488.  
  1489.             case EOB_ACT_LAST_MATCH:
  1490.                 yy_c_buf_p =
  1491.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1492.  
  1493.                 yy_current_state = yy_get_previous_state();
  1494.  
  1495.                 yy_cp = yy_c_buf_p;
  1496.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1497.                 goto yy_find_action;
  1498.             }
  1499.         break;
  1500.         }
  1501.  
  1502.     default:
  1503.         YY_FATAL_ERROR(
  1504.             "fatal flex scanner internal error--no action found" );
  1505.     } /* end of action switch */
  1506.         } /* end of scanning one token */
  1507.     } /* end of yylex */
  1508.  
  1509.  
  1510. /* yy_get_next_buffer - try to read in a new buffer
  1511.  *
  1512.  * Returns a code representing an action:
  1513.  *    EOB_ACT_LAST_MATCH -
  1514.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1515.  *    EOB_ACT_END_OF_FILE - end of file
  1516.  */
  1517.  
  1518. static int yy_get_next_buffer()
  1519.     {
  1520.     register char *dest = yy_current_buffer->yy_ch_buf;
  1521.     register char *source = yytext_ptr;
  1522.     register int number_to_move, i;
  1523.     int ret_val;
  1524.  
  1525.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1526.         YY_FATAL_ERROR(
  1527.         "fatal flex scanner internal error--end of buffer missed" );
  1528.  
  1529.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  1530.         { /* Don't try to fill the buffer, so this is an EOF. */
  1531.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1532.             {
  1533.             /* We matched a single character, the EOB, so
  1534.              * treat this as a final EOF.
  1535.              */
  1536.             return EOB_ACT_END_OF_FILE;
  1537.             }
  1538.  
  1539.         else
  1540.             {
  1541.             /* We matched some text prior to the EOB, first
  1542.              * process it.
  1543.              */
  1544.             return EOB_ACT_LAST_MATCH;
  1545.             }
  1546.         }
  1547.  
  1548.     /* Try to read more data. */
  1549.  
  1550.     /* First move last chars to start of buffer. */
  1551.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1552.  
  1553.     for ( i = 0; i < number_to_move; ++i )
  1554.         *(dest++) = *(source++);
  1555.  
  1556.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1557.         /* don't do the read, it's not guaranteed to return an EOF,
  1558.          * just force an EOF
  1559.          */
  1560.         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  1561.  
  1562.     else
  1563.         {
  1564.         int num_to_read =
  1565.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1566.  
  1567.         while ( num_to_read <= 0 )
  1568.             { /* Not enough room in the buffer - grow it. */
  1569. #ifdef YY_USES_REJECT
  1570.             YY_FATAL_ERROR(
  1571. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1572. #else
  1573.  
  1574.             /* just a shorter name for the current buffer */
  1575.             YY_BUFFER_STATE b = yy_current_buffer;
  1576.  
  1577.             int yy_c_buf_p_offset =
  1578.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  1579.  
  1580.             if ( b->yy_is_our_buffer )
  1581.                 {
  1582.                 int new_size = b->yy_buf_size * 2;
  1583.  
  1584.                 if ( new_size <= 0 )
  1585.                     b->yy_buf_size += b->yy_buf_size / 8;
  1586.                 else
  1587.                     b->yy_buf_size *= 2;
  1588.  
  1589.                 b->yy_ch_buf = (char *)
  1590.                     /* Include room in for 2 EOB chars. */
  1591.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  1592.                              b->yy_buf_size + 2 );
  1593.                 }
  1594.             else
  1595.                 /* Can't grow it, we don't own it. */
  1596.                 b->yy_ch_buf = 0;
  1597.  
  1598.             if ( ! b->yy_ch_buf )
  1599.                 YY_FATAL_ERROR(
  1600.                 "fatal error - scanner input buffer overflow" );
  1601.  
  1602.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1603.  
  1604.             num_to_read = yy_current_buffer->yy_buf_size -
  1605.                         number_to_move - 1;
  1606. #endif
  1607.             }
  1608.  
  1609.         if ( num_to_read > YY_READ_BUF_SIZE )
  1610.             num_to_read = YY_READ_BUF_SIZE;
  1611.  
  1612.         /* Read in more data. */
  1613.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1614.             yy_n_chars, num_to_read );
  1615.  
  1616.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1617.         }
  1618.  
  1619.     if ( yy_n_chars == 0 )
  1620.         {
  1621.         if ( number_to_move == YY_MORE_ADJ )
  1622.             {
  1623.             ret_val = EOB_ACT_END_OF_FILE;
  1624.             yyrestart( yyin );
  1625.             }
  1626.  
  1627.         else
  1628.             {
  1629.             ret_val = EOB_ACT_LAST_MATCH;
  1630.             yy_current_buffer->yy_buffer_status =
  1631.                 YY_BUFFER_EOF_PENDING;
  1632.             }
  1633.         }
  1634.  
  1635.     else
  1636.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1637.  
  1638.     yy_n_chars += number_to_move;
  1639.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1640.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1641.  
  1642.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1643.  
  1644.     return ret_val;
  1645.     }
  1646.  
  1647.  
  1648. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1649.  
  1650. static yy_state_type yy_get_previous_state()
  1651.     {
  1652.     register yy_state_type yy_current_state;
  1653.     register char *yy_cp;
  1654.  
  1655.     yy_current_state = yy_start;
  1656.  
  1657.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1658.         {
  1659.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1660.         if ( yy_accept[yy_current_state] )
  1661.             {
  1662.             yy_last_accepting_state = yy_current_state;
  1663.             yy_last_accepting_cpos = yy_cp;
  1664.             }
  1665.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1666.             {
  1667.             yy_current_state = (int) yy_def[yy_current_state];
  1668.             if ( yy_current_state >= 256 )
  1669.                 yy_c = yy_meta[(unsigned int) yy_c];
  1670.             }
  1671.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1672.         }
  1673.  
  1674.     return yy_current_state;
  1675.     }
  1676.  
  1677.  
  1678. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1679.  *
  1680.  * synopsis
  1681.  *    next_state = yy_try_NUL_trans( current_state );
  1682.  */
  1683.  
  1684. #ifdef YY_USE_PROTOS
  1685. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1686. #else
  1687. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1688. yy_state_type yy_current_state;
  1689. #endif
  1690.     {
  1691.     register int yy_is_jam;
  1692.     register char *yy_cp = yy_c_buf_p;
  1693.  
  1694.     register YY_CHAR yy_c = 1;
  1695.     if ( yy_accept[yy_current_state] )
  1696.         {
  1697.         yy_last_accepting_state = yy_current_state;
  1698.         yy_last_accepting_cpos = yy_cp;
  1699.         }
  1700.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1701.         {
  1702.         yy_current_state = (int) yy_def[yy_current_state];
  1703.         if ( yy_current_state >= 256 )
  1704.             yy_c = yy_meta[(unsigned int) yy_c];
  1705.         }
  1706.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1707.     yy_is_jam = (yy_current_state == 255);
  1708.  
  1709.     return yy_is_jam ? 0 : yy_current_state;
  1710.     }
  1711.  
  1712.  
  1713. #ifndef YY_NO_UNPUT
  1714. #ifdef YY_USE_PROTOS
  1715. static void yyunput( int c, register char *yy_bp )
  1716. #else
  1717. static void yyunput( c, yy_bp )
  1718. int c;
  1719. register char *yy_bp;
  1720. #endif
  1721.     {
  1722.     register char *yy_cp = yy_c_buf_p;
  1723.  
  1724.     /* undo effects of setting up yytext */
  1725.     *yy_cp = yy_hold_char;
  1726.  
  1727.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1728.         { /* need to shift things up to make room */
  1729.         /* +2 for EOB chars. */
  1730.         register int number_to_move = yy_n_chars + 2;
  1731.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1732.                     yy_current_buffer->yy_buf_size + 2];
  1733.         register char *source =
  1734.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1735.  
  1736.         while ( source > yy_current_buffer->yy_ch_buf )
  1737.             *--dest = *--source;
  1738.  
  1739.         yy_cp += (int) (dest - source);
  1740.         yy_bp += (int) (dest - source);
  1741.         yy_current_buffer->yy_n_chars =
  1742.             yy_n_chars = yy_current_buffer->yy_buf_size;
  1743.  
  1744.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1745.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1746.         }
  1747.  
  1748.     *--yy_cp = (char) c;
  1749.  
  1750.  
  1751.     yytext_ptr = yy_bp;
  1752.     yy_hold_char = *yy_cp;
  1753.     yy_c_buf_p = yy_cp;
  1754.     }
  1755. #endif    /* ifndef YY_NO_UNPUT */
  1756.  
  1757.  
  1758. #ifdef __cplusplus
  1759. static int yyinput()
  1760. #else
  1761. static int input()
  1762. #endif
  1763.     {
  1764.     int c;
  1765.  
  1766.     *yy_c_buf_p = yy_hold_char;
  1767.  
  1768.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1769.         {
  1770.         /* yy_c_buf_p now points to the character we want to return.
  1771.          * If this occurs *before* the EOB characters, then it's a
  1772.          * valid NUL; if not, then we've hit the end of the buffer.
  1773.          */
  1774.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1775.             /* This was really a NUL. */
  1776.             *yy_c_buf_p = '\0';
  1777.  
  1778.         else
  1779.             { /* need more input */
  1780.             int offset = yy_c_buf_p - yytext_ptr;
  1781.             ++yy_c_buf_p;
  1782.  
  1783.             switch ( yy_get_next_buffer() )
  1784.                 {
  1785.                 case EOB_ACT_LAST_MATCH:
  1786.                     /* This happens because yy_g_n_b()
  1787.                      * sees that we've accumulated a
  1788.                      * token and flags that we need to
  1789.                      * try matching the token before
  1790.                      * proceeding.  But for input(),
  1791.                      * there's no matching to consider.
  1792.                      * So convert the EOB_ACT_LAST_MATCH
  1793.                      * to EOB_ACT_END_OF_FILE.
  1794.                      */
  1795.  
  1796.                     /* Reset buffer status. */
  1797.                     yyrestart( yyin );
  1798.  
  1799.                     /* fall through */
  1800.  
  1801.                 case EOB_ACT_END_OF_FILE:
  1802.                     {
  1803.                     if ( yywrap() )
  1804.                         return EOF;
  1805.  
  1806.                     if ( ! yy_did_buffer_switch_on_eof )
  1807.                         YY_NEW_FILE;
  1808. #ifdef __cplusplus
  1809.                     return yyinput();
  1810. #else
  1811.                     return input();
  1812. #endif
  1813.                     }
  1814.  
  1815.                 case EOB_ACT_CONTINUE_SCAN:
  1816.                     yy_c_buf_p = yytext_ptr + offset;
  1817.                     break;
  1818.                 }
  1819.             }
  1820.         }
  1821.  
  1822.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1823.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1824.     yy_hold_char = *++yy_c_buf_p;
  1825.  
  1826.  
  1827.     return c;
  1828.     }
  1829.  
  1830.  
  1831. #ifdef YY_USE_PROTOS
  1832. void yyrestart( FILE *input_file )
  1833. #else
  1834. void yyrestart( input_file )
  1835. FILE *input_file;
  1836. #endif
  1837.     {
  1838.     if ( ! yy_current_buffer )
  1839.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1840.  
  1841.     yy_init_buffer( yy_current_buffer, input_file );
  1842.     yy_load_buffer_state();
  1843.     }
  1844.  
  1845.  
  1846. #ifdef YY_USE_PROTOS
  1847. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1848. #else
  1849. void yy_switch_to_buffer( new_buffer )
  1850. YY_BUFFER_STATE new_buffer;
  1851. #endif
  1852.     {
  1853.     if ( yy_current_buffer == new_buffer )
  1854.         return;
  1855.  
  1856.     if ( yy_current_buffer )
  1857.         {
  1858.         /* Flush out information for old buffer. */
  1859.         *yy_c_buf_p = yy_hold_char;
  1860.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1861.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1862.         }
  1863.  
  1864.     yy_current_buffer = new_buffer;
  1865.     yy_load_buffer_state();
  1866.  
  1867.     /* We don't actually know whether we did this switch during
  1868.      * EOF (yywrap()) processing, but the only time this flag
  1869.      * is looked at is after yywrap() is called, so it's safe
  1870.      * to go ahead and always set it.
  1871.      */
  1872.     yy_did_buffer_switch_on_eof = 1;
  1873.     }
  1874.  
  1875.  
  1876. #ifdef YY_USE_PROTOS
  1877. void yy_load_buffer_state( void )
  1878. #else
  1879. void yy_load_buffer_state()
  1880. #endif
  1881.     {
  1882.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1883.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1884.     yyin = yy_current_buffer->yy_input_file;
  1885.     yy_hold_char = *yy_c_buf_p;
  1886.     }
  1887.  
  1888.  
  1889. #ifdef YY_USE_PROTOS
  1890. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1891. #else
  1892. YY_BUFFER_STATE yy_create_buffer( file, size )
  1893. FILE *file;
  1894. int size;
  1895. #endif
  1896.     {
  1897.     YY_BUFFER_STATE b;
  1898.  
  1899.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1900.     if ( ! b )
  1901.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1902.  
  1903.     b->yy_buf_size = size;
  1904.  
  1905.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1906.      * we need to put in 2 end-of-buffer characters.
  1907.      */
  1908.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1909.     if ( ! b->yy_ch_buf )
  1910.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1911.  
  1912.     b->yy_is_our_buffer = 1;
  1913.  
  1914.     yy_init_buffer( b, file );
  1915.  
  1916.     return b;
  1917.     }
  1918.  
  1919.  
  1920. #ifdef YY_USE_PROTOS
  1921. void yy_delete_buffer( YY_BUFFER_STATE b )
  1922. #else
  1923. void yy_delete_buffer( b )
  1924. YY_BUFFER_STATE b;
  1925. #endif
  1926.     {
  1927.  
  1928.     if ( ! b )
  1929.         return;
  1930.  
  1931.     if ( b == yy_current_buffer )
  1932.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1933.  
  1934.     if ( b->yy_is_our_buffer )
  1935.         yy_flex_free( (void *) b->yy_ch_buf );
  1936.  
  1937.     yy_flex_free( (void *) b );
  1938.     }
  1939.  
  1940.  
  1941.  
  1942. #ifdef YY_USE_PROTOS
  1943. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1944. #else
  1945. void yy_init_buffer( b, file )
  1946. YY_BUFFER_STATE b;
  1947. FILE *file;
  1948. #endif
  1949.  
  1950.  
  1951.     {
  1952.     yy_flush_buffer( b );
  1953.  
  1954.     b->yy_input_file = file;
  1955.     b->yy_fill_buffer = 1;
  1956.  
  1957. #if YY_ALWAYS_INTERACTIVE
  1958.     b->yy_is_interactive = 1;
  1959. #else
  1960. #if YY_NEVER_INTERACTIVE
  1961.     b->yy_is_interactive = 0;
  1962. #else
  1963.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1964. #endif
  1965. #endif
  1966.     }
  1967.  
  1968.  
  1969. #ifdef YY_USE_PROTOS
  1970. void yy_flush_buffer( YY_BUFFER_STATE b )
  1971. #else
  1972. void yy_flush_buffer( b )
  1973. YY_BUFFER_STATE b;
  1974. #endif
  1975.  
  1976.     {
  1977.     if ( ! b )
  1978.         return;
  1979.  
  1980.     b->yy_n_chars = 0;
  1981.  
  1982.     /* We always need two end-of-buffer characters.  The first causes
  1983.      * a transition to the end-of-buffer state.  The second causes
  1984.      * a jam in that state.
  1985.      */
  1986.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1987.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1988.  
  1989.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1990.  
  1991.     b->yy_at_bol = 1;
  1992.     b->yy_buffer_status = YY_BUFFER_NEW;
  1993.  
  1994.     if ( b == yy_current_buffer )
  1995.         yy_load_buffer_state();
  1996.     }
  1997.  
  1998.  
  1999. #ifndef YY_NO_SCAN_BUFFER
  2000. #ifdef YY_USE_PROTOS
  2001. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  2002. #else
  2003. YY_BUFFER_STATE yy_scan_buffer( base, size )
  2004. char *base;
  2005. yy_size_t size;
  2006. #endif
  2007.     {
  2008.     YY_BUFFER_STATE b;
  2009.  
  2010.     if ( size < 2 ||
  2011.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  2012.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  2013.         /* They forgot to leave room for the EOB's. */
  2014.         return 0;
  2015.  
  2016.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  2017.     if ( ! b )
  2018.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  2019.  
  2020.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  2021.     b->yy_buf_pos = b->yy_ch_buf = base;
  2022.     b->yy_is_our_buffer = 0;
  2023.     b->yy_input_file = 0;
  2024.     b->yy_n_chars = b->yy_buf_size;
  2025.     b->yy_is_interactive = 0;
  2026.     b->yy_at_bol = 1;
  2027.     b->yy_fill_buffer = 0;
  2028.     b->yy_buffer_status = YY_BUFFER_NEW;
  2029.  
  2030.     yy_switch_to_buffer( b );
  2031.  
  2032.     return b;
  2033.     }
  2034. #endif
  2035.  
  2036.  
  2037. #ifndef YY_NO_SCAN_STRING
  2038. #ifdef YY_USE_PROTOS
  2039. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  2040. #else
  2041. YY_BUFFER_STATE yy_scan_string( yy_str )
  2042. yyconst char *yy_str;
  2043. #endif
  2044.     {
  2045.     int len;
  2046.     for ( len = 0; yy_str[len]; ++len )
  2047.         ;
  2048.  
  2049.     return yy_scan_bytes( yy_str, len );
  2050.     }
  2051. #endif
  2052.  
  2053.  
  2054. #ifndef YY_NO_SCAN_BYTES
  2055. #ifdef YY_USE_PROTOS
  2056. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  2057. #else
  2058. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  2059. yyconst char *bytes;
  2060. int len;
  2061. #endif
  2062.     {
  2063.     YY_BUFFER_STATE b;
  2064.     char *buf;
  2065.     yy_size_t n;
  2066.     int i;
  2067.  
  2068.     /* Get memory for full buffer, including space for trailing EOB's. */
  2069.     n = len + 2;
  2070.     buf = (char *) yy_flex_alloc( n );
  2071.     if ( ! buf )
  2072.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  2073.  
  2074.     for ( i = 0; i < len; ++i )
  2075.         buf[i] = bytes[i];
  2076.  
  2077.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  2078.  
  2079.     b = yy_scan_buffer( buf, n );
  2080.     if ( ! b )
  2081.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  2082.  
  2083.     /* It's okay to grow etc. this buffer, and we should throw it
  2084.      * away when we're done.
  2085.      */
  2086.     b->yy_is_our_buffer = 1;
  2087.  
  2088.     return b;
  2089.     }
  2090. #endif
  2091.  
  2092.  
  2093. #ifndef YY_NO_PUSH_STATE
  2094. #ifdef YY_USE_PROTOS
  2095. static void yy_push_state( int new_state )
  2096. #else
  2097. static void yy_push_state( new_state )
  2098. int new_state;
  2099. #endif
  2100.     {
  2101.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  2102.         {
  2103.         yy_size_t new_size;
  2104.  
  2105.         yy_start_stack_depth += YY_START_STACK_INCR;
  2106.         new_size = yy_start_stack_depth * sizeof( int );
  2107.  
  2108.         if ( ! yy_start_stack )
  2109.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  2110.  
  2111.         else
  2112.             yy_start_stack = (int *) yy_flex_realloc(
  2113.                     (void *) yy_start_stack, new_size );
  2114.  
  2115.         if ( ! yy_start_stack )
  2116.             YY_FATAL_ERROR(
  2117.             "out of memory expanding start-condition stack" );
  2118.         }
  2119.  
  2120.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  2121.  
  2122.     BEGIN(new_state);
  2123.     }
  2124. #endif
  2125.  
  2126.  
  2127. #ifndef YY_NO_POP_STATE
  2128. static void yy_pop_state()
  2129.     {
  2130.     if ( --yy_start_stack_ptr < 0 )
  2131.         YY_FATAL_ERROR( "start-condition stack underflow" );
  2132.  
  2133.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  2134.     }
  2135. #endif
  2136.  
  2137.  
  2138. #ifndef YY_NO_TOP_STATE
  2139. static int yy_top_state()
  2140.     {
  2141.     return yy_start_stack[yy_start_stack_ptr - 1];
  2142.     }
  2143. #endif
  2144.  
  2145. #ifndef YY_EXIT_FAILURE
  2146. #define YY_EXIT_FAILURE 2
  2147. #endif
  2148.  
  2149. #ifdef YY_USE_PROTOS
  2150. static void yy_fatal_error( yyconst char msg[] )
  2151. #else
  2152. static void yy_fatal_error( msg )
  2153. char msg[];
  2154. #endif
  2155.     {
  2156.     (void) fprintf( stderr, "%s\n", msg );
  2157.     exit( YY_EXIT_FAILURE );
  2158.     }
  2159.  
  2160.  
  2161.  
  2162. /* Redefine yyless() so it works in section 3 code. */
  2163.  
  2164. #undef yyless
  2165. #define yyless(n) \
  2166.     do \
  2167.         { \
  2168.         /* Undo effects of setting up yytext. */ \
  2169.         yytext[yyleng] = yy_hold_char; \
  2170.         yy_c_buf_p = yytext + n; \
  2171.         yy_hold_char = *yy_c_buf_p; \
  2172.         *yy_c_buf_p = '\0'; \
  2173.         yyleng = n; \
  2174.         } \
  2175.     while ( 0 )
  2176.  
  2177.  
  2178. /* Internal utility routines. */
  2179.  
  2180. #ifndef yytext_ptr
  2181. #ifdef YY_USE_PROTOS
  2182. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  2183. #else
  2184. static void yy_flex_strncpy( s1, s2, n )
  2185. char *s1;
  2186. yyconst char *s2;
  2187. int n;
  2188. #endif
  2189.     {
  2190.     register int i;
  2191.     for ( i = 0; i < n; ++i )
  2192.         s1[i] = s2[i];
  2193.     }
  2194. #endif
  2195.  
  2196. #ifdef YY_NEED_STRLEN
  2197. #ifdef YY_USE_PROTOS
  2198. static int yy_flex_strlen( yyconst char *s )
  2199. #else
  2200. static int yy_flex_strlen( s )
  2201. yyconst char *s;
  2202. #endif
  2203.     {
  2204.     register int n;
  2205.     for ( n = 0; s[n]; ++n )
  2206.         ;
  2207.  
  2208.     return n;
  2209.     }
  2210. #endif
  2211.  
  2212.  
  2213. #ifdef YY_USE_PROTOS
  2214. static void *yy_flex_alloc( yy_size_t size )
  2215. #else
  2216. static void *yy_flex_alloc( size )
  2217. yy_size_t size;
  2218. #endif
  2219.     {
  2220.     return (void *) malloc( size );
  2221.     }
  2222.  
  2223. #ifdef YY_USE_PROTOS
  2224. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  2225. #else
  2226. static void *yy_flex_realloc( ptr, size )
  2227. void *ptr;
  2228. yy_size_t size;
  2229. #endif
  2230.     {
  2231.     /* The cast to (char *) in the following accommodates both
  2232.      * implementations that use char* generic pointers, and those
  2233.      * that use void* generic pointers.  It works with the latter
  2234.      * because both ANSI C and C++ allow castless assignment from
  2235.      * any pointer type to void*, and deal with argument conversions
  2236.      * as though doing an assignment.
  2237.      */
  2238.     return (void *) realloc( (char *) ptr, size );
  2239.     }
  2240.  
  2241. #ifdef YY_USE_PROTOS
  2242. static void yy_flex_free( void *ptr )
  2243. #else
  2244. static void yy_flex_free( ptr )
  2245. void *ptr;
  2246. #endif
  2247.     {
  2248.     free( ptr );
  2249.     }
  2250.  
  2251. #if YY_MAIN
  2252. int main()
  2253.     {
  2254.     yylex();
  2255.     return 0;
  2256.     }
  2257. #endif
  2258. // #line 188 "asm.yy"
  2259.  
  2260.  
  2261. void scanner_init()
  2262. {
  2263.     vec_init(strdupped, sizeof(char*));
  2264. }
  2265.  
  2266. void asm_src_buffer_push(struct membuf *buffer)
  2267. {
  2268.     if(src_buffer_depth == MAX_SRC_BUFFER_DEPTH)
  2269.     {
  2270.     fprintf(stderr, "source buffers nested too deep\n");
  2271.     exit(-1);
  2272.     }
  2273.     src_buffers[src_buffer_depth++] = YY_CURRENT_BUFFER;
  2274.     yy_scan_bytes(membuf_get(buffer), membuf_memlen(buffer));
  2275. }
  2276.  
  2277. static char *strdupped_get(char *text)
  2278. {
  2279.     char **pp;
  2280.     /*printf("get \"%s\" => ", text);*/
  2281.     if(vec_insert_uniq(strdupped, strdupped_cmp, &text, (void*)&pp))
  2282.     {
  2283.         /* replace the pointer to <text> since <text> will be reused */
  2284.         *pp = strdup(text);
  2285.     }
  2286.     /*printf("%p\n", *pp);*/
  2287.     return *pp;
  2288. }
  2289.  
  2290. static void strdupped_free(void *a)
  2291. {
  2292.     char *b = *(char**)a;
  2293.     /*printf("free => %p \"%s\"\n", b, b);*/
  2294.     free(b);
  2295. }
  2296.  
  2297. static int strdupped_cmp(const void *a, const void *b)
  2298. {
  2299.     char *c = *(char**)a;
  2300.     char *d = *(char**)b;
  2301.  
  2302.     return strcmp(c, d);
  2303. }
  2304.  
  2305. void scanner_free()
  2306. {
  2307.     vec_free(strdupped, strdupped_free);
  2308. }
  2309.  
  2310. void yycleanup()
  2311. {
  2312.   if (YY_CURRENT_BUFFER)
  2313.     yy_delete_buffer(YY_CURRENT_BUFFER);
  2314.   if (yy_start_stack)
  2315.   {
  2316.       yy_flex_free(yy_start_stack);
  2317.       yy_start_stack = 0;
  2318.       yy_start_stack_ptr = 0;
  2319.       yy_start_stack_depth = 0;
  2320.   }
  2321. }
  2322.  
  2323.  
  2324.