开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
a2k_p1.c.preserve
资源名称：gnusql-0.7b5.1.tar.gz　[点击查看]
上传用户：dgyhgb
上传日期：2007-01-07
资源大小：676k
文件大小：37k
源码类别：

SQL Server

开发平台：

Unix_Linux

a2k_p1.c.preserve：源码内容
  1. /* A lexical scanner generated by flex */
  3. /* scanner skeleton version:
  4.  * $Header: /home/horse/u0/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp Locker: vern $
  5.  */
  7. #define FLEX_SCANNER
  9. #include <stdio.h>
  12. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  13. #ifdef c_plusplus
  14. #ifndef __cplusplus
  15. #define __cplusplus
  16. #endif
  17. #endif
  20. #ifdef __cplusplus
  22. #include <stdlib.h>
  23. #include <osfcn.h>
  25. /* use prototypes in function declarations */
  26. #define YY_USE_PROTOS
  28. /* the "const" storage-class-modifier is valid */
  29. #define YY_USE_CONST
  31. #else /* ! __cplusplus */
  33. #ifdef __STDC__
  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__ */
  43. #define YY_USE_PROTOS
  44. #define YY_USE_CONST
  46. #endif /* __STDC__ */
  47. #endif /* ! __cplusplus */
  50. #ifdef __TURBOC__
  51. #define YY_USE_CONST
  52. #endif
  55. #ifndef YY_USE_CONST
  56. #define const
  57. #endif
  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
  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
  79. /* returned upon end-of-file */
  80. #define YY_END_TOK 0
  82. /* copy whatever the last rule matched to the standard output */
  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 )
  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
  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 )
  104. /* report a fatal error */
  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.  */
  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 )
  129. /* default yywrap function - always treat EOF as an EOF */
  130. #define yywrap() 1
  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 *
  138. /* action number for EOF rule of a given start state */
  139. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  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 )
  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 )) 
  155. /* code executed at the end of each rule */
  156. #define YY_BREAK break;
  158. #define YY_END_OF_BUFFER_CHAR 0
  160. #ifndef YY_BUF_SIZE
  161. #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
  162. #endif
  164. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  166. #define FLEX_DEBUG
  167. #define YY_CHAR unsigned char
  168. # line 1 "a2k_p1.l"
  169. #define INITIAL 0
  170. # line 2 "a2k_p1.l"
  171. /*
  172.  *  a2k_p1.l - ansi 2 knr processing
  173.  *            
  174.  *  This file is a part of GNU SQL Server
  175.  *
  176.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  177.  *  Developed at the Institute of System Programming
  178.  *  This file is written by Michael Kimelman.
  179.  * 
  180.  *  This program is free software; you can redistribute it and/or modify
  181.  *  it under the terms of the GNU General Public License as published by
  182.  *  the Free Software Foundation; either version 2 of the License, or
  183.  *  (at your option) any later version.
  184.  *
  185.  *  This program is distributed in the hope that it will be useful,
  186.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  187.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  188.  *  GNU General Public License for more details.
  189.  *
  190.  *  You should have received a copy of the GNU General Public License
  191.  *  along with this program; if not, write to the Free Software
  192.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  193.  *
  194.  *  Contact:  gss@ispras.ru
  195.  *
  196.  */
  198. #include <assert.h>
  200. /* $Id: a2k_p1.l,v 1.245 1997/03/31 03:46:38 kml Exp $ */
  202. #define C_str 1
  203. #define C_str1 2
  204. #define Skip 3
  205. # line 46 "a2k_p1.l"
  207. /* done after the current pattern has been matched and before the
  208.  * corresponding action - sets up yytext
  209.  */
  210. #define YY_DO_BEFORE_ACTION 
  211. yytext = yy_bp; 
  212. yyleng = yy_cp - yy_bp; 
  213. yy_hold_char = *yy_cp; 
  214. *yy_cp = ''; 
  215. yy_c_buf_p = yy_cp;
  217. #define EOB_ACT_CONTINUE_SCAN 0
  218. #define EOB_ACT_END_OF_FILE 1
  219. #define EOB_ACT_LAST_MATCH 2
  221. /* return all but the first 'n' matched characters back to the input stream */
  222. #define yyless(n) 
  223. do 
  224. { 
  225. /* undo effects of setting up yytext */ 
  226. *yy_cp = yy_hold_char; 
  227. yy_c_buf_p = yy_cp = yy_bp + n; 
  228. YY_DO_BEFORE_ACTION; /* set up yytext again */ 
  229. } 
  230. while ( 0 )
  232. #define unput(c) yyunput( c, yytext )
  235. struct yy_buffer_state
  236.     {
  237.     FILE *yy_input_file;
  239.     YY_CHAR *yy_ch_buf; /* input buffer */
  240.     YY_CHAR *yy_buf_pos; /* current position in input buffer */
  242.     /* size of input buffer in bytes, not including room for EOB characters */
  243.     int yy_buf_size;
  245.     /* number of characters read into yy_ch_buf, not including EOB characters */
  246.     int yy_n_chars;
  248.     int yy_eof_status; /* whether we've seen an EOF on this buffer */
  249. #define EOF_NOT_SEEN 0
  250.     /* "pending" happens when the EOF has been seen but there's still
  251.      * some text process
  252.      */
  253. #define EOF_PENDING 1
  254. #define EOF_DONE 2
  255.     };
  257. static YY_BUFFER_STATE yy_current_buffer;
  259. /* we provide macros for accessing buffer states in case in the
  260.  * future we want to put the buffer states in a more general
  261.  * "scanner state"
  262.  */
  263. #define YY_CURRENT_BUFFER yy_current_buffer
  266. /* yy_hold_char holds the character lost when yytext is formed */
  267. static YY_CHAR yy_hold_char;
  269. static int yy_n_chars; /* number of characters read into yy_ch_buf */
  273. #ifndef YY_USER_ACTION
  274. #define YY_USER_ACTION
  275. #endif
  277. #ifndef YY_USER_INIT
  278. #define YY_USER_INIT
  279. #endif
  281. extern YY_CHAR *yytext;
  282. extern int yyleng;
  283. extern FILE *yyin, *yyout;
  285. YY_CHAR *yytext;
  286. int yyleng;
  288. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  290. #define YY_END_OF_BUFFER 42
  291. typedef int yy_state_type;
  292. static const short int yy_accept[189] =
  293.     {   0,
  294.         0,    0,    0,    0,    0,    0,    0,    0,   42,    3,
  295.         3,    2,    3,    3,    3,    3,    3,    3,    3,   23,
  296.        41,   22,   23,   40,   24,   25,   27,   40,   39,   40,
  297.        24,   37,   41,   19,    0,    7,    5,    4,    6,    5,
  298.         0,    0,   17,   18,   18,   18,   18,   18,   18,   18,
  299.        23,   21,   20,   24,   38,   39,    0,   24,   37,   38,
  300.        38,   38,   38,   38,   38,    0,   19,    0,    0,    0,
  301.        18,   18,   18,   18,    8,   18,   18,   18,   18,   38,
  302.         0,    0,    0,    0,    0,    0,    0,    0,    0,   38,
  303.        38,   38,   28,   38,   38,   38,   38,    0,    1,   18,
  305.        18,   18,   18,   18,   18,   18,   18,    0,   26,    0,
  306.         0,    0,   28,    0,    0,    0,    0,   38,   38,   38,
  307.        38,   38,   38,   38,   38,   18,   10,   18,   18,   18,
  308.        16,   18,   18,    0,    0,    0,    0,    0,    0,    0,
  309.         0,   38,   30,   38,   38,   38,   36,   38,   38,   18,
  310.        11,    9,   18,   18,   13,    0,   30,    0,    0,    0,
  311.        36,    0,    0,   38,   31,   29,   38,   38,   33,   12,
  312.        18,   15,    0,   31,   29,    0,    0,   33,   32,   38,
  313.        35,   14,   32,    0,   35,   34,   34,    0
  314.     } ;
  316. static const YY_CHAR yy_ec[256] =
  317.     {   0,
  318.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  319.         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
  320.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  321.         1,    2,    1,    4,    5,    1,    1,    1,    1,    6,
  322.         7,    8,    1,    9,    1,    1,   10,   11,   11,   11,
  323.        11,   11,   11,   11,   11,   11,   11,    1,    1,    1,
  324.         1,    1,    1,    1,   14,   13,   15,   16,   17,   18,
  325.        19,   13,   20,   13,   13,   21,   22,   23,   13,   24,
  326.        13,   25,   26,   13,   27,   13,   13,   13,   13,   13,
  327.         1,   12,    1,    1,   13,    1,   14,   13,   15,   16,
  329.        17,   18,   19,   13,   20,   13,   13,   21,   22,   23,
  330.        13,   24,   13,   25,   26,   13,   27,   13,   13,   13,
  331.        13,   13,    1,    1,    1,    1,    1,    1,    1,    1,
  332.         1,    1,    1,    1,    1,    1,    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,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  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
  346.     } ;
  348. static const YY_CHAR yy_meta[28] =
  349.     {   0,
  350.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         2,    1,    3,    3,    3,    3,    3,    3,    3,    3,
  352.         3,    3,    3,    3,    3,    3,    3
  353.     } ;
  355. static const short int yy_base[202] =
  356.     {   0,
  357.         0,    9,   17,   19,   30,   39,  255,  254,  256,  259,
  358.        43,  259,  250,  252,  259,  251,  244,   49,   54,  259,
  359.       259,  259,   21,  259,  249,  259,  259,    0,  248,  241,
  360.        25,   66,  245,  259,   53,  259,  245,  259,  244,  243,
  361.        18,   87,  239,    0,  226,   15,   43,  222,  216,  217,
  362.       259,  259,  259,  237,    0,  236,   55,   83,   81,  220,
  363.        83,   77,  216,  210,  211,  230,  259,   99,  102,  103,
  364.         0,  214,  205,  214,  213,  213,  204,  212,  209,    0,
  365.       106,  107,  110,  207,   98,  104,  203,  197,  198,  202,
  366.       193,  202,  201,  201,  192,  200,  197,  115,  259,  192,
  368.       194,  190,  192,  187,  190,  187,  188,  116,  259,  186,
  369.       177,  186,  185,  185,  176,  184,  181,  176,  178,  174,
  370.       176,  171,  174,  171,  172,  165,    0,  169,  168,  158,
  371.         0,  162,  165,  162,  164,  160,  162,  157,  160,  157,
  372.       158,  151,    0,  155,  154,  144,    0,  148,  151,  151,
  373.         0,    0,  151,  152,    0,  142,  259,  146,  145,  135,
  374.       259,   81,   81,   74,    0,    0,   68,   50,    0,    0,
  375.        40,    0,   36,  259,  259,   31,   32,  259,    0,   20,
  376.         0,    0,  259,    0,  259,    0,  259,  259,  127,  130,
  377.       133,  136,  139,    0,  142,  145,  147,  149,  152,  155,
  379.       158
  380.     } ;
  382. static const short int yy_def[202] =
  383.     {   0,
  384.       189,  189,  190,  190,  191,  191,  192,  192,  188,  188,
  385.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  386.       188,  188,  193,  188,  188,  188,  188,  194,  188,  188,
  387.       188,  194,  195,  188,  188,  188,  188,  188,  188,  188,
  388.       196,  188,   19,  197,  197,  197,  197,  197,  197,  197,
  389.       188,  188,  188,  188,  198,  188,  199,  188,  188,  198,
  390.       198,  198,  198,  198,  198,  195,  188,  196,  200,  196,
  391.       197,  197,  197,  197,  197,  197,  197,  197,  197,  198,
  392.       199,  201,  199,  188,  188,  188,  188,  188,  188,  198,
  393.       198,  198,  198,  198,  198,  198,  198,  196,  188,  197,
  395.       197,  197,  197,  197,  197,  197,  197,  199,  188,  188,
  396.       188,  188,  188,  188,  188,  188,  188,  198,  198,  198,
  397.       198,  198,  198,  198,  198,  197,  197,  197,  197,  197,
  398.       197,  197,  197,  188,  188,  188,  188,  188,  188,  188,
  399.       188,  198,  198,  198,  198,  198,  198,  198,  198,  197,
  400.       197,  197,  197,  197,  197,  188,  188,  188,  188,  188,
  401.       188,  188,  188,  198,  198,  198,  198,  198,  198,  197,
  402.       197,  197,  188,  188,  188,  188,  188,  188,  198,  198,
  403.       198,  197,  188,  188,  188,  198,  188,    0,  188,  188,
  404.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  406.       188
  407.     } ;
  409. static const short int yy_nxt[287] =
  410.     {   0,
  411.       188,   11,   55,   12,   13,   14,   15,  188,   16,   17,
  412.        18,  188,   12,   19,   14,   15,  187,   16,   17,   21,
  413.        22,   21,   22,   52,   53,   69,   58,   70,   23,   59,
  414.        23,   25,   26,   27,   28,   73,  186,   74,   29,   30,
  415.        31,   26,   27,   32,   35,  185,  184,   29,   30,   36,
  416.        42,   37,  183,   43,   35,   36,  182,   37,   38,   36,
  417.        75,   37,   82,  181,   83,   76,   44,   44,   44,   45,
  418.        46,   44,   44,   47,   48,   44,   44,   49,   44,   44,
  419.        50,   60,   61,  180,   58,   62,   63,   59,   42,   64,
  420.       179,   43,   65,   36,   93,   37,   84,   85,  178,   94,
  422.        86,   87,  177,   91,   88,   92,   69,   89,   70,   69,
  423.        69,   99,   70,   82,   82,   83,  109,   82,  111,   83,
  424.       112,  113,   69,   82,   70,   83,  114,   10,   10,   10,
  425.        20,   20,   20,   24,   24,   24,   33,   33,   33,   51,
  426.        51,   51,   66,   66,   66,   68,   68,   68,   71,   71,
  427.        80,   80,   81,   81,   81,   98,   98,   98,  108,  108,
  428.       108,  176,  175,  174,  173,  172,  171,  170,  169,  168,
  429.       167,  166,  165,  164,  163,  162,  161,  160,  159,  158,
  430.       157,  156,  155,  154,  153,  152,  151,  150,  149,  148,
  431.       147,  146,  145,  144,  143,  142,  141,  140,  139,  138,
  433.       137,  136,  135,  134,  133,  132,  131,  130,  129,  128,
  434.       127,  126,  125,  124,  123,  122,  121,  120,  119,  118,
  435.       117,  116,  115,  110,  107,  106,  105,  104,  103,  102,
  436.       101,  100,   67,   97,   96,   95,   90,   56,   54,   79,
  437.        78,   77,   72,  188,   40,   39,   40,   67,   57,   56,
  438.        54,   41,   40,   39,   38,  188,   34,   34,    9,  188,
  439.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  440.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  441.       188,  188,  188,  188,  188,  188
  442.     } ;
  444. static const short int yy_chk[287] =
  445.     {   0,
  446.         0,    1,  194,    1,    1,    1,    1,    0,    1,    1,
  447.         2,    0,    2,    2,    2,    2,  184,    2,    2,    3,
  448.         3,    4,    4,   23,   23,   41,   31,   41,    3,   31,
  449.         4,    5,    5,    5,    5,   46,  180,   46,    5,    5,
  450.         6,    6,    6,    6,   11,  177,  176,    6,    6,   11,
  451.        18,   11,  173,   18,   35,   18,  171,   18,   19,   35,
  452.        47,   35,   57,  168,   57,   47,   19,   19,   19,   19,
  453.        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
  454.        19,   32,   32,  167,   58,   32,   32,   58,   42,   32,
  455.       164,   42,   32,   42,   62,   42,   59,   59,  163,   62,
  457.        59,   59,  162,   61,   59,   61,   68,   59,   68,   69,
  458.        70,   69,   70,   81,   82,   81,   82,   83,   85,   83,
  459.        85,   86,   98,  108,   98,  108,   86,  189,  189,  189,
  460.       190,  190,  190,  191,  191,  191,  192,  192,  192,  193,
  461.       193,  193,  195,  195,  195,  196,  196,  196,  197,  197,
  462.       198,  198,  199,  199,  199,  200,  200,  200,  201,  201,
  463.       201,  160,  159,  158,  156,  154,  153,  150,  149,  148,
  464.       146,  145,  144,  142,  141,  140,  139,  138,  137,  136,
  465.       135,  134,  133,  132,  130,  129,  128,  126,  125,  124,
  466.       123,  122,  121,  120,  119,  118,  117,  116,  115,  114,
  468.       113,  112,  111,  110,  107,  106,  105,  104,  103,  102,
  469.       101,  100,   97,   96,   95,   94,   93,   92,   91,   90,
  470.        89,   88,   87,   84,   79,   78,   77,   76,   75,   74,
  471.        73,   72,   66,   65,   64,   63,   60,   56,   54,   50,
  472.        49,   48,   45,   43,   40,   39,   37,   33,   30,   29,
  473.        25,   17,   16,   14,   13,    9,    8,    7,  188,  188,
  474.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  475.       188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
  476.       188,  188,  188,  188,  188,  188
  477.     } ;
  479. static yy_state_type yy_last_accepting_state;
  480. static YY_CHAR *yy_last_accepting_cpos;
  482. extern int yy_flex_debug;
  483. int yy_flex_debug = 1;
  485. static const short int yy_rule_linenum[41] =
  486.     {   0,
  487.        51,   52,   56,   57,   58,   59,   60,   62,   63,   64,
  488.        65,   66,   67,   68,   69,   70,   71,   72,   73,   77,
  489.        78,   79,   80,   81,   82,   83,   84,   85,   86,   87,
  490.        88,   89,   90,   91,   92,   93,   94,   95,   96,   97
  491.     } ;
  493. /* the intent behind this definition is that it'll catch
  494.  * any uses of REJECT which flex missed
  495.  */
  496. #define REJECT reject_used_but_not_detected
  497. #define yymore() yymore_used_but_not_detected
  498. #define YY_MORE_ADJ 0
  500. /* these variables are all declared out here so that section 3 code can
  501.  * manipulate them
  502.  */
  503. /* points to current character in buffer */
  504. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  505. static int yy_init = 1; /* whether we need to initialize */
  506. static int yy_start = 0; /* start state number */
  508. /* flag which is used to allow yywrap()'s to do buffer switches
  509.  * instead of setting up a fresh yyin.  A bit of a hack ...
  510.  */
  511. static int yy_did_buffer_switch_on_eof;
  513. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  514. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  515. static int yy_get_next_buffer YY_PROTO(( void ));
  516. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  517. void yyrestart YY_PROTO(( FILE *input_file ));
  518. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  519. void yy_load_buffer_state YY_PROTO(( void ));
  520. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  521. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  522. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  524. #define yy_new_buffer yy_create_buffer
  526. #ifdef __cplusplus
  527. static int yyinput YY_PROTO(( void ));
  528. #else
  529. static int input YY_PROTO(( void ));
  530. #endif
  532. YY_DECL
  533.     {
  534.     register yy_state_type yy_current_state;
  535.     register YY_CHAR *yy_cp, *yy_bp;
  536.     register int yy_act;
  539.     
  540.   /*********************************************
  541.    *                C lexics                   *
  542.    *********************************************/
  544.     if ( yy_init )
  545. {
  546. YY_USER_INIT;
  548. if ( ! yy_start )
  549.     yy_start = 1; /* first start state */
  551. if ( ! yyin )
  552.     yyin = stdin;
  554. if ( ! yyout )
  555.     yyout = stdout;
  557. if ( yy_current_buffer )
  558.     yy_init_buffer( yy_current_buffer, yyin );
  559. else
  560.     yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  562. yy_load_buffer_state();
  564. yy_init = 0;
  565. }
  567.     while ( 1 ) /* loops until end-of-file is reached */
  568. {
  569. yy_cp = yy_c_buf_p;
  571. /* support of yytext */
  572. *yy_cp = yy_hold_char;
  574. /* yy_bp points to the position in yy_ch_buf of the start of the
  575.  * current run.
  576.  */
  577. yy_bp = yy_cp;
  579. yy_current_state = yy_start;
  580. if ( yy_bp[-1] == 'n' )
  581.     ++yy_current_state;
  582. yy_match:
  583. do
  584.     {
  585.     register YY_CHAR yy_c = yy_ec[*yy_cp];
  586.     if ( yy_accept[yy_current_state] )
  587. {
  588. yy_last_accepting_state = yy_current_state;
  589. yy_last_accepting_cpos = yy_cp;
  590. }
  591.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  592. {
  593. yy_current_state = yy_def[yy_current_state];
  594. if ( yy_current_state >= 189 )
  595.     yy_c = yy_meta[yy_c];
  596. }
  597.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  598.     ++yy_cp;
  599.     }
  600. while ( yy_current_state != 188 );
  601. yy_cp = yy_last_accepting_cpos;
  602. yy_current_state = yy_last_accepting_state;
  604. yy_find_action:
  605. yy_act = yy_accept[yy_current_state];
  607. YY_DO_BEFORE_ACTION;
  608. YY_USER_ACTION;
  610. do_action: /* this label is used only to access EOF actions */
  612. if ( yy_flex_debug )
  613.     {
  614.     if ( yy_act == 0 )
  615. fprintf( stderr, "--scanner backtrackingn" );
  616.     else if ( yy_act < 41 )
  617. fprintf( stderr, "--accepting rule at line %d ("%s")n",
  618.          yy_rule_linenum[yy_act], yytext );
  619.     else if ( yy_act == 41 )
  620. fprintf( stderr, "--accepting default rule ("%s")n",
  621.          yytext );
  622.     else if ( yy_act == 42 )
  623. fprintf( stderr, "--(end of buffer or a NUL)n" );
  624.     else
  625. fprintf( stderr, "--EOFn" );
  626.     }
  628. switch ( yy_act )
  629.     {
  630.     case 0: /* must backtrack */
  631.     /* undo the effects of YY_DO_BEFORE_ACTION */
  632.     *yy_cp = yy_hold_char;
  633.     yy_cp = yy_last_accepting_cpos;
  634.     yy_current_state = yy_last_accepting_state;
  635.     goto yy_find_action;
  637. case 1:
  638. # line 51 "a2k_p1.l"
  639. ECHO;
  640. YY_BREAK
  641. case 2:
  642. # line 52 "a2k_p1.l"
  643. {
  644.                           ECHO;
  645.   BEGIN(C_str);
  646. }
  647. YY_BREAK
  648. case 3:
  649. # line 56 "a2k_p1.l"
  650. ECHO;
  651. YY_BREAK
  652. case 4:
  653. # line 57 "a2k_p1.l"
  654. fputs("/**/",yyout);  /* ## --> comments in macro */
  655. YY_BREAK
  656. case 5:
  657. # line 58 "a2k_p1.l"
  658. fputs(",",yyout);     /* condence spaces in calls */
  659. YY_BREAK
  660. case 6:
  661. # line 59 "a2k_p1.l"
  662. fputs("(",yyout);    /*        ---- // ----      */
  663. YY_BREAK
  664. case 7:
  665. # line 60 "a2k_p1.l"
  666. fputs(")",yyout);    /*          ---- // ----    */
  667. YY_BREAK
  668.                 /* adjust cpp directives    */ 
  669. case 8:
  670. # line 62 "a2k_p1.l"
  671. fputs("#if",yyout);     
  672. YY_BREAK
  673. case 9:
  674. # line 63 "a2k_p1.l"
  675. fputs("#ifdef",yyout);  
  676. YY_BREAK
  677. case 10:
  678. # line 64 "a2k_p1.l"
  679. fputs("#else",yyout);   
  680. YY_BREAK
  681. case 11:
  682. # line 65 "a2k_p1.l"
  683. fputs("#endif",yyout);  
  684. YY_BREAK
  685. case 12:
  686. # line 66 "a2k_p1.l"
  687. fputs("#define",yyout);  
  688. YY_BREAK
  689. case 13:
  690. # line 67 "a2k_p1.l"
  691. fputs("#undef",yyout);  
  692. YY_BREAK
  693. case 14:
  694. # line 68 "a2k_p1.l"
  695. { fputs("#include",yyout); BEGIN(Skip); }
  696. YY_BREAK
  697. case 15:
  698. # line 69 "a2k_p1.l"
  699. { fputs("#pragma",yyout);  BEGIN(Skip); }
  700. YY_BREAK
  701. case 16:
  702. # line 70 "a2k_p1.l"
  703. { fputs("
  704. YY_BREAK
  705. case 17:
  706. # line 71 "a2k_p1.l"
  707. fputs("#",yyout);  
  708. YY_BREAK
  709. case 18:
  710. # line 72 "a2k_p1.l"
  711. { fprintf(yyout,""%s",yytext+1); BEGIN(C_str); }
  712. YY_BREAK
  713. case 19:
  714. # line 73 "a2k_p1.l"
  715. { ECHO; BEGIN(INITIAL); }
  716. YY_BREAK
  717.   /*********************************************
  718.    *               C string recognizer         *
  719.    *********************************************/
  720. case 20:
  721. # line 77 "a2k_p1.l"
  722. { ECHO; }
  723. YY_BREAK
  724. case 21:
  725. # line 78 "a2k_p1.l"
  726. { ECHO; }
  727. YY_BREAK
  728. case 22:
  729. # line 79 "a2k_p1.l"
  730. { BEGIN(C_str1); }
  731. YY_BREAK
  732. case 23:
  733. # line 80 "a2k_p1.l"
  734. { ECHO; }
  735. YY_BREAK
  736. case 24:
  737. # line 81 "a2k_p1.l"
  738. ; /* waiting */
  739. YY_BREAK
  740. case 25:
  741. # line 82 "a2k_p1.l"
  742. ; /* waiting */
  743. YY_BREAK
  744. case 26:
  745. # line 83 "a2k_p1.l"
  746. ; /* waiting */
  747. YY_BREAK
  748. case 27:
  749. # line 84 "a2k_p1.l"
  750. { BEGIN(C_str);  } /* clip strings */
  751. YY_BREAK
  752. case 28:
  753. # line 85 "a2k_p1.l"
  754. { fputs(""n#if",yyout);       BEGIN(INITIAL);  }
  755. YY_BREAK
  756. case 29:
  757. # line 86 "a2k_p1.l"
  758. { fputs(""n#ifdef",yyout);    BEGIN(INITIAL);  }
  759. YY_BREAK
  760. case 30:
  761. # line 87 "a2k_p1.l"
  762. { fputs(""n#else",yyout);     BEGIN(INITIAL);  }
  763. YY_BREAK
  764. case 31:
  765. # line 88 "a2k_p1.l"
  766. { fputs(""n#endif",yyout);    BEGIN(INITIAL);  }
  767. YY_BREAK
  768. case 32:
  769. # line 89 "a2k_p1.l"
  770. { fputs(""n#define",yyout);    BEGIN(INITIAL);  }
  771. YY_BREAK
  772. case 33:
  773. # line 90 "a2k_p1.l"
  774. { fputs(""n#undef",yyout);    BEGIN(INITIAL);  }
  775. YY_BREAK
  776. case 34:
  777. # line 91 "a2k_p1.l"
  778. { fputs(""n#include",yyout);  BEGIN(Skip);  }
  779. YY_BREAK
  780. case 35:
  781. # line 92 "a2k_p1.l"
  782. { fputs(""n#pragma",yyout);   BEGIN(Skip);  }
  783. YY_BREAK
  784. case 36:
  785. # line 93 "a2k_p1.l"
  786. { fputs(""n
  787. YY_BREAK
  788. case 37:
  789. # line 94 "a2k_p1.l"
  790. { fputs(""n#",yyout);         BEGIN(INITIAL);  }
  791. YY_BREAK
  792. case 38:
  793. # line 95 "a2k_p1.l"
  794. fputs(yytext+1,yyout); /* threw away # and leave name inside string */
  795. YY_BREAK
  796. case 39:
  797. # line 96 "a2k_p1.l"
  798. { fputs("",",yyout); BEGIN(INITIAL);  }
  799. YY_BREAK
  800. case 40:
  801. # line 97 "a2k_p1.l"
  802. { fprintf(yyout,""%s",yytext); BEGIN(INITIAL);  }
  803. YY_BREAK
  804. case 41:
  805. # line 98 "a2k_p1.l"
  806. ECHO;
  807. YY_BREAK
  808. case YY_STATE_EOF(INITIAL):
  809. case YY_STATE_EOF(C_str):
  810. case YY_STATE_EOF(C_str1):
  811. case YY_STATE_EOF(Skip):
  812.     yyterminate();
  814.     case YY_END_OF_BUFFER:
  815. {
  816. /* amount of text matched not including the EOB char */
  817. int yy_amount_of_matched_text = yy_cp - yytext - 1;
  819. /* undo the effects of YY_DO_BEFORE_ACTION */
  820. *yy_cp = yy_hold_char;
  822. /* note that here we test for yy_c_buf_p "<=" to the position
  823.  * of the first EOB in the buffer, since yy_c_buf_p will
  824.  * already have been incremented past the NUL character
  825.  * (since all states make transitions on EOB to the end-
  826.  * of-buffer state).  Contrast this with the test in yyinput().
  827.  */
  828. if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  829.     /* this was really a NUL */
  830.     {
  831.     yy_state_type yy_next_state;
  833.     yy_c_buf_p = yytext + yy_amount_of_matched_text;
  835.     yy_current_state = yy_get_previous_state();
  837.     /* okay, we're now positioned to make the
  838.      * NUL transition.  We couldn't have
  839.      * yy_get_previous_state() go ahead and do it
  840.      * for us because it doesn't know how to deal
  841.      * with the possibility of jamming (and we
  842.      * don't want to build jamming into it because
  843.      * then it will run more slowly)
  844.      */
  846.     yy_next_state = yy_try_NUL_trans( yy_current_state );
  848.     yy_bp = yytext + YY_MORE_ADJ;
  850.     if ( yy_next_state )
  851. {
  852. /* consume the NUL */
  853. yy_cp = ++yy_c_buf_p;
  854. yy_current_state = yy_next_state;
  855. goto yy_match;
  856. }
  858.     else
  859. {
  860.     yy_cp = yy_last_accepting_cpos;
  861.     yy_current_state = yy_last_accepting_state;
  862. goto yy_find_action;
  863. }
  864.     }
  866. else switch ( yy_get_next_buffer() )
  867.     {
  868.     case EOB_ACT_END_OF_FILE:
  869. {
  870. yy_did_buffer_switch_on_eof = 0;
  872. if ( yywrap() )
  873.     {
  874.     /* note: because we've taken care in
  875.      * yy_get_next_buffer() to have set up yytext,
  876.      * we can now set up yy_c_buf_p so that if some
  877.      * total hoser (like flex itself) wants
  878.      * to call the scanner after we return the
  879.      * YY_NULL, it'll still work - another YY_NULL
  880.      * will get returned.
  881.      */
  882.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  884.     yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  885.     goto do_action;
  886.     }
  888. else
  889.     {
  890.     if ( ! yy_did_buffer_switch_on_eof )
  891. YY_NEW_FILE;
  892.     }
  893. }
  894. break;
  896.     case EOB_ACT_CONTINUE_SCAN:
  897. yy_c_buf_p = yytext + yy_amount_of_matched_text;
  899. yy_current_state = yy_get_previous_state();
  901. yy_cp = yy_c_buf_p;
  902. yy_bp = yytext + YY_MORE_ADJ;
  903. goto yy_match;
  905.     case EOB_ACT_LAST_MATCH:
  906. yy_c_buf_p =
  907.     &yy_current_buffer->yy_ch_buf[yy_n_chars];
  909. yy_current_state = yy_get_previous_state();
  911. yy_cp = yy_c_buf_p;
  912. yy_bp = yytext + YY_MORE_ADJ;
  913. goto yy_find_action;
  914.     }
  915. break;
  916. }
  918.     default:
  919. #ifdef FLEX_DEBUG
  920. printf( "action # %dn", yy_act );
  921. #endif
  922. YY_FATAL_ERROR(
  923. "fatal flex scanner internal error--no action found" );
  924.     }
  925. }
  926.     }
  929. /* yy_get_next_buffer - try to read in a new buffer
  930.  *
  931.  * synopsis
  932.  *     int yy_get_next_buffer();
  933.  *     
  934.  * returns a code representing an action
  935.  *     EOB_ACT_LAST_MATCH - 
  936.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  937.  *     EOB_ACT_END_OF_FILE - end of file
  938.  */
  940. static int yy_get_next_buffer()
  942.     {
  943.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  944.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  945.     register int number_to_move, i;
  946.     int ret_val;
  948.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  949. YY_FATAL_ERROR(
  950. "fatal flex scanner internal error--end of buffer missed" );
  952.     /* try to read more data */
  954.     /* first move last chars to start of buffer */
  955.     number_to_move = yy_c_buf_p - yytext;
  957.     for ( i = 0; i < number_to_move; ++i )
  958. *(dest++) = *(source++);
  960.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  961. /* don't do the read, it's not guaranteed to return an EOF,
  962.  * just force an EOF
  963.  */
  964. yy_n_chars = 0;
  966.     else
  967. {
  968. int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  970. if ( num_to_read > YY_READ_BUF_SIZE )
  971.     num_to_read = YY_READ_BUF_SIZE;
  973. else if ( num_to_read <= 0 )
  974.     YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  976. /* read in more data */
  977. YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  978.   yy_n_chars, num_to_read );
  979. }
  981.     if ( yy_n_chars == 0 )
  982. {
  983. if ( number_to_move - YY_MORE_ADJ == 1 )
  984.     {
  985.     ret_val = EOB_ACT_END_OF_FILE;
  986.     yy_current_buffer->yy_eof_status = EOF_DONE;
  987.     }
  989. else
  990.     {
  991.     ret_val = EOB_ACT_LAST_MATCH;
  992.     yy_current_buffer->yy_eof_status = EOF_PENDING;
  993.     }
  994. }
  996.     else
  997. ret_val = EOB_ACT_CONTINUE_SCAN;
  999.     yy_n_chars += number_to_move;
  1000.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1001.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1003.     /* yytext begins at the second character in yy_ch_buf; the first
  1004.      * character is the one which preceded it before reading in the latest
  1005.      * buffer; it needs to be kept around in case it's a newline, so
  1006.      * yy_get_previous_state() will have with '^' rules active
  1007.      */
  1009.     yytext = &yy_current_buffer->yy_ch_buf[1];
  1011.     return ( ret_val );
  1012.     }
  1015. /* yy_get_previous_state - get the state just before the EOB char was reached
  1016.  *
  1017.  * synopsis
  1018.  *     yy_state_type yy_get_previous_state();
  1019.  */
  1021. static yy_state_type yy_get_previous_state()
  1023.     {
  1024.     register yy_state_type yy_current_state;
  1025.     register YY_CHAR *yy_cp;
  1027.     register YY_CHAR *yy_bp = yytext;
  1029.     yy_current_state = yy_start;
  1030.     if ( yy_bp[-1] == 'n' )
  1031. ++yy_current_state;
  1033.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1034. {
  1035. register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  1036. if ( yy_accept[yy_current_state] )
  1037.     {
  1038.     yy_last_accepting_state = yy_current_state;
  1039.     yy_last_accepting_cpos = yy_cp;
  1040.     }
  1041. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1042.     {
  1043.     yy_current_state = yy_def[yy_current_state];
  1044.     if ( yy_current_state >= 189 )
  1045. yy_c = yy_meta[yy_c];
  1046.     }
  1047. yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1048. }
  1050.     return ( yy_current_state );
  1051.     }
  1054. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1055.  *
  1056.  * synopsis
  1057.  *     next_state = yy_try_NUL_trans( current_state );
  1058.  */
  1060. #ifdef YY_USE_PROTOS
  1061. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  1062. #else
  1063. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1064. register yy_state_type yy_current_state;
  1065. #endif
  1067.     {
  1068.     register int yy_is_jam;
  1069.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1071.     register YY_CHAR yy_c = 1;
  1072.     if ( yy_accept[yy_current_state] )
  1073. {
  1074. yy_last_accepting_state = yy_current_state;
  1075. yy_last_accepting_cpos = yy_cp;
  1076. }
  1077.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1078. {
  1079. yy_current_state = yy_def[yy_current_state];
  1080. if ( yy_current_state >= 189 )
  1081.     yy_c = yy_meta[yy_c];
  1082. }
  1083.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1084.     yy_is_jam = (yy_current_state == 188);
  1086.     return ( yy_is_jam ? 0 : yy_current_state );
  1087.     }
  1090. #ifdef YY_USE_PROTOS
  1091. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1092. #else
  1093. static void yyunput( c, yy_bp )
  1094. YY_CHAR c;
  1095. register YY_CHAR *yy_bp;
  1096. #endif
  1098.     {
  1099.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1101.     /* undo effects of setting up yytext */
  1102.     *yy_cp = yy_hold_char;
  1104.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1105. { /* need to shift things up to make room */
  1106. register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  1107. register YY_CHAR *dest =
  1108.     &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  1109. register YY_CHAR *source =
  1110.     &yy_current_buffer->yy_ch_buf[number_to_move];
  1112. while ( source > yy_current_buffer->yy_ch_buf )
  1113.     *--dest = *--source;
  1115. yy_cp += dest - source;
  1116. yy_bp += dest - source;
  1117. yy_n_chars = yy_current_buffer->yy_buf_size;
  1119. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1120.     YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1121. }
  1123.     if ( yy_cp > yy_bp && yy_cp[-1] == 'n' )
  1124. yy_cp[-2] = 'n';
  1126.     *--yy_cp = c;
  1128.     /* note: the formal parameter *must* be called "yy_bp" for this
  1129.      *       macro to now work correctly
  1130.      */
  1131.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1132.     }
  1135. #ifdef __cplusplus
  1136. static int yyinput()
  1137. #else
  1138. static int input()
  1139. #endif
  1141.     {
  1142.     int c;
  1143.     YY_CHAR *yy_cp = yy_c_buf_p;
  1145.     *yy_cp = yy_hold_char;
  1147.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1148. {
  1149. /* yy_c_buf_p now points to the character we want to return.
  1150.  * If this occurs *before* the EOB characters, then it's a
  1151.  * valid NUL; if not, then we've hit the end of the buffer.
  1152.  */
  1153. if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1154.     /* this was really a NUL */
  1155.     *yy_c_buf_p = '';
  1157. else
  1158.     { /* need more input */
  1159.     yytext = yy_c_buf_p;
  1160.     ++yy_c_buf_p;
  1162.     switch ( yy_get_next_buffer() )
  1163. {
  1164. case EOB_ACT_END_OF_FILE:
  1165.     {
  1166.     if ( yywrap() )
  1167. {
  1168. yy_c_buf_p = yytext + YY_MORE_ADJ;
  1169. return ( EOF );
  1170. }
  1172.     YY_NEW_FILE;
  1174. #ifdef __cplusplus
  1175.     return ( yyinput() );
  1176. #else
  1177.     return ( input() );
  1178. #endif
  1179.     }
  1180.     break;
  1182. case EOB_ACT_CONTINUE_SCAN:
  1183.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  1184.     break;
  1186. case EOB_ACT_LAST_MATCH:
  1187. #ifdef __cplusplus
  1188.     YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1189. #else
  1190.     YY_FATAL_ERROR( "unexpected last match in input()" );
  1191. #endif
  1192. }
  1193.     }
  1194. }
  1196.     c = *yy_c_buf_p;
  1197.     yy_hold_char = *++yy_c_buf_p;
  1199.     return ( c );
  1200.     }
  1203. #ifdef YY_USE_PROTOS
  1204. void yyrestart( FILE *input_file )
  1205. #else
  1206. void yyrestart( input_file )
  1207. FILE *input_file;
  1208. #endif
  1210.     {
  1211.     yy_init_buffer( yy_current_buffer, input_file );
  1212.     yy_load_buffer_state();
  1213.     }
  1216. #ifdef YY_USE_PROTOS
  1217. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1218. #else
  1219. void yy_switch_to_buffer( new_buffer )
  1220. YY_BUFFER_STATE new_buffer;
  1221. #endif
  1223.     {
  1224.     if ( yy_current_buffer == new_buffer )
  1225. return;
  1227.     if ( yy_current_buffer )
  1228. {
  1229. /* flush out information for old buffer */
  1230. *yy_c_buf_p = yy_hold_char;
  1231. yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1232. yy_current_buffer->yy_n_chars = yy_n_chars;
  1233. }
  1235.     yy_current_buffer = new_buffer;
  1236.     yy_load_buffer_state();
  1238.     /* we don't actually know whether we did this switch during
  1239.      * EOF (yywrap()) processing, but the only time this flag
  1240.      * is looked at is after yywrap() is called, so it's safe
  1241.      * to go ahead and always set it.
  1242.      */
  1243.     yy_did_buffer_switch_on_eof = 1;
  1244.     }
  1247. #ifdef YY_USE_PROTOS
  1248. void yy_load_buffer_state( void )
  1249. #else
  1250. void yy_load_buffer_state()
  1251. #endif
  1253.     {
  1254.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1255.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1256.     yyin = yy_current_buffer->yy_input_file;
  1257.     yy_hold_char = *yy_c_buf_p;
  1258.     }
  1261. #ifdef YY_USE_PROTOS
  1262. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1263. #else
  1264. YY_BUFFER_STATE yy_create_buffer( file, size )
  1265. FILE *file;
  1266. int size;
  1267. #endif
  1269.     {
  1270.     YY_BUFFER_STATE b;
  1272.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1274.     if ( ! b )
  1275. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1277.     b->yy_buf_size = size;
  1279.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1280.      * we need to put in 2 end-of-buffer characters.
  1281.      */
  1282.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1284.     if ( ! b->yy_ch_buf )
  1285. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1287.     yy_init_buffer( b, file );
  1289.     return ( b );
  1290.     }
  1293. #ifdef YY_USE_PROTOS
  1294. void yy_delete_buffer( YY_BUFFER_STATE b )
  1295. #else
  1296. void yy_delete_buffer( b )
  1297. YY_BUFFER_STATE b;
  1298. #endif
  1300.     {
  1301.     if ( b == yy_current_buffer )
  1302. yy_current_buffer = (YY_BUFFER_STATE) 0;
  1304.     free( (char *) b->yy_ch_buf );
  1305.     free( (char *) b );
  1306.     }
  1309. #ifdef YY_USE_PROTOS
  1310. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1311. #else
  1312. void yy_init_buffer( b, file )
  1313. YY_BUFFER_STATE b;
  1314. FILE *file;
  1315. #endif
  1317.     {
  1318.     b->yy_input_file = file;
  1320.     /* we put in the 'n' and start reading from [1] so that an
  1321.      * initial match-at-newline will be true.
  1322.      */
  1324.     b->yy_ch_buf[0] = 'n';
  1325.     b->yy_n_chars = 1;
  1327.     /* we always need two end-of-buffer characters.  The first causes
  1328.      * a transition to the end-of-buffer state.  The second causes
  1329.      * a jam in that state.
  1330.      */
  1331.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1332.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1334.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1336.     b->yy_eof_status = EOF_NOT_SEEN;
  1337.     }
  1338. # line 98 "a2k_p1.l"
  1342. int
  1343. yywrap()
  1344. {
  1345.   return 1;
  1346. }
  1348. int
  1349. main (argc,argv)
  1350.      i4_t argc;
  1351.      char **argv;
  1352. {
  1353.   if ( argc != 3 )
  1354.     {
  1355.       fprintf("Usage: %s input_file output_filen",argv[0]);
  1356.       return 1;
  1357.     }
  1358.   yy_flex_debug = 0;
  1359.   yyin = fopen(argv[1],"r");
  1360.   assert( yyin != NULL);
  1361.   yyout = fopen(argv[2],"w");
  1362.   assert(yyout != NULL);
  1363.   yylex();
  1364.   fclose(yyin);
  1365.   fclose(yyout);
  1366.   return 0;
  1367. }
  1368. int yywrap() { return 1; }