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

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

SQL Server

开发平台：

Unix_Linux

scan_c.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 "scan_c.l"
  169. #define INITIAL 0
  170. # line 2 "scan_c.l"
  171. /*
  172.  *  scan_c.l - scanner-extractor of GNU SQL/C compiler
  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. /* $Id: scan_c.l,v 1.247 1997/04/21 14:26:13 kml Exp $ */
  200. #include "xmem.h"
  201. #include "gsqltrn.h"
  202. #include "sql_decl.h"
  203. #include "procname.h"
  204. #include <assert.h>
  206. #define SWITCH_COND(cond)  { save_condition();BEGIN(cond);}
  207. #define REST_COND            rest_condition();
  209. #define SCANNER_NAME      yylex_extractor
  211. #ifdef YY_DECL
  212. #  undef YY_DECL
  213. #endif
  214. #define YY_DECL           int SCANNER_NAME(void)
  216. YY_DECL;
  218. #define YY_USER_INIT      { BEGIN(START_CONDITION); line_num=1; }
  219. #define YY_USER_ACTION    if(yy_flex_debug){ 
  220.   fprintf(stderr,"nCurrent lex state=%dn",yy_start);}
  222. #define SQL_PROC(code)  if(code){file_pos=line_num; return 1<<code;}
  224. static str_buf c_scanner_buffer={0,0,NULL};
  225. #define sql_str(s,l)  buffer_string(&c_scanner_buffer,s,l)
  227. /* defined in main routine */
  228. int open_file(FILE **f,char *ext);
  230. static void  save_condition __P((void));
  231. static void  rest_condition __P((void));
  233. #ifndef START_CONDITION
  234. #  define START_CONDITION   scan_mode_state
  235. #endif
  237. #define BEGIN_MODE(v)    { BEGIN(v); scan_mode_state=v; }
  239. static char *statement_scanner_buffer=NULL;
  240. static int   line_num=1;
  241. static int   io_diff=0;
  242. static char *progname_out=NULL;
  243. static int   bline=1; 
  245. #define APPEND_BUFFER { sql_str(yytext,yyleng);} 
  246. #define POP_BUFFER pop_cl_buffer()
  248. void
  249. pop_cl_buffer(void)
  250. {
  251.   register char *b=sql_str(NULL,0);
  252.   statement_scanner_buffer=b?savestring(b):NULL;
  253. }
  255. #define C_lang 1
  256. #define c_comment 2
  257. #define C_str 3
  258. #define ESQL 4
  259. #define MOD 5
  260. #define SCH 6
  261. #define SQL 7
  262. #define SQL_str 8
  263. #define SQL_ident 9
  264. #define SQL_comment 10
  265. # line 100 "scan_c.l"
  267. /* done after the current pattern has been matched and before the
  268.  * corresponding action - sets up yytext
  269.  */
  270. #define YY_DO_BEFORE_ACTION 
  271. yytext = yy_bp; 
  272. yyleng = yy_cp - yy_bp; 
  273. yy_hold_char = *yy_cp; 
  274. *yy_cp = ''; 
  275. yy_c_buf_p = yy_cp;
  277. #define EOB_ACT_CONTINUE_SCAN 0
  278. #define EOB_ACT_END_OF_FILE 1
  279. #define EOB_ACT_LAST_MATCH 2
  281. /* return all but the first 'n' matched characters back to the input stream */
  282. #define yyless(n) 
  283. do 
  284. { 
  285. /* undo effects of setting up yytext */ 
  286. *yy_cp = yy_hold_char; 
  287. yy_c_buf_p = yy_cp = yy_bp + n; 
  288. YY_DO_BEFORE_ACTION; /* set up yytext again */ 
  289. } 
  290. while ( 0 )
  292. #define unput(c) yyunput( c, yytext )
  295. struct yy_buffer_state
  296.     {
  297.     FILE *yy_input_file;
  299.     YY_CHAR *yy_ch_buf; /* input buffer */
  300.     YY_CHAR *yy_buf_pos; /* current position in input buffer */
  302.     /* size of input buffer in bytes, not including room for EOB characters */
  303.     int yy_buf_size;
  305.     /* number of characters read into yy_ch_buf, not including EOB characters */
  306.     int yy_n_chars;
  308.     int yy_eof_status; /* whether we've seen an EOF on this buffer */
  309. #define EOF_NOT_SEEN 0
  310.     /* "pending" happens when the EOF has been seen but there's still
  311.      * some text process
  312.      */
  313. #define EOF_PENDING 1
  314. #define EOF_DONE 2
  315.     };
  317. static YY_BUFFER_STATE yy_current_buffer;
  319. /* we provide macros for accessing buffer states in case in the
  320.  * future we want to put the buffer states in a more general
  321.  * "scanner state"
  322.  */
  323. #define YY_CURRENT_BUFFER yy_current_buffer
  326. /* yy_hold_char holds the character lost when yytext is formed */
  327. static YY_CHAR yy_hold_char;
  329. static int yy_n_chars; /* number of characters read into yy_ch_buf */
  333. #ifndef YY_USER_ACTION
  334. #define YY_USER_ACTION
  335. #endif
  337. #ifndef YY_USER_INIT
  338. #define YY_USER_INIT
  339. #endif
  341. extern YY_CHAR *yytext;
  342. extern int yyleng;
  343. extern FILE *yyin, *yyout;
  345. YY_CHAR *yytext;
  346. int yyleng;
  348. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  350. #define YY_END_OF_BUFFER 46
  351. typedef int yy_state_type;
  352. static const short int yy_accept[158] =
  353.     {   0,
  354.         0,    0,    0,    0,   12,   12,    0,    0,    0,    0,
  355.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  356.         0,    0,   46,   44,   27,    6,   44,   44,   44,   44,
  357.        44,   27,   44,   44,   45,    3,   45,    5,    5,    3,
  358.         5,    5,    5,   12,   14,   13,   10,   11,    7,   10,
  359.        33,   28,   32,   30,   29,   33,   33,   17,   21,   33,
  360.        33,   33,   33,   33,   33,   33,   33,   33,   45,   45,
  361.        45,   45,   36,   35,   37,   39,   38,   41,   42,   43,
  362.        27,   31,    0,    0,    0,    0,   27,    0,    0,    4,
  363.         1,    0,    2,    0,   12,   13,   13,   15,   10,    9,
  365.         8,   28,   16,    0,    0,    0,    0,    0,   36,   34,
  366.        39,   40,    0,    0,    0,    0,    0,    0,    0,    0,
  367.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  368.         0,    0,    0,   22,    0,    0,    0,    0,    0,    0,
  369.        23,    0,    0,    0,    0,   24,    0,   18,    0,    0,
  370.         0,   25,   19,    0,    0,   20,    0
  371.     } ;
  373. static const YY_CHAR yy_ec[256] =
  374.     {   0,
  375.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  376.         1,    4,    5,    1,    1,    1,    1,    1,    1,    1,
  377.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  378.         1,    2,    1,    6,    1,    7,    1,    1,    8,    1,
  379.         1,    9,    1,    1,   10,    1,   11,   12,   12,   12,
  380.        12,   12,   12,   12,   12,   12,   12,    1,   13,    1,
  381.         1,    1,    1,    1,   15,   12,   16,   17,   18,   12,
  382.        19,   20,   21,   12,   22,   23,   24,   25,   26,   27,
  383.        28,   29,   30,   31,   32,   33,   34,   35,   12,   12,
  384.         1,   14,    1,    1,   12,    1,   15,   12,   16,   17,
  386.        18,   12,   19,   20,   21,   12,   22,   23,   24,   25,
  387.        26,   27,   28,   29,   30,   31,   32,   33,   34,   35,
  388.        12,   12,    1,    1,    1,    1,    1,    1,    1,    1,
  389.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  390.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  391.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  392.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  393.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  394.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  395.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  397.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  398.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  399.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  400.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  401.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  402.         1,    1,    1,    1,    1
  403.     } ;
  405. static const YY_CHAR yy_meta[36] =
  406.     {   0,
  407.         1,    1,    2,    1,    1,    3,    1,    4,    5,    1,
  408.         1,    6,    1,    1,    6,    6,    6,    6,    6,    6,
  409.         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
  410.         6,    6,    6,    6,    6
  411.     } ;
  413. static const short int yy_base[180] =
  414.     {   0,
  415.         0,   23,    2,   46,    3,   11,   15,   28,   63,   75,
  416.        76,   81,   98,    0,   20,   39,   20,   42,   16,   40,
  417.       317,  316,  318,  321,    5,  321,  307,  293,  286,  285,
  418.       287,  100,   56,  277,  321,  321,  302,  321,   73,  321,
  419.       117,  301,  274,    0,  321,   59,  321,  321,  321,   93,
  420.       321,   80,  321,  321,  321,  298,  298,  321,  321,  288,
  421.       279,  275,  280,  273,  272,  271,  281,  277,  274,  267,
  422.       266,  268,    0,  321,  285,    0,  321,  286,  321,  321,
  423.        93,  321,  260,  272,  263,  271,  121,  131,  252,  321,
  424.       321,  268,  321,  122,    0,  101,  132,  321,  321,  321,
  426.       321,  140,  321,  269,  258,  268,  249,  250,    0,  321,
  427.         0,  321,  262,  264,  251,  245,  260,  252,  258,  248,
  428.       246,  251,  241,  200,    0,  207,  224,  209,  194,  178,
  429.       184,    0,  120,  321,  119,   60,  102,  113,    0,  108,
  430.       321,    0,   88,   88,   69,  321,    0,  321,   49,    0,
  431.        22,  321,  321,   14,    0,  321,  321,  144,  150,  156,
  432.       162,  168,  174,  180,  186,  192,  198,  204,  210,  216,
  433.       222,  228,  234,  239,  244,  249,  254,  259,  264
  434.     } ;
  436. static const short int yy_def[180] =
  437.     {   0,
  438.       158,  158,  159,  160,  161,  161,  162,  162,  163,  163,
  439.        10,   10,   10,   13,  159,  159,  164,  164,  165,  165,
  440.       166,  166,  157,  157,  157,  157,  157,  157,  157,  157,
  441.       157,  157,  167,  157,  157,  157,  157,  157,  157,  157,
  442.       167,  157,  157,  168,  157,  169,  157,  157,  157,  170,
  443.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  444.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  445.       157,  157,  171,  157,  157,  172,  157,  157,  157,  157,
  446.       157,  157,  157,  157,  157,  157,  157,  167,  157,  157,
  447.       157,  157,  157,  157,  168,  169,  169,  157,  157,  157,
  449.       157,  157,  157,  157,  157,  157,  157,  157,  171,  157,
  450.       172,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  451.       157,  157,  157,  157,  173,  157,  157,  157,  157,  157,
  452.       157,  174,  157,  157,  157,  157,  157,  157,  175,  157,
  453.       157,  176,  157,  157,  157,  157,  177,  157,  157,  178,
  454.       157,  157,  157,  157,  179,  157,    0,  157,  157,  157,
  455.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  456.       157,  157,  157,  157,  157,  157,  157,  157,  157
  457.     } ;
  459. static const short int yy_nxt[357] =
  460.     {   0,
  461.       157,   25,   26,   25,   26,   45,   81,   36,   81,   27,
  462.       157,   46,   37,   45,   28,   29,   30,   48,   77,   46,
  463.        49,   78,   74,   31,   32,   26,   25,   75,   50,   33,
  464.        48,  155,   27,   49,   69,   70,   71,   28,   29,   30,
  465.        34,   50,   77,   72,   74,   78,   31,   39,   26,   75,
  466.       154,   40,   41,   69,   70,   71,   42,   91,   91,   91,
  467.        91,  136,   72,   43,   52,   53,   52,   97,   54,   98,
  468.        55,   88,   56,   57,   94,   58,   52,   53,   52,   88,
  469.        54,  102,   55,  102,   56,   57,   51,   58,   59,  143,
  470.        89,   51,   60,   59,   81,  100,   81,   60,  101,   61,
  472.       151,   87,   62,   81,   61,  150,   88,   62,   51,  157,
  473.        51,  157,   63,   64,   65,  149,   66,   89,   91,   91,
  474.        91,   91,   87,   94,   81,  147,   67,   88,   88,  145,
  475.       144,   68,   91,   91,   91,   91,  142,  125,   89,   89,
  476.        97,  102,   98,  102,   24,   24,   24,   24,   24,   24,
  477.        35,   35,   35,   35,   35,   35,   38,   38,   38,   38,
  478.        38,   38,   44,   44,   44,   44,   44,   44,   47,   47,
  479.        47,   47,   47,   47,   51,   51,   51,   51,   51,   51,
  480.        73,   73,   73,   73,   73,   73,   76,   76,   76,   76,
  481.        76,   76,   79,   79,   79,   79,   79,   79,   90,   90,
  483.        90,   90,   90,   90,   95,  140,   95,   95,  139,   95,
  484.        96,  138,   96,   96,   96,   96,   99,   99,   99,   99,
  485.        99,   99,  109,  137,  109,  136,  109,  109,  111,  135,
  486.       133,  111,  111,  111,  134,  134,  134,  134,  134,  141,
  487.       141,  141,  141,  141,  146,  146,  146,  146,  146,  148,
  488.       148,  148,  148,  148,  152,  152,  152,  152,  152,  153,
  489.       153,  153,  153,  153,  156,  156,  156,  156,  156,  125,
  490.       132,  131,  130,  129,  128,  127,  126,  125,  124,  123,
  491.       122,  121,  120,  119,  118,  117,   92,  116,  115,  114,
  492.       113,  112,  110,   86,   85,   84,   83,  108,  107,  106,
  494.        85,   84,   83,  105,   86,  104,  103,   82,   92,   93,
  495.        93,   92,   86,   85,   84,   83,   82,  157,   80,   80,
  496.        23,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  497.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  498.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  499.       157,  157,  157,  157,  157,  157
  500.     } ;
  502. static const short int yy_chk[357] =
  503.     {   0,
  504.         0,    1,    1,    1,    3,    5,   25,    3,   25,    1,
  505.         0,    5,    3,    6,    1,    1,    1,    7,   19,    6,
  506.         7,   19,   17,    1,    2,    2,    2,   17,    7,    2,
  507.         8,  154,    2,    8,   15,   15,   15,    2,    2,    2,
  508.         2,    8,   20,   15,   18,   20,    2,    4,    4,   18,
  509.       151,    4,    4,   16,   16,   16,    4,   33,   33,   33,
  510.        33,  136,   16,    4,    9,    9,    9,   46,    9,   46,
  511.         9,  149,    9,    9,   39,    9,   10,   10,   10,   39,
  512.        10,   52,   10,   52,   10,   10,   11,   10,   11,  136,
  513.        39,   12,   11,   12,   81,   50,   81,   12,   50,   11,
  515.       145,   32,   11,   32,   12,  144,   32,   12,   13,   96,
  516.        13,   96,   13,   13,   13,  143,   13,   32,   41,   41,
  517.        41,   41,   87,   94,   87,  140,   13,   87,   94,  138,
  518.       137,   13,   88,   88,   88,   88,  135,  133,   87,   94,
  519.        97,  102,   97,  102,  158,  158,  158,  158,  158,  158,
  520.       159,  159,  159,  159,  159,  159,  160,  160,  160,  160,
  521.       160,  160,  161,  161,  161,  161,  161,  161,  162,  162,
  522.       162,  162,  162,  162,  163,  163,  163,  163,  163,  163,
  523.       164,  164,  164,  164,  164,  164,  165,  165,  165,  165,
  524.       165,  165,  166,  166,  166,  166,  166,  166,  167,  167,
  526.       167,  167,  167,  167,  168,  131,  168,  168,  130,  168,
  527.       169,  129,  169,  169,  169,  169,  170,  170,  170,  170,
  528.       170,  170,  171,  128,  171,  127,  171,  171,  172,  126,
  529.       124,  172,  172,  172,  173,  173,  173,  173,  173,  174,
  530.       174,  174,  174,  174,  175,  175,  175,  175,  175,  176,
  531.       176,  176,  176,  176,  177,  177,  177,  177,  177,  178,
  532.       178,  178,  178,  178,  179,  179,  179,  179,  179,  123,
  533.       122,  121,  120,  119,  118,  117,  116,  115,  114,  113,
  534.       108,  107,  106,  105,  104,   92,   89,   86,   85,   84,
  535.        83,   78,   75,   72,   71,   70,   69,   68,   67,   66,
  537.        65,   64,   63,   62,   61,   60,   57,   56,   43,   42,
  538.        37,   34,   31,   30,   29,   28,   27,   23,   22,   21,
  539.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  540.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  541.       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
  542.       157,  157,  157,  157,  157,  157
  543.     } ;
  545. static yy_state_type yy_last_accepting_state;
  546. static YY_CHAR *yy_last_accepting_cpos;
  548. extern int yy_flex_debug;
  549. int yy_flex_debug = 1;
  551. static const short int yy_rule_linenum[45] =
  552.     {   0,
  553.       114,  119,  124,  128,  129,  130,  134,  135,  136,  137,
  554.       138,  146,  147,  148,  151,  161,  169,  178,  182,  187,
  555.       193,  207,  219,  223,  236,  236,  250,  251,  252,  256,
  556.       260,  263,  267,  273,  274,  279,  280,  287,  292,  293,
  557.       294,  301,  302,  306
  558.     } ;
  560. /* the intent behind this definition is that it'll catch
  561.  * any uses of REJECT which flex missed
  562.  */
  563. #define REJECT reject_used_but_not_detected
  564. #define yymore() yymore_used_but_not_detected
  565. #define YY_MORE_ADJ 0
  567. /* these variables are all declared out here so that section 3 code can
  568.  * manipulate them
  569.  */
  570. /* points to current character in buffer */
  571. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  572. static int yy_init = 1; /* whether we need to initialize */
  573. static int yy_start = 0; /* start state number */
  575. /* flag which is used to allow yywrap()'s to do buffer switches
  576.  * instead of setting up a fresh yyin.  A bit of a hack ...
  577.  */
  578. static int yy_did_buffer_switch_on_eof;
  580. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  581. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  582. static int yy_get_next_buffer YY_PROTO(( void ));
  583. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  584. void yyrestart YY_PROTO(( FILE *input_file ));
  585. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  586. void yy_load_buffer_state YY_PROTO(( void ));
  587. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  588. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  589. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  591. #define yy_new_buffer yy_create_buffer
  593. #ifdef __cplusplus
  594. static int yyinput YY_PROTO(( void ));
  595. #else
  596. static int input YY_PROTO(( void ));
  597. #endif
  599. YY_DECL
  600.     {
  601.     register yy_state_type yy_current_state;
  602.     register YY_CHAR *yy_cp, *yy_bp;
  603.     register int yy_act;
  606.     static int esql_caller = 0;
  607.     static int rout_title  = 0;
  609.     int comment_caller     = 0;
  610.     int first_start        = yy_init;
  611.     int with_grant_options = 0;
  612.     
  613.     #ifdef FLEX_DEBUG
  614.       yy_flex_debug=client_scanner_debug;
  615.     #endif
  616.   /*********************************************
  617.    *                C lexics                   *
  618.    *********************************************/
  620.     if ( yy_init )
  621. {
  622. YY_USER_INIT;
  624. if ( ! yy_start )
  625.     yy_start = 1; /* first start state */
  627. if ( ! yyin )
  628.     yyin = stdin;
  630. if ( ! yyout )
  631.     yyout = stdout;
  633. if ( yy_current_buffer )
  634.     yy_init_buffer( yy_current_buffer, yyin );
  635. else
  636.     yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  638. yy_load_buffer_state();
  640. yy_init = 0;
  641. }
  643.     while ( 1 ) /* loops until end-of-file is reached */
  644. {
  645. yy_cp = yy_c_buf_p;
  647. /* support of yytext */
  648. *yy_cp = yy_hold_char;
  650. /* yy_bp points to the position in yy_ch_buf of the start of the
  651.  * current run.
  652.  */
  653. yy_bp = yy_cp;
  655. yy_current_state = yy_start;
  656. if ( yy_bp[-1] == 'n' )
  657.     ++yy_current_state;
  658. yy_match:
  659. do
  660.     {
  661.     register YY_CHAR yy_c = yy_ec[*yy_cp];
  662.     if ( yy_accept[yy_current_state] )
  663. {
  664. yy_last_accepting_state = yy_current_state;
  665. yy_last_accepting_cpos = yy_cp;
  666. }
  667.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  668. {
  669. yy_current_state = yy_def[yy_current_state];
  670. if ( yy_current_state >= 158 )
  671.     yy_c = yy_meta[yy_c];
  672. }
  673.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  674.     ++yy_cp;
  675.     }
  676. while ( yy_current_state != 157 );
  677. yy_cp = yy_last_accepting_cpos;
  678. yy_current_state = yy_last_accepting_state;
  680. yy_find_action:
  681. yy_act = yy_accept[yy_current_state];
  683. YY_DO_BEFORE_ACTION;
  684. YY_USER_ACTION;
  686. do_action: /* this label is used only to access EOF actions */
  688. if ( yy_flex_debug )
  689.     {
  690.     if ( yy_act == 0 )
  691. fprintf( stderr, "--scanner backtrackingn" );
  692.     else if ( yy_act < 45 )
  693. fprintf( stderr, "--accepting rule at line %d ("%s")n",
  694.          yy_rule_linenum[yy_act], yytext );
  695.     else if ( yy_act == 45 )
  696. fprintf( stderr, "--accepting default rule ("%s")n",
  697.          yytext );
  698.     else if ( yy_act == 46 )
  699. fprintf( stderr, "--(end of buffer or a NUL)n" );
  700.     else
  701. fprintf( stderr, "--EOFn" );
  702.     }
  704. switch ( yy_act )
  705.     {
  706.     case 0: /* must backtrack */
  707.     /* undo the effects of YY_DO_BEFORE_ACTION */
  708.     *yy_cp = yy_hold_char;
  709.     yy_cp = yy_last_accepting_cpos;
  710.     yy_current_state = yy_last_accepting_state;
  711.     goto yy_find_action;
  713. case 1:
  714. # line 114 "scan_c.l"
  715. {
  716.                           esql_caller=C_lang;
  717.                           bline=line_num;
  718.                           BEGIN_MODE(ESQL);
  719. }
  720. YY_BREAK
  721. case 2:
  722. # line 119 "scan_c.l"
  723. {
  724.                           ECHO;
  725.   comment_caller=C_lang;
  726.   BEGIN_MODE(c_comment);
  727. }
  728. YY_BREAK
  729. case 3:
  730. # line 124 "scan_c.l"
  731. {
  732.                           ECHO;
  733.   BEGIN_MODE(C_str);
  734. }
  735. YY_BREAK
  736. case 4:
  737. # line 129 "scan_c.l"
  738. case 5:
  739. # line 129 "scan_c.l"
  740. { ECHO; }
  741. YY_BREAK
  742. case 6:
  743. # line 130 "scan_c.l"
  744. { ECHO; line_num++; }
  745. YY_BREAK
  746.   /*********************************************
  747.    *               C string recognizer         *
  748.    *********************************************/
  749. case 7:
  750. # line 134 "scan_c.l"
  751. { ECHO; BEGIN_MODE(C_lang); }
  752. YY_BREAK
  753. case 8:
  754. # line 135 "scan_c.l"
  755. { ECHO; }
  756. YY_BREAK
  757. case 9:
  758. # line 136 "scan_c.l"
  759. { ECHO; ++line_num; }
  760. YY_BREAK
  761. case 10:
  762. # line 137 "scan_c.l"
  763. { ECHO; }
  764. YY_BREAK
  765. case 11:
  766. # line 138 "scan_c.l"
  767. { 
  768.                            ECHO;
  769.                            yyerror("Unterminated C string");
  770.                            BEGIN_MODE(C_lang);
  771.                          }
  772. YY_BREAK
  773.   /*********************************************
  774.    *             C comment recornizer          *
  775.    *********************************************/
  776. case 12:
  777. # line 146 "scan_c.l"
  778. { if (comment_caller == C_lang) { ECHO; } }
  779. YY_BREAK
  780. case 13:
  781. # line 147 "scan_c.l"
  782. { if (comment_caller == C_lang) { ECHO; } }
  783. YY_BREAK
  784. case 14:
  785. # line 148 "scan_c.l"
  786. { if (comment_caller == C_lang) { ECHO; }
  787.                               line_num++;
  788.     }
  789. YY_BREAK
  790. case 15:
  791. # line 151 "scan_c.l"
  792. { if (comment_caller == C_lang)
  793. {
  794.   ECHO; 
  795. }
  796.       BEGIN_MODE(comment_caller);
  797.     }
  798. YY_BREAK
  799.   /*********************************************
  800.    *        lexics of embedded SQL in C        *
  801.    *********************************************/
  802. case 16:
  803. # line 161 "scan_c.l"
  804. { if(esql_caller==C_lang)
  805.     {
  806.       comment_caller=ESQL;
  807.       BEGIN_MODE(c_comment);
  808.     }
  809.                           else
  810.     yyerror("Lex: Unrecognizable literal'/*'n");
  811. }
  812. YY_BREAK
  813. case 17:
  814. # line 169 "scan_c.l"
  815. { 
  816.                           BEGIN_MODE(esql_caller);
  817.   POP_BUFFER;
  818.   SQL_PROC(ESQL); 
  819. }
  820. YY_BREAK
  821.   /*********************************************
  822.    *          embedded SQL lexics              *
  823.    *********************************************/
  824. case 18:
  825. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  826. yy_c_buf_p = yy_cp = yy_bp + 6;
  827. YY_DO_BEFORE_ACTION; /* set up yytext again */
  828. # line 178 "scan_c.l"
  829. {
  830.                            BEGIN_MODE(MOD);
  831.    APPEND_BUFFER;
  832.  }
  833. YY_BREAK
  834. case 19:
  835. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  836. yy_c_buf_p = yy_cp = yy_bp + 7;
  837. YY_DO_BEFORE_ACTION; /* set up yytext again */
  838. # line 182 "scan_c.l"
  839. { 
  840.                            POP_BUFFER;
  841.    APPEND_BUFFER;
  842.    SQL_PROC(MOD);
  843.  }
  844. YY_BREAK
  845. case 20:
  846. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  847. yy_c_buf_p = yy_cp = yy_bp + 9;
  848. YY_DO_BEFORE_ACTION; /* set up yytext again */
  849. # line 187 "scan_c.l"
  850. {
  851.    rout_title=1;
  852.    POP_BUFFER;
  853.    APPEND_BUFFER;
  854.    SQL_PROC(MOD);
  855.  }
  856. YY_BREAK
  857. case 21:
  858. # line 193 "scan_c.l"
  859. {
  860.                            APPEND_BUFFER;
  861.    if(rout_title)
  862.      rout_title=0;
  863.    else
  864.      {
  865.        POP_BUFFER;
  866.        SQL_PROC(MOD);
  867.      } 
  868.  }
  869. YY_BREAK
  870.   /*********************************************
  871.    *          clean  SQL SCH lexic             *
  872.    *********************************************/
  873. case 22:
  874. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  875. yy_c_buf_p = yy_cp -= 1;
  876. YY_DO_BEFORE_ACTION; /* set up yytext again */
  877. # line 207 "scan_c.l"
  878. {
  879.                             {
  880.                               BEGIN_MODE(SCH);
  881.                               POP_BUFFER;
  882.                               APPEND_BUFFER;
  883.                               if(first_start)
  884.                                 first_start=0;
  885.                               else
  886.                                 {
  887.                                   SQL_PROC(SCH);
  888.                                 }
  889.                             }                    }
  890. YY_BREAK
  891. case 23:
  892. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  893. yy_c_buf_p = yy_cp = yy_bp + 4;
  894. YY_DO_BEFORE_ACTION; /* set up yytext again */
  895. # line 219 "scan_c.l"
  896. {
  897.    APPEND_BUFFER;
  898.                            with_grant_options=1;
  899.  }
  900. YY_BREAK
  901. case 24:
  902. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  903. yy_c_buf_p = yy_cp = yy_bp + 5;
  904. YY_DO_BEFORE_ACTION; /* set up yytext again */
  905. # line 223 "scan_c.l"
  906. {
  907.                            if(with_grant_options)
  908.                              {
  909.        APPEND_BUFFER;
  910.        with_grant_options=0;
  911.      }
  912.                            else
  913.                              {
  914.        POP_BUFFER;
  915.        APPEND_BUFFER;
  916.        SQL_PROC(SCH);
  917.      }
  918.  }
  919. YY_BREAK
  920. case 25:
  921. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  922. yy_c_buf_p = yy_cp = yy_bp + 6;
  923. YY_DO_BEFORE_ACTION; /* set up yytext again */
  924. # line 236 "scan_c.l"
  925. {
  926.                            POP_BUFFER;
  927.    APPEND_BUFFER;
  928.    SQL_PROC(SCH);
  929.  }
  930. YY_BREAK
  931. case YY_STATE_EOF(SCH):
  932. # line 241 "scan_c.l"
  933. {
  934.                            POP_BUFFER;
  935.                            BEGIN(INITIAL);
  936.    SQL_PROC(SCH);
  937.  }
  938. YY_BREAK
  939.   /*********************************************
  940.    *          common SQL  keywords             *
  941.    *********************************************/
  942. case 27:
  943. # line 250 "scan_c.l"
  944. /* do nothing */;
  945. YY_BREAK
  946. case 28:
  947. # line 251 "scan_c.l"
  948. { APPEND_BUFFER; }
  949. YY_BREAK
  950. case 29:
  951. # line 252 "scan_c.l"
  952. {
  953.                            APPEND_BUFFER;
  954.    SWITCH_COND(SQL_str);
  955.  }
  956. YY_BREAK
  957. case 30:
  958. # line 256 "scan_c.l"
  959. {
  960.                            APPEND_BUFFER;
  961.    SWITCH_COND(SQL_ident);
  962.  }
  963. YY_BREAK
  964. case 31:
  965. # line 260 "scan_c.l"
  966. {
  967.                            SWITCH_COND(SQL_comment);  
  968.  }
  969. YY_BREAK
  970. case 32:
  971. # line 263 "scan_c.l"
  972. {
  973.                            APPEND_BUFFER;
  974.    line_num++; 
  975.  }
  976. YY_BREAK
  977. case 33:
  978. # line 267 "scan_c.l"
  979. { 
  980.                            APPEND_BUFFER;
  981.  }
  982. YY_BREAK
  983.   /*********************************************
  984.    *             SQL string recognizer         *
  985.    *********************************************/
  986. case 34:
  987. # line 273 "scan_c.l"
  988. { APPEND_BUFFER; }
  989. YY_BREAK
  990. case 35:
  991. # line 274 "scan_c.l"
  992. {
  993.                            yyerror(" Unterminated SQL string ");
  994.            line_num++; 
  995.    REST_COND;
  996.          }
  997. YY_BREAK
  998. case 36:
  999. # line 279 "scan_c.l"
  1000. { APPEND_BUFFER; }
  1001. YY_BREAK
  1002. case 37:
  1003. # line 280 "scan_c.l"
  1004. {
  1005.                            APPEND_BUFFER;
  1006.                            REST_COND;
  1007.  }
  1008. YY_BREAK
  1009.   /*********************************************
  1010.    *             SQL string recognizer         *
  1011.    *********************************************/
  1012. case 38:
  1013. # line 287 "scan_c.l"
  1014. {
  1015.                            yyerror(" Unterminated SQL identifier ");
  1016.            line_num++; 
  1017.    REST_COND;
  1018.          }
  1019. YY_BREAK
  1020. case 39:
  1021. # line 292 "scan_c.l"
  1022. { APPEND_BUFFER; }
  1023. YY_BREAK
  1024. case 40:
  1025. # line 293 "scan_c.l"
  1026. { APPEND_BUFFER; }
  1027. YY_BREAK
  1028. case 41:
  1029. # line 294 "scan_c.l"
  1030. {
  1031.    APPEND_BUFFER ;
  1032.                            REST_COND;
  1033.  }
  1034. YY_BREAK
  1035.   /*********************************************
  1036.    *             SQL comment recognizer        *
  1037.    *********************************************/
  1038. case 42:
  1039. # line 301 "scan_c.l"
  1040. /* do nothing */;
  1041. YY_BREAK
  1042. case 43:
  1043. # line 302 "scan_c.l"
  1044. {
  1045.                            line_num++;
  1046.    REST_COND;
  1047.  }
  1048. YY_BREAK
  1049. case 44:
  1050. # line 306 "scan_c.l"
  1051. { 
  1052.                            ECHO;
  1053.    BEGIN_MODE(C_lang);
  1054.  }
  1055. YY_BREAK
  1056. case 45:
  1057. # line 310 "scan_c.l"
  1058. ECHO;
  1059. YY_BREAK
  1060. case YY_STATE_EOF(INITIAL):
  1061. case YY_STATE_EOF(C_lang):
  1062. case YY_STATE_EOF(c_comment):
  1063. case YY_STATE_EOF(C_str):
  1064. case YY_STATE_EOF(ESQL):
  1065. case YY_STATE_EOF(MOD):
  1066. case YY_STATE_EOF(SQL):
  1067. case YY_STATE_EOF(SQL_str):
  1068. case YY_STATE_EOF(SQL_ident):
  1069. case YY_STATE_EOF(SQL_comment):
  1070.     yyterminate();
  1072.     case YY_END_OF_BUFFER:
  1073. {
  1074. /* amount of text matched not including the EOB char */
  1075. int yy_amount_of_matched_text = yy_cp - yytext - 1;
  1077. /* undo the effects of YY_DO_BEFORE_ACTION */
  1078. *yy_cp = yy_hold_char;
  1080. /* note that here we test for yy_c_buf_p "<=" to the position
  1081.  * of the first EOB in the buffer, since yy_c_buf_p will
  1082.  * already have been incremented past the NUL character
  1083.  * (since all states make transitions on EOB to the end-
  1084.  * of-buffer state).  Contrast this with the test in yyinput().
  1085.  */
  1086. if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1087.     /* this was really a NUL */
  1088.     {
  1089.     yy_state_type yy_next_state;
  1091.     yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1093.     yy_current_state = yy_get_previous_state();
  1095.     /* okay, we're now positioned to make the
  1096.      * NUL transition.  We couldn't have
  1097.      * yy_get_previous_state() go ahead and do it
  1098.      * for us because it doesn't know how to deal
  1099.      * with the possibility of jamming (and we
  1100.      * don't want to build jamming into it because
  1101.      * then it will run more slowly)
  1102.      */
  1104.     yy_next_state = yy_try_NUL_trans( yy_current_state );
  1106.     yy_bp = yytext + YY_MORE_ADJ;
  1108.     if ( yy_next_state )
  1109. {
  1110. /* consume the NUL */
  1111. yy_cp = ++yy_c_buf_p;
  1112. yy_current_state = yy_next_state;
  1113. goto yy_match;
  1114. }
  1116.     else
  1117. {
  1118.     yy_cp = yy_last_accepting_cpos;
  1119.     yy_current_state = yy_last_accepting_state;
  1120. goto yy_find_action;
  1121. }
  1122.     }
  1124. else switch ( yy_get_next_buffer() )
  1125.     {
  1126.     case EOB_ACT_END_OF_FILE:
  1127. {
  1128. yy_did_buffer_switch_on_eof = 0;
  1130. if ( yywrap() )
  1131.     {
  1132.     /* note: because we've taken care in
  1133.      * yy_get_next_buffer() to have set up yytext,
  1134.      * we can now set up yy_c_buf_p so that if some
  1135.      * total hoser (like flex itself) wants
  1136.      * to call the scanner after we return the
  1137.      * YY_NULL, it'll still work - another YY_NULL
  1138.      * will get returned.
  1139.      */
  1140.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  1142.     yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  1143.     goto do_action;
  1144.     }
  1146. else
  1147.     {
  1148.     if ( ! yy_did_buffer_switch_on_eof )
  1149. YY_NEW_FILE;
  1150.     }
  1151. }
  1152. break;
  1154.     case EOB_ACT_CONTINUE_SCAN:
  1155. yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1157. yy_current_state = yy_get_previous_state();
  1159. yy_cp = yy_c_buf_p;
  1160. yy_bp = yytext + YY_MORE_ADJ;
  1161. goto yy_match;
  1163.     case EOB_ACT_LAST_MATCH:
  1164. yy_c_buf_p =
  1165.     &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1167. yy_current_state = yy_get_previous_state();
  1169. yy_cp = yy_c_buf_p;
  1170. yy_bp = yytext + YY_MORE_ADJ;
  1171. goto yy_find_action;
  1172.     }
  1173. break;
  1174. }
  1176.     default:
  1177. #ifdef FLEX_DEBUG
  1178. printf( "action # %dn", yy_act );
  1179. #endif
  1180. YY_FATAL_ERROR(
  1181. "fatal flex scanner internal error--no action found" );
  1182.     }
  1183. }
  1184.     }
  1187. /* yy_get_next_buffer - try to read in a new buffer
  1188.  *
  1189.  * synopsis
  1190.  *     int yy_get_next_buffer();
  1191.  *     
  1192.  * returns a code representing an action
  1193.  *     EOB_ACT_LAST_MATCH - 
  1194.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1195.  *     EOB_ACT_END_OF_FILE - end of file
  1196.  */
  1198. static int yy_get_next_buffer()
  1200.     {
  1201.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  1202.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  1203.     register int number_to_move, i;
  1204.     int ret_val;
  1206.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1207. YY_FATAL_ERROR(
  1208. "fatal flex scanner internal error--end of buffer missed" );
  1210.     /* try to read more data */
  1212.     /* first move last chars to start of buffer */
  1213.     number_to_move = yy_c_buf_p - yytext;
  1215.     for ( i = 0; i < number_to_move; ++i )
  1216. *(dest++) = *(source++);
  1218.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  1219. /* don't do the read, it's not guaranteed to return an EOF,
  1220.  * just force an EOF
  1221.  */
  1222. yy_n_chars = 0;
  1224.     else
  1225. {
  1226. int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  1228. if ( num_to_read > YY_READ_BUF_SIZE )
  1229.     num_to_read = YY_READ_BUF_SIZE;
  1231. else if ( num_to_read <= 0 )
  1232.     YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  1234. /* read in more data */
  1235. YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1236.   yy_n_chars, num_to_read );
  1237. }
  1239.     if ( yy_n_chars == 0 )
  1240. {
  1241. if ( number_to_move - YY_MORE_ADJ == 1 )
  1242.     {
  1243.     ret_val = EOB_ACT_END_OF_FILE;
  1244.     yy_current_buffer->yy_eof_status = EOF_DONE;
  1245.     }
  1247. else
  1248.     {
  1249.     ret_val = EOB_ACT_LAST_MATCH;
  1250.     yy_current_buffer->yy_eof_status = EOF_PENDING;
  1251.     }
  1252. }
  1254.     else
  1255. ret_val = EOB_ACT_CONTINUE_SCAN;
  1257.     yy_n_chars += number_to_move;
  1258.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1259.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1261.     /* yytext begins at the second character in yy_ch_buf; the first
  1262.      * character is the one which preceded it before reading in the latest
  1263.      * buffer; it needs to be kept around in case it's a newline, so
  1264.      * yy_get_previous_state() will have with '^' rules active
  1265.      */
  1267.     yytext = &yy_current_buffer->yy_ch_buf[1];
  1269.     return ( ret_val );
  1270.     }
  1273. /* yy_get_previous_state - get the state just before the EOB char was reached
  1274.  *
  1275.  * synopsis
  1276.  *     yy_state_type yy_get_previous_state();
  1277.  */
  1279. static yy_state_type yy_get_previous_state()
  1281.     {
  1282.     register yy_state_type yy_current_state;
  1283.     register YY_CHAR *yy_cp;
  1285.     register YY_CHAR *yy_bp = yytext;
  1287.     yy_current_state = yy_start;
  1288.     if ( yy_bp[-1] == 'n' )
  1289. ++yy_current_state;
  1291.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1292. {
  1293. register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  1294. if ( yy_accept[yy_current_state] )
  1295.     {
  1296.     yy_last_accepting_state = yy_current_state;
  1297.     yy_last_accepting_cpos = yy_cp;
  1298.     }
  1299. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1300.     {
  1301.     yy_current_state = yy_def[yy_current_state];
  1302.     if ( yy_current_state >= 158 )
  1303. yy_c = yy_meta[yy_c];
  1304.     }
  1305. yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1306. }
  1308.     return ( yy_current_state );
  1309.     }
  1312. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1313.  *
  1314.  * synopsis
  1315.  *     next_state = yy_try_NUL_trans( current_state );
  1316.  */
  1318. #ifdef YY_USE_PROTOS
  1319. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  1320. #else
  1321. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1322. register yy_state_type yy_current_state;
  1323. #endif
  1325.     {
  1326.     register int yy_is_jam;
  1327.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1329.     register YY_CHAR yy_c = 1;
  1330.     if ( yy_accept[yy_current_state] )
  1331. {
  1332. yy_last_accepting_state = yy_current_state;
  1333. yy_last_accepting_cpos = yy_cp;
  1334. }
  1335.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1336. {
  1337. yy_current_state = yy_def[yy_current_state];
  1338. if ( yy_current_state >= 158 )
  1339.     yy_c = yy_meta[yy_c];
  1340. }
  1341.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1342.     yy_is_jam = (yy_current_state == 157);
  1344.     return ( yy_is_jam ? 0 : yy_current_state );
  1345.     }
  1348. #ifdef YY_USE_PROTOS
  1349. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1350. #else
  1351. static void yyunput( c, yy_bp )
  1352. YY_CHAR c;
  1353. register YY_CHAR *yy_bp;
  1354. #endif
  1356.     {
  1357.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1359.     /* undo effects of setting up yytext */
  1360.     *yy_cp = yy_hold_char;
  1362.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1363. { /* need to shift things up to make room */
  1364. register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  1365. register YY_CHAR *dest =
  1366.     &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  1367. register YY_CHAR *source =
  1368.     &yy_current_buffer->yy_ch_buf[number_to_move];
  1370. while ( source > yy_current_buffer->yy_ch_buf )
  1371.     *--dest = *--source;
  1373. yy_cp += dest - source;
  1374. yy_bp += dest - source;
  1375. yy_n_chars = yy_current_buffer->yy_buf_size;
  1377. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1378.     YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1379. }
  1381.     if ( yy_cp > yy_bp && yy_cp[-1] == 'n' )
  1382. yy_cp[-2] = 'n';
  1384.     *--yy_cp = c;
  1386.     /* note: the formal parameter *must* be called "yy_bp" for this
  1387.      *       macro to now work correctly
  1388.      */
  1389.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1390.     }
  1393. #ifdef __cplusplus
  1394. static int yyinput()
  1395. #else
  1396. static int input()
  1397. #endif
  1399.     {
  1400.     int c;
  1401.     YY_CHAR *yy_cp = yy_c_buf_p;
  1403.     *yy_cp = yy_hold_char;
  1405.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1406. {
  1407. /* yy_c_buf_p now points to the character we want to return.
  1408.  * If this occurs *before* the EOB characters, then it's a
  1409.  * valid NUL; if not, then we've hit the end of the buffer.
  1410.  */
  1411. if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1412.     /* this was really a NUL */
  1413.     *yy_c_buf_p = '';
  1415. else
  1416.     { /* need more input */
  1417.     yytext = yy_c_buf_p;
  1418.     ++yy_c_buf_p;
  1420.     switch ( yy_get_next_buffer() )
  1421. {
  1422. case EOB_ACT_END_OF_FILE:
  1423.     {
  1424.     if ( yywrap() )
  1425. {
  1426. yy_c_buf_p = yytext + YY_MORE_ADJ;
  1427. return ( EOF );
  1428. }
  1430.     YY_NEW_FILE;
  1432. #ifdef __cplusplus
  1433.     return ( yyinput() );
  1434. #else
  1435.     return ( input() );
  1436. #endif
  1437.     }
  1438.     break;
  1440. case EOB_ACT_CONTINUE_SCAN:
  1441.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  1442.     break;
  1444. case EOB_ACT_LAST_MATCH:
  1445. #ifdef __cplusplus
  1446.     YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1447. #else
  1448.     YY_FATAL_ERROR( "unexpected last match in input()" );
  1449. #endif
  1450. }
  1451.     }
  1452. }
  1454.     c = *yy_c_buf_p;
  1455.     yy_hold_char = *++yy_c_buf_p;
  1457.     return ( c );
  1458.     }
  1461. #ifdef YY_USE_PROTOS
  1462. void yyrestart( FILE *input_file )
  1463. #else
  1464. void yyrestart( input_file )
  1465. FILE *input_file;
  1466. #endif
  1468.     {
  1469.     yy_init_buffer( yy_current_buffer, input_file );
  1470.     yy_load_buffer_state();
  1471.     }
  1474. #ifdef YY_USE_PROTOS
  1475. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1476. #else
  1477. void yy_switch_to_buffer( new_buffer )
  1478. YY_BUFFER_STATE new_buffer;
  1479. #endif
  1481.     {
  1482.     if ( yy_current_buffer == new_buffer )
  1483. return;
  1485.     if ( yy_current_buffer )
  1486. {
  1487. /* flush out information for old buffer */
  1488. *yy_c_buf_p = yy_hold_char;
  1489. yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1490. yy_current_buffer->yy_n_chars = yy_n_chars;
  1491. }
  1493.     yy_current_buffer = new_buffer;
  1494.     yy_load_buffer_state();
  1496.     /* we don't actually know whether we did this switch during
  1497.      * EOF (yywrap()) processing, but the only time this flag
  1498.      * is looked at is after yywrap() is called, so it's safe
  1499.      * to go ahead and always set it.
  1500.      */
  1501.     yy_did_buffer_switch_on_eof = 1;
  1502.     }
  1505. #ifdef YY_USE_PROTOS
  1506. void yy_load_buffer_state( void )
  1507. #else
  1508. void yy_load_buffer_state()
  1509. #endif
  1511.     {
  1512.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1513.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1514.     yyin = yy_current_buffer->yy_input_file;
  1515.     yy_hold_char = *yy_c_buf_p;
  1516.     }
  1519. #ifdef YY_USE_PROTOS
  1520. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1521. #else
  1522. YY_BUFFER_STATE yy_create_buffer( file, size )
  1523. FILE *file;
  1524. int size;
  1525. #endif
  1527.     {
  1528.     YY_BUFFER_STATE b;
  1530.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1532.     if ( ! b )
  1533. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1535.     b->yy_buf_size = size;
  1537.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1538.      * we need to put in 2 end-of-buffer characters.
  1539.      */
  1540.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1542.     if ( ! b->yy_ch_buf )
  1543. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1545.     yy_init_buffer( b, file );
  1547.     return ( b );
  1548.     }
  1551. #ifdef YY_USE_PROTOS
  1552. void yy_delete_buffer( YY_BUFFER_STATE b )
  1553. #else
  1554. void yy_delete_buffer( b )
  1555. YY_BUFFER_STATE b;
  1556. #endif
  1558.     {
  1559.     if ( b == yy_current_buffer )
  1560. yy_current_buffer = (YY_BUFFER_STATE) 0;
  1562.     free( (char *) b->yy_ch_buf );
  1563.     free( (char *) b );
  1564.     }
  1567. #ifdef YY_USE_PROTOS
  1568. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1569. #else
  1570. void yy_init_buffer( b, file )
  1571. YY_BUFFER_STATE b;
  1572. FILE *file;
  1573. #endif
  1575.     {
  1576.     b->yy_input_file = file;
  1578.     /* we put in the 'n' and start reading from [1] so that an
  1579.      * initial match-at-newline will be true.
  1580.      */
  1582.     b->yy_ch_buf[0] = 'n';
  1583.     b->yy_n_chars = 1;
  1585.     /* we always need two end-of-buffer characters.  The first causes
  1586.      * a transition to the end-of-buffer state.  The second causes
  1587.      * a jam in that state.
  1588.      */
  1589.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1590.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1592.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1594.     b->yy_eof_status = EOF_NOT_SEEN;
  1595.     }
  1596. # line 310 "scan_c.l"
  1599. typedef struct save_yy_cond {
  1600.       int yy_cond;
  1601.       struct save_yy_cond *nxt;
  1602.     } *sv_ys_ptr;
  1604. static sv_ys_ptr save_yy_start=NULL;
  1606. static void
  1607. save_condition (void)
  1608. {
  1609.   register sv_ys_ptr nptr=(sv_ys_ptr)xmalloc(sizeof(struct save_yy_cond));
  1610.   nptr->yy_cond=yy_start;
  1611.   nptr->nxt=save_yy_start;
  1612.   save_yy_start=nptr;
  1613. #ifdef FLEX_DEBUG
  1614.   if(yy_flex_debug)
  1615.     fprintf(stderr,"n Lex: save condition :%d => (%d)n",
  1616.             yy_start,nptr->yy_cond);
  1617. #endif
  1618. }
  1620. static void
  1621. rest_condition(void)
  1622. {
  1623.   register sv_ys_ptr nptr=save_yy_start;
  1624.   if(nptr==NULL)
  1625.     fatal("Lex: Impossible restore conditions before save it !",NULL);
  1626.   yy_start=nptr->yy_cond;
  1627.   save_yy_start=nptr->nxt;
  1628. #ifdef FLEX_DEBUG
  1629.   if(yy_flex_debug)
  1630.     fprintf(stderr,"n Lex: restore condition :%d <=(%d)n",
  1631.             yy_start,nptr->yy_cond);
  1632. #endif
  1633.   xfree(nptr);
  1634. }
  1636. static struct
  1637. {
  1638.   char *mode;
  1639.   char *ext;
  1640.   int   state;
  1641. } scan_modes[] =
  1642. { 
  1643.   {"0"     ,"? ?",INITIAL},
  1644.   {"SQL"   ,"sql",SQL},
  1645.   {"MODULE","sql",MOD},
  1646.   {"SCHEMA","sql",SCH},
  1647.   {"C"     ,"ec" ,C_lang},
  1648.   {"DMP"   ,"trl",-1}
  1649. };
  1651. void
  1652. client_scan_mode(int *p,char *s)
  1653. { 
  1654.   register int k;
  1655.   if(!s)
  1656.     return;
  1657.   for(k=sizeof(scan_modes)/sizeof(*scan_modes);k--;)
  1658.     if(0==strcmp(s,scan_modes[k].mode))
  1659.        break;
  1660.   *p=scan_modes[k].state;
  1661. }
  1663. static void
  1664. outtype(char *text,int ins_directives)
  1665. {
  1666.   char *p;
  1667.   if (ins_directives & 1)
  1668.     fprintf (yyout,"
  1669.      progname_out);
  1670.   if (text)
  1671.     for (p = text; *p ; p++)
  1672.       if (*p != 'n')
  1673.         putc(*p,yyout);
  1674.       else
  1675.         {
  1676.           if (ins_directives & 4)
  1677.             {
  1678. #if __STDC__   /* we assume produced code will be compiled by the same compiler */
  1679.               fputs(""nt"",yyout);
  1680.               io_diff++;
  1681. #else
  1682.               while (*p == ' ' || *p == 'n' || *p == 't') p++;
  1683.               putc(' ',yyout); p--;
  1684. #endif
  1685.             }
  1686.           else
  1687.             {
  1688.               putc('n',yyout);
  1689.               io_diff++;
  1690.             }
  1691.         }
  1692.   if (ins_directives & 2)
  1693.     {
  1694.       fprintf(yyout,"
  1695.       io_diff++;
  1696.     }
  1697. }
  1700. int
  1701. scanner (void)
  1702. {
  1703.   extern int open_file  __P((FILE ** f, char *ext));
  1704.   int sm, oldsm;
  1705.   sm = 0;
  1706.   oldsm = scan_mode_state;
  1707.   
  1708.   if ( ( yyin = fopen (progname, "r") ) == NULL )
  1709.     {
  1710.       yyerror ("can't open input file");
  1711.       return 0;
  1712.     }
  1713.   if (open_file (&yyout, "c") )
  1714.     {
  1715.       char b[120];
  1716.       strcpy (b, sql_prg);
  1717.       strcat (b, ".c");
  1718.       progname_out = savestring (b);
  1719.     }
  1720.   else
  1721.     yyfatal ("Can't create .c output file");
  1722.   if (scan_mode_state == INITIAL)
  1723.     {
  1724.       register i4_t k;
  1725.       register char *pn = progname+strlen(progname);
  1726.       for (k = sizeof(scan_modes)/sizeof(*scan_modes); k--; )
  1727.         if (0 == strcmp(pn - strlen(scan_modes[k].ext),scan_modes[k].ext))
  1728.   break;
  1729.       scan_mode_state = scan_modes[k].state;
  1730.     }
  1731. #if 0  
  1732.   /*
  1733.    * analyzing for dump extension - 
  1734.    * may be load tree dump and continue processing from dumping point
  1735.    */
  1736.   if (scan_mode_state == INITIAL)
  1737.     {
  1738.       register int k;
  1739.       register char *pn = progname+strlen(progname);
  1740.       for (k = 0; compiler_passes[k].sname; k++)
  1741.         if (0 == strcmp(pn - strlen(compiler_passes[k].ext),compiler_passes[k].ext))
  1742.   { 
  1743.     scan_mode_state = -1;
  1744.     break;
  1745.   }
  1746.     }
  1747. #endif  
  1748.   yy_init = 1;
  1749.   io_diff = 0;
  1750.   line_num = 1;
  1751.   outtype ("/* This file is created automatically by gsql compiler */n"
  1752.    "#include <gnusql/sql.h>n"
  1753.    "#include "",0);
  1754.   outtype (sql_prg,0);
  1755.   outtype (".Sc"nn",2);
  1756.   while (SCANNER_NAME () )
  1757.     {
  1758.       extern char *prepare_statement(char *a,i4_t b,char **repl);
  1759.       char *repl = NULL;
  1760.       if (sm == 0)
  1761. {
  1762.   if(scan_mode_state == SCH)
  1763.             {
  1764.               int ln = line_num;
  1765.               line_num = 1;
  1766.               outtype ("n"
  1767.                        "#include "dyn_funcs.h"n"
  1768.                        "n"
  1769.                        "int main(int argc, char **argv) {n", 1);
  1770.               line_num = ln ;
  1771.             }
  1772.   sm = scan_mode_state;
  1773. }
  1774.       else
  1775. assert ((sm == scan_mode_state) || (sm == INITIAL));
  1776.       if (statement_scanner_buffer == NULL)
  1777. yyfatal ( "Unexpected null input line");
  1778.       if (sm == SCH) /* if we scan schema - there is no need to compile */
  1779.         {            /* anything now - let's do it all at run time      */
  1780.           outtype ("  SQL__execute_immediate ("", 0);
  1781.           outtype (statement_scanner_buffer, 4);
  1782.           outtype ("  ");n"
  1783.                    "  if(SQLCODE>0)n"
  1784.                    "    fprintf(stderr,"SQL warning:%s\n",gsqlca.errmsg);n"
  1785.                    "  if(SQLCODE<0){n"
  1786.                    "    fprintf(stderr,"SQL error:%s\n",gsqlca.errmsg);n"
  1787.                    "    goto errexit;n"
  1788.                    "  }n"
  1789.                    , 0);
  1790.         }
  1791.       else if ( ! prepare_statement (statement_scanner_buffer, bline,
  1792.                                      (sm == MOD? NULL:&repl)) )
  1793. return 0;
  1794.       io_diff -= line_num - bline;
  1795.       if (sm != MOD)
  1796.         outtype (repl, (sm == SCH) ? 0 : 3 );
  1797.       bline = line_num;
  1798.     }
  1799.   if (sm == SCH)
  1800.     outtype ("n"
  1801.              "  " CALL_COMMIT_str "n"
  1802.              "  return 0;n"
  1803.              " errexit:n"
  1804.              "  " CALL_ROLLBACK_str "n"
  1805.              "  return SQLCODE;n"
  1806.              "}n"
  1807.              "/* end of create schema routine */n"
  1808.              "n", 0);
  1809.   scan_mode_state = oldsm;
  1810.   if (yyin != stdin )
  1811.     fclose (yyin);
  1812.   fclose (yyout);
  1813.   return 1;
  1814. }
  1815. int yywrap() { return 1; }