1: 
    2: #line 3 "deflex.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 41
  367: #define YY_END_OF_BUFFER 42
  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[198] =
  376:     {   0,
  377:         0,    0,   42,   41,   34,   36,   35,   33,   41,   28,
  378:        41,   31,   40,   38,   27,   32,   37,   39,   28,   28,
  379:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  380:        28,   28,   28,    0,   29,   28,    0,   30,   31,   27,
  381:        32,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  382:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  383:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  384:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  385:        28,   28,   28,   28,   28,   28,   12,    6,   28,    7,
  386:        28,   28,   28,   28,   28,   28,   28,   28,    1,   28,
  387: 
  388:        28,   28,   16,   28,   28,   28,   28,   28,   28,   28,
  389:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  390:        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  391:        17,   28,   28,   28,   28,   28,   28,   28,   28,   28,
  392:        28,   14,   28,   28,   28,   19,   21,   28,   28,   28,
  393:        28,   28,   28,   18,    9,   28,   10,   28,   28,    2,
  394:        28,   28,   15,   28,   28,   28,   28,   11,   13,   28,
  395:         5,   28,   28,   22,   28,    8,   28,   28,   28,   28,
  396:        28,   28,   20,    4,   28,   28,   28,   24,   28,   26,
  397:        28,    3,   28,   28,   23,   25,    0
  398: 
  399:     } ;
  400: 
  401: static yyconst flex_int32_t yy_ec[256] =
  402:     {   0,
  403:         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  404:         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
  405:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  406:         1,    5,    1,    6,    1,    7,    1,    1,    8,    1,
  407:         1,    9,    1,   10,    7,   11,   12,   13,   13,   13,
  408:        13,   13,   13,   13,   13,   13,   13,    7,   14,    1,
  409:        15,    1,    7,   16,   17,   18,   19,   20,   21,   22,
  410:        23,   24,   25,    7,   26,   27,   28,   29,   30,   31,
  411:         7,   32,   33,   34,   35,   36,   37,   38,   39,   40,
  412:         1,    1,    1,    1,    7,    1,   22,   22,   22,   22,
  413: 
  414:        22,   22,    7,    7,    7,    7,    7,    7,    7,    7,
  415:         7,    7,    7,    7,    7,    7,    7,    7,    7,   22,
  416:         7,    7,    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:         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: 
  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,    1,    1,    1,    1,    1,
  428:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  429:         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  430:         1,    1,    1,    1,    1
  431:     } ;
  432: 
  433: static yyconst flex_int32_t yy_meta[41] =
  434:     {   0,
  435:         1,    1,    2,    1,    1,    1,    3,    1,    1,    1,
  436:         1,    4,    5,    1,    1,    4,    6,    6,    6,    6,
  437:         6,    6,    3,    3,    3,    3,    3,    3,    3,    3,
  438:         3,    3,    3,    3,    3,    3,    3,    3,    3,    3
  439:     } ;
  440: 
  441: static yyconst flex_int16_t yy_base[205] =
  442:     {   0,
  443:         0,    0,  229,  230,  230,  230,  230,  230,  222,    0,
  444:       219,    0,  230,  230,    0,    0,  230,    0,  209,  195,
  445:        24,  186,  202,   14,  197,  186,   27,  188,  198,   25,
  446:       197,  196,  184,  209,  230,    0,  206,  230,    0,    0,
  447:         0,    0,  180,   27,  178,  178,   27,  193,  178,  183,
  448:       189,  179,  177,  175,  178,  185,  182,  183,  170,  181,
  449:       165,  164,  170,  173,  172,  159,  174,  171,  170,  158,
  450:       156,  156,  151,  152,  149,  161,   34,  145,  160,  145,
  451:       146,  154,  157,  147,  141,  139,    0,    0,  138,    0,
  452:       139,  135,  137,  135,  135,   29,  149,  140,    0,  136,
  453: 
  454:       139,  145,    0,  136,  139,  132,  132,   30,  132,  135,
  455:       138,  129,  119,  118,  126,  116,  122,  119,  115,  115,
  456:       124,  127,  109,  112,  121,  119,  106,  111,  108,  106,
  457:         0,  106,  103,  112,   99,   91,   97,   99,   95,   88,
  458:        99,    0,   93,  103,   94,    0,    0,   97,   91,   87,
  459:        90,   84,   83,    0,    0,   95,    0,   97,   80,    0,
  460:        92,   91,    0,   78,   70,   91,   74,    0,    0,   82,
  461:         0,   89,   88,    0,   84,    0,   82,   85,   83,   69,
  462:        66,   56,    0,    0,   39,   36,   35,    0,   44,    0,
  463:        43,    0,   40,   39,    0,    0,  230,   67,   71,   77,
  464: 
  465:        83,   85,   91,   95
  466:     } ;
  467: 
  468: static yyconst flex_int16_t yy_def[205] =
  469:     {   0,
  470:       197,    1,  197,  197,  197,  197,  197,  197,  198,  199,
  471:       200,  201,  197,  197,  202,  203,  197,  204,  199,  199,
  472:       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
  473:       199,  199,  199,  198,  197,  199,  200,  197,  201,  202,
  474:       203,  199,  199,  199,  199,  199,  199,  199,  199,  199,
  475:       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
  476:       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
  477: