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

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

SQL Server

开发平台：

Unix_Linux

monitor.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 "monitor.l"
  169. #define INITIAL 0
  170. # line 2 "monitor.l"
  171. /*
  172.  *  monitor.l - DB line monitor
  173.  *            
  174.  *  $Id: monitor.l,v 1.248 1997/04/03 14:36:10 kml Exp $
  175.  *
  176.  *  This file is a part of GNU SQL Server
  177.  *
  178.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  179.  *  Developed at the Institute of System Programming, Russia
  180.  *  This file is written by Michael Kimelman.
  181.  * 
  182.  *  This program is free software; you can redistribute it and/or modify
  183.  *  it under the terms of the GNU General Public License as published by
  184.  *  the Free Software Foundation; either version 2 of the License, or
  185.  *  (at your option) any later version.
  186.  *
  187.  *  This program is distributed in the hope that it will be useful,
  188.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  189.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  190.  *  GNU General Public License for more details.
  191.  *
  192.  *  You should have received a copy of the GNU General Public License
  193.  *  along with this program; if not, write to the Free Software
  194.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  195.  *
  196.  *  Contact:  gss@ispras.ru
  197.  *
  198.  */
  199.   
  200. #include "xmem.h"
  201. #include "sql_decl.h"
  202. #include "sql.h"
  203. #include "dyn_funcs.h"
  204. #include <assert.h>
  205.   
  207. #define SWITCH_COND(cond)  { save_condition();BEGIN(cond);}
  208. #define REST_COND            rest_condition();
  210. #define SCANNER_NAME      yylex_extractor
  212. #ifdef YY_DECL
  213. #  undef YY_DECL
  214. #endif
  215. #define YY_DECL           i4_t SCANNER_NAME(void)
  217. YY_DECL;
  219. #define SQL_PROC(code)  if(code){return code;}
  221. static str_buf c_scanner_buffer={0,0,NULL};
  222. #define sql_str(s,l)  buffer_string(&c_scanner_buffer,s,l)
  224. static void  save_condition(YY_PROTO(void));
  225. static void  rest_condition(YY_PROTO(void));
  227. static char *statement_scanner_buffer=NULL;
  229. #define APPEND_BUFFER { sql_str(yytext,yyleng);} 
  230. #define POP_BUFFER pop_cl_buffer()
  231. #define NEW_LINE        {
  232.   if (smth_done) fprintf(stderr,"(:%d)>",++line_num);
  233.   else           fprintf(stderr,"FreeSQL(:%d)>",++line_num); }
  235. void pop_cl_buffer(void)
  236. {
  237.   register char *b=sql_str(NULL,0);
  238.   statement_scanner_buffer= (b?savestring(b):NULL);
  239. }
  241. #define SQL_str 1
  242. #define SQL_comment 2
  243. #define Start 3
  244. # line 84 "monitor.l"
  246. /* done after the current pattern has been matched and before the
  247.  * corresponding action - sets up yytext
  248.  */
  249. #define YY_DO_BEFORE_ACTION 
  250. yytext = yy_bp; 
  251. yyleng = yy_cp - yy_bp; 
  252. yy_hold_char = *yy_cp; 
  253. *yy_cp = ''; 
  254. yy_c_buf_p = yy_cp;
  256. #define EOB_ACT_CONTINUE_SCAN 0
  257. #define EOB_ACT_END_OF_FILE 1
  258. #define EOB_ACT_LAST_MATCH 2
  260. /* return all but the first 'n' matched characters back to the input stream */
  261. #define yyless(n) 
  262. do 
  263. { 
  264. /* undo effects of setting up yytext */ 
  265. *yy_cp = yy_hold_char; 
  266. yy_c_buf_p = yy_cp = yy_bp + n; 
  267. YY_DO_BEFORE_ACTION; /* set up yytext again */ 
  268. } 
  269. while ( 0 )
  271. #define unput(c) yyunput( c, yytext )
  274. struct yy_buffer_state
  275.     {
  276.     FILE *yy_input_file;
  278.     YY_CHAR *yy_ch_buf; /* input buffer */
  279.     YY_CHAR *yy_buf_pos; /* current position in input buffer */
  281.     /* size of input buffer in bytes, not including room for EOB characters */
  282.     int yy_buf_size;
  284.     /* number of characters read into yy_ch_buf, not including EOB characters */
  285.     int yy_n_chars;
  287.     int yy_eof_status; /* whether we've seen an EOF on this buffer */
  288. #define EOF_NOT_SEEN 0
  289.     /* "pending" happens when the EOF has been seen but there's still
  290.      * some text process
  291.      */
  292. #define EOF_PENDING 1
  293. #define EOF_DONE 2
  294.     };
  296. static YY_BUFFER_STATE yy_current_buffer;
  298. /* we provide macros for accessing buffer states in case in the
  299.  * future we want to put the buffer states in a more general
  300.  * "scanner state"
  301.  */
  302. #define YY_CURRENT_BUFFER yy_current_buffer
  305. /* yy_hold_char holds the character lost when yytext is formed */
  306. static YY_CHAR yy_hold_char;
  308. static int yy_n_chars; /* number of characters read into yy_ch_buf */
  312. #ifndef YY_USER_ACTION
  313. #define YY_USER_ACTION
  314. #endif
  316. #ifndef YY_USER_INIT
  317. #define YY_USER_INIT
  318. #endif
  320. extern YY_CHAR *yytext;
  321. extern int yyleng;
  322. extern FILE *yyin, *yyout;
  324. YY_CHAR *yytext;
  325. int yyleng;
  327. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  329. #define YY_END_OF_BUFFER 17
  330. typedef int yy_state_type;
  331. static const short int yy_accept[29] =
  332.     {   0,
  333.         0,    0,    0,    0,    0,    0,    0,    0,   17,    7,
  334.         2,    6,    4,    3,    7,    1,   10,    9,   12,   13,
  335.        14,   15,    2,    5,   10,   11,    8,    0
  336.     } ;
  338. static const YY_CHAR yy_ec[256] =
  339.     {   0,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  341.         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.         1,    2,    1,    4,    1,    1,    1,    1,    5,    1,
  344.         1,    1,    1,    1,    6,    1,    1,    1,    1,    1,
  345.         1,    1,    1,    1,    1,    1,    1,    1,    7,    1,
  346.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  347.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  352.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  353.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  354.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  355.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  356.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  357.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  358.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  359.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  360.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  362.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  363.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  364.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  365.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  366.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  367.         1,    1,    1,    1,    1
  368.     } ;
  370. static const YY_CHAR yy_meta[8] =
  371.     {   0,
  372.         1,    1,    2,    2,    2,    1,    1
  373.     } ;
  375. static const short int yy_base[31] =
  376.     {   0,
  377.         0,    0,    7,    0,   22,   21,    0,    0,   23,   26,
  378.        20,   26,   26,   26,   15,   26,    0,   26,   16,   14,
  379.        26,   26,   16,   26,    0,   26,   26,   26,   14,   16
  380.     } ;
  382. static const short int yy_def[31] =
  383.     {   0,
  384.        28,    1,   28,    3,   29,   29,    1,    1,   28,   28,
  385.        28,   28,   28,   28,   28,   28,   30,   28,   28,   28,
  386.        28,   28,   28,   28,   30,   28,   28,    0,   28,   28
  387.     } ;
  389. static const short int yy_nxt[34] =
  390.     {   0,
  391.        10,   11,   12,   13,   14,   15,   16,   17,   17,   18,
  392.        19,   20,   17,   17,   21,   21,   25,   23,   27,   26,
  393.        24,   23,   28,   22,   22,    9,   28,   28,   28,   28,
  394.        28,   28,   28
  395.     } ;
  397. static const short int yy_chk[34] =
  398.     {   0,
  399.         1,    1,    1,    1,    1,    1,    1,    3,    3,    3,
  400.         3,    3,    3,    3,   29,   29,   30,   23,   20,   19,
  401.        15,   11,    9,    6,    5,   28,   28,   28,   28,   28,
  402.        28,   28,   28
  403.     } ;
  405. static yy_state_type yy_last_accepting_state;
  406. static YY_CHAR *yy_last_accepting_cpos;
  408. extern int yy_flex_debug;
  409. int yy_flex_debug = 1;
  411. static const short int yy_rule_linenum[16] =
  412.     {   0,
  413.        93,   97,   98,  103,  109,  112,  119,  126,  127,  132,
  414.       133,  134,  142,  152,  153
  415.     } ;
  417. /* the intent behind this definition is that it'll catch
  418.  * any uses of REJECT which flex missed
  419.  */
  420. #define REJECT reject_used_but_not_detected
  421. #define yymore() yymore_used_but_not_detected
  422. #define YY_MORE_ADJ 0
  424. /* these variables are all declared out here so that section 3 code can
  425.  * manipulate them
  426.  */
  427. /* points to current character in buffer */
  428. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  429. static int yy_init = 1; /* whether we need to initialize */
  430. static int yy_start = 0; /* start state number */
  432. /* flag which is used to allow yywrap()'s to do buffer switches
  433.  * instead of setting up a fresh yyin.  A bit of a hack ...
  434.  */
  435. static int yy_did_buffer_switch_on_eof;
  437. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  438. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  439. static int yy_get_next_buffer YY_PROTO(( void ));
  440. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  441. void yyrestart YY_PROTO(( FILE *input_file ));
  442. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  443. void yy_load_buffer_state YY_PROTO(( void ));
  444. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  445. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  446. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  448. #define yy_new_buffer yy_create_buffer
  450. #ifdef __cplusplus
  451. static int yyinput YY_PROTO(( void ));
  452. #else
  453. static int input YY_PROTO(( void ));
  454. #endif
  456. YY_DECL
  457.     {
  458.     register yy_state_type yy_current_state;
  459.     register YY_CHAR *yy_cp, *yy_bp;
  460.     register int yy_act;
  463.     i4_t sql_str_d_quote=0;
  464.     static i4_t line_num = 0;
  465.     i4_t smth_done = 0;
  467.                          NEW_LINE;
  468.   /*********************************************
  469.    *        lexics of embedded SQL in C        *
  470.    *********************************************/
  472.     if ( yy_init )
  473. {
  474. YY_USER_INIT;
  476. if ( ! yy_start )
  477.     yy_start = 1; /* first start state */
  479. if ( ! yyin )
  480.     yyin = stdin;
  482. if ( ! yyout )
  483.     yyout = stdout;
  485. if ( yy_current_buffer )
  486.     yy_init_buffer( yy_current_buffer, yyin );
  487. else
  488.     yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  490. yy_load_buffer_state();
  492. yy_init = 0;
  493. }
  495.     while ( 1 ) /* loops until end-of-file is reached */
  496. {
  497. yy_cp = yy_c_buf_p;
  499. /* support of yytext */
  500. *yy_cp = yy_hold_char;
  502. /* yy_bp points to the position in yy_ch_buf of the start of the
  503.  * current run.
  504.  */
  505. yy_bp = yy_cp;
  507. yy_current_state = yy_start;
  508. yy_match:
  509. do
  510.     {
  511.     register YY_CHAR yy_c = yy_ec[*yy_cp];
  512.     if ( yy_accept[yy_current_state] )
  513. {
  514. yy_last_accepting_state = yy_current_state;
  515. yy_last_accepting_cpos = yy_cp;
  516. }
  517.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  518. {
  519. yy_current_state = yy_def[yy_current_state];
  520. if ( yy_current_state >= 29 )
  521.     yy_c = yy_meta[yy_c];
  522. }
  523.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  524.     ++yy_cp;
  525.     }
  526. while ( yy_current_state != 28 );
  527. yy_cp = yy_last_accepting_cpos;
  528. yy_current_state = yy_last_accepting_state;
  530. yy_find_action:
  531. yy_act = yy_accept[yy_current_state];
  533. YY_DO_BEFORE_ACTION;
  534. YY_USER_ACTION;
  536. do_action: /* this label is used only to access EOF actions */
  538. if ( yy_flex_debug )
  539.     {
  540.     if ( yy_act == 0 )
  541. fprintf( stderr, "--scanner backtrackingn" );
  542.     else if ( yy_act < 16 )
  543. fprintf( stderr, "--accepting rule at line %d ("%s")n",
  544.          yy_rule_linenum[yy_act], yytext );
  545.     else if ( yy_act == 16 )
  546. fprintf( stderr, "--accepting default rule ("%s")n",
  547.          yytext );
  548.     else if ( yy_act == 17 )
  549. fprintf( stderr, "--(end of buffer or a NUL)n" );
  550.     else
  551. fprintf( stderr, "--EOFn" );
  552.     }
  554. switch ( yy_act )
  555.     {
  556.     case 0: /* must backtrack */
  557.     /* undo the effects of YY_DO_BEFORE_ACTION */
  558.     *yy_cp = yy_hold_char;
  559.     yy_cp = yy_last_accepting_cpos;
  560.     yy_current_state = yy_last_accepting_state;
  561.     goto yy_find_action;
  563. case 1:
  564. # line 93 "monitor.l"
  565. {
  566.    POP_BUFFER;
  567.    SQL_PROC(1); 
  568.  }
  569. YY_BREAK
  570. case 2:
  571. # line 97 "monitor.l"
  572. { if(smth_done) { APPEND_BUFFER; } }
  573. YY_BREAK
  574. case 3:
  575. # line 98 "monitor.l"
  576. {
  577.                            APPEND_BUFFER;
  578.                            smth_done = 1;
  579.    SWITCH_COND(SQL_str);
  580.  }
  581. YY_BREAK
  582. case 4:
  583. # line 103 "monitor.l"
  584. {
  585.                            APPEND_BUFFER;
  586.                            smth_done = 1;
  587.    sql_str_d_quote=1;
  588.    SWITCH_COND(SQL_str);
  589.  }
  590. YY_BREAK
  591. case 5:
  592. # line 109 "monitor.l"
  593. {
  594.                            SWITCH_COND(SQL_comment);  
  595.  }
  596. YY_BREAK
  597. case 6:
  598. # line 112 "monitor.l"
  599. {
  600.                            if (smth_done)
  601.                              {
  602.                                APPEND_BUFFER;
  603.                              }
  604.                            NEW_LINE;
  605.  }
  606. YY_BREAK
  607. case 7:
  608. # line 119 "monitor.l"
  609. {
  610.                            APPEND_BUFFER;
  611.                            smth_done = 1;
  612.  }
  613. YY_BREAK
  614.   /*********************************************
  615.    *             SQL string recognizer         *
  616.    *********************************************/
  617. case 8:
  618. # line 126 "monitor.l"
  619. { APPEND_BUFFER; }
  620. YY_BREAK
  621. case 9:
  622. # line 127 "monitor.l"
  623. {
  624.                            yyerror(" Unterminated SQL string ");
  625.                            NEW_LINE;
  626.    REST_COND;
  627.          }
  628. YY_BREAK
  629. case 10:
  630. # line 132 "monitor.l"
  631. { APPEND_BUFFER; }
  632. YY_BREAK
  633. case 11:
  634. # line 133 "monitor.l"
  635. { APPEND_BUFFER; }
  636. YY_BREAK
  637. case 12:
  638. # line 134 "monitor.l"
  639. {
  640.    APPEND_BUFFER ;
  641.            if(sql_str_d_quote) 
  642.                              {
  643.        sql_str_d_quote=0;
  644.        REST_COND;
  645.      }
  646.  }
  647. YY_BREAK
  648. case 13:
  649. # line 142 "monitor.l"
  650. {
  651.                            APPEND_BUFFER;
  652.    if(!sql_str_d_quote) 
  653.      {
  654.        REST_COND;
  655.      }
  656.  }
  657. YY_BREAK
  658.   /*********************************************
  659.    *             SQL comment recognizer        *
  660.    *********************************************/
  661. case 14:
  662. # line 152 "monitor.l"
  663. /* do nothing */;
  664. YY_BREAK
  665. case 15:
  666. # line 153 "monitor.l"
  667. {
  668.                            NEW_LINE;
  669.    REST_COND;
  670.  }
  671. YY_BREAK
  672. case 16:
  673. # line 157 "monitor.l"
  674. ECHO;
  675. YY_BREAK
  676. case YY_STATE_EOF(INITIAL):
  677. case YY_STATE_EOF(SQL_str):
  678. case YY_STATE_EOF(SQL_comment):
  679. case YY_STATE_EOF(Start):
  680.     yyterminate();
  682.     case YY_END_OF_BUFFER:
  683. {
  684. /* amount of text matched not including the EOB char */
  685. int yy_amount_of_matched_text = yy_cp - yytext - 1;
  687. /* undo the effects of YY_DO_BEFORE_ACTION */
  688. *yy_cp = yy_hold_char;
  690. /* note that here we test for yy_c_buf_p "<=" to the position
  691.  * of the first EOB in the buffer, since yy_c_buf_p will
  692.  * already have been incremented past the NUL character
  693.  * (since all states make transitions on EOB to the end-
  694.  * of-buffer state).  Contrast this with the test in yyinput().
  695.  */
  696. if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  697.     /* this was really a NUL */
  698.     {
  699.     yy_state_type yy_next_state;
  701.     yy_c_buf_p = yytext + yy_amount_of_matched_text;
  703.     yy_current_state = yy_get_previous_state();
  705.     /* okay, we're now positioned to make the
  706.      * NUL transition.  We couldn't have
  707.      * yy_get_previous_state() go ahead and do it
  708.      * for us because it doesn't know how to deal
  709.      * with the possibility of jamming (and we
  710.      * don't want to build jamming into it because
  711.      * then it will run more slowly)
  712.      */
  714.     yy_next_state = yy_try_NUL_trans( yy_current_state );
  716.     yy_bp = yytext + YY_MORE_ADJ;
  718.     if ( yy_next_state )
  719. {
  720. /* consume the NUL */
  721. yy_cp = ++yy_c_buf_p;
  722. yy_current_state = yy_next_state;
  723. goto yy_match;
  724. }
  726.     else
  727. {
  728.     yy_cp = yy_last_accepting_cpos;
  729.     yy_current_state = yy_last_accepting_state;
  730. goto yy_find_action;
  731. }
  732.     }
  734. else switch ( yy_get_next_buffer() )
  735.     {
  736.     case EOB_ACT_END_OF_FILE:
  737. {
  738. yy_did_buffer_switch_on_eof = 0;
  740. if ( yywrap() )
  741.     {
  742.     /* note: because we've taken care in
  743.      * yy_get_next_buffer() to have set up yytext,
  744.      * we can now set up yy_c_buf_p so that if some
  745.      * total hoser (like flex itself) wants
  746.      * to call the scanner after we return the
  747.      * YY_NULL, it'll still work - another YY_NULL
  748.      * will get returned.
  749.      */
  750.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  752.     yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  753.     goto do_action;
  754.     }
  756. else
  757.     {
  758.     if ( ! yy_did_buffer_switch_on_eof )
  759. YY_NEW_FILE;
  760.     }
  761. }
  762. break;
  764.     case EOB_ACT_CONTINUE_SCAN:
  765. yy_c_buf_p = yytext + yy_amount_of_matched_text;
  767. yy_current_state = yy_get_previous_state();
  769. yy_cp = yy_c_buf_p;
  770. yy_bp = yytext + YY_MORE_ADJ;
  771. goto yy_match;
  773.     case EOB_ACT_LAST_MATCH:
  774. yy_c_buf_p =
  775.     &yy_current_buffer->yy_ch_buf[yy_n_chars];
  777. yy_current_state = yy_get_previous_state();
  779. yy_cp = yy_c_buf_p;
  780. yy_bp = yytext + YY_MORE_ADJ;
  781. goto yy_find_action;
  782.     }
  783. break;
  784. }
  786.     default:
  787. #ifdef FLEX_DEBUG
  788. printf( "action # %dn", yy_act );
  789. #endif
  790. YY_FATAL_ERROR(
  791. "fatal flex scanner internal error--no action found" );
  792.     }
  793. }
  794.     }
  797. /* yy_get_next_buffer - try to read in a new buffer
  798.  *
  799.  * synopsis
  800.  *     int yy_get_next_buffer();
  801.  *     
  802.  * returns a code representing an action
  803.  *     EOB_ACT_LAST_MATCH - 
  804.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  805.  *     EOB_ACT_END_OF_FILE - end of file
  806.  */
  808. static int yy_get_next_buffer()
  810.     {
  811.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  812.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  813.     register int number_to_move, i;
  814.     int ret_val;
  816.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  817. YY_FATAL_ERROR(
  818. "fatal flex scanner internal error--end of buffer missed" );
  820.     /* try to read more data */
  822.     /* first move last chars to start of buffer */
  823.     number_to_move = yy_c_buf_p - yytext;
  825.     for ( i = 0; i < number_to_move; ++i )
  826. *(dest++) = *(source++);
  828.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  829. /* don't do the read, it's not guaranteed to return an EOF,
  830.  * just force an EOF
  831.  */
  832. yy_n_chars = 0;
  834.     else
  835. {
  836. int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  838. if ( num_to_read > YY_READ_BUF_SIZE )
  839.     num_to_read = YY_READ_BUF_SIZE;
  841. else if ( num_to_read <= 0 )
  842.     YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  844. /* read in more data */
  845. YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  846.   yy_n_chars, num_to_read );
  847. }
  849.     if ( yy_n_chars == 0 )
  850. {
  851. if ( number_to_move - YY_MORE_ADJ == 1 )
  852.     {
  853.     ret_val = EOB_ACT_END_OF_FILE;
  854.     yy_current_buffer->yy_eof_status = EOF_DONE;
  855.     }
  857. else
  858.     {
  859.     ret_val = EOB_ACT_LAST_MATCH;
  860.     yy_current_buffer->yy_eof_status = EOF_PENDING;
  861.     }
  862. }
  864.     else
  865. ret_val = EOB_ACT_CONTINUE_SCAN;
  867.     yy_n_chars += number_to_move;
  868.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  869.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  871.     /* yytext begins at the second character in yy_ch_buf; the first
  872.      * character is the one which preceded it before reading in the latest
  873.      * buffer; it needs to be kept around in case it's a newline, so
  874.      * yy_get_previous_state() will have with '^' rules active
  875.      */
  877.     yytext = &yy_current_buffer->yy_ch_buf[1];
  879.     return ( ret_val );
  880.     }
  883. /* yy_get_previous_state - get the state just before the EOB char was reached
  884.  *
  885.  * synopsis
  886.  *     yy_state_type yy_get_previous_state();
  887.  */
  889. static yy_state_type yy_get_previous_state()
  891.     {
  892.     register yy_state_type yy_current_state;
  893.     register YY_CHAR *yy_cp;
  895.     yy_current_state = yy_start;
  897.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  898. {
  899. register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  900. if ( yy_accept[yy_current_state] )
  901.     {
  902.     yy_last_accepting_state = yy_current_state;
  903.     yy_last_accepting_cpos = yy_cp;
  904.     }
  905. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  906.     {
  907.     yy_current_state = yy_def[yy_current_state];
  908.     if ( yy_current_state >= 29 )
  909. yy_c = yy_meta[yy_c];
  910.     }
  911. yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  912. }
  914.     return ( yy_current_state );
  915.     }
  918. /* yy_try_NUL_trans - try to make a transition on the NUL character
  919.  *
  920.  * synopsis
  921.  *     next_state = yy_try_NUL_trans( current_state );
  922.  */
  924. #ifdef YY_USE_PROTOS
  925. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  926. #else
  927. static yy_state_type yy_try_NUL_trans( yy_current_state )
  928. register yy_state_type yy_current_state;
  929. #endif
  931.     {
  932.     register int yy_is_jam;
  933.     register YY_CHAR *yy_cp = yy_c_buf_p;
  935.     register YY_CHAR yy_c = 1;
  936.     if ( yy_accept[yy_current_state] )
  937. {
  938. yy_last_accepting_state = yy_current_state;
  939. yy_last_accepting_cpos = yy_cp;
  940. }
  941.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  942. {
  943. yy_current_state = yy_def[yy_current_state];
  944. if ( yy_current_state >= 29 )
  945.     yy_c = yy_meta[yy_c];
  946. }
  947.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  948.     yy_is_jam = (yy_current_state == 28);
  950.     return ( yy_is_jam ? 0 : yy_current_state );
  951.     }
  954. #ifdef YY_USE_PROTOS
  955. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  956. #else
  957. static void yyunput( c, yy_bp )
  958. YY_CHAR c;
  959. register YY_CHAR *yy_bp;
  960. #endif
  962.     {
  963.     register YY_CHAR *yy_cp = yy_c_buf_p;
  965.     /* undo effects of setting up yytext */
  966.     *yy_cp = yy_hold_char;
  968.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  969. { /* need to shift things up to make room */
  970. register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  971. register YY_CHAR *dest =
  972.     &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  973. register YY_CHAR *source =
  974.     &yy_current_buffer->yy_ch_buf[number_to_move];
  976. while ( source > yy_current_buffer->yy_ch_buf )
  977.     *--dest = *--source;
  979. yy_cp += dest - source;
  980. yy_bp += dest - source;
  981. yy_n_chars = yy_current_buffer->yy_buf_size;
  983. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  984.     YY_FATAL_ERROR( "flex scanner push-back overflow" );
  985. }
  987.     if ( yy_cp > yy_bp && yy_cp[-1] == 'n' )
  988. yy_cp[-2] = 'n';
  990.     *--yy_cp = c;
  992.     /* note: the formal parameter *must* be called "yy_bp" for this
  993.      *       macro to now work correctly
  994.      */
  995.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  996.     }
  999. #ifdef __cplusplus
  1000. static int yyinput()
  1001. #else
  1002. static int input()
  1003. #endif
  1005.     {
  1006.     int c;
  1007.     YY_CHAR *yy_cp = yy_c_buf_p;
  1009.     *yy_cp = yy_hold_char;
  1011.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1012. {
  1013. /* yy_c_buf_p now points to the character we want to return.
  1014.  * If this occurs *before* the EOB characters, then it's a
  1015.  * valid NUL; if not, then we've hit the end of the buffer.
  1016.  */
  1017. if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1018.     /* this was really a NUL */
  1019.     *yy_c_buf_p = '';
  1021. else
  1022.     { /* need more input */
  1023.     yytext = yy_c_buf_p;
  1024.     ++yy_c_buf_p;
  1026.     switch ( yy_get_next_buffer() )
  1027. {
  1028. case EOB_ACT_END_OF_FILE:
  1029.     {
  1030.     if ( yywrap() )
  1031. {
  1032. yy_c_buf_p = yytext + YY_MORE_ADJ;
  1033. return ( EOF );
  1034. }
  1036.     YY_NEW_FILE;
  1038. #ifdef __cplusplus
  1039.     return ( yyinput() );
  1040. #else
  1041.     return ( input() );
  1042. #endif
  1043.     }
  1044.     break;
  1046. case EOB_ACT_CONTINUE_SCAN:
  1047.     yy_c_buf_p = yytext + YY_MORE_ADJ;
  1048.     break;
  1050. case EOB_ACT_LAST_MATCH:
  1051. #ifdef __cplusplus
  1052.     YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1053. #else
  1054.     YY_FATAL_ERROR( "unexpected last match in input()" );
  1055. #endif
  1056. }
  1057.     }
  1058. }
  1060.     c = *yy_c_buf_p;
  1061.     yy_hold_char = *++yy_c_buf_p;
  1063.     return ( c );
  1064.     }
  1067. #ifdef YY_USE_PROTOS
  1068. void yyrestart( FILE *input_file )
  1069. #else
  1070. void yyrestart( input_file )
  1071. FILE *input_file;
  1072. #endif
  1074.     {
  1075.     yy_init_buffer( yy_current_buffer, input_file );
  1076.     yy_load_buffer_state();
  1077.     }
  1080. #ifdef YY_USE_PROTOS
  1081. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1082. #else
  1083. void yy_switch_to_buffer( new_buffer )
  1084. YY_BUFFER_STATE new_buffer;
  1085. #endif
  1087.     {
  1088.     if ( yy_current_buffer == new_buffer )
  1089. return;
  1091.     if ( yy_current_buffer )
  1092. {
  1093. /* flush out information for old buffer */
  1094. *yy_c_buf_p = yy_hold_char;
  1095. yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1096. yy_current_buffer->yy_n_chars = yy_n_chars;
  1097. }
  1099.     yy_current_buffer = new_buffer;
  1100.     yy_load_buffer_state();
  1102.     /* we don't actually know whether we did this switch during
  1103.      * EOF (yywrap()) processing, but the only time this flag
  1104.      * is looked at is after yywrap() is called, so it's safe
  1105.      * to go ahead and always set it.
  1106.      */
  1107.     yy_did_buffer_switch_on_eof = 1;
  1108.     }
  1111. #ifdef YY_USE_PROTOS
  1112. void yy_load_buffer_state( void )
  1113. #else
  1114. void yy_load_buffer_state()
  1115. #endif
  1117.     {
  1118.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1119.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1120.     yyin = yy_current_buffer->yy_input_file;
  1121.     yy_hold_char = *yy_c_buf_p;
  1122.     }
  1125. #ifdef YY_USE_PROTOS
  1126. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1127. #else
  1128. YY_BUFFER_STATE yy_create_buffer( file, size )
  1129. FILE *file;
  1130. int size;
  1131. #endif
  1133.     {
  1134.     YY_BUFFER_STATE b;
  1136.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1138.     if ( ! b )
  1139. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1141.     b->yy_buf_size = size;
  1143.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1144.      * we need to put in 2 end-of-buffer characters.
  1145.      */
  1146.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1148.     if ( ! b->yy_ch_buf )
  1149. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1151.     yy_init_buffer( b, file );
  1153.     return ( b );
  1154.     }
  1157. #ifdef YY_USE_PROTOS
  1158. void yy_delete_buffer( YY_BUFFER_STATE b )
  1159. #else
  1160. void yy_delete_buffer( b )
  1161. YY_BUFFER_STATE b;
  1162. #endif
  1164.     {
  1165.     if ( b == yy_current_buffer )
  1166. yy_current_buffer = (YY_BUFFER_STATE) 0;
  1168.     free( (char *) b->yy_ch_buf );
  1169.     free( (char *) b );
  1170.     }
  1173. #ifdef YY_USE_PROTOS
  1174. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1175. #else
  1176. void yy_init_buffer( b, file )
  1177. YY_BUFFER_STATE b;
  1178. FILE *file;
  1179. #endif
  1181.     {
  1182.     b->yy_input_file = file;
  1184.     /* we put in the 'n' and start reading from [1] so that an
  1185.      * initial match-at-newline will be true.
  1186.      */
  1188.     b->yy_ch_buf[0] = 'n';
  1189.     b->yy_n_chars = 1;
  1191.     /* we always need two end-of-buffer characters.  The first causes
  1192.      * a transition to the end-of-buffer state.  The second causes
  1193.      * a jam in that state.
  1194.      */
  1195.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1196.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1198.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1200.     b->yy_eof_status = EOF_NOT_SEEN;
  1201.     }
  1202. # line 157 "monitor.l"
  1205. typedef struct save_yy_cond {
  1206.       i4_t yy_cond;
  1207.       struct save_yy_cond *nxt;
  1208.     } *sv_ys_ptr;
  1210. static sv_ys_ptr save_yy_start=NULL;
  1212. static void
  1213. save_condition(YY_PROTO(void))
  1214. {
  1215.   register sv_ys_ptr nptr=(sv_ys_ptr)xmalloc(sizeof(struct save_yy_cond));
  1216.   nptr->yy_cond=yy_start;
  1217.   nptr->nxt=save_yy_start;
  1218.   save_yy_start=nptr;
  1219. #ifdef FLEX_DEBUG
  1220.   if(yy_flex_debug)
  1221.     fprintf(stderr,"n Lex: save condition :%d => (%d)n",
  1222.             yy_start,nptr->yy_cond);
  1223. #endif
  1224. }
  1226. static void
  1227. rest_condition(YY_PROTO(void))
  1228. {
  1229.   register sv_ys_ptr nptr=save_yy_start;
  1230.   if(nptr==NULL)
  1231.     fatal("Lex: Impossible restore conditions before save it !",NULL);
  1232.   yy_start=nptr->yy_cond;
  1233.   save_yy_start=nptr->nxt;
  1234. #ifdef FLEX_DEBUG
  1235.   if(yy_flex_debug)
  1236.     fprintf(stderr,"n Lex: restore condition :%d <=(%d)n",
  1237.             yy_start,nptr->yy_cond);
  1238. #endif
  1239.   xfree(nptr);
  1240. }
  1242. int
  1243. print_width(dyn_sql_type_code_t t,int len)
  1244. {
  1245.   switch(t)
  1246.     {
  1247.     case SQL__Long  : 
  1248.     case SQL__Real  : return 10;
  1249.     case SQL__Short : return  5;
  1250.     case SQL__Double: return 15;
  1251.     default:                   ;
  1252.     }
  1253.   return len; 
  1254. }
  1256. void
  1257. error_rprt(char *st,int rc, char *stmt)
  1258. {
  1259.   fprintf(stderr,"n#### Error occured in '%s'n%snat "%s"n",
  1260.           stmt,gsqlca.errmsg,st);
  1261. }
  1263. int
  1264. main(int argc, char *argv[])
  1265. {
  1266.   static char buffer[4096*4];
  1267.   int stmt = 0;
  1268.   int rc;
  1269.   int i,j;
  1270.   static char *sps =
  1271.     "                                                                       "
  1272.     "                                                                       "
  1273.     "                                                                       "
  1274.     "                                                                       "
  1275.     "                                                                       "
  1276.     ;
  1277.   yyin = stdin;
  1278.   yyout = stderr;
  1279. #if 0 
  1280.   if (argc > 1)
  1281.     {
  1282.       char *host , *user, *passwd;
  1283.       host   = argv[1];
  1284.       user   = (argc > 2 ? argv[2]: getlogin() );
  1285.       passwd = (argc > 3 ? argv[3]: NULL);
  1286.       if(SQL__session(host,user,passwd)!=0)       /* Not implemented yet */
  1287.         yyfatal("Can't connect to given host");
  1288.     }
  1289. #endif
  1290.   
  1291. #define CHECK(st) if((rc=SQL__##st)!=0){ error_rprt(#st,rc,statement_scanner_buffer); goto error; }
  1292.   while(SCANNER_NAME())
  1293.     {
  1294.       char *b;
  1295.       int   l = strlen(statement_scanner_buffer);
  1296.       int  *clms = NULL;
  1297.       
  1298.       SQL_DESCR in,out;
  1299.       
  1300.       if(statement_scanner_buffer==NULL)
  1301.         continue;
  1302.       if(strncmp(statement_scanner_buffer,"select",strlen("select")))
  1303.         {
  1304.           /* if not select statement */
  1305.           CHECK(execute_immediate(statement_scanner_buffer));
  1306.           stmt++;
  1307.           continue;
  1308.         }
  1310.       /* put select in parenthesys */
  1311.       b = xmalloc(l+3);
  1312.       b[0] = '(';
  1313.       strcpy(b+1,statement_scanner_buffer);
  1314.       strcat(b+1+l,")");
  1315.       xfree(statement_scanner_buffer);
  1316.       statement_scanner_buffer = b;
  1317.           
  1318.       b = xmalloc(20);
  1319.       sprintf(b,"%dth Stmt",stmt++);
  1321.       CHECK(prepare(b,statement_scanner_buffer));
  1322.       CHECK(allocate_cursor(b,"CURSOR"));
  1323.       in  = SQL__allocate_descr("IN",0);
  1324.       out = SQL__allocate_descr("OUT",0);
  1326.       CHECK(describe(b,1,in));
  1327.       CHECK(describe(b,0,out));
  1329.       clms = (int*)xmalloc(out->count*sizeof(int));
  1330.       
  1331.       /* open cursor and write headers */
  1332.       j=1;
  1333.       fprintf(stderr,"n|");
  1334.       for( i=0; i < out->count; i++)
  1335.         {
  1336.           int jj, k = 0;
  1337.           sql_descr_element_t *e = &(out->values[i]);
  1338.           if (e->unnamed)
  1339.             jj=fprintf(stderr," col_%03d ",i);
  1340.           else
  1341.             jj=fprintf(stderr," %s ",e->name);
  1342.           k = print_width(e->type,e->length) - jj;
  1343.           jj += fprintf(stderr,"%s|",sps+strlen(sps)- (k>0?k:0) );
  1344.           clms [i] = jj - 1;
  1345.           j += jj;
  1346.         }
  1348.       /* -------------------------------------------------*/
  1349.       fprintf(stderr,"n");
  1350.       for(i=j;i--;)
  1351.         fprintf(stderr,"-");
  1353.       if(in->count)
  1354.         {
  1355.           CHECK(open_cursor("CURSOR",in));
  1356.         }
  1357.       else
  1358.         {
  1359.           CHECK(open_cursor("CURSOR",NULL));
  1360.         }
  1361.         
  1362.       while(1)
  1363.         {
  1364.           char oline[1024];
  1365.           for( i=0; i < out->count; i++)
  1366.             out->values[i].indicator = 0;
  1368.           CHECK(fetch("CURSOR",out));
  1369.           
  1370.           if(SQLCODE!=0)
  1371.             break;
  1372.           
  1373.           sprintf(oline,"n|");
  1374.           for (i=0; i < out->count; i++)
  1375.             {
  1376.               int k ;
  1377.               int kk = 0 ;
  1378.               char buf[4096] ;
  1379.               sql_descr_element_t *e = &(out->values[i]) ;
  1380.               
  1381.               if (e->indicator < 0)
  1382.                 {
  1383.                   if (!e->nullable)
  1384.                     if (e->name)
  1385.                       fprintf(stderr,"nindicator < 0 for 'not null' field '%s'",e->name);
  1386.                     else
  1387.                       fprintf(stderr,"nindicator < 0 for 'not null' field '%d'",i);
  1388.                   sprintf(buf,"null");
  1389.                 }
  1390.               else switch(e->type)
  1391.                 {
  1392.                 case SQL__Char:
  1393.                 case SQL__CharVar:
  1394.                   sprintf(buf,"%s",(char*)e->data);
  1395.                   break;
  1396.                 case SQL__Double: /* DOUBLE */
  1397.                 case SQL__Float: /* FLOAT  */
  1398.                   sprintf(buf,"%g",*((double*)(e->data)));
  1399.                   break;
  1400.                 case SQL__Real: /* REAL   */
  1401.                   sprintf(buf,"%g",*((float*)(e->data)));
  1402.                   break;
  1403.                 case SQL__Int: /* int */
  1404.                   sprintf(buf,"%X",*((int*)(e->data)));
  1405.                   break;
  1406.                 case SQL__Short: /* small */
  1407.                   sprintf(buf,"%d",(int)*((short*)(e->data)));
  1408.                   break;
  1409.                 default:
  1410.                   sprintf(buf," **%d** ",e->type);
  1411.                 }
  1412.               assert(kk==0);
  1413.               k = (clms[i] - strlen(buf))/2; 
  1414.               if (k > 4*clms[i])
  1415.                 {
  1416.                   strcat(oline,"!!");
  1417.                   k = 0;
  1418.                 }
  1419.               k = sprintf(oline+strlen(oline),"%s%s",
  1420.                           sps + strlen(sps) - (k>0?k:0),buf);
  1421.               k = clms[i] - k;
  1422.               sprintf(oline+strlen(oline),"%s|",
  1423.                       sps + strlen(sps) - (k>0?k:0));
  1424.             }
  1425.           fprintf(stderr,"%s",oline);
  1426.         }
  1427.       
  1428.       /* -------------------------------------------------*/
  1429.       fprintf(stderr,"n");
  1430.       for(i=j;i--;)
  1431.         fprintf(stderr,"-");
  1432.       fprintf(stderr,"nn");
  1433.       CHECK(close_cursor("CURSOR"));
  1434.       CHECK(deallocate_prepare(b));
  1435.     error:
  1436.       SQL__deallocate_descr(&in);
  1437.       SQL__deallocate_descr(&out);
  1438.       xfree(clms);
  1439.       xfree(b);
  1440.       b = NULL;
  1441.     }
  1442.       
  1443.   _SQL_commit();
  1444.   return 0;
  1445. }
  1446. int yywrap() { return 1; }