home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / imagemap / imap_csim_lex.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-22  |  46.9 KB  |  1,827 lines
  1. #define yy_create_buffer csim__create_buffer
  2. #define yy_delete_buffer csim__delete_buffer
  3. #define yy_scan_buffer csim__scan_buffer
  4. #define yy_scan_string csim__scan_string
  5. #define yy_scan_bytes csim__scan_bytes
  6. #define yy_flex_debug csim__flex_debug
  7. #define yy_init_buffer csim__init_buffer
  8. #define yy_flush_buffer csim__flush_buffer
  9. #define yy_load_buffer_state csim__load_buffer_state
  10. #define yy_switch_to_buffer csim__switch_to_buffer
  11. #define yyin csim_in
  12. #define yyleng csim_leng
  13. #define yylex csim_lex
  14. #define yyout csim_out
  15. #define yyrestart csim_restart
  16. #define yytext csim_text
  17.  
  18. #line 19 "imap_csim_lex.c"
  19. /* A lexical scanner generated by flex */
  20.  
  21. /* Scanner skeleton version:
  22.  * $Header: /cvs/gnome/gimp/plug-ins/imagemap/imap_csim_lex.c,v 1.3 2000/05/22 17:10:17 mitch Exp $
  23.  */
  24.  
  25. #define FLEX_SCANNER
  26. #define YY_FLEX_MAJOR_VERSION 2
  27. #define YY_FLEX_MINOR_VERSION 5
  28.  
  29. #include <stdio.h>
  30.  
  31.  
  32. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  33. #ifdef c_plusplus
  34. #ifndef __cplusplus
  35. #define __cplusplus
  36. #endif
  37. #endif
  38.  
  39.  
  40. #ifdef __cplusplus
  41.  
  42. #include <stdlib.h>
  43. #include <unistd.h>
  44.  
  45. /* Use prototypes in function declarations. */
  46. #define YY_USE_PROTOS
  47.  
  48. /* The "const" storage-class-modifier is valid. */
  49. #define YY_USE_CONST
  50.  
  51. #else    /* ! __cplusplus */
  52.  
  53. #if __STDC__
  54.  
  55. #define YY_USE_PROTOS
  56. #define YY_USE_CONST
  57.  
  58. #endif    /* __STDC__ */
  59. #endif    /* ! __cplusplus */
  60.  
  61. #ifdef __TURBOC__
  62.  #pragma warn -rch
  63.  #pragma warn -use
  64. #include <io.h>
  65. #include <stdlib.h>
  66. #define YY_USE_CONST
  67. #define YY_USE_PROTOS
  68. #endif
  69.  
  70. #ifdef YY_USE_CONST
  71. #define yyconst const
  72. #else
  73. #define yyconst
  74. #endif
  75.  
  76.  
  77. #ifdef YY_USE_PROTOS
  78. #define YY_PROTO(proto) proto
  79. #else
  80. #define YY_PROTO(proto) ()
  81. #endif
  82.  
  83. /* Returned upon end-of-file. */
  84. #define YY_NULL 0
  85.  
  86. /* Promotes a possibly negative, possibly signed char to an unsigned
  87.  * integer for use as an array index.  If the signed char is negative,
  88.  * we want to instead treat it as an 8-bit unsigned char, hence the
  89.  * double cast.
  90.  */
  91. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  92.  
  93. /* Enter a start condition.  This macro really ought to take a parameter,
  94.  * but we do it the disgusting crufty way forced on us by the ()-less
  95.  * definition of BEGIN.
  96.  */
  97. #define BEGIN yy_start = 1 + 2 *
  98.  
  99. /* Translate the current start state into a value that can be later handed
  100.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  101.  * compatibility.
  102.  */
  103. #define YY_START ((yy_start - 1) / 2)
  104. #define YYSTATE YY_START
  105.  
  106. /* Action number for EOF rule of a given start state. */
  107. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  108.  
  109. /* Special action meaning "start processing a new file". */
  110. #define YY_NEW_FILE yyrestart( yyin )
  111.  
  112. #define YY_END_OF_BUFFER_CHAR 0
  113.  
  114. /* Size of default input buffer. */
  115. #define YY_BUF_SIZE 16384
  116.  
  117. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  118.  
  119. extern int yyleng;
  120. extern FILE *yyin, *yyout;
  121.  
  122. #define EOB_ACT_CONTINUE_SCAN 0
  123. #define EOB_ACT_END_OF_FILE 1
  124. #define EOB_ACT_LAST_MATCH 2
  125.  
  126. /* The funky do-while in the following #define is used to turn the definition
  127.  * int a single C statement (which needs a semi-colon terminator).  This
  128.  * avoids problems with code like:
  129.  *
  130.  *     if ( condition_holds )
  131.  *        yyless( 5 );
  132.  *    else
  133.  *        do_something_else();
  134.  *
  135.  * Prior to using the do-while the compiler would get upset at the
  136.  * "else" because it interpreted the "if" statement as being all
  137.  * done when it reached the ';' after the yyless() call.
  138.  */
  139.  
  140. /* Return all but the first 'n' matched characters back to the input stream. */
  141.  
  142. #define yyless(n) \
  143.     do \
  144.         { \
  145.         /* Undo effects of setting up yytext. */ \
  146.         *yy_cp = yy_hold_char; \
  147.         YY_RESTORE_YY_MORE_OFFSET \
  148.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  149.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  150.         } \
  151.     while ( 0 )
  152.  
  153. #define unput(c) yyunput( c, yytext_ptr )
  154.  
  155. /* The following is because we cannot portably get our hands on size_t
  156.  * (without autoconf's help, which isn't available because we want
  157.  * flex-generated scanners to compile on their own).
  158.  */
  159. typedef unsigned int yy_size_t;
  160.  
  161.  
  162. struct yy_buffer_state
  163.     {
  164.     FILE *yy_input_file;
  165.  
  166.     char *yy_ch_buf;        /* input buffer */
  167.     char *yy_buf_pos;        /* current position in input buffer */
  168.  
  169.     /* Size of input buffer in bytes, not including room for EOB
  170.      * characters.
  171.      */
  172.     yy_size_t yy_buf_size;
  173.  
  174.     /* Number of characters read into yy_ch_buf, not including EOB
  175.      * characters.
  176.      */
  177.     int yy_n_chars;
  178.  
  179.     /* Whether we "own" the buffer - i.e., we know we created it,
  180.      * and can realloc() it to grow it, and should free() it to
  181.      * delete it.
  182.      */
  183.     int yy_is_our_buffer;
  184.  
  185.     /* Whether this is an "interactive" input source; if so, and
  186.      * if we're using stdio for input, then we want to use getc()
  187.      * instead of fread(), to make sure we stop fetching input after
  188.      * each newline.
  189.      */
  190.     int yy_is_interactive;
  191.  
  192.     /* Whether we're considered to be at the beginning of a line.
  193.      * If so, '^' rules will be active on the next match, otherwise
  194.      * not.
  195.      */
  196.     int yy_at_bol;
  197.  
  198.     /* Whether to try to fill the input buffer when we reach the
  199.      * end of it.
  200.      */
  201.     int yy_fill_buffer;
  202.  
  203.     int yy_buffer_status;
  204. #define YY_BUFFER_NEW 0
  205. #define YY_BUFFER_NORMAL 1
  206.     /* When an EOF's been seen but there's still some text to process
  207.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  208.      * shouldn't try reading from the input source any more.  We might
  209.      * still have a bunch of tokens to match, though, because of
  210.      * possible backing-up.
  211.      *
  212.      * When we actually see the EOF, we change the status to "new"
  213.      * (via yyrestart()), so that the user can continue scanning by
  214.      * just pointing yyin at a new input file.
  215.      */
  216. #define YY_BUFFER_EOF_PENDING 2
  217.     };
  218.  
  219. static YY_BUFFER_STATE yy_current_buffer = 0;
  220.  
  221. /* We provide macros for accessing buffer states in case in the
  222.  * future we want to put the buffer states in a more general
  223.  * "scanner state".
  224.  */
  225. #define YY_CURRENT_BUFFER yy_current_buffer
  226.  
  227.  
  228. /* yy_hold_char holds the character lost when yytext is formed. */
  229. static char yy_hold_char;
  230.  
  231. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  232.  
  233.  
  234. int yyleng;
  235.  
  236. /* Points to current character in buffer. */
  237. static char *yy_c_buf_p = (char *) 0;
  238. static int yy_init = 1;        /* whether we need to initialize */
  239. static int yy_start = 0;    /* start state number */
  240.  
  241. /* Flag which is used to allow yywrap()'s to do buffer switches
  242.  * instead of setting up a fresh yyin.  A bit of a hack ...
  243.  */
  244. static int yy_did_buffer_switch_on_eof;
  245.  
  246. void yyrestart YY_PROTO(( FILE *input_file ));
  247.  
  248. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  249. void yy_load_buffer_state YY_PROTO(( void ));
  250. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  251. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  252. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  253. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  254. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  255.  
  256. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  257. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
  258. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  259.  
  260. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  261. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  262. static void yy_flex_free YY_PROTO(( void * ));
  263.  
  264. #define yy_new_buffer yy_create_buffer
  265.  
  266. #define yy_set_interactive(is_interactive) \
  267.     { \
  268.     if ( ! yy_current_buffer ) \
  269.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  270.     yy_current_buffer->yy_is_interactive = is_interactive; \
  271.     }
  272.  
  273. #define yy_set_bol(at_bol) \
  274.     { \
  275.     if ( ! yy_current_buffer ) \
  276.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  277.     yy_current_buffer->yy_at_bol = at_bol; \
  278.     }
  279.  
  280. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  281.  
  282.  
  283. #define yywrap() 1
  284. #define YY_SKIP_YYWRAP
  285. typedef unsigned char YY_CHAR;
  286. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  287. typedef int yy_state_type;
  288. extern char *yytext;
  289. #define yytext_ptr yytext
  290.  
  291. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  292. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  293. static int yy_get_next_buffer YY_PROTO(( void ));
  294. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  295.  
  296. /* Done after the current pattern has been matched and before the
  297.  * corresponding action - sets up yytext.
  298.  */
  299. #define YY_DO_BEFORE_ACTION \
  300.     yytext_ptr = yy_bp; \
  301.     yyleng = (int) (yy_cp - yy_bp); \
  302.     yy_hold_char = *yy_cp; \
  303.     *yy_cp = '\0'; \
  304.     yy_c_buf_p = yy_cp;
  305.  
  306. #define YY_NUM_RULES 32
  307. #define YY_END_OF_BUFFER 33
  308. static yyconst short int yy_accept[154] =
  309.     {   0,
  310.        29,   29,   28,   28,    0,    0,   33,   31,   30,   30,
  311.        26,   29,   29,   31,   29,   31,   31,   31,   31,   29,
  312.        31,   31,   31,   31,   31,   31,   31,   31,   31,   28,
  313.        27,   32,   32,   32,   30,   29,   29,   29,   29,    0,
  314.         0,    0,    0,    0,    0,   29,   29,    0,    0,    0,
  315.         0,    0,    0,    0,    0,    0,    0,    0,    0,   28,
  316.         0,    0,    0,    0,    0,   23,    0,    0,    0,    0,
  317.         0,    6,   12,    0,    0,    0,    0,    0,    0,    7,
  318.         0,    0,    0,    0,    4,   13,    3,   15,    0,    0,
  319.         0,   24,   14,    0,    0,    0,    0,    0,    0,    0,
  320.  
  321.         0,    5,    0,    0,    0,    0,    0,    0,    0,    0,
  322.        16,    0,    0,    8,    0,   10,   17,    9,   25,   22,
  323.         0,    0,   18,   11,    0,   21,    0,    0,    0,    0,
  324.         0,    0,    0,    0,    0,    0,   20,    0,    0,    0,
  325.        19,    0,    0,    0,    0,    1,    0,    0,    0,    0,
  326.         0,    2,    0
  327.     } ;
  328.  
  329. static yyconst int yy_ec[256] =
  330.     {   0,
  331.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  332.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  333.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  334.         1,    4,    5,    6,    7,    8,    1,    1,    1,    1,
  335.         1,    1,    9,    1,   10,   11,   12,   13,   13,   13,
  336.        13,   13,   13,   13,   13,   13,   13,   14,    1,   15,
  337.         1,   16,    1,    1,   17,   18,   19,   20,   21,   22,
  338.        23,   24,   25,    1,    1,   26,   27,   28,   29,   30,
  339.         1,   31,   32,   33,   34,   35,   36,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,   17,   18,   19,   20,
  341.  
  342.        21,   22,   23,   24,   25,    1,    1,   26,   27,   28,
  343.        29,   30,    1,   31,   32,   33,   34,   35,   36,    1,
  344.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  345.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  346.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  347.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  350.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  352.  
  353.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  354.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  355.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  356.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  357.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  358.         1,    1,    1,    1,    1
  359.     } ;
  360.  
  361. static yyconst int yy_meta[37] =
  362.     {   0,
  363.         1,    1,    2,    1,    1,    3,    1,    1,    1,    1,
  364.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  365.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  366.         1,    1,    1,    1,    1,    1
  367.     } ;
  368.  
  369. static yyconst short int yy_base[158] =
  370.     {   0,
  371.         0,    0,  193,  192,   34,   35,  197,  200,   37,   44,
  372.       200,   38,   29,  169,   41,  190,   27,  165,  164,   47,
  373.        34,  165,  174,   44,  162,   39,  172,  156,  162,    0,
  374.       200,  176,  200,  175,   64,   51,   58,   65,   63,  167,
  375.       173,  149,  160,  149,  150,  165,  164,  151,  154,  151,
  376.       143,  145,  147,   59,  153,  150,  137,  146,  146,    0,
  377.       155,  154,   72,  133,  152,  200,  144,  140,  128,  135,
  378.       135,  200,  200,  135,  124,  128,  124,  123,  121,  200,
  379.       127,  122,  115,   73,  137,  200,  142,  200,  124,  124,
  380.       119,  200,  200,  121,  107,  121,  105,  117,  116,  119,
  381.  
  382.       111,  124,  126,  101,   99,   97,  107,   97,   93,   94,
  383.       200,   92,   94,  200,  115,  200,  200,  200,  200,  200,
  384.        90,  100,  200,  200,   70,  200,   91,   85,   97,   57,
  385.        84,   84,   82,   93,   89,   93,  200,   80,   81,   78,
  386.       200,   77,   82,   92,   75,  200,   71,   77,   56,   52,
  387.        29,  200,  200,   92,   95,   98,  100
  388.     } ;
  389.  
  390. static yyconst short int yy_def[158] =
  391.     {   0,
  392.       153,    1,  154,  154,  155,  155,  153,  153,  153,  153,
  393.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  394.       153,  153,  153,  153,  153,  153,  153,  153,  153,  156,
  395.       153,  157,  153,  157,  153,  153,  153,  153,  153,  153,
  396.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  397.       153,  153,  153,  153,  153,  153,  153,  153,  153,  156,
  398.       157,  157,  157,  153,  153,  153,  153,  153,  153,  153,
  399.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  400.       153,  153,  153,  157,  157,  153,  153,  153,  153,  153,
  401.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  402.  
  403.       153,  157,  153,  153,  153,  153,  153,  153,  153,  153,
  404.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  405.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  406.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  407.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  408.       153,  153,    0,  153,  153,  153,  153
  409.     } ;
  410.  
  411. static yyconst short int yy_nxt[237] =
  412.     {   0,
  413.         8,    9,   10,    9,    8,   11,    8,    8,    8,   12,
  414.        13,   14,   15,    8,   16,    8,   17,   18,   19,    8,
  415.        20,    8,    8,   21,   22,    8,   23,   24,   25,    8,
  416.         8,   26,   27,   28,    8,   29,   33,   33,   35,   35,
  417.        35,   39,  152,   34,   34,   35,   35,   35,   36,   38,
  418.        37,   36,   42,   37,   48,   46,   46,   43,   38,   47,
  419.        52,   38,   55,   39,   49,   35,   35,   35,   36,   56,
  420.        37,   38,   53,   46,   46,   39,   76,   47,   38,  151,
  421.        77,   84,   84,   38,  150,   78,  128,   85,  102,  129,
  422.       133,  134,   30,   30,   30,   32,   32,   32,   60,   60,
  423.  
  424.        61,  149,   61,  148,  147,  146,  145,  144,  143,  142,
  425.       141,  140,  139,  138,  137,  136,  135,  132,  131,  130,
  426.       127,  126,  125,  124,  123,  122,  121,  120,  119,  118,
  427.       117,  116,  115,   62,  114,  113,  112,  111,  110,  109,
  428.       108,  107,  106,  105,  104,  103,   62,  101,  100,   99,
  429.        98,   97,   96,   95,   94,   93,   92,   91,   90,   89,
  430.        88,   87,   86,   84,   62,   83,   82,   81,   80,   79,
  431.        75,   74,   73,   72,   71,   70,   47,   47,   69,   68,
  432.        67,   66,   65,   64,   63,   62,   59,   58,   57,   54,
  433.        51,   50,   45,   44,   41,   40,  153,   31,   31,    7,
  434.  
  435.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  436.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  437.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  438.       153,  153,  153,  153,  153,  153
  439.     } ;
  440.  
  441. static yyconst short int yy_chk[237] =
  442.     {   0,
  443.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  444.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  445.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  446.         1,    1,    1,    1,    1,    1,    5,    6,    9,    9,
  447.         9,   13,  151,    5,    6,   10,   10,   10,   12,   13,
  448.        12,   15,   17,   15,   21,   20,   20,   17,   12,   20,
  449.        24,   15,   26,   36,   21,   35,   35,   35,   37,   26,
  450.        37,   36,   24,   38,   38,   39,   54,   38,   37,  150,
  451.        54,   63,   84,   39,  149,   54,  125,   63,   84,  125,
  452.       130,  130,  154,  154,  154,  155,  155,  155,  156,  156,
  453.  
  454.       157,  148,  157,  147,  145,  144,  143,  142,  140,  139,
  455.       138,  136,  135,  134,  133,  132,  131,  129,  128,  127,
  456.       122,  121,  115,  113,  112,  110,  109,  108,  107,  106,
  457.       105,  104,  103,  102,  101,  100,   99,   98,   97,   96,
  458.        95,   94,   91,   90,   89,   87,   85,   83,   82,   81,
  459.        79,   78,   77,   76,   75,   74,   71,   70,   69,   68,
  460.        67,   65,   64,   62,   61,   59,   58,   57,   56,   55,
  461.        53,   52,   51,   50,   49,   48,   47,   46,   45,   44,
  462.        43,   42,   41,   40,   34,   32,   29,   28,   27,   25,
  463.        23,   22,   19,   18,   16,   14,    7,    4,    3,  153,
  464.  
  465.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  466.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  467.       153,  153,  153,  153,  153,  153,  153,  153,  153,  153,
  468.       153,  153,  153,  153,  153,  153
  469.     } ;
  470.  
  471. static yy_state_type yy_last_accepting_state;
  472. static char *yy_last_accepting_cpos;
  473.  
  474. /* The intent behind this definition is that it'll catch
  475.  * any uses of REJECT which flex missed.
  476.  */
  477. #define REJECT reject_used_but_not_detected
  478. #define yymore() yymore_used_but_not_detected
  479. #define YY_MORE_ADJ 0
  480. #define YY_RESTORE_YY_MORE_OFFSET
  481. char *yytext;
  482. #line 1 "imap_csim.l"
  483. #define INITIAL 0
  484. #line 2 "imap_csim.l"
  485. /*
  486.  * This is a plug-in for the GIMP.
  487.  *
  488.  * Generates clickable image maps.
  489.  *
  490.  * Copyright (C) 1998-1999 Maurits Rijk  lpeek.mrijk@consunet.nl
  491.  *
  492.  * This program is free software; you can redistribute it and/or modify
  493.  * it under the terms of the GNU General Public License as published by
  494.  * the Free Software Foundation; either version 2 of the License, or
  495.  * (at your option) any later version.
  496.  *
  497.  * This program is distributed in the hope that it will be useful,
  498.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  499.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  500.  * GNU General Public License for more details.
  501.  *
  502.  * You should have received a copy of the GNU General Public License
  503.  * along with this program; if not, write to the Free Software
  504.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  505.  *
  506.  */
  507.  
  508. #include "imap_csim_parse.h"
  509. #define quoted_string 1
  510.  
  511. #define comment 2
  512.  
  513. #line 514 "imap_csim_lex.c"
  514.  
  515. /* Macros after this point can all be overridden by user definitions in
  516.  * section 1.
  517.  */
  518.  
  519. #ifndef YY_SKIP_YYWRAP
  520. #ifdef __cplusplus
  521. extern "C" int yywrap YY_PROTO(( void ));
  522. #else
  523. extern int yywrap YY_PROTO(( void ));
  524. #endif
  525. #endif
  526.  
  527. #ifndef YY_NO_UNPUT
  528. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  529. #endif
  530.  
  531. #ifndef yytext_ptr
  532. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  533. #endif
  534.  
  535. #ifdef YY_NEED_STRLEN
  536. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  537. #endif
  538.  
  539. #ifndef YY_NO_INPUT
  540. #ifdef __cplusplus
  541. static int yyinput YY_PROTO(( void ));
  542. #else
  543. static int input YY_PROTO(( void ));
  544. #endif
  545. #endif
  546.  
  547. #if YY_STACK_USED
  548. static int yy_start_stack_ptr = 0;
  549. static int yy_start_stack_depth = 0;
  550. static int *yy_start_stack = 0;
  551. #ifndef YY_NO_PUSH_STATE
  552. static void yy_push_state YY_PROTO(( int new_state ));
  553. #endif
  554. #ifndef YY_NO_POP_STATE
  555. static void yy_pop_state YY_PROTO(( void ));
  556. #endif
  557. #ifndef YY_NO_TOP_STATE
  558. static int yy_top_state YY_PROTO(( void ));
  559. #endif
  560.  
  561. #else
  562. #define YY_NO_PUSH_STATE 1
  563. #define YY_NO_POP_STATE 1
  564. #define YY_NO_TOP_STATE 1
  565. #endif
  566.  
  567. #ifdef YY_MALLOC_DECL
  568. YY_MALLOC_DECL
  569. #else
  570. #if __STDC__
  571. #ifndef __cplusplus
  572. #include <stdlib.h>
  573. #endif
  574. #else
  575. /* Just try to get by without declaring the routines.  This will fail
  576.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  577.  * or sizeof(void*) != sizeof(int).
  578.  */
  579. #endif
  580. #endif
  581.  
  582. /* Amount of stuff to slurp up with each read. */
  583. #ifndef YY_READ_BUF_SIZE
  584. #define YY_READ_BUF_SIZE 8192
  585. #endif
  586.  
  587. /* Copy whatever the last rule matched to the standard output. */
  588.  
  589. #ifndef ECHO
  590. /* This used to be an fputs(), but since the string might contain NUL's,
  591.  * we now use fwrite().
  592.  */
  593. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  594. #endif
  595.  
  596. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  597.  * is returned in "result".
  598.  */
  599. #ifndef YY_INPUT
  600. #define YY_INPUT(buf,result,max_size) \
  601.     if ( yy_current_buffer->yy_is_interactive ) \
  602.         { \
  603.         int c = '*', n; \
  604.         for ( n = 0; n < max_size && \
  605.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  606.             buf[n] = (char) c; \
  607.         if ( c == '\n' ) \
  608.             buf[n++] = (char) c; \
  609.         if ( c == EOF && ferror( yyin ) ) \
  610.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  611.         result = n; \
  612.         } \
  613.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  614.           && ferror( yyin ) ) \
  615.         YY_FATAL_ERROR( "input in flex scanner failed" );
  616. #endif
  617.  
  618. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  619.  * we don't want an extra ';' after the "return" because that will cause
  620.  * some compilers to complain about unreachable statements.
  621.  */
  622. #ifndef yyterminate
  623. #define yyterminate() return YY_NULL
  624. #endif
  625.  
  626. /* Number of entries by which start-condition stack grows. */
  627. #ifndef YY_START_STACK_INCR
  628. #define YY_START_STACK_INCR 25
  629. #endif
  630.  
  631. /* Report a fatal error. */
  632. #ifndef YY_FATAL_ERROR
  633. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  634. #endif
  635.  
  636. /* Default declaration of generated scanner - a define so the user can
  637.  * easily add parameters.
  638.  */
  639. #ifndef YY_DECL
  640. #define YY_DECL int yylex YY_PROTO(( void ))
  641. #endif
  642.  
  643. /* Code executed at the beginning of each rule, after yytext and yyleng
  644.  * have been set up.
  645.  */
  646. #ifndef YY_USER_ACTION
  647. #define YY_USER_ACTION
  648. #endif
  649.  
  650. /* Code executed at the end of each rule. */
  651. #ifndef YY_BREAK
  652. #define YY_BREAK break;
  653. #endif
  654.  
  655. #define YY_RULE_SETUP \
  656.     YY_USER_ACTION
  657.  
  658. YY_DECL
  659.     {
  660.     register yy_state_type yy_current_state;
  661.     register char *yy_cp, *yy_bp;
  662.     register int yy_act;
  663.  
  664. #line 37 "imap_csim.l"
  665.  
  666.  
  667. #line 668 "imap_csim_lex.c"
  668.  
  669.     if ( yy_init )
  670.         {
  671.         yy_init = 0;
  672.  
  673. #ifdef YY_USER_INIT
  674.         YY_USER_INIT;
  675. #endif
  676.  
  677.         if ( ! yy_start )
  678.             yy_start = 1;    /* first start state */
  679.  
  680.         if ( ! yyin )
  681.             yyin = stdin;
  682.  
  683.         if ( ! yyout )
  684.             yyout = stdout;
  685.  
  686.         if ( ! yy_current_buffer )
  687.             yy_current_buffer =
  688.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  689.  
  690.         yy_load_buffer_state();
  691.         }
  692.  
  693.     while ( 1 )        /* loops until end-of-file is reached */
  694.         {
  695.         yy_cp = yy_c_buf_p;
  696.  
  697.         /* Support of yytext. */
  698.         *yy_cp = yy_hold_char;
  699.  
  700.         /* yy_bp points to the position in yy_ch_buf of the start of
  701.          * the current run.
  702.          */
  703.         yy_bp = yy_cp;
  704.  
  705.         yy_current_state = yy_start;
  706. yy_match:
  707.         do
  708.             {
  709.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  710.             if ( yy_accept[yy_current_state] )
  711.                 {
  712.                 yy_last_accepting_state = yy_current_state;
  713.                 yy_last_accepting_cpos = yy_cp;
  714.                 }
  715.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  716.                 {
  717.                 yy_current_state = (int) yy_def[yy_current_state];
  718.                 if ( yy_current_state >= 154 )
  719.                     yy_c = yy_meta[(unsigned int) yy_c];
  720.                 }
  721.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  722.             ++yy_cp;
  723.             }
  724.         while ( yy_base[yy_current_state] != 200 );
  725.  
  726. yy_find_action:
  727.         yy_act = yy_accept[yy_current_state];
  728.         if ( yy_act == 0 )
  729.             { /* have to back up */
  730.             yy_cp = yy_last_accepting_cpos;
  731.             yy_current_state = yy_last_accepting_state;
  732.             yy_act = yy_accept[yy_current_state];
  733.             }
  734.  
  735.         YY_DO_BEFORE_ACTION;
  736.  
  737.  
  738. do_action:    /* This label is used only to access EOF actions. */
  739.  
  740.  
  741.         switch ( yy_act )
  742.     { /* beginning of action switch */
  743.             case 0: /* must back up */
  744.             /* undo the effects of YY_DO_BEFORE_ACTION */
  745.             *yy_cp = yy_hold_char;
  746.             yy_cp = yy_last_accepting_cpos;
  747.             yy_current_state = yy_last_accepting_state;
  748.             goto yy_find_action;
  749.  
  750. case 1:
  751. YY_RULE_SETUP
  752. #line 39 "imap_csim.l"
  753. {
  754.                    BEGIN(comment);
  755.                    return AUTHOR;
  756.                 }
  757.     YY_BREAK
  758. case 2:
  759. YY_RULE_SETUP
  760. #line 44 "imap_csim.l"
  761. {
  762.                    BEGIN(comment);
  763.                    return DESCRIPTION;
  764.                 }
  765.     YY_BREAK
  766. case 3:
  767. YY_RULE_SETUP
  768. #line 49 "imap_csim.l"
  769. {
  770.                    BEGIN(comment);
  771.                    return BEGIN_COMMENT;
  772.                 }
  773.     YY_BREAK
  774. case 4:
  775. YY_RULE_SETUP
  776. #line 54 "imap_csim.l"
  777. {
  778.                    BEGIN(INITIAL);
  779.                    return END_COMMENT;
  780.                     }
  781.     YY_BREAK
  782. case 5:
  783. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  784. yy_c_buf_p = yy_cp -= 3;
  785. YY_DO_BEFORE_ACTION; /* set up yytext again */
  786. YY_RULE_SETUP
  787. #line 59 "imap_csim.l"
  788. {
  789.                       strcpy(csim_lval.id, yytext);
  790.                    csim_lval.id[yyleng - 1] = '\0';
  791.                       return STRING;
  792.                 }
  793.     YY_BREAK
  794. case 6:
  795. YY_RULE_SETUP
  796. #line 65 "imap_csim.l"
  797. return IMG;
  798.     YY_BREAK
  799. case 7:
  800. YY_RULE_SETUP
  801. #line 67 "imap_csim.l"
  802. return SRC;
  803.     YY_BREAK
  804. case 8:
  805. YY_RULE_SETUP
  806. #line 69 "imap_csim.l"
  807. return WIDTH;
  808.     YY_BREAK
  809. case 9:
  810. YY_RULE_SETUP
  811. #line 71 "imap_csim.l"
  812. return HEIGHT;
  813.     YY_BREAK
  814. case 10:
  815. YY_RULE_SETUP
  816. #line 73 "imap_csim.l"
  817. return BORDER;
  818.     YY_BREAK
  819. case 11:
  820. YY_RULE_SETUP
  821. #line 75 "imap_csim.l"
  822. return USEMAP;
  823.     YY_BREAK
  824. case 12:
  825. YY_RULE_SETUP
  826. #line 77 "imap_csim.l"
  827. return START_MAP;
  828.     YY_BREAK
  829. case 13:
  830. YY_RULE_SETUP
  831. #line 79 "imap_csim.l"
  832. return END_MAP;
  833.     YY_BREAK
  834. case 14:
  835. YY_RULE_SETUP
  836. #line 81 "imap_csim.l"
  837. return NAME;
  838.     YY_BREAK
  839. case 15:
  840. YY_RULE_SETUP
  841. #line 83 "imap_csim.l"
  842. return AREA;
  843.     YY_BREAK
  844. case 16:
  845. YY_RULE_SETUP
  846. #line 85 "imap_csim.l"
  847. return SHAPE;
  848.     YY_BREAK
  849. case 17:
  850. YY_RULE_SETUP
  851. #line 87 "imap_csim.l"
  852. return COORDS;
  853.     YY_BREAK
  854. case 18:
  855. YY_RULE_SETUP
  856. #line 89 "imap_csim.l"
  857. return TARGET;
  858.     YY_BREAK
  859. case 19:
  860. YY_RULE_SETUP
  861. #line 91 "imap_csim.l"
  862. return ONMOUSEOVER;
  863.     YY_BREAK
  864. case 20:
  865. YY_RULE_SETUP
  866. #line 93 "imap_csim.l"
  867. return ONMOUSEOUT;
  868.     YY_BREAK
  869. case 21:
  870. YY_RULE_SETUP
  871. #line 95 "imap_csim.l"
  872. return ONFOCUS;
  873.     YY_BREAK
  874. case 22:
  875. YY_RULE_SETUP
  876. #line 97 "imap_csim.l"
  877. return ONBLUR;
  878.     YY_BREAK
  879. case 23:
  880. YY_RULE_SETUP
  881. #line 99 "imap_csim.l"
  882. return ALT;
  883.     YY_BREAK
  884. case 24:
  885. YY_RULE_SETUP
  886. #line 101 "imap_csim.l"
  887. return HREF;
  888.     YY_BREAK
  889. case 25:
  890. YY_RULE_SETUP
  891. #line 103 "imap_csim.l"
  892. return NOHREF;
  893.     YY_BREAK
  894. case 26:
  895. YY_RULE_SETUP
  896. #line 105 "imap_csim.l"
  897. {
  898.                    BEGIN(quoted_string);
  899.                    *csim_lval.id = 0;
  900.                 }
  901.     YY_BREAK
  902. case 27:
  903. YY_RULE_SETUP
  904. #line 110 "imap_csim.l"
  905. {
  906.                    BEGIN(INITIAL);
  907.                    return STRING;
  908.                 }
  909.     YY_BREAK
  910. case 28:
  911. YY_RULE_SETUP
  912. #line 115 "imap_csim.l"
  913. strcpy(csim_lval.id, yytext);
  914.     YY_BREAK
  915. case 29:
  916. YY_RULE_SETUP
  917. #line 117 "imap_csim.l"
  918. {
  919.                                    csim_lval.value = atof(yytext);
  920.                    return FLOAT;
  921.                 }
  922.     YY_BREAK
  923. case 30:
  924. YY_RULE_SETUP
  925. #line 122 "imap_csim.l"
  926. ; /* Eat white space */
  927.     YY_BREAK
  928. case 31:
  929. YY_RULE_SETUP
  930. #line 124 "imap_csim.l"
  931. return *yytext;
  932.     YY_BREAK
  933. case 32:
  934. YY_RULE_SETUP
  935. #line 126 "imap_csim.l"
  936. ECHO;
  937.     YY_BREAK
  938. #line 939 "imap_csim_lex.c"
  939. case YY_STATE_EOF(INITIAL):
  940. case YY_STATE_EOF(quoted_string):
  941. case YY_STATE_EOF(comment):
  942.     yyterminate();
  943.  
  944.     case YY_END_OF_BUFFER:
  945.         {
  946.         /* Amount of text matched not including the EOB char. */
  947.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  948.  
  949.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  950.         *yy_cp = yy_hold_char;
  951.         YY_RESTORE_YY_MORE_OFFSET
  952.  
  953.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  954.             {
  955.             /* We're scanning a new file or input source.  It's
  956.              * possible that this happened because the user
  957.              * just pointed yyin at a new source and called
  958.              * yylex().  If so, then we have to assure
  959.              * consistency between yy_current_buffer and our
  960.              * globals.  Here is the right place to do so, because
  961.              * this is the first action (other than possibly a
  962.              * back-up) that will match for the new input source.
  963.              */
  964.             yy_n_chars = yy_current_buffer->yy_n_chars;
  965.             yy_current_buffer->yy_input_file = yyin;
  966.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  967.             }
  968.  
  969.         /* Note that here we test for yy_c_buf_p "<=" to the position
  970.          * of the first EOB in the buffer, since yy_c_buf_p will
  971.          * already have been incremented past the NUL character
  972.          * (since all states make transitions on EOB to the
  973.          * end-of-buffer state).  Contrast this with the test
  974.          * in input().
  975.          */
  976.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  977.             { /* This was really a NUL. */
  978.             yy_state_type yy_next_state;
  979.  
  980.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  981.  
  982.             yy_current_state = yy_get_previous_state();
  983.  
  984.             /* Okay, we're now positioned to make the NUL
  985.              * transition.  We couldn't have
  986.              * yy_get_previous_state() go ahead and do it
  987.              * for us because it doesn't know how to deal
  988.              * with the possibility of jamming (and we don't
  989.              * want to build jamming into it because then it
  990.              * will run more slowly).
  991.              */
  992.  
  993.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  994.  
  995.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  996.  
  997.             if ( yy_next_state )
  998.                 {
  999.                 /* Consume the NUL. */
  1000.                 yy_cp = ++yy_c_buf_p;
  1001.                 yy_current_state = yy_next_state;
  1002.                 goto yy_match;
  1003.                 }
  1004.  
  1005.             else
  1006.                 {
  1007.                 yy_cp = yy_c_buf_p;
  1008.                 goto yy_find_action;
  1009.                 }
  1010.             }
  1011.  
  1012.         else switch ( yy_get_next_buffer() )
  1013.             {
  1014.             case EOB_ACT_END_OF_FILE:
  1015.                 {
  1016.                 yy_did_buffer_switch_on_eof = 0;
  1017.  
  1018.                 if ( yywrap() )
  1019.                     {
  1020.                     /* Note: because we've taken care in
  1021.                      * yy_get_next_buffer() to have set up
  1022.                      * yytext, we can now set up
  1023.                      * yy_c_buf_p so that if some total
  1024.                      * hoser (like flex itself) wants to
  1025.                      * call the scanner after we return the
  1026.                      * YY_NULL, it'll still work - another
  1027.                      * YY_NULL will get returned.
  1028.                      */
  1029.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1030.  
  1031.                     yy_act = YY_STATE_EOF(YY_START);
  1032.                     goto do_action;
  1033.                     }
  1034.  
  1035.                 else
  1036.                     {
  1037.                     if ( ! yy_did_buffer_switch_on_eof )
  1038.                         YY_NEW_FILE;
  1039.                     }
  1040.                 break;
  1041.                 }
  1042.  
  1043.             case EOB_ACT_CONTINUE_SCAN:
  1044.                 yy_c_buf_p =
  1045.                     yytext_ptr + yy_amount_of_matched_text;
  1046.  
  1047.                 yy_current_state = yy_get_previous_state();
  1048.  
  1049.                 yy_cp = yy_c_buf_p;
  1050.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1051.                 goto yy_match;
  1052.  
  1053.             case EOB_ACT_LAST_MATCH:
  1054.                 yy_c_buf_p =
  1055.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1056.  
  1057.                 yy_current_state = yy_get_previous_state();
  1058.  
  1059.                 yy_cp = yy_c_buf_p;
  1060.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1061.                 goto yy_find_action;
  1062.             }
  1063.         break;
  1064.         }
  1065.  
  1066.     default:
  1067.         YY_FATAL_ERROR(
  1068.             "fatal flex scanner internal error--no action found" );
  1069.     } /* end of action switch */
  1070.         } /* end of scanning one token */
  1071.     } /* end of yylex */
  1072.  
  1073.  
  1074. /* yy_get_next_buffer - try to read in a new buffer
  1075.  *
  1076.  * Returns a code representing an action:
  1077.  *    EOB_ACT_LAST_MATCH -
  1078.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1079.  *    EOB_ACT_END_OF_FILE - end of file
  1080.  */
  1081.  
  1082. static int yy_get_next_buffer()
  1083.     {
  1084.     register char *dest = yy_current_buffer->yy_ch_buf;
  1085.     register char *source = yytext_ptr;
  1086.     register int number_to_move, i;
  1087.     int ret_val;
  1088.  
  1089.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1090.         YY_FATAL_ERROR(
  1091.         "fatal flex scanner internal error--end of buffer missed" );
  1092.  
  1093.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  1094.         { /* Don't try to fill the buffer, so this is an EOF. */
  1095.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1096.             {
  1097.             /* We matched a single character, the EOB, so
  1098.              * treat this as a final EOF.
  1099.              */
  1100.             return EOB_ACT_END_OF_FILE;
  1101.             }
  1102.  
  1103.         else
  1104.             {
  1105.             /* We matched some text prior to the EOB, first
  1106.              * process it.
  1107.              */
  1108.             return EOB_ACT_LAST_MATCH;
  1109.             }
  1110.         }
  1111.  
  1112.     /* Try to read more data. */
  1113.  
  1114.     /* First move last chars to start of buffer. */
  1115.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1116.  
  1117.     for ( i = 0; i < number_to_move; ++i )
  1118.         *(dest++) = *(source++);
  1119.  
  1120.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1121.         /* don't do the read, it's not guaranteed to return an EOF,
  1122.          * just force an EOF
  1123.          */
  1124.         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  1125.  
  1126.     else
  1127.         {
  1128.         int num_to_read =
  1129.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1130.  
  1131.         while ( num_to_read <= 0 )
  1132.             { /* Not enough room in the buffer - grow it. */
  1133. #ifdef YY_USES_REJECT
  1134.             YY_FATAL_ERROR(
  1135. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1136. #else
  1137.  
  1138.             /* just a shorter name for the current buffer */
  1139.             YY_BUFFER_STATE b = yy_current_buffer;
  1140.  
  1141.             int yy_c_buf_p_offset =
  1142.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  1143.  
  1144.             if ( b->yy_is_our_buffer )
  1145.                 {
  1146.                 int new_size = b->yy_buf_size * 2;
  1147.  
  1148.                 if ( new_size <= 0 )
  1149.                     b->yy_buf_size += b->yy_buf_size / 8;
  1150.                 else
  1151.                     b->yy_buf_size *= 2;
  1152.  
  1153.                 b->yy_ch_buf = (char *)
  1154.                     /* Include room in for 2 EOB chars. */
  1155.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  1156.                              b->yy_buf_size + 2 );
  1157.                 }
  1158.             else
  1159.                 /* Can't grow it, we don't own it. */
  1160.                 b->yy_ch_buf = 0;
  1161.  
  1162.             if ( ! b->yy_ch_buf )
  1163.                 YY_FATAL_ERROR(
  1164.                 "fatal error - scanner input buffer overflow" );
  1165.  
  1166.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1167.  
  1168.             num_to_read = yy_current_buffer->yy_buf_size -
  1169.                         number_to_move - 1;
  1170. #endif
  1171.             }
  1172.  
  1173.         if ( num_to_read > YY_READ_BUF_SIZE )
  1174.             num_to_read = YY_READ_BUF_SIZE;
  1175.  
  1176.         /* Read in more data. */
  1177.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1178.             yy_n_chars, num_to_read );
  1179.  
  1180.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1181.         }
  1182.  
  1183.     if ( yy_n_chars == 0 )
  1184.         {
  1185.         if ( number_to_move == YY_MORE_ADJ )
  1186.             {
  1187.             ret_val = EOB_ACT_END_OF_FILE;
  1188.             yyrestart( yyin );
  1189.             }
  1190.  
  1191.         else
  1192.             {
  1193.             ret_val = EOB_ACT_LAST_MATCH;
  1194.             yy_current_buffer->yy_buffer_status =
  1195.                 YY_BUFFER_EOF_PENDING;
  1196.             }
  1197.         }
  1198.  
  1199.     else
  1200.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1201.  
  1202.     yy_n_chars += number_to_move;
  1203.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1204.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1205.  
  1206.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1207.  
  1208.     return ret_val;
  1209.     }
  1210.  
  1211.  
  1212. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1213.  
  1214. static yy_state_type yy_get_previous_state()
  1215.     {
  1216.     register yy_state_type yy_current_state;
  1217.     register char *yy_cp;
  1218.  
  1219.     yy_current_state = yy_start;
  1220.  
  1221.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1222.         {
  1223.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1224.         if ( yy_accept[yy_current_state] )
  1225.             {
  1226.             yy_last_accepting_state = yy_current_state;
  1227.             yy_last_accepting_cpos = yy_cp;
  1228.             }
  1229.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1230.             {
  1231.             yy_current_state = (int) yy_def[yy_current_state];
  1232.             if ( yy_current_state >= 154 )
  1233.                 yy_c = yy_meta[(unsigned int) yy_c];
  1234.             }
  1235.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1236.         }
  1237.  
  1238.     return yy_current_state;
  1239.     }
  1240.  
  1241.  
  1242. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1243.  *
  1244.  * synopsis
  1245.  *    next_state = yy_try_NUL_trans( current_state );
  1246.  */
  1247.  
  1248. #ifdef YY_USE_PROTOS
  1249. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1250. #else
  1251. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1252. yy_state_type yy_current_state;
  1253. #endif
  1254.     {
  1255.     register int yy_is_jam;
  1256.     register char *yy_cp = yy_c_buf_p;
  1257.  
  1258.     register YY_CHAR yy_c = 1;
  1259.     if ( yy_accept[yy_current_state] )
  1260.         {
  1261.         yy_last_accepting_state = yy_current_state;
  1262.         yy_last_accepting_cpos = yy_cp;
  1263.         }
  1264.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1265.         {
  1266.         yy_current_state = (int) yy_def[yy_current_state];
  1267.         if ( yy_current_state >= 154 )
  1268.             yy_c = yy_meta[(unsigned int) yy_c];
  1269.         }
  1270.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1271.     yy_is_jam = (yy_current_state == 153);
  1272.  
  1273.     return yy_is_jam ? 0 : yy_current_state;
  1274.     }
  1275.  
  1276.  
  1277. #ifndef YY_NO_UNPUT
  1278. #ifdef YY_USE_PROTOS
  1279. static void yyunput( int c, register char *yy_bp )
  1280. #else
  1281. static void yyunput( c, yy_bp )
  1282. int c;
  1283. register char *yy_bp;
  1284. #endif
  1285.     {
  1286.     register char *yy_cp = yy_c_buf_p;
  1287.  
  1288.     /* undo effects of setting up yytext */
  1289.     *yy_cp = yy_hold_char;
  1290.  
  1291.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1292.         { /* need to shift things up to make room */
  1293.         /* +2 for EOB chars. */
  1294.         register int number_to_move = yy_n_chars + 2;
  1295.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1296.                     yy_current_buffer->yy_buf_size + 2];
  1297.         register char *source =
  1298.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1299.  
  1300.         while ( source > yy_current_buffer->yy_ch_buf )
  1301.             *--dest = *--source;
  1302.  
  1303.         yy_cp += (int) (dest - source);
  1304.         yy_bp += (int) (dest - source);
  1305.         yy_current_buffer->yy_n_chars =
  1306.             yy_n_chars = yy_current_buffer->yy_buf_size;
  1307.  
  1308.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1309.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1310.         }
  1311.  
  1312.     *--yy_cp = (char) c;
  1313.  
  1314.  
  1315.     yytext_ptr = yy_bp;
  1316.     yy_hold_char = *yy_cp;
  1317.     yy_c_buf_p = yy_cp;
  1318.     }
  1319. #endif    /* ifndef YY_NO_UNPUT */
  1320.  
  1321.  
  1322. #ifdef __cplusplus
  1323. static int yyinput()
  1324. #else
  1325. static int input()
  1326. #endif
  1327.     {
  1328.     int c;
  1329.  
  1330.     *yy_c_buf_p = yy_hold_char;
  1331.  
  1332.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1333.         {
  1334.         /* yy_c_buf_p now points to the character we want to return.
  1335.          * If this occurs *before* the EOB characters, then it's a
  1336.          * valid NUL; if not, then we've hit the end of the buffer.
  1337.          */
  1338.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1339.             /* This was really a NUL. */
  1340.             *yy_c_buf_p = '\0';
  1341.  
  1342.         else
  1343.             { /* need more input */
  1344.             int offset = yy_c_buf_p - yytext_ptr;
  1345.             ++yy_c_buf_p;
  1346.  
  1347.             switch ( yy_get_next_buffer() )
  1348.                 {
  1349.                 case EOB_ACT_LAST_MATCH:
  1350.                     /* This happens because yy_g_n_b()
  1351.                      * sees that we've accumulated a
  1352.                      * token and flags that we need to
  1353.                      * try matching the token before
  1354.                      * proceeding.  But for input(),
  1355.                      * there's no matching to consider.
  1356.                      * So convert the EOB_ACT_LAST_MATCH
  1357.                      * to EOB_ACT_END_OF_FILE.
  1358.                      */
  1359.  
  1360.                     /* Reset buffer status. */
  1361.                     yyrestart( yyin );
  1362.  
  1363.                     /* fall through */
  1364.  
  1365.                 case EOB_ACT_END_OF_FILE:
  1366.                     {
  1367.                     if ( yywrap() )
  1368.                         return EOF;
  1369.  
  1370.                     if ( ! yy_did_buffer_switch_on_eof )
  1371.                         YY_NEW_FILE;
  1372. #ifdef __cplusplus
  1373.                     return yyinput();
  1374. #else
  1375.                     return input();
  1376. #endif
  1377.                     }
  1378.  
  1379.                 case EOB_ACT_CONTINUE_SCAN:
  1380.                     yy_c_buf_p = yytext_ptr + offset;
  1381.                     break;
  1382.                 }
  1383.             }
  1384.         }
  1385.  
  1386.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1387.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1388.     yy_hold_char = *++yy_c_buf_p;
  1389.  
  1390.  
  1391.     return c;
  1392.     }
  1393.  
  1394.  
  1395. #ifdef YY_USE_PROTOS
  1396. void yyrestart( FILE *input_file )
  1397. #else
  1398. void yyrestart( input_file )
  1399. FILE *input_file;
  1400. #endif
  1401.     {
  1402.     if ( ! yy_current_buffer )
  1403.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1404.  
  1405.     yy_init_buffer( yy_current_buffer, input_file );
  1406.     yy_load_buffer_state();
  1407.     }
  1408.  
  1409.  
  1410. #ifdef YY_USE_PROTOS
  1411. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1412. #else
  1413. void yy_switch_to_buffer( new_buffer )
  1414. YY_BUFFER_STATE new_buffer;
  1415. #endif
  1416.     {
  1417.     if ( yy_current_buffer == new_buffer )
  1418.         return;
  1419.  
  1420.     if ( yy_current_buffer )
  1421.         {
  1422.         /* Flush out information for old buffer. */
  1423.         *yy_c_buf_p = yy_hold_char;
  1424.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1425.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1426.         }
  1427.  
  1428.     yy_current_buffer = new_buffer;
  1429.     yy_load_buffer_state();
  1430.  
  1431.     /* We don't actually know whether we did this switch during
  1432.      * EOF (yywrap()) processing, but the only time this flag
  1433.      * is looked at is after yywrap() is called, so it's safe
  1434.      * to go ahead and always set it.
  1435.      */
  1436.     yy_did_buffer_switch_on_eof = 1;
  1437.     }
  1438.  
  1439.  
  1440. #ifdef YY_USE_PROTOS
  1441. void yy_load_buffer_state( void )
  1442. #else
  1443. void yy_load_buffer_state()
  1444. #endif
  1445.     {
  1446.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1447.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1448.     yyin = yy_current_buffer->yy_input_file;
  1449.     yy_hold_char = *yy_c_buf_p;
  1450.     }
  1451.  
  1452.  
  1453. #ifdef YY_USE_PROTOS
  1454. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1455. #else
  1456. YY_BUFFER_STATE yy_create_buffer( file, size )
  1457. FILE *file;
  1458. int size;
  1459. #endif
  1460.     {
  1461.     YY_BUFFER_STATE b;
  1462.  
  1463.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1464.     if ( ! b )
  1465.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1466.  
  1467.     b->yy_buf_size = size;
  1468.  
  1469.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1470.      * we need to put in 2 end-of-buffer characters.
  1471.      */
  1472.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1473.     if ( ! b->yy_ch_buf )
  1474.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1475.  
  1476.     b->yy_is_our_buffer = 1;
  1477.  
  1478.     yy_init_buffer( b, file );
  1479.  
  1480.     return b;
  1481.     }
  1482.  
  1483.  
  1484. #ifdef YY_USE_PROTOS
  1485. void yy_delete_buffer( YY_BUFFER_STATE b )
  1486. #else
  1487. void yy_delete_buffer( b )
  1488. YY_BUFFER_STATE b;
  1489. #endif
  1490.     {
  1491.     if ( ! b )
  1492.         return;
  1493.  
  1494.     if ( b == yy_current_buffer )
  1495.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1496.  
  1497.     if ( b->yy_is_our_buffer )
  1498.         yy_flex_free( (void *) b->yy_ch_buf );
  1499.  
  1500.     yy_flex_free( (void *) b );
  1501.     }
  1502.  
  1503.  
  1504. #ifndef YY_ALWAYS_INTERACTIVE
  1505. #ifndef YY_NEVER_INTERACTIVE
  1506. extern int isatty YY_PROTO(( int ));
  1507. #endif
  1508. #endif
  1509.  
  1510. #ifdef YY_USE_PROTOS
  1511. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1512. #else
  1513. void yy_init_buffer( b, file )
  1514. YY_BUFFER_STATE b;
  1515. FILE *file;
  1516. #endif
  1517.  
  1518.  
  1519.     {
  1520.     yy_flush_buffer( b );
  1521.  
  1522.     b->yy_input_file = file;
  1523.     b->yy_fill_buffer = 1;
  1524.  
  1525. #if YY_ALWAYS_INTERACTIVE
  1526.     b->yy_is_interactive = 1;
  1527. #else
  1528. #if YY_NEVER_INTERACTIVE
  1529.     b->yy_is_interactive = 0;
  1530. #else
  1531.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1532. #endif
  1533. #endif
  1534.     }
  1535.  
  1536.  
  1537. #ifdef YY_USE_PROTOS
  1538. void yy_flush_buffer( YY_BUFFER_STATE b )
  1539. #else
  1540. void yy_flush_buffer( b )
  1541. YY_BUFFER_STATE b;
  1542. #endif
  1543.  
  1544.     {
  1545.     if ( ! b )
  1546.         return;
  1547.  
  1548.     b->yy_n_chars = 0;
  1549.  
  1550.     /* We always need two end-of-buffer characters.  The first causes
  1551.      * a transition to the end-of-buffer state.  The second causes
  1552.      * a jam in that state.
  1553.      */
  1554.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1555.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1556.  
  1557.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1558.  
  1559.     b->yy_at_bol = 1;
  1560.     b->yy_buffer_status = YY_BUFFER_NEW;
  1561.  
  1562.     if ( b == yy_current_buffer )
  1563.         yy_load_buffer_state();
  1564.     }
  1565.  
  1566.  
  1567. #ifndef YY_NO_SCAN_BUFFER
  1568. #ifdef YY_USE_PROTOS
  1569. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1570. #else
  1571. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1572. char *base;
  1573. yy_size_t size;
  1574. #endif
  1575.     {
  1576.     YY_BUFFER_STATE b;
  1577.  
  1578.     if ( size < 2 ||
  1579.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1580.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1581.         /* They forgot to leave room for the EOB's. */
  1582.         return 0;
  1583.  
  1584.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1585.     if ( ! b )
  1586.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1587.  
  1588.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1589.     b->yy_buf_pos = b->yy_ch_buf = base;
  1590.     b->yy_is_our_buffer = 0;
  1591.     b->yy_input_file = 0;
  1592.     b->yy_n_chars = b->yy_buf_size;
  1593.     b->yy_is_interactive = 0;
  1594.     b->yy_at_bol = 1;
  1595.     b->yy_fill_buffer = 0;
  1596.     b->yy_buffer_status = YY_BUFFER_NEW;
  1597.  
  1598.     yy_switch_to_buffer( b );
  1599.  
  1600.     return b;
  1601.     }
  1602. #endif
  1603.  
  1604.  
  1605. #ifndef YY_NO_SCAN_STRING
  1606. #ifdef YY_USE_PROTOS
  1607. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  1608. #else
  1609. YY_BUFFER_STATE yy_scan_string( yy_str )
  1610. yyconst char *yy_str;
  1611. #endif
  1612.     {
  1613.     int len;
  1614.     for ( len = 0; yy_str[len]; ++len )
  1615.         ;
  1616.  
  1617.     return yy_scan_bytes( yy_str, len );
  1618.     }
  1619. #endif
  1620.  
  1621.  
  1622. #ifndef YY_NO_SCAN_BYTES
  1623. #ifdef YY_USE_PROTOS
  1624. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1625. #else
  1626. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1627. yyconst char *bytes;
  1628. int len;
  1629. #endif
  1630.     {
  1631.     YY_BUFFER_STATE b;
  1632.     char *buf;
  1633.     yy_size_t n;
  1634.     int i;
  1635.  
  1636.     /* Get memory for full buffer, including space for trailing EOB's. */
  1637.     n = len + 2;
  1638.     buf = (char *) yy_flex_alloc( n );
  1639.     if ( ! buf )
  1640.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1641.  
  1642.     for ( i = 0; i < len; ++i )
  1643.         buf[i] = bytes[i];
  1644.  
  1645.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1646.  
  1647.     b = yy_scan_buffer( buf, n );
  1648.     if ( ! b )
  1649.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1650.  
  1651.     /* It's okay to grow etc. this buffer, and we should throw it
  1652.      * away when we're done.
  1653.      */
  1654.     b->yy_is_our_buffer = 1;
  1655.  
  1656.     return b;
  1657.     }
  1658. #endif
  1659.  
  1660.  
  1661. #ifndef YY_NO_PUSH_STATE
  1662. #ifdef YY_USE_PROTOS
  1663. static void yy_push_state( int new_state )
  1664. #else
  1665. static void yy_push_state( new_state )
  1666. int new_state;
  1667. #endif
  1668.     {
  1669.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1670.         {
  1671.         yy_size_t new_size;
  1672.  
  1673.         yy_start_stack_depth += YY_START_STACK_INCR;
  1674.         new_size = yy_start_stack_depth * sizeof( int );
  1675.  
  1676.         if ( ! yy_start_stack )
  1677.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1678.  
  1679.         else
  1680.             yy_start_stack = (int *) yy_flex_realloc(
  1681.                     (void *) yy_start_stack, new_size );
  1682.  
  1683.         if ( ! yy_start_stack )
  1684.             YY_FATAL_ERROR(
  1685.             "out of memory expanding start-condition stack" );
  1686.         }
  1687.  
  1688.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1689.  
  1690.     BEGIN(new_state);
  1691.     }
  1692. #endif
  1693.  
  1694.  
  1695. #ifndef YY_NO_POP_STATE
  1696. static void yy_pop_state()
  1697.     {
  1698.     if ( --yy_start_stack_ptr < 0 )
  1699.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1700.  
  1701.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1702.     }
  1703. #endif
  1704.  
  1705.  
  1706. #ifndef YY_NO_TOP_STATE
  1707. static int yy_top_state()
  1708.     {
  1709.     return yy_start_stack[yy_start_stack_ptr - 1];
  1710.     }
  1711. #endif
  1712.  
  1713. #ifndef YY_EXIT_FAILURE
  1714. #define YY_EXIT_FAILURE 2
  1715. #endif
  1716.  
  1717. #ifdef YY_USE_PROTOS
  1718. static void yy_fatal_error( yyconst char msg[] )
  1719. #else
  1720. static void yy_fatal_error( msg )
  1721. char msg[];
  1722. #endif
  1723.     {
  1724.     (void) fprintf( stderr, "%s\n", msg );
  1725.     exit( YY_EXIT_FAILURE );
  1726.     }
  1727.  
  1728.  
  1729.  
  1730. /* Redefine yyless() so it works in section 3 code. */
  1731.  
  1732. #undef yyless
  1733. #define yyless(n) \
  1734.     do \
  1735.         { \
  1736.         /* Undo effects of setting up yytext. */ \
  1737.         yytext[yyleng] = yy_hold_char; \
  1738.         yy_c_buf_p = yytext + n; \
  1739.         yy_hold_char = *yy_c_buf_p; \
  1740.         *yy_c_buf_p = '\0'; \
  1741.         yyleng = n; \
  1742.         } \
  1743.     while ( 0 )
  1744.  
  1745.  
  1746. /* Internal utility routines. */
  1747.  
  1748. #ifndef yytext_ptr
  1749. #ifdef YY_USE_PROTOS
  1750. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  1751. #else
  1752. static void yy_flex_strncpy( s1, s2, n )
  1753. char *s1;
  1754. yyconst char *s2;
  1755. int n;
  1756. #endif
  1757.     {
  1758.     register int i;
  1759.     for ( i = 0; i < n; ++i )
  1760.         s1[i] = s2[i];
  1761.     }
  1762. #endif
  1763.  
  1764. #ifdef YY_NEED_STRLEN
  1765. #ifdef YY_USE_PROTOS
  1766. static int yy_flex_strlen( yyconst char *s )
  1767. #else
  1768. static int yy_flex_strlen( s )
  1769. yyconst char *s;
  1770. #endif
  1771.     {
  1772.     register int n;
  1773.     for ( n = 0; s[n]; ++n )
  1774.         ;
  1775.  
  1776.     return n;
  1777.     }
  1778. #endif
  1779.  
  1780.  
  1781. #ifdef YY_USE_PROTOS
  1782. static void *yy_flex_alloc( yy_size_t size )
  1783. #else
  1784. static void *yy_flex_alloc( size )
  1785. yy_size_t size;
  1786. #endif
  1787.     {
  1788.     return (void *) malloc( size );
  1789.     }
  1790.  
  1791. #ifdef YY_USE_PROTOS
  1792. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  1793. #else
  1794. static void *yy_flex_realloc( ptr, size )
  1795. void *ptr;
  1796. yy_size_t size;
  1797. #endif
  1798.     {
  1799.     /* The cast to (char *) in the following accommodates both
  1800.      * implementations that use char* generic pointers, and those
  1801.      * that use void* generic pointers.  It works with the latter
  1802.      * because both ANSI C and C++ allow castless assignment from
  1803.      * any pointer type to void*, and deal with argument conversions
  1804.      * as though doing an assignment.
  1805.      */
  1806.     return (void *) realloc( (char *) ptr, size );
  1807.     }
  1808.  
  1809. #ifdef YY_USE_PROTOS
  1810. static void yy_flex_free( void *ptr )
  1811. #else
  1812. static void yy_flex_free( ptr )
  1813. void *ptr;
  1814. #endif
  1815.     {
  1816.     free( ptr );
  1817.     }
  1818.  
  1819. #if YY_MAIN
  1820. int main()
  1821.     {
  1822.     yylex();
  1823.     return 0;
  1824.     }
  1825. #endif
  1826. #line 126 "imap_csim.l"
  1827.