home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / src / binutils.2 / binutils / arlex.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  33.6 KB  |  1,260 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* scanner skeleton version:
  4.  * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8.  
  9. #include <stdio.h>
  10.  
  11.  
  12. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  13. #ifdef c_plusplus
  14. #ifndef __cplusplus
  15. #define __cplusplus
  16. #endif
  17. #endif
  18.  
  19.  
  20. #ifdef __cplusplus
  21.  
  22. #include <stdlib.h>
  23. #include <osfcn.h>
  24.  
  25. /* use prototypes in function declarations */
  26. #define YY_USE_PROTOS
  27.  
  28. /* the "const" storage-class-modifier is valid */
  29. #define YY_USE_CONST
  30.  
  31. #else    /* ! __cplusplus */
  32.  
  33. #ifdef __STDC__
  34.  
  35. #ifdef __GNUC__
  36. #include <stddef.h>
  37. void *malloc( size_t );
  38. void free( void* );
  39. #else
  40. #include <stdlib.h>
  41. #endif    /* __GNUC__ */
  42.  
  43. #define YY_USE_PROTOS
  44. #define YY_USE_CONST
  45.  
  46. #endif    /* __STDC__ */
  47. #endif    /* ! __cplusplus */
  48.  
  49.  
  50. #ifdef __TURBOC__
  51. #define YY_USE_CONST
  52. #endif
  53.  
  54.  
  55. #ifndef YY_USE_CONST
  56. #define const
  57. #endif
  58.  
  59.  
  60. #ifdef YY_USE_PROTOS
  61. #define YY_PROTO(proto) proto
  62. #else
  63. #define YY_PROTO(proto) ()
  64. /* we can't get here if it's an ANSI C compiler, or a C++ compiler,
  65.  * so it's got to be a K&R compiler, and therefore there's no standard
  66.  * place from which to include these definitions
  67.  */
  68. char *malloc();
  69. int free();
  70. int read();
  71. #endif
  72.  
  73.  
  74. /* amount of stuff to slurp up with each read */
  75. #ifndef YY_READ_BUF_SIZE
  76. #define YY_READ_BUF_SIZE 8192
  77. #endif
  78.  
  79. /* returned upon end-of-file */
  80. #define YY_END_TOK 0
  81.  
  82. /* copy whatever the last rule matched to the standard output */
  83.  
  84. /* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
  85. /* this used to be an fputs(), but since the string might contain NUL's,
  86.  * we now use fwrite()
  87.  */
  88. #define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
  89.  
  90. /* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  91.  * is returned in "result".
  92.  */
  93. #define YY_INPUT(buf,result,max_size) \
  94.     if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
  95.         YY_FATAL_ERROR( "read() in flex scanner failed" );
  96. #define YY_NULL 0
  97.  
  98. /* no semi-colon after return; correct usage is to write "yyterminate();" -
  99.  * we don't want an extra ';' after the "return" because that will cause
  100.  * some compilers to complain about unreachable statements.
  101.  */
  102. #define yyterminate() return ( YY_NULL )
  103.  
  104. /* report a fatal error */
  105.  
  106. /* The funky do-while is used to turn this macro definition into
  107.  * a single C statement (which needs a semi-colon terminator).
  108.  * This avoids problems with code like:
  109.  *
  110.  *     if ( something_happens )
  111.  *        YY_FATAL_ERROR( "oops, the something happened" );
  112.  *    else
  113.  *        everything_okay();
  114.  *
  115.  * Prior to using the do-while the compiler would get upset at the
  116.  * "else" because it interpreted the "if" statement as being all
  117.  * done when it reached the ';' after the YY_FATAL_ERROR() call.
  118.  */
  119.  
  120. #define YY_FATAL_ERROR(msg) \
  121.     do \
  122.         { \
  123.         (void) fputs( msg, stderr ); \
  124.         (void) putc( '\n', stderr ); \
  125.         exit( 1 ); \
  126.         } \
  127.     while ( 0 )
  128.  
  129. /* default yywrap function - always treat EOF as an EOF */
  130. #define yywrap() 1
  131.  
  132. /* enter a start condition.  This macro really ought to take a parameter,
  133.  * but we do it the disgusting crufty way forced on us by the ()-less
  134.  * definition of BEGIN
  135.  */
  136. #define BEGIN yy_start = 1 + 2 *
  137.  
  138. /* action number for EOF rule of a given start state */
  139. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  140.  
  141. /* special action meaning "start processing a new file" */
  142. #define YY_NEW_FILE \
  143.     do \
  144.         { \
  145.         yy_init_buffer( yy_current_buffer, yyin ); \
  146.         yy_load_buffer_state(); \
  147.         } \
  148.     while ( 0 )
  149.  
  150. /* default declaration of generated scanner - a define so the user can
  151.  * easily add parameters
  152.  */
  153. #define YY_DECL int yylex YY_PROTO(( void )) 
  154.  
  155. /* code executed at the end of each rule */
  156. #define YY_BREAK break;
  157.  
  158. #define YY_END_OF_BUFFER_CHAR 0
  159.  
  160. #ifndef YY_BUF_SIZE
  161. #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
  162. #endif
  163.  
  164. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  165.  
  166. #define YY_CHAR char
  167. # line 1 "arlex.l"
  168. #define INITIAL 0
  169. # line 2 "arlex.l"
  170. /* arlex.l - Strange script language lexer */
  171.  
  172. /*   Copyright (C) 1992 Free Software Foundation, Inc.
  173.  
  174. This file is part of GNU Binutils.
  175.  
  176. This program is free software; you can redistribute it and/or modify
  177. it under the terms of the GNU General Public License as published by
  178. the Free Software Foundation; either version 2 of the License, or
  179. (at your option) any later version.
  180.  
  181. This program is distributed in the hope that it will be useful,
  182. but WITHOUT ANY WARRANTY; without even the implied warranty of
  183. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  184. GNU General Public License for more details.
  185.  
  186. You should have received a copy of the GNU General Public License
  187. along with this program; if not, write to the Free Software
  188. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  189.  
  190.  
  191. /* Contributed by Steve Chamberlain
  192.              sac@cygnus.com
  193.  
  194. */
  195. #define DONTDECLARE_MALLOC
  196. #include <ansidecl.h>
  197. #include "arparse.h"
  198. extern char *strdup();
  199. int linenumber;
  200. # line 33 "arlex.l"
  201.  
  202. /* done after the current pattern has been matched and before the
  203.  * corresponding action - sets up yytext
  204.  */
  205. #define YY_DO_BEFORE_ACTION \
  206.     yytext = yy_bp; \
  207.     yyleng = yy_cp - yy_bp; \
  208.     yy_hold_char = *yy_cp; \
  209.     *yy_cp = '\0'; \
  210.     yy_c_buf_p = yy_cp;
  211.  
  212. #define EOB_ACT_CONTINUE_SCAN 0
  213. #define EOB_ACT_END_OF_FILE 1
  214. #define EOB_ACT_LAST_MATCH 2
  215.  
  216. /* return all but the first 'n' matched characters back to the input stream */
  217. #define yyless(n) \
  218.     do \
  219.         { \
  220.         /* undo effects of setting up yytext */ \
  221.         *yy_cp = yy_hold_char; \
  222.         yy_c_buf_p = yy_cp = yy_bp + n; \
  223.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  224.         } \
  225.     while ( 0 )
  226.  
  227. #define unput(c) yyunput( c, yytext )
  228.  
  229.  
  230. struct yy_buffer_state
  231.     {
  232.     FILE *yy_input_file;
  233.  
  234.     YY_CHAR *yy_ch_buf;        /* input buffer */
  235.     YY_CHAR *yy_buf_pos;    /* current position in input buffer */
  236.  
  237.     /* size of input buffer in bytes, not including room for EOB characters*/
  238.     int yy_buf_size;    
  239.  
  240.     /* number of characters read into yy_ch_buf, not including EOB characters */
  241.     int yy_n_chars;
  242.  
  243.     int yy_eof_status;        /* whether we've seen an EOF on this buffer */
  244. #define EOF_NOT_SEEN 0
  245.     /* "pending" happens when the EOF has been seen but there's still
  246.      * some text process
  247.      */
  248. #define EOF_PENDING 1
  249. #define EOF_DONE 2
  250.     };
  251.  
  252. static YY_BUFFER_STATE yy_current_buffer;
  253.  
  254. /* we provide macros for accessing buffer states in case in the
  255.  * future we want to put the buffer states in a more general
  256.  * "scanner state"
  257.  */
  258. #define YY_CURRENT_BUFFER yy_current_buffer
  259.  
  260.  
  261. /* yy_hold_char holds the character lost when yytext is formed */
  262. static YY_CHAR yy_hold_char;
  263.  
  264. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  265.  
  266.  
  267.  
  268. #ifndef YY_USER_ACTION
  269. #define YY_USER_ACTION
  270. #endif
  271.  
  272. #ifndef YY_USER_INIT
  273. #define YY_USER_INIT
  274. #endif
  275.  
  276. extern YY_CHAR *yytext;
  277. extern int yyleng;
  278. extern FILE *yyin, *yyout;
  279.  
  280. YY_CHAR *yytext;
  281. int yyleng;
  282.  
  283. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  284.  
  285. #define YY_END_OF_BUFFER 41
  286. typedef int yy_state_type;
  287. static const short int yy_accept[177] =
  288.     {   0,
  289.         0,    0,   41,   40,   39,   38,   35,   32,   33,   36,
  290.        40,   34,   37,   35,   35,   35,   35,   35,   35,   35,
  291.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  292.        35,   35,   35,   35,   35,   35,   36,   31,   37,   35,
  293.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  294.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  295.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  296.        35,   35,    7,   35,   35,   35,   35,   35,   35,   35,
  297.        35,   35,   35,   35,   35,   35,   22,   35,   35,   35,
  298.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  299.  
  300.        35,   35,   35,   10,   11,   12,   35,   15,   35,   35,
  301.        35,   35,   35,   35,   35,   35,   35,   25,   26,   27,
  302.        35,   30,   35,   35,   35,    3,   35,   35,   35,   35,
  303.        35,   35,   35,   35,   35,   18,   35,   35,   35,   35,
  304.        35,   35,   35,    1,    2,    4,    5,   35,   35,   35,
  305.        35,   35,   16,   17,   19,   20,   35,   35,   35,   35,
  306.        35,   35,    8,    9,   13,   14,   35,   23,   24,   28,
  307.        29,   35,   35,    6,   21,    0
  308.     } ;
  309.  
  310. static const YY_CHAR yy_ec[128] =
  311.     {   0,
  312.         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
  313.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  314.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  315.         1,    3,    1,    1,    1,    4,    1,    1,    1,    5,
  316.         6,    7,    8,    9,    4,    4,    4,    4,    4,    4,
  317.         4,    4,    4,    4,    4,    4,    4,    4,   10,    1,
  318.         1,    1,    1,    1,   11,   12,   13,   14,   15,   16,
  319.         4,   17,   18,    4,    4,   19,   20,   21,   22,   23,
  320.         4,   24,   25,   26,   27,   28,    4,   29,   30,    4,
  321.         1,    1,    1,    1,    4,    1,   31,   32,   33,   34,
  322.  
  323.        35,   36,    4,   37,   38,    4,    4,   39,   40,   41,
  324.        42,   43,    4,   44,   45,   46,   47,   48,    4,   49,
  325.        50,    4,    1,    1,    1,    1,    1
  326.     } ;
  327.  
  328. static const YY_CHAR yy_meta[51] =
  329.     {   0,
  330.         1,    2,    1,    3,    1,    1,    1,    1,    1,    1,
  331.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  332.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  333.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  334.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3
  335.     } ;
  336.  
  337. static const short int yy_base[180] =
  338.     {   0,
  339.         0,    0,  193,  194,  194,  194,    0,  194,  194,    0,
  340.       190,  194,    0,  177,   32,   37,   32,  163,  174,  170,
  341.       164,  171,  174,  169,  149,   15,   22,   17,  135,  146,
  342.       142,  136,  143,  146,  141,    0,    0,  194,    0,  161,
  343.       159,  158,  153,  147,  156,  143,  149,  148,  141,  150,
  344.       141,  135,  138,  127,  125,  124,  119,  113,  122,  109,
  345.       115,  114,  107,  116,  107,  101,  104,   43,  136,  135,
  346.       130,  129,    0,  119,  123,  118,  114,  118,  119,  122,
  347.       124,   25,  104,  103,   98,   97,    0,   87,   91,   86,
  348.        82,   86,   87,   90,   92,  105,  100,   97,   94,   93,
  349.  
  350.       105,  106,  102,    0,    0,    0,  104,    0,   92,   75,
  351.        70,   67,   64,   63,   75,   76,   72,    0,    0,    0,
  352.        74,    0,   62,   91,   88,    0,   86,   85,   73,   85,
  353.        79,   83,   70,   62,   59,    0,   57,   56,   44,   56,
  354.        50,   54,   41,    0,    0,    0,    0,   63,   58,   59,
  355.        67,   66,    0,    0,    0,    0,   38,   33,   34,   42,
  356.        41,   51,    0,    0,    0,    0,   30,    0,    0,    0,
  357.         0,   43,   21,    0,    0,  194,   65,   66,   69
  358.     } ;
  359.  
  360. static const short int yy_def[180] =
  361.     {   0,
  362.       176,    1,  176,  176,  176,  176,  177,  176,  176,  178,
  363.       176,  176,  179,  177,  177,  177,  177,  177,  177,  177,
  364.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  365.       177,  177,  177,  177,  177,  177,  178,  176,  179,  177,
  366.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  367.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  368.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  369.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  370.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  371.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  372.  
  373.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  374.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  375.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  376.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  377.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  378.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  379.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  380.       177,  177,  177,  177,  177,    0,  176,  176,  176
  381.     } ;
  382.  
  383. static const short int yy_nxt[245] =
  384.     {   0,
  385.         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  386.        14,    7,   15,   16,   17,   18,   19,    7,   20,    7,
  387.         7,   21,    7,   22,   23,    7,    7,   24,    7,    7,
  388.        25,    7,   26,   27,   28,   29,   30,    7,   31,    7,
  389.         7,   32,    7,   33,   34,    7,    7,   35,    7,    7,
  390.        41,   43,   45,   55,   44,   42,   57,   59,   56,   58,
  391.        46,   96,   97,  110,  111,   60,   37,   36,   37,   39,
  392.       175,   39,  174,  173,  172,  171,  170,  169,  168,  167,
  393.       166,  165,  164,  163,  162,  161,  160,  159,  158,  157,
  394.       156,  155,  154,  153,  152,  151,  150,  149,  148,  147,
  395.  
  396.       146,  145,  144,  143,  142,  141,  140,  139,  138,  137,
  397.       136,  135,  134,  133,  132,  131,  130,  129,  128,  127,
  398.       126,  125,  124,  123,  122,  121,  120,  119,  118,  117,
  399.       116,  115,  114,  113,  112,  109,  108,  107,  106,  105,
  400.       104,  103,  102,  101,  100,   99,   98,   95,   94,   93,
  401.        92,   91,   90,   89,   88,   87,   86,   85,   84,   83,
  402.        82,   81,   80,   79,   78,   77,   76,   75,   74,   73,
  403.        72,   71,   70,   69,   68,   67,   66,   65,   64,   63,
  404.        62,   61,   54,   53,   52,   51,   50,   49,   48,   47,
  405.        40,   38,  176,    3,  176,  176,  176,  176,  176,  176,
  406.  
  407.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  408.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  409.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  410.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  411.       176,  176,  176,  176
  412.     } ;
  413.  
  414. static const short int yy_chk[245] =
  415.     {   0,
  416.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  417.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  418.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  419.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  420.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  421.        15,   16,   17,   26,   16,   15,   27,   28,   26,   27,
  422.        17,   68,   68,   82,   82,   28,  178,  177,  178,  179,
  423.       173,  179,  172,  167,  162,  161,  160,  159,  158,  157,
  424.       152,  151,  150,  149,  148,  143,  142,  141,  140,  139,
  425.       138,  137,  135,  134,  133,  132,  131,  130,  129,  128,
  426.  
  427.       127,  125,  124,  123,  121,  117,  116,  115,  114,  113,
  428.       112,  111,  110,  109,  107,  103,  102,  101,  100,   99,
  429.        98,   97,   96,   95,   94,   93,   92,   91,   90,   89,
  430.        88,   86,   85,   84,   83,   81,   80,   79,   78,   77,
  431.        76,   75,   74,   72,   71,   70,   69,   67,   66,   65,
  432.        64,   63,   62,   61,   60,   59,   58,   57,   56,   55,
  433.        54,   53,   52,   51,   50,   49,   48,   47,   46,   45,
  434.        44,   43,   42,   41,   40,   35,   34,   33,   32,   31,
  435.        30,   29,   25,   24,   23,   22,   21,   20,   19,   18,
  436.        14,   11,    3,  176,  176,  176,  176,  176,  176,  176,
  437.  
  438.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  439.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  440.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  441.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  442.       176,  176,  176,  176
  443.     } ;
  444.  
  445. static yy_state_type yy_last_accepting_state;
  446. static YY_CHAR *yy_last_accepting_cpos;
  447.  
  448. /* the intent behind this definition is that it'll catch
  449.  * any uses of REJECT which flex missed
  450.  */
  451. #define REJECT reject_used_but_not_detected
  452. #define yymore() yymore_used_but_not_detected
  453. #define YY_MORE_ADJ 0
  454.  
  455. /* these variables are all declared out here so that section 3 code can
  456.  * manipulate them
  457.  */
  458. /* points to current character in buffer */
  459. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  460. static int yy_init = 1;        /* whether we need to initialize */
  461. static int yy_start = 0;    /* start state number */
  462.  
  463. /* flag which is used to allow yywrap()'s to do buffer switches
  464.  * instead of setting up a fresh yyin.  A bit of a hack ...
  465.  */
  466. static int yy_did_buffer_switch_on_eof;
  467.  
  468. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  469. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  470. static int yy_get_next_buffer YY_PROTO(( void ));
  471. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  472. void yyrestart YY_PROTO(( FILE *input_file ));
  473. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  474. void yy_load_buffer_state YY_PROTO(( void ));
  475. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  476. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  477. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  478.  
  479. #define yy_new_buffer yy_create_buffer
  480.  
  481. #ifdef __cplusplus
  482. static int yyinput YY_PROTO(( void ));
  483. #else
  484. static int input YY_PROTO(( void ));
  485. #endif
  486.  
  487. YY_DECL
  488.     {
  489.     register yy_state_type yy_current_state;
  490.     register YY_CHAR *yy_cp, *yy_bp;
  491.     register int yy_act;
  492.  
  493.  
  494.  
  495.  
  496.     if ( yy_init )
  497.     {
  498.     YY_USER_INIT;
  499.  
  500.     if ( ! yy_start )
  501.         yy_start = 1;    /* first start state */
  502.  
  503.     if ( ! yyin )
  504.         yyin = stdin;
  505.  
  506.     if ( ! yyout )
  507.         yyout = stdout;
  508.  
  509.     if ( yy_current_buffer )
  510.         yy_init_buffer( yy_current_buffer, yyin );
  511.     else
  512.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  513.  
  514.     yy_load_buffer_state();
  515.  
  516.     yy_init = 0;
  517.     }
  518.  
  519.     while ( 1 )        /* loops until end-of-file is reached */
  520.     {
  521.     yy_cp = yy_c_buf_p;
  522.  
  523.     /* support of yytext */
  524.     *yy_cp = yy_hold_char;
  525.  
  526.     /* yy_bp points to the position in yy_ch_buf of the start of the
  527.      * current run.
  528.      */
  529.     yy_bp = yy_cp;
  530.  
  531.     yy_current_state = yy_start;
  532. yy_match:
  533.     do
  534.         {
  535.         register YY_CHAR yy_c = yy_ec[*yy_cp];
  536.         if ( yy_accept[yy_current_state] )
  537.         {
  538.         yy_last_accepting_state = yy_current_state;
  539.         yy_last_accepting_cpos = yy_cp;
  540.         }
  541.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  542.         {
  543.         yy_current_state = yy_def[yy_current_state];
  544.         if ( yy_current_state >= 177 )
  545.             yy_c = yy_meta[yy_c];
  546.         }
  547.         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  548.         ++yy_cp;
  549.         }
  550.     while ( yy_base[yy_current_state] != 194 );
  551.  
  552. yy_find_action:
  553.     yy_act = yy_accept[yy_current_state];
  554.  
  555.     YY_DO_BEFORE_ACTION;
  556.     YY_USER_ACTION;
  557.  
  558. do_action:    /* this label is used only to access EOF actions */
  559.  
  560.  
  561.     switch ( yy_act )
  562.         {
  563.         case 0: /* must backtrack */
  564.         /* undo the effects of YY_DO_BEFORE_ACTION */
  565.         *yy_cp = yy_hold_char;
  566.         yy_cp = yy_last_accepting_cpos;
  567.         yy_current_state = yy_last_accepting_state;
  568.         goto yy_find_action;
  569.  
  570. case 1:
  571. # line 35 "arlex.l"
  572. { return ADDLIB; }
  573.     YY_BREAK
  574. case 2:
  575. # line 36 "arlex.l"
  576. { return ADDMOD; }
  577.     YY_BREAK
  578. case 3:
  579. # line 37 "arlex.l"
  580. { return CLEAR; }
  581.     YY_BREAK
  582. case 4:
  583. # line 38 "arlex.l"
  584. { return CREATE; }
  585.     YY_BREAK
  586. case 5:
  587. # line 39 "arlex.l"
  588. { return DELETE; }
  589.     YY_BREAK
  590. case 6:
  591. # line 40 "arlex.l"
  592. { return DIRECTORY; }
  593.     YY_BREAK
  594. case 7:
  595. # line 41 "arlex.l"
  596. { return END; }
  597.     YY_BREAK
  598. case 8:
  599. # line 42 "arlex.l"
  600. { return EXTRACT; }
  601.     YY_BREAK
  602. case 9:
  603. # line 43 "arlex.l"
  604. { return FULLDIR; }
  605.     YY_BREAK
  606. case 10:
  607. # line 44 "arlex.l"
  608. { return HELP; }
  609.     YY_BREAK
  610. case 11:
  611. # line 45 "arlex.l"
  612. { return LIST; }
  613.     YY_BREAK
  614. case 12:
  615. # line 46 "arlex.l"
  616. { return OPEN; }
  617.     YY_BREAK
  618. case 13:
  619. # line 47 "arlex.l"
  620. { return REPLACE; }
  621.     YY_BREAK
  622. case 14:
  623. # line 48 "arlex.l"
  624. { return VERBOSE; }
  625.     YY_BREAK
  626. case 15:
  627. # line 49 "arlex.l"
  628. { return SAVE; }
  629.     YY_BREAK
  630. case 16:
  631. # line 50 "arlex.l"
  632. { return ADDLIB; }
  633.     YY_BREAK
  634. case 17:
  635. # line 51 "arlex.l"
  636. { return ADDMOD; }
  637.     YY_BREAK
  638. case 18:
  639. # line 52 "arlex.l"
  640. { return CLEAR; }
  641.     YY_BREAK
  642. case 19:
  643. # line 53 "arlex.l"
  644. { return CREATE; }
  645.     YY_BREAK
  646. case 20:
  647. # line 54 "arlex.l"
  648. { return DELETE; }
  649.     YY_BREAK
  650. case 21:
  651. # line 55 "arlex.l"
  652. { return DIRECTORY; }
  653.     YY_BREAK
  654. case 22:
  655. # line 56 "arlex.l"
  656. { return END; }
  657.     YY_BREAK
  658. case 23:
  659. # line 57 "arlex.l"
  660. { return EXTRACT; }
  661.     YY_BREAK
  662. case 24:
  663. # line 58 "arlex.l"
  664. { return FULLDIR; }
  665.     YY_BREAK
  666. case 25:
  667. # line 59 "arlex.l"
  668. { return HELP; }
  669.     YY_BREAK
  670. case 26:
  671. # line 60 "arlex.l"
  672. { return LIST; }
  673.     YY_BREAK
  674. case 27:
  675. # line 61 "arlex.l"
  676. { return OPEN; }
  677.     YY_BREAK
  678. case 28:
  679. # line 62 "arlex.l"
  680. { return REPLACE; }
  681.     YY_BREAK
  682. case 29:
  683. # line 63 "arlex.l"
  684. { return VERBOSE; }
  685.     YY_BREAK
  686. case 30:
  687. # line 64 "arlex.l"
  688. { return SAVE; }
  689.     YY_BREAK
  690. case 31:
  691. # line 65 "arlex.l"
  692. { linenumber ++; }
  693.     YY_BREAK
  694. case 32:
  695. # line 66 "arlex.l"
  696. { return '('; }
  697.     YY_BREAK
  698. case 33:
  699. # line 67 "arlex.l"
  700. { return ')'; }
  701.     YY_BREAK
  702. case 34:
  703. # line 68 "arlex.l"
  704. { return ','; }
  705.     YY_BREAK
  706. case 35:
  707. # line 69 "arlex.l"
  708. {     
  709.         yylval.name =  strdup(yytext);
  710.         return FILENAME;
  711.         }
  712.     YY_BREAK
  713. case 36:
  714. # line 73 "arlex.l"
  715. { }
  716.     YY_BREAK
  717. case 37:
  718. # line 74 "arlex.l"
  719. { }
  720.     YY_BREAK
  721. case 38:
  722. # line 75 "arlex.l"
  723. { }
  724.     YY_BREAK
  725. case 39:
  726. # line 76 "arlex.l"
  727. { linenumber ++; return NEWLINE; }    
  728.     YY_BREAK
  729. case 40:
  730. # line 78 "arlex.l"
  731. ECHO;
  732.     YY_BREAK
  733. case YY_STATE_EOF(INITIAL):
  734.     yyterminate();
  735.  
  736.         case YY_END_OF_BUFFER:
  737.         {
  738.         /* amount of text matched not including the EOB char */
  739.         int yy_amount_of_matched_text = yy_cp - yytext - 1;
  740.  
  741.         /* undo the effects of YY_DO_BEFORE_ACTION */
  742.         *yy_cp = yy_hold_char;
  743.  
  744.         /* note that here we test for yy_c_buf_p "<=" to the position
  745.          * of the first EOB in the buffer, since yy_c_buf_p will
  746.          * already have been incremented past the NUL character
  747.          * (since all states make transitions on EOB to the end-
  748.          * of-buffer state).  Contrast this with the test in yyinput().
  749.          */
  750.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  751.             /* this was really a NUL */
  752.             {
  753.             yy_state_type yy_next_state;
  754.  
  755.             yy_c_buf_p = yytext + yy_amount_of_matched_text;
  756.  
  757.             yy_current_state = yy_get_previous_state();
  758.  
  759.             /* okay, we're now positioned to make the
  760.              * NUL transition.  We couldn't have
  761.              * yy_get_previous_state() go ahead and do it
  762.              * for us because it doesn't know how to deal
  763.              * with the possibility of jamming (and we
  764.              * don't want to build jamming into it because
  765.              * then it will run more slowly)
  766.              */
  767.  
  768.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  769.  
  770.             yy_bp = yytext + YY_MORE_ADJ;
  771.  
  772.             if ( yy_next_state )
  773.             {
  774.             /* consume the NUL */
  775.             yy_cp = ++yy_c_buf_p;
  776.             yy_current_state = yy_next_state;
  777.             goto yy_match;
  778.             }
  779.  
  780.             else
  781.             {
  782.             goto yy_find_action;
  783.             }
  784.             }
  785.  
  786.         else switch ( yy_get_next_buffer() )
  787.             {
  788.             case EOB_ACT_END_OF_FILE:
  789.             {
  790.             yy_did_buffer_switch_on_eof = 0;
  791.  
  792.             if ( yywrap() )
  793.                 {
  794.                 /* note: because we've taken care in
  795.                  * yy_get_next_buffer() to have set up yytext,
  796.                  * we can now set up yy_c_buf_p so that if some
  797.                  * total hoser (like flex itself) wants
  798.                  * to call the scanner after we return the
  799.                  * YY_NULL, it'll still work - another YY_NULL
  800.                  * will get returned.
  801.                  */
  802.                 yy_c_buf_p = yytext + YY_MORE_ADJ;
  803.  
  804.                 yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  805.                 goto do_action;
  806.                 }
  807.  
  808.             else
  809.                 {
  810.                 if ( ! yy_did_buffer_switch_on_eof )
  811.                 YY_NEW_FILE;
  812.                 }
  813.             }
  814.             break;
  815.  
  816.             case EOB_ACT_CONTINUE_SCAN:
  817.             yy_c_buf_p = yytext + yy_amount_of_matched_text;
  818.  
  819.             yy_current_state = yy_get_previous_state();
  820.  
  821.             yy_cp = yy_c_buf_p;
  822.             yy_bp = yytext + YY_MORE_ADJ;
  823.             goto yy_match;
  824.  
  825.             case EOB_ACT_LAST_MATCH:
  826.             yy_c_buf_p =
  827.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  828.  
  829.             yy_current_state = yy_get_previous_state();
  830.  
  831.             yy_cp = yy_c_buf_p;
  832.             yy_bp = yytext + YY_MORE_ADJ;
  833.             goto yy_find_action;
  834.             }
  835.         break;
  836.         }
  837.  
  838.         default:
  839. #ifdef FLEX_DEBUG
  840.         printf( "action # %d\n", yy_act );
  841. #endif
  842.         YY_FATAL_ERROR(
  843.             "fatal flex scanner internal error--no action found" );
  844.         }
  845.     }
  846.     }
  847.  
  848.  
  849. /* yy_get_next_buffer - try to read in a new buffer
  850.  *
  851.  * synopsis
  852.  *     int yy_get_next_buffer();
  853.  *     
  854.  * returns a code representing an action
  855.  *     EOB_ACT_LAST_MATCH - 
  856.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  857.  *     EOB_ACT_END_OF_FILE - end of file
  858.  */
  859.  
  860. static int yy_get_next_buffer()
  861.  
  862.     {
  863.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  864.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  865.     register int number_to_move, i;
  866.     int ret_val;
  867.  
  868.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  869.     YY_FATAL_ERROR(
  870.         "fatal flex scanner internal error--end of buffer missed" );
  871.  
  872.     /* try to read more data */
  873.  
  874.     /* first move last chars to start of buffer */
  875.     number_to_move = yy_c_buf_p - yytext;
  876.  
  877.     for ( i = 0; i < number_to_move; ++i )
  878.     *(dest++) = *(source++);
  879.  
  880.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  881.     /* don't do the read, it's not guaranteed to return an EOF,
  882.      * just force an EOF
  883.      */
  884.     yy_n_chars = 0;
  885.  
  886.     else
  887.     {
  888.     int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  889.  
  890.     if ( num_to_read > YY_READ_BUF_SIZE )
  891.         num_to_read = YY_READ_BUF_SIZE;
  892.  
  893.     else if ( num_to_read <= 0 )
  894.         YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  895.  
  896.     /* read in more data */
  897.     YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  898.           yy_n_chars, num_to_read );
  899.     }
  900.  
  901.     if ( yy_n_chars == 0 )
  902.     {
  903.     if ( number_to_move == 1 )
  904.         {
  905.         ret_val = EOB_ACT_END_OF_FILE;
  906.         yy_current_buffer->yy_eof_status = EOF_DONE;
  907.         }
  908.  
  909.     else
  910.         {
  911.         ret_val = EOB_ACT_LAST_MATCH;
  912.         yy_current_buffer->yy_eof_status = EOF_PENDING;
  913.         }
  914.     }
  915.  
  916.     else
  917.     ret_val = EOB_ACT_CONTINUE_SCAN;
  918.  
  919.     yy_n_chars += number_to_move;
  920.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  921.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  922.  
  923.     /* yytext begins at the second character in yy_ch_buf; the first
  924.      * character is the one which preceded it before reading in the latest
  925.      * buffer; it needs to be kept around in case it's a newline, so
  926.      * yy_get_previous_state() will have with '^' rules active
  927.      */
  928.  
  929.     yytext = &yy_current_buffer->yy_ch_buf[1];
  930.  
  931.     return ( ret_val );
  932.     }
  933.  
  934.  
  935. /* yy_get_previous_state - get the state just before the EOB char was reached
  936.  *
  937.  * synopsis
  938.  *     yy_state_type yy_get_previous_state();
  939.  */
  940.  
  941. static yy_state_type yy_get_previous_state()
  942.  
  943.     {
  944.     register yy_state_type yy_current_state;
  945.     register YY_CHAR *yy_cp;
  946.  
  947.     yy_current_state = yy_start;
  948.  
  949.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  950.     {
  951.     register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  952.     if ( yy_accept[yy_current_state] )
  953.         {
  954.         yy_last_accepting_state = yy_current_state;
  955.         yy_last_accepting_cpos = yy_cp;
  956.         }
  957.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  958.         {
  959.         yy_current_state = yy_def[yy_current_state];
  960.         if ( yy_current_state >= 177 )
  961.         yy_c = yy_meta[yy_c];
  962.         }
  963.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  964.     }
  965.  
  966.     return ( yy_current_state );
  967.     }
  968.  
  969.  
  970. /* yy_try_NUL_trans - try to make a transition on the NUL character
  971.  *
  972.  * synopsis
  973.  *     next_state = yy_try_NUL_trans( current_state );
  974.  */
  975.  
  976. #ifdef YY_USE_PROTOS
  977. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  978. #else
  979. static yy_state_type yy_try_NUL_trans( yy_current_state )
  980. register yy_state_type yy_current_state;
  981. #endif
  982.  
  983.     {
  984.     register int yy_is_jam;
  985.     register YY_CHAR *yy_cp = yy_c_buf_p;
  986.  
  987.     register YY_CHAR yy_c = 1;
  988.     if ( yy_accept[yy_current_state] )
  989.     {
  990.     yy_last_accepting_state = yy_current_state;
  991.     yy_last_accepting_cpos = yy_cp;
  992.     }
  993.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  994.     {
  995.     yy_current_state = yy_def[yy_current_state];
  996.     if ( yy_current_state >= 177 )
  997.         yy_c = yy_meta[yy_c];
  998.     }
  999.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1000.     yy_is_jam = (yy_current_state == 176);
  1001.  
  1002.     return ( yy_is_jam ? 0 : yy_current_state );
  1003.     }
  1004.  
  1005.  
  1006. #ifdef YY_USE_PROTOS
  1007. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1008. #else
  1009. static void yyunput( c, yy_bp )
  1010. YY_CHAR c;
  1011. register YY_CHAR *yy_bp;
  1012. #endif
  1013.  
  1014.     {
  1015.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1016.  
  1017.     /* undo effects of setting up yytext */
  1018.     *yy_cp = yy_hold_char;
  1019.  
  1020.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1021.     { /* need to shift things up to make room */
  1022.     register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  1023.     register YY_CHAR *dest =
  1024.         &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  1025.     register YY_CHAR *source =
  1026.         &yy_current_buffer->yy_ch_buf[number_to_move];
  1027.  
  1028.     while ( source > yy_current_buffer->yy_ch_buf )
  1029.         *--dest = *--source;
  1030.  
  1031.     yy_cp += dest - source;
  1032.     yy_bp += dest - source;
  1033.     yy_n_chars = yy_current_buffer->yy_buf_size;
  1034.  
  1035.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1036.         YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1037.     }
  1038.  
  1039.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  1040.     yy_cp[-2] = '\n';
  1041.  
  1042.     *--yy_cp = c;
  1043.  
  1044.     /* note: the formal parameter *must* be called "yy_bp" for this
  1045.      *       macro to now work correctly
  1046.      */
  1047.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1048.     }
  1049.  
  1050.  
  1051. #ifdef __cplusplus
  1052. static int yyinput()
  1053. #else
  1054. static int input()
  1055. #endif
  1056.  
  1057.     {
  1058.     int c;
  1059.     YY_CHAR *yy_cp = yy_c_buf_p;
  1060.  
  1061.     *yy_cp = yy_hold_char;
  1062.  
  1063.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1064.     {
  1065.     /* yy_c_buf_p now points to the character we want to return.
  1066.      * If this occurs *before* the EOB characters, then it's a
  1067.      * valid NUL; if not, then we've hit the end of the buffer.
  1068.      */
  1069.     if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1070.         /* this was really a NUL */
  1071.         *yy_c_buf_p = '\0';
  1072.  
  1073.     else
  1074.         { /* need more input */
  1075.         yytext = yy_c_buf_p;
  1076.         ++yy_c_buf_p;
  1077.  
  1078.         switch ( yy_get_next_buffer() )
  1079.         {
  1080.         case EOB_ACT_END_OF_FILE:
  1081.             {
  1082.             if ( yywrap() )
  1083.             {
  1084.             yy_c_buf_p = yytext + YY_MORE_ADJ;
  1085.             return ( EOF );
  1086.             }
  1087.  
  1088.             YY_NEW_FILE;
  1089.  
  1090. #ifdef __cplusplus
  1091.             return ( yyinput() );
  1092. #else
  1093.             return ( input() );
  1094. #endif
  1095.             }
  1096.             break;
  1097.  
  1098.         case EOB_ACT_CONTINUE_SCAN:
  1099.             yy_c_buf_p = yytext + YY_MORE_ADJ;
  1100.             break;
  1101.  
  1102.         case EOB_ACT_LAST_MATCH:
  1103. #ifdef __cplusplus
  1104.             YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1105. #else
  1106.             YY_FATAL_ERROR( "unexpected last match in input()" );
  1107. #endif
  1108.         }
  1109.         }
  1110.     }
  1111.  
  1112.     c = *yy_c_buf_p;
  1113.     yy_hold_char = *++yy_c_buf_p;
  1114.  
  1115.     return ( c );
  1116.     }
  1117.  
  1118.  
  1119. #ifdef YY_USE_PROTOS
  1120. void yyrestart( FILE *input_file )
  1121. #else
  1122. void yyrestart( input_file )
  1123. FILE *input_file;
  1124. #endif
  1125.  
  1126.     {
  1127.     yy_init_buffer( yy_current_buffer, input_file );
  1128.     yy_load_buffer_state();
  1129.     }
  1130.  
  1131.  
  1132. #ifdef YY_USE_PROTOS
  1133. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1134. #else
  1135. void yy_switch_to_buffer( new_buffer )
  1136. YY_BUFFER_STATE new_buffer;
  1137. #endif
  1138.  
  1139.     {
  1140.     if ( yy_current_buffer == new_buffer )
  1141.     return;
  1142.  
  1143.     if ( yy_current_buffer )
  1144.     {
  1145.     /* flush out information for old buffer */
  1146.     *yy_c_buf_p = yy_hold_char;
  1147.     yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1148.     yy_current_buffer->yy_n_chars = yy_n_chars;
  1149.     }
  1150.  
  1151.     yy_current_buffer = new_buffer;
  1152.     yy_load_buffer_state();
  1153.  
  1154.     /* we don't actually know whether we did this switch during
  1155.      * EOF (yywrap()) processing, but the only time this flag
  1156.      * is looked at is after yywrap() is called, so it's safe
  1157.      * to go ahead and always set it.
  1158.      */
  1159.     yy_did_buffer_switch_on_eof = 1;
  1160.     }
  1161.  
  1162.  
  1163. #ifdef YY_USE_PROTOS
  1164. void yy_load_buffer_state( void )
  1165. #else
  1166. void yy_load_buffer_state()
  1167. #endif
  1168.  
  1169.     {
  1170.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1171.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1172.     yyin = yy_current_buffer->yy_input_file;
  1173.     yy_hold_char = *yy_c_buf_p;
  1174.     }
  1175.  
  1176.  
  1177. #ifdef YY_USE_PROTOS
  1178. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1179. #else
  1180. YY_BUFFER_STATE yy_create_buffer( file, size )
  1181. FILE *file;
  1182. int size;
  1183. #endif
  1184.  
  1185.     {
  1186.     YY_BUFFER_STATE b;
  1187.  
  1188.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1189.  
  1190.     if ( ! b )
  1191.     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1192.  
  1193.     b->yy_buf_size = size;
  1194.  
  1195.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1196.      * we need to put in 2 end-of-buffer characters.
  1197.      */
  1198.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1199.  
  1200.     if ( ! b->yy_ch_buf )
  1201.     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1202.  
  1203.     yy_init_buffer( b, file );
  1204.  
  1205.     return ( b );
  1206.     }
  1207.  
  1208.  
  1209. #ifdef YY_USE_PROTOS
  1210. void yy_delete_buffer( YY_BUFFER_STATE b )
  1211. #else
  1212. void yy_delete_buffer( b )
  1213. YY_BUFFER_STATE b;
  1214. #endif
  1215.  
  1216.     {
  1217.     if ( b == yy_current_buffer )
  1218.     yy_current_buffer = (YY_BUFFER_STATE) 0;
  1219.  
  1220.     free( (char *) b->yy_ch_buf );
  1221.     free( (char *) b );
  1222.     }
  1223.  
  1224.  
  1225. #ifdef YY_USE_PROTOS
  1226. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1227. #else
  1228. void yy_init_buffer( b, file )
  1229. YY_BUFFER_STATE b;
  1230. FILE *file;
  1231. #endif
  1232.  
  1233.     {
  1234.     b->yy_input_file = file;
  1235.  
  1236.     /* we put in the '\n' and start reading from [1] so that an
  1237.      * initial match-at-newline will be true.
  1238.      */
  1239.  
  1240.     b->yy_ch_buf[0] = '\n';
  1241.     b->yy_n_chars = 1;
  1242.  
  1243.     /* we always need two end-of-buffer characters.  The first causes
  1244.      * a transition to the end-of-buffer state.  The second causes
  1245.      * a jam in that state.
  1246.      */
  1247.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1248.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1249.  
  1250.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1251.  
  1252.     b->yy_eof_status = EOF_NOT_SEEN;
  1253.     }
  1254. # line 78 "arlex.l"
  1255.  
  1256. #ifndef yywrap
  1257. /* Needed for lex, though not flex. */
  1258. int yywrap() { return 1; }
  1259. #endif
  1260.