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 33
   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 __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: #else
   50: typedef signed char flex_int8_t;
   51: typedef short int flex_int16_t;
   52: typedef int flex_int32_t;
   53: typedef unsigned char flex_uint8_t; 
   54: typedef unsigned short int flex_uint16_t;
   55: typedef unsigned int flex_uint32_t;
   56: #endif /* ! C99 */
   57: 
   58: /* Limits of integral types. */
   59: #ifndef INT8_MIN
   60: #define INT8_MIN               (-128)
   61: #endif
   62: #ifndef INT16_MIN
   63: #define INT16_MIN              (-32767-1)
   64: #endif
   65: #ifndef INT32_MIN
   66: #define INT32_MIN              (-2147483647-1)
   67: #endif
   68: #ifndef INT8_MAX
   69: #define INT8_MAX               (127)
   70: #endif
   71: #ifndef INT16_MAX
   72: #define INT16_MAX              (32767)
   73: #endif
   74: #ifndef INT32_MAX
   75: #define INT32_MAX              (2147483647)
   76: #endif
   77: #ifndef UINT8_MAX
   78: #define UINT8_MAX              (255U)
   79: #endif
   80: #ifndef UINT16_MAX
   81: #define UINT16_MAX             (65535U)
   82: #endif
   83: #ifndef UINT32_MAX
   84: #define UINT32_MAX             (4294967295U)
   85: #endif
   86: 
   87: #endif /* ! FLEXINT_H */
   88: 
   89: #ifdef __cplusplus
   90: 
   91: /* The "const" storage-class-modifier is valid. */
   92: #define YY_USE_CONST
   93: 
   94: #else   /* ! __cplusplus */
   95: 
   96: #if __STDC__
   97: 
   98: #define YY_USE_CONST
   99: 
  100: #endif  /* __STDC__ */
  101: #endif  /* ! __cplusplus */
  102: 
  103: #ifdef YY_USE_CONST
  104: #define yyconst const
  105: #else
  106: #define yyconst
  107: #endif
  108: 
  109: /* Returned upon end-of-file. */
  110: #define YY_NULL 0
  111: 
  112: /* Promotes a possibly negative, possibly signed char to an unsigned
  113:  * integer for use as an array index.  If the signed char is negative,
  114:  * we want to instead treat it as an 8-bit unsigned char, hence the
  115:  * double cast.
  116:  */
  117: #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  118: 
  119: /* Enter a start condition.  This macro really ought to take a parameter,
  120:  * but we do it the disgusting crufty way forced on us by the ()-less
  121:  * definition of BEGIN.
  122:  */
  123: #define BEGIN (yy_start) = 1 + 2 *
  124: 
  125: /* Translate the current start state into a value that can be later handed
  126:  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  127:  * compatibility.
  128:  */
  129: #define YY_START (((yy_start) - 1) / 2)
  130: #define YYSTATE YY_START
  131: 
  132: /* Action number for EOF rule of a given start state. */
  133: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  134: 
  135: /* Special action meaning "start processing a new file". */
  136: #define YY_NEW_FILE yyrestart(yyin  )
  137: 
  138: #define YY_END_OF_BUFFER_CHAR 0
  139: 
  140: /* Size of default input buffer. */
  141: #ifndef YY_BUF_SIZE
  142: #define YY_BUF_SIZE 16384
  143: #endif
  144: 
  145: /* The state buf must be large enough to hold one state per character in the main buffer.
  146:  */
  147: #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
  148: 
  149: #ifndef YY_TYPEDEF_YY_BUFFER_STATE
  150: #define YY_TYPEDEF_YY_BUFFER_STATE
  151: typedef struct yy_buffer_state *YY_BUFFER_STATE;
  152: #endif
  153: 
  154: extern int yyleng;
  155: 
  156: extern FILE *yyin, *yyout;
  157: 
  158: #define EOB_ACT_CONTINUE_SCAN 0
  159: #define EOB_ACT_END_OF_FILE 1
  160: #define EOB_ACT_LAST_MATCH 2
  161: 
  162:     #define YY_LESS_LINENO(n)
  163:     
  164: /* Return all but the first "n" matched characters back to the input stream. */
  165: #define yyless(n) \
  166:         do \
  167:                 { \
  168:                 /* Undo effects of setting up yytext. */ \
  169:         int yyless_macro_arg = (n); \
  170:         YY_LESS_LINENO(yyless_macro_arg);\
  171:                 *yy_cp = (yy_hold_char); \
  172:                 YY_RESTORE_YY_MORE_OFFSET \
  173:                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
  174:                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  175:                 } \
  176:         while ( 0 )
  177: 
  178: #define unput(c) yyunput( c, (yytext_ptr)  )
  179: 
  180: /* The following is because we cannot portably get our hands on size_t
  181:  * (without autoconf's help, which isn't available because we want
  182:  * flex-generated scanners to compile on their own).
  183:  */
  184: 
  185: #ifndef YY_TYPEDEF_YY_SIZE_T
  186: #define YY_TYPEDEF_YY_SIZE_T
  187: typedef unsigned int yy_size_t;
  188: #endif
  189: 
  190: #ifndef YY_STRUCT_YY_BUFFER_STATE
  191: #define YY_STRUCT_YY_BUFFER_STATE
  192: struct yy_buffer_state
  193:         {
  194:         FILE *yy_input_file;
  195: 
  196:         char *yy_ch_buf;               /* input buffer */
  197:         char *yy_buf_pos;              /* current position in input buffer */
  198: 
  199:         /* Size of input buffer in bytes, not including room for EOB
  200:          * characters.
  201:          */
  202:         yy_size_t yy_buf_size;
  203: 
  204:         /* Number of characters read into yy_ch_buf, not including EOB
  205:          * characters.
  206:          */
  207:         int yy_n_chars;
  208: 
  209:         /* Whether we "own" the buffer - i.e., we know we created it,
  210:          * and can realloc() it to grow it, and should free() it to
  211:          * delete it.
  212:          */
  213:         int yy_is_our_buffer;
  214: 
  215:         /* Whether this is an "interactive" input source; if so, and
  216:          * if we're using stdio for input, then we want to use getc()
  217:          * instead of fread(), to make sure we stop fetching input after
  218:          * each newline.
  219:          */
  220:         int yy_is_interactive;
  221: 
  222:         /* Whether we're considered to be at the beginning of a line.
  223:          * If so, '^' rules will be active on the next match, otherwise
  224:          * not.
  225:          */
  226:         int yy_at_bol;
  227: 
  228:     int yy_bs_lineno; /**< The line count. */
  229:     int yy_bs_column; /**< The column count. */
  230:     
  231:         /* Whether to try to fill the input buffer when we reach the
  232:          * end of it.
  233:          */
  234:         int yy_fill_buffer;
  235: 
  236:         int yy_buffer_status;
  237: 
  238: #define YY_BUFFER_NEW 0
  239: #define YY_BUFFER_NORMAL 1
  240:         /* When an EOF's been seen but there's still some text to process
  241:          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  242:          * shouldn't try reading from the input source any more.  We might
  243:          * still have a bunch of tokens to match, though, because of
  244:          * possible backing-up.
  245:          *
  246:          * When we actually see the EOF, we change the status to "new"
  247:          * (via yyrestart()), so that the user can continue scanning by
  248:          * just pointing yyin at a new input file.
  249:          */
  250: #define YY_BUFFER_EOF_PENDING 2
  251: 
  252:         };
  253: #endif /* !YY_STRUCT_YY_BUFFER_STATE */
  254: 
  255: /* Stack of input buffers. */
  256: static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
  257: static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
  258: static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
  259: 
  260: /* We provide macros for accessing buffer states in case in the
  261:  * future we want to put the buffer states in a more general
  262:  * "scanner state".
  263:  *
  264:  * Returns the top of the stack, or NULL.
  265:  */
  266: #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
  267:                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
  268:                           : NULL)
  269: 
  270: /* Same as previous macro, but useful when we know that the buffer stack is not
  271:  * NULL or when we need an lvalue. For internal use only.
  272:  */
  273: #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
  274: 
  275: /* yy_hold_char holds the character lost when yytext is formed. */
  276: static char yy_hold_char;
  277: static int yy_n_chars;          /* number of characters read into yy_ch_buf */
  278: int yyleng;
  279: 
  280: /* Points to current character in buffer. */
  281: static char *yy_c_buf_p = (char *) 0;
  282: static int yy_init = 0;         /* whether we need to initialize */
  283: static int yy_start = 0;        /* start state number */
  284: 
  285: /* Flag which is used to allow yywrap()'s to do buffer switches
  286:  * instead of setting up a fresh yyin.  A bit of a hack ...
  287:  */
  288: static int yy_did_buffer_switch_on_eof;
  289: 
  290: void yyrestart (FILE *input_file  );
  291: void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
  292: YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
  293: void yy_delete_buffer (YY_BUFFER_STATE b  );
  294: void yy_flush_buffer (YY_BUFFER_STATE b  );
  295: void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
  296: void yypop_buffer_state (void );
  297: 
  298: static void yyensure_buffer_stack (void );
  299: static void yy_load_buffer_state (void );
  300: static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
  301: 
  302: #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
  303: 
  304: YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
  305: YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
  306: YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
  307: 
  308: void *yyalloc (yy_size_t  );
  309: void *yyrealloc (void *,yy_size_t  );
  310: void yyfree (void *  );
  311: 
  312: #define yy_new_buffer yy_create_buffer
  313: 
  314: #define yy_set_interactive(is_interactive) \
  315:         { \
  316:         if ( ! YY_CURRENT_BUFFER ){ \
  317:         yyensure_buffer_stack (); \
  318:                 YY_CURRENT_BUFFER_LVALUE =    \
  319:             yy_create_buffer(yyin,YY_BUF_SIZE ); \
  320:         } \
  321:         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  322:         }
  323: 
  324: #define yy_set_bol(at_bol) \
  325:         { \
  326:         if ( ! YY_CURRENT_BUFFER ){\
  327:         yyensure_buffer_stack (); \
  328:                 YY_CURRENT_BUFFER_LVALUE =    \
  329:             yy_create_buffer(yyin,YY_BUF_SIZE ); \
  330:         } \
  331:         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  332:         }
  333: 
  334: #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
  335: 
  336: /* Begin user sect3 */
  337: 
  338: typedef unsigned char YY_CHAR;
  339: 
  340: FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  341: 
  342: typedef int yy_state_type;
  343: 
  344: extern int yylineno;
  345: 
  346: int yylineno = 1;
  347: 
  348: extern char *yytext;
  349: #define yytext_ptr yytext
  350: 
  351: static yy_state_type yy_get_previous_state (void );
  352: static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
  353: static int yy_get_next_buffer (void );
  354: static void yy_fatal_error (yyconst char msg[]  );
  355: 
  356: /* Done after the current pattern has been matched and before the
  357:  * corresponding action - sets up yytext.
  358:  */
  359: #define YY_DO_BEFORE_ACTION \
  360:         (yytext_ptr) = yy_bp; \
  361:         yyleng = (size_t) (yy_cp - yy_bp); \
  362:         (yy_hold_char) = *yy_cp; \
  363:         *yy_cp = '\0'; \
  364:         (yy_c_buf_p) = yy_cp;
  365: 
  366: #define YY_NUM_RULES 40
  367: #define YY_END_OF_BUFFER 41
  368: /* This struct is not used in this scanner,
  369:    but its presence is necessary. */
  370: struct yy_trans_info
  371:         {
  372:         flex_int32_t yy_verify;
  373:         flex_int32_t yy_nxt;
  374:         };
  375: static yyconst flex_int16_t yy_accept[177] =
  376:     {   0,
  377:         0,    0,   41,   40,   39,   38,   35,   32,   33,   36,
  378:        40,   34,   37,   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,   36,   31,   37,   35,
  381:        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  382:        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  383:        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  384:        35,   35,    7,   35,   35,   35,   35,   35,   35,   35,
  385:        35,   35,   35,   35,   35,   35,   22,   35,   35,   35,
  386:        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  387: 
  388:        35,   35,   35,   10,   11,   12,   35,   15,   35,   35,
  389:        35,   35,   35,   35,   35,   35,   35,   25,   26,   27,
  390:        35,   30,   35,   35,   35,    3,   35,   35,   35,   35,
  391:        35,   35,   35,   35,   35,   18,   35,   35,   35,   35,
  392:        35,   35,   35,    1,    2,    4,    5,   35,   35,   35,
  393:        35,   35,   16,   17,   19,   20,   35,   35,   35,   35,
  394:        35,   35,    8,    9,   13,   14,   35,   23,   24,   28,
  395:        29,   35,   35,    6,   21,    0
  396:     } ;
  397: 
  398: static yyconst flex_int32_t yy_ec[256] =
  399:     {   0,
  400:         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
  401:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  402:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  403:         1,    3,    1,    1,    1,    4,    1,    1,    1,    5,
  404:         6,    7,    8,    9,    4,    4,    4,    4,    4,    4,
  405:         4,    4,    4,    4,    4,    4,    4,    4,   10,    1,
  406:         1,    1,    1,    1,   11,   12,   13,   14,   15,   16,
  407:         4,   17,   18,    4,    4,   19,   20,   21,   22,   23,
  408:         4,   24,   25,   26,   27,   28,    4,   29,   30,    4,
  409:         1,    4,    1,    1,    4,    1,   31,   32,   33,   34,
  410: 
  411:        35,   36,    4,   37,   38,    4,    4,   39,   40,   41,
  412:        42,   43,    4,   44,   45,   46,   47,   48,    4,   49,
  413:        50,    4,    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:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  419:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  420:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  421: 
  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,    1,    1,    1,    1,    1,
  425:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  426:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  427:         1,    1,    1,    1,    1
  428:     } ;
  429: 
  430: static yyconst flex_int32_t yy_meta[51] =
  431:     {   0,
  432:         1,    2,    1,    3,    1,    1,    1,    1,    1,    1,
  433:         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  434:         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  435:         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  436:         3,    3,    3,    3,    3,    3,    3,    3,    3,    3
  437:     } ;
  438: 
  439: static yyconst flex_int16_t yy_base[180] =
  440:     {   0,
  441:         0,    0,  193,  194,  194,  194,    0,  194,  194,    0,
  442:       190,  194,    0,  177,   32,   37,   32,  163,  174,  170,
  443:       164,  171,  174,  169,  149,   15,   22,   17,  135,  146,
  444:       142,  136,  143,  146,  141,    0,    0,  194,    0,  161,
  445:       159,  158,  153,  147,  156,  143,  149,  148,  141,  150,
  446:       141,  135,  138,  127,  125,  124,  119,  113,  122,  109,
  447:       115,  114,  107,  116,  107,  101,  104,   43,  136,  135,
  448:       130,  129,    0,  119,  123,  118,  114,  118,  119,  122,
  449:       124,   25,  104,  103,   98,   97,    0,   87,   91,   86,
  450:        82,   86,   87,   90,   92,  105,  100,   97,   94,   93,
  451: 
  452:       105,  106,  102,    0,    0,    0,  104,    0,   92,   75,
  453:        70,   67,   64,   63,   75,   76,   72,    0,    0,    0,
  454:        74,    0,   62,   91,   88,    0,   86,   85,   73,   85,
  455:        79,   83,   70,   62,   59,    0,   57,   56,   44,   56,
  456:        50,   54,   41,    0,    0,    0,    0,   63,   58,   59,
  457:        67,   66,    0,    0,    0,    0,   38,   33,   34,   42,
  458:        41,   51,    0,    0,    0,    0,   30,    0,    0,    0,
  459:         0,   43,   21,    0,    0,  194,   65,   66,   69
  460:     } ;
  461: 
  462: static yyconst flex_int16_t yy_def[180] =
  463:     {   0,
  464:       176,    1,  176,  176,  176,  176,  177,  176,  176,  178,
  465:       176,  176,  179,  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,  178,  176,  179,  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:       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  472:       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  473:       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  474: 
  475:       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  476:       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  477:       <