Subversion Repositories Kolibri OS

Rev

Rev 5219 | Blame | Compare with Previous | Last modification | View Log | RSS feed

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