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