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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqltest.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：57k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqltest.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* mysqltest test tool
  18.  * See man page for more information.
  19.  *
  20.  * Written by:
  21.  *   Sasha Pachev <sasha@mysql.com>
  22.  *   Matt Wagner  <matt@mysql.com>
  23.  *   Monty
  24.  **/
  26. /**********************************************************************
  27.   TODO:
  29. - Print also the queries that returns a result to the log file;  This makes
  30.   it much easier to find out what's wrong.
  32. - Do comparison line by line, instead of doing a full comparison of
  33.   the text file.  This will save space as we don't need to keep many
  34.   results in memory.  It will also make it possible to do simple
  35.   'comparison' fixes like accepting the result even if a float differed
  36.   in the last decimals.
  38. - Don't buffer lines from the test that you don't expect to need
  39.   again.
  41. - Change 'read_line' to be faster by using the readline.cc code;
  42.   We can do better than calling feof() for each character!
  44. **********************************************************************/
  46. #define MTEST_VERSION "1.7"
  48. #include <global.h>
  49. #include <my_sys.h>
  50. #include <m_string.h>
  51. #include <mysql.h>
  52. #include <mysql_version.h>
  53. #include <m_ctype.h>
  54. #include <my_config.h>
  55. #include <my_dir.h>
  56. #include <mysqld_error.h>
  57. #include <stdio.h>
  58. #include <stdlib.h>
  59. #include <getopt.h>
  60. #include <stdarg.h>
  61. #include <sys/stat.h>
  62. #include <unistd.h>
  63. #include <errno.h>
  64. #include <violite.h>
  66. #define MAX_QUERY  65536
  67. #define PAD_SIZE 128
  68. #define MAX_CONS   1024
  69. #define MAX_INCLUDE_DEPTH 16
  70. #define LAZY_GUESS_BUF_SIZE 8192
  71. #define INIT_Q_LINES   1024
  72. #define MIN_VAR_ALLOC   32
  73. #define BLOCK_STACK_DEPTH  32
  74. #define MAX_EXPECTED_ERRORS 10
  75. #define QUERY_SEND  1
  76. #define QUERY_REAP  2
  78. static int record = 0, verbose = 0, silent = 0, opt_sleep=0;
  79. static char *db = 0, *pass=0;
  80. const char* user = 0, *host = 0, *unix_sock = 0;
  81. static int port = 0;
  82. static uint start_lineno, *lineno;
  84. static char **default_argv;
  85. static const char *load_default_groups[]= { "mysqltest","client",0 };
  87. static FILE* file_stack[MAX_INCLUDE_DEPTH];
  88. static FILE** cur_file;
  89. static FILE** file_stack_end;
  90. static uint lineno_stack[MAX_INCLUDE_DEPTH];
  91. static char TMPDIR[FN_REFLEN];
  93. static int block_stack[BLOCK_STACK_DEPTH];
  94. static int *cur_block, *block_stack_end;
  95. static uint global_expected_errno[MAX_EXPECTED_ERRORS];
  97. DYNAMIC_ARRAY q_lines;
  99. typedef struct 
  100. {
  101.   char file[FN_REFLEN];
  102.   ulong pos;
  103. } MASTER_POS ;
  105. struct connection
  106. {
  107.   MYSQL mysql;
  108.   char *name;
  109. };
  111. typedef struct
  112. {
  113.   int read_lines,current_line;
  114. } PARSER;
  116. PARSER parser;
  117. MASTER_POS master_pos;
  118. int block_ok = 1; /* set to 0 if the current block should not be executed */
  119. int false_block_depth = 0;
  120. const char* result_file = 0; /* if set, all results are concated and
  121. compared against this file*/
  123. typedef struct
  124. {
  125.   char* name;
  126.   char* str_val;
  127.   int str_val_len;
  128.   int int_val;
  129.   int alloced_len;
  130.   int int_dirty; /* do not update string if int is updated until first read */
  131. } VAR;
  133. VAR var_reg[10];
  134. /*Perl/shell-like variable registers */
  136. struct connection cons[MAX_CONS];
  137. struct connection* cur_con, *next_con, *cons_end;
  139. /* this should really be called command */
  140. struct st_query
  141. {
  142.   char *query, *first_argument;
  143.   int first_word_len;
  144.   my_bool abort_on_error, require_file;
  145.   uint expected_errno[MAX_EXPECTED_ERRORS];
  146.   char record_file[FN_REFLEN];
  147.   /* Add new commands before Q_UNKNOWN */
  148.   enum { Q_CONNECTION=1,     Q_QUERY, 
  149.          Q_CONNECT,          Q_SLEEP, 
  150.          Q_INC,              Q_DEC,
  151.          Q_SOURCE,           Q_DISCONNECT,
  152.          Q_LET,              Q_ECHO, 
  153.          Q_WHILE,            Q_END_BLOCK,
  154.          Q_SYSTEM,           Q_RESULT, 
  155.          Q_REQUIRE,          Q_SAVE_MASTER_POS,
  156.          Q_SYNC_WITH_MASTER, Q_ERROR, 
  157.          Q_SEND,             Q_REAP, 
  158.          Q_DIRTY_CLOSE,      Q_REPLACE,
  159.  Q_PING,
  160.          Q_UNKNOWN,                             /* Unknown command.   */
  161.          Q_COMMENT,                             /* Comments, ignored. */
  162.          Q_COMMENT_WITH_COMMAND
  163.   } type;
  164. };
  166. const char *command_names[] = {
  167.   "connection",       "query",
  168.   "connect",          "sleep",
  169.   "inc",              "dec",
  170.   "source",           "disconnect",
  171.   "let",              "echo",
  172.   "while",            "end",
  173.   "system",           "result",
  174.   "require",          "save_master_pos",
  175.   "sync_with_master", "error",
  176.   "send",             "reap", 
  177.   "dirty_close",      "replace_result",
  178.   "ping",
  179.   0
  180. };
  182. TYPELIB command_typelib= {array_elements(command_names),"",
  183.   command_names};
  185. DYNAMIC_STRING ds_res;
  187. int dyn_string_cmp(DYNAMIC_STRING* ds, const char* fname);
  188. void reject_dump(const char* record_file, char* buf, int size);
  190. int close_connection(struct st_query* q);
  191. VAR* var_get(char* var_name, char* var_name_end, int raw);
  193. /* Definitions for replace */
  195. typedef struct st_pointer_array { /* when using array-strings */
  196.   TYPELIB typelib; /* Pointer to strings */
  197.   byte *str; /* Strings is here */
  198.   int7 *flag; /* Flag about each var. */
  199.   uint  array_allocs,max_count,length,max_length;
  200. } POINTER_ARRAY;
  202. struct st_replace;
  203. struct st_replace *init_replace(my_string *from, my_string *to, uint count,
  204. my_string word_end_chars);
  205. uint replace_strings(struct st_replace *rep, my_string *start,
  206.      uint *max_length, my_string from);
  207. static int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name);
  208. void free_pointer_array(POINTER_ARRAY *pa);
  209. static int initialize_replace_buffer(void);
  210. static void free_replace_buffer(void);
  212. struct st_replace *glob_replace;
  213. static char *out_buff;
  214. static uint out_length;
  217. static void close_cons()
  218. {
  219.   DBUG_ENTER("close_cons");
  220.   for (--next_con; next_con >= cons; --next_con)
  221.   {
  222.     mysql_close(&next_con->mysql);
  223.     my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
  224.   }
  225.   DBUG_VOID_RETURN;
  226. }
  228. static void close_files()
  229. {
  230.   do
  231.   {
  232.     if (*cur_file != stdin)
  233.       my_fclose(*cur_file,MYF(0));
  234.   } while (cur_file-- != file_stack);
  235. }
  237. static void free_used_memory()
  238. {
  239.   uint i;
  240.   DBUG_ENTER("free_used_memory");
  241.   close_cons();
  242.   close_files();
  243.   for (i=0 ; i < q_lines.elements ; i++)
  244.   {
  245.     struct st_query **q= dynamic_element(&q_lines, i, struct st_query**);
  246.     my_free((gptr) (*q)->query,MYF(MY_ALLOW_ZERO_PTR));
  247.     my_free((gptr) (*q),MYF(0));
  248.   }
  249.   delete_dynamic(&q_lines);
  250.   dynstr_free(&ds_res);
  251.   my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  252.   free_defaults(default_argv);
  253.   my_end(MY_CHECK_ERROR);
  254.   DBUG_VOID_RETURN;
  255. }
  257. static void die(const char* fmt, ...)
  258. {
  259.   va_list args;
  260.   DBUG_ENTER("die");
  261.   va_start(args, fmt);
  262.   if (fmt)
  263.   {
  264.     fprintf(stderr, "%s: ", my_progname);
  265.     vfprintf(stderr, fmt, args);
  266.     fprintf(stderr, "n");
  267.   }
  268.   va_end(args);
  269.   free_used_memory();
  270.   exit(1);
  271. }
  273. static void abort_not_supported_test()
  274. {
  275.   DBUG_ENTER("abort_not_supported_test");
  276.   fprintf(stderr, "This test is not supported by this installationn");
  277.   if (!silent)
  278.     printf("skippedn");
  279.   free_used_memory();
  280.   exit(2);
  281. }
  283. static void verbose_msg(const char* fmt, ...)
  284. {
  285.   va_list args;
  286.   if (!verbose) return;
  288.   va_start(args, fmt);
  290.   fprintf(stderr, "%s: At line %u: ", my_progname, start_lineno);
  291.   vfprintf(stderr, fmt, args);
  292.   fprintf(stderr, "n");
  293.   va_end(args);
  294. }
  297. void init_parser()
  298. {
  299.   parser.current_line = parser.read_lines = 0;
  300.   memset(&var_reg,0, sizeof(var_reg));
  301. }
  303. int hex_val(int c)
  304. {
  305.   if (isdigit(c))
  306.     return c - '0';
  307.   else if ((c = tolower(c)) >= 'a' && c <= 'f')
  308.     return c - 'a' + 10;
  309.   else
  310.     return -1;
  311. }
  313. int dyn_string_cmp(DYNAMIC_STRING* ds, const char* fname)
  314. {
  315.   MY_STAT stat_info;
  316.   char *tmp;
  317.   int res;
  318.   int fd;
  319.   DBUG_ENTER("dyn_string_cmp");
  321.   if (!my_stat(fname, &stat_info, MYF(MY_WME)))
  322.     die(NullS);
  323.   if (stat_info.st_size != ds->length)
  324.     DBUG_RETURN(2);
  325.   if (!(tmp = (char*) my_malloc(ds->length, MYF(MY_WME))))
  326.     die(NullS);
  327.   if ((fd = my_open(fname, O_RDONLY, MYF(MY_WME))) < 0)
  328.     die(NullS);
  329.   if (my_read(fd, (byte*)tmp, stat_info.st_size, MYF(MY_WME|MY_NABP)))
  330.     die(NullS);
  331.   res = (memcmp(tmp, ds->str, stat_info.st_size)) ?  1 : 0;
  332.   my_free((gptr) tmp, MYF(0));
  333.   my_close(fd, MYF(MY_WME));
  335.   DBUG_RETURN(res);
  336. }
  338. static int check_result(DYNAMIC_STRING* ds, const char* fname,
  339. my_bool require_option)
  340. {
  341.   int error = 0;
  342.   int res=dyn_string_cmp(ds, fname);
  344.   if (res && require_option)
  345.     abort_not_supported_test();
  346.   switch (res)
  347.   {
  348.   case 0:
  349.     break; /* ok */
  350.   case 2:
  351.     verbose_msg("Result length mismatch");
  352.     error = 1;
  353.     break;
  354.   case 1:
  355.     verbose_msg("Result content mismatch");
  356.     error = 1;
  357.     break;
  358.   default: /* impossible */
  359.     die("Unknown error code from dyn_string_cmp()");
  360.   }
  361.   if (error)
  362.     reject_dump(fname, ds->str, ds->length);
  363.   return error;
  364. }
  366. VAR* var_get(char* var_name, char* var_name_end, int raw)
  367. {
  368.   int digit;
  369.   VAR* v;
  370.   if (*var_name++ != '$')
  371.   {
  372.     --var_name;
  373.     goto err;
  374.   }
  375.   digit = *var_name - '0';
  376.   if (!(digit < 10 && digit >= 0))
  377.   {
  378.     --var_name;
  379.     goto err;
  380.   }
  381.   v = var_reg + digit;
  382.   if (!raw && v->int_dirty)
  383.   {
  384.     sprintf(v->str_val, "%d", v->int_val);
  385.     v->int_dirty = 0;
  386.   }
  387.   return v;
  388. err:
  389.   if (var_name_end)
  390.     *var_name_end = 0;
  391.   die("Unsupported variable name: %s", var_name);
  392.   return 0;
  393. }
  395. int var_set(char* var_name, char* var_name_end, char* var_val,
  396.     char* var_val_end)
  397. {
  398.   int digit;
  399.   int val_len;
  400.   VAR* v;
  401.   if (*var_name++ != '$')
  402.     {
  403.       --var_name;
  404.       *var_name_end = 0;
  405.       die("Variable name in %s does not start with '$'", var_name);
  406.     }
  407.   digit = *var_name - '0';
  408.   if (!(digit < 10 && digit >= 0))
  409.     {
  410.       *var_name_end = 0;
  411.       die("Unsupported variable name: %s", var_name);
  412.     }
  413.   v = var_reg + digit;
  414.   if (v->alloced_len < (val_len = (int)(var_val_end - var_val)+1))
  415.     {
  416.       v->alloced_len = (val_len < MIN_VAR_ALLOC) ? MIN_VAR_ALLOC : val_len;
  417.      if (!(v->str_val =
  418.   v->str_val ? my_realloc(v->str_val, v->alloced_len,  MYF(MY_WME)) :
  419.    my_malloc(v->alloced_len, MYF(MY_WME))))
  420.  die("Out of memory");
  421.     }
  422.   memcpy(v->str_val, var_val, val_len-1);
  423.   v->str_val_len = val_len;
  424.   v->str_val[val_len] = 0;
  425.   v->int_val = atoi(v->str_val);
  426.   return 0;
  427. }
  429. int open_file(const char* name)
  430. {
  431.   if (*cur_file && cur_file == file_stack_end)
  432.     die("Source directives are nesting too deep");
  433.   if (!(*(cur_file+1) = my_fopen(name, O_RDONLY, MYF(MY_WME))))
  434.     die(NullS);
  435.   cur_file++;
  436.   *++lineno=1;
  438.   return 0;
  439. }
  441. int do_source(struct st_query* q)
  442. {
  443.   char* p=q->first_argument, *name;
  444.   if (!*p)
  445.     die("Missing file name in sourcen");
  446.   name = p;
  447.   while (*p && !isspace(*p))
  448.     p++;
  449.   *p = 0;
  451.   return open_file(name);
  452. }
  455. int eval_expr(VAR* v, char* p, char* p_end)
  456. {
  457.   VAR* vp;
  458.   if (*p == '$')
  459.     {
  460.       if ((vp = var_get(p,p_end,0)))
  461. {
  462.   memcpy(v, vp, sizeof(VAR));
  463.   return 0;
  464. }
  465.     }
  466.   else
  467.     {
  468.       v->str_val = p;
  469.       v->str_val_len = p_end ? p_end - p : strlen(p);
  470.       return 0;
  471.     }
  473.   if (p_end)
  474.     *p_end = 0;
  475.   die("Invalid expr: %s", p);
  476.   return 1;
  477. }
  479. int do_inc(struct st_query* q)
  480. {
  481.   char* p=q->first_argument;
  482.   VAR* v;
  483.   v = var_get(p, 0, 1);
  484.   v->int_val++;
  485.   v->int_dirty = 1;
  486.   return 0;
  487. }
  489. int do_dec(struct st_query* q)
  490. {
  491.   char* p=q->first_argument;
  492.   VAR* v;
  493.   v = var_get(p, 0, 1);
  494.   v->int_val--;
  495.   v->int_dirty = 1;
  496.   return 0;
  497. }
  499. int do_system(struct st_query* q)
  500. {
  501.   char* p=q->first_argument;
  502.   VAR v;
  503.   eval_expr(&v, p, 0); /* NULL terminated */
  504.   if (v.str_val_len > 1)
  505.     {
  506.       char expr_buf[512];
  507.       if ((uint)v.str_val_len > sizeof(expr_buf) - 1)
  508. v.str_val_len = sizeof(expr_buf) - 1;
  509.       memcpy(expr_buf, v.str_val, v.str_val_len);
  510.       expr_buf[v.str_val_len] = 0;
  511.       if (system(expr_buf) && q->abort_on_error)
  512. die("system command '%s' failed", expr_buf);
  513.     }
  514.   return 0;
  515. }
  517. int do_echo(struct st_query* q)
  518. {
  519.   char* p=q->first_argument;
  520.   VAR v;
  521.   eval_expr(&v, p, 0); /* NULL terminated */
  522.   if (v.str_val_len > 1)
  523.     {
  524.       fflush(stdout);
  525.       write(1, v.str_val, v.str_val_len - 1);
  526.     }
  527.   write(1, "n", 1);
  528.   return 0;
  529. }
  531. int do_sync_with_master(struct st_query* q)
  532. {
  533.   MYSQL_RES* res;
  534.   MYSQL_ROW row;
  535.   MYSQL* mysql = &cur_con->mysql;
  536.   char query_buf[FN_REFLEN+128];
  537.   int offset = 0;
  538.   char* p = q->first_argument;
  539.   if(*p)
  540.     offset = atoi(p);
  541.   
  542.   sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
  543.   master_pos.pos + offset);
  544.   if(mysql_query(mysql, query_buf))
  545.     die("At line %u: failed in %s: %d: %s", start_lineno, query_buf,
  546. mysql_errno(mysql), mysql_error(mysql));
  548.   if(!(res = mysql_store_result(mysql)))
  549.     die("line %u: mysql_store_result() retuned NULL", start_lineno);
  550.   if(!(row = mysql_fetch_row(res)))
  551.     die("line %u: empty result in %s", start_lineno, query_buf);
  552.   if(!row[0])
  553.     die("Error on slave while syncing with master");
  554.   mysql_free_result(res);
  555.       
  556.   return 0;
  557. }
  559. int do_save_master_pos()
  560. {
  561.   MYSQL_RES* res;
  562.   MYSQL_ROW row;
  563.   MYSQL* mysql = &cur_con->mysql;
  564.   if(mysql_query(mysql, "show master status"))
  565.     die("At line %u: failed in show master status: %d: %s", start_lineno,
  566. mysql_errno(mysql), mysql_error(mysql));
  568.   if(!(res = mysql_store_result(mysql)))
  569.     die("line %u: mysql_store_result() retuned NULL", start_lineno);
  570.   if(!(row = mysql_fetch_row(res)))
  571.     die("line %u: empty result in show master status", start_lineno);
  572.   strncpy(master_pos.file, row[0], sizeof(master_pos.file));
  573.   master_pos.pos = strtoul(row[1], (char**) 0, 10); 
  574.   mysql_free_result(res);
  575.       
  576.   return 0;
  577. }
  580. int do_let(struct st_query* q)
  581. {
  582.   char* p=q->first_argument;
  583.   char *var_name, *var_name_end, *var_val_start;
  584.   if (!*p)
  585.     die("Missing variable name in letn");
  586.   var_name = p;
  587.   while(*p && (*p != '=' || isspace(*p)))
  588.     p++;
  589.   var_name_end = p;
  590.   if (*p == '=') p++;
  591.   while(*p && isspace(*p))
  592.     p++;
  593.   var_val_start = p;
  594.   while(*p && !isspace(*p))
  595.     p++;
  596.   return var_set(var_name, var_name_end, var_val_start, p);
  597. }
  599. int do_sleep(struct st_query* q)
  600. {
  601.   char* p=q->first_argument;
  602.   struct timeval t;
  603.   int dec_mul = 1000000;
  604.   while(*p && isspace(*p)) p++;
  605.   if (!*p)
  606.     die("Missing argument in sleepn");
  607.   t.tv_usec = 0;
  608.   if (opt_sleep)
  609.     t.tv_sec = opt_sleep;
  610.   else
  611.   {
  612.     t.tv_sec = atoi(p);
  613.     while(*p && *p != '.' && !isspace(*p))
  614.       p++;
  615.     if (*p == '.')
  616.     {
  617.       char c;
  618.       char *p_end;
  619.       p++;
  620.       p_end = p + 6;
  622.       for(;p <= p_end; ++p)
  623.       {
  624. c = *p - '0';
  625. if (c < 10 && c >= 0)
  626. {
  627.   t.tv_usec = t.tv_usec * 10 + c;
  628.   dec_mul /= 10;
  629. }
  630. else
  631.   break;
  632.       }
  633.     }
  634.   }
  635.   t.tv_usec *= dec_mul;
  636.   return select(0,0,0,0, &t);
  637. }
  639. static void get_file_name(char *filename, struct st_query* q)
  640. {
  641.   char* p=q->first_argument;
  642.   strnmov(filename, p, FN_REFLEN);
  643.   /* Remove end space */
  644.   while (p > filename && isspace(p[-1]))
  645.     p--;
  646.   p[0]=0;
  647. }
  650. static void get_ints(uint *to,struct st_query* q)
  651. {
  652.   char* p=q->first_argument;
  653.   long val;
  654.   DBUG_ENTER("get_ints");
  656.   if (!*p)
  657.     die("Missing argument in %sn", q->query);
  659.   for (; (p=str2int(p,10,(long) INT_MIN, (long) INT_MAX, &val)) ; p++)
  660.   {
  661.     *to++= (uint) val;
  662.     if (*p != ',')
  663.       break;
  664.   }
  665.   *to++=0; /* End of data */
  666.   DBUG_VOID_RETURN;
  667. }
  669. /*
  670.   Get a string;  Return ptr to end of string
  671.   Strings may be surrounded by " or '
  672. */
  675. static void get_string(char **to_ptr, char **from_ptr,
  676.        struct st_query* q)
  677. {
  678.   reg1 char c,sep;
  679.   char *to= *to_ptr, *from= *from_ptr;
  680.   DBUG_ENTER("get_string");
  682.   /* Find separator */
  683.   if (*from == '"' || *from == ''')
  684.     sep= *from++;
  685.   else
  686.     sep=' '; /* Separated with space */
  688.   for ( ; (c=*from) ; from++)
  689.   {
  690.     if (c == '\' && from[1])
  691.     { /* Escaped character */
  692.       /* We can't translate  -> ASCII 0 as replace can't handle ASCII 0 */
  693.       switch (*++from) {
  694.       case 'n':
  695. *to++= 'n';
  696. break;
  697.       case 't':
  698. *to++= 't';
  699. break;
  700.       case 'r':
  701. *to++ = 'r';
  702. break;
  703.       case 'b':
  704. *to++ = 'b';
  705. break;
  706.       case 'Z': /* ^Z must be escaped on Win32 */
  707. *to++='32';
  708. break;
  709.       default:
  710. *to++ = *from;
  711. break;
  712.       }
  713.     }
  714.     else if (c == sep)
  715.     {
  716.       if (c == ' ' || c != *++from)
  717. break; /* Found end of string */
  718.       *to++=c; /* Copy duplicated separator */
  719.     }
  720.     else
  721.       *to++=c;
  722.   }
  723.   if (*from != ' ' && *from)
  724.     die("Wrong string argument in %sn", q->query);
  726.   while (isspace(*from)) /* Point to next string */
  727.     from++;
  729.   *to++ =0; /* End of string marker */
  730.   *to_ptr= to;
  731.   *from_ptr= from;
  732. }
  735. /*
  736.   Get arguments for replace. The syntax is:
  737.   replace from to [from to ...]
  738.   Where each argument may be quoted with ' or "
  739. */
  741. static void get_replace(struct st_query *q)
  742. {
  743.   uint i;
  744.   char *from=q->first_argument;
  745.   char *buff,*start;
  746.   char word_end_chars[256],*pos;
  747.   POINTER_ARRAY to_array,from_array;
  748.   DBUG_ENTER("get_replace");
  750.   bzero((char*) &to_array,sizeof(to_array));
  751.   bzero((char*) &from_array,sizeof(from_array));
  752.   if (!*from)
  753.     die("Missing argument in %sn", q->query);
  754.   start=buff=my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
  755.   while (*from)
  756.   {
  757.     char *to=buff;
  758.     get_string(&buff, &from, q);
  759.     if (!*from)
  760.       die("Wrong number of arguments to replace in %sn", q->query);
  761.     insert_pointer_name(&from_array,to);
  762.     to=buff;
  763.     get_string(&buff, &from, q);
  764.     insert_pointer_name(&to_array,to);
  765.   }
  766.   for (i=1,pos=word_end_chars ; i < 256 ; i++)
  767.     if (isspace(i))
  768.       *pos++=i;
  769.   *pos=0; /* End pointer */
  770.   if (!(glob_replace=init_replace((char**) from_array.typelib.type_names,
  771.   (char**) to_array.typelib.type_names,
  772.   (uint) from_array.typelib.count,
  773.   word_end_chars)) ||
  774.       initialize_replace_buffer())
  775.     die("Can't initialize replace from %sn", q->query);
  776.   free_pointer_array(&from_array);
  777.   free_pointer_array(&to_array);
  778.   my_free(start, MYF(0));
  779. }
  781. void free_replace()
  782. {
  783.   DBUG_ENTER("free_replace");
  784.   my_free((char*) glob_replace,MYF(0));
  785.   glob_replace=0;
  786.   free_replace_buffer();
  787.   DBUG_VOID_RETURN;
  788. }
  791. int select_connection(struct st_query* q)
  792. {
  793.   char* p=q->first_argument, *name;
  794.   struct connection *con;
  795.   DBUG_ENTER("select_connection");
  796.   DBUG_PRINT("enter",("name: '%s'",p));
  798.   if (!*p)
  799.     die("Missing connection name in connectn");
  800.   name = p;
  801.   while(*p && !isspace(*p))
  802.     p++;
  803.   *p = 0;
  805.   for (con = cons; con < next_con; con++)
  806.   {
  807.     if (!strcmp(con->name, name))
  808.     {
  809.       cur_con = con;
  810.       DBUG_RETURN(0);
  811.     }
  812.   }
  813.   die("connection '%s' not found in connection pool", name);
  814.   DBUG_RETURN(1); /* Never reached */
  815. }
  817. int close_connection(struct st_query* q)
  818. {
  819.   char* p=q->first_argument, *name;
  820.   struct connection *con;
  821.   DBUG_ENTER("close_connection");
  822.   DBUG_PRINT("enter",("name: '%s'",p));
  824.   if (!*p)
  825.     die("Missing connection name in connectn");
  826.   name = p;
  827.   while(*p && !isspace(*p))
  828.     p++;
  829.   *p = 0;
  831.   for(con = cons; con < next_con; con++)
  832.   {
  833.     if (!strcmp(con->name, name))
  834.     {
  835.       if(q->type == Q_DIRTY_CLOSE)
  836. {
  837.   if(con->mysql.net.vio)
  838.     {
  839.       vio_delete(con->mysql.net.vio);
  840.       con->mysql.net.vio = 0;
  841.     }
  842. }
  844.       mysql_close(&con->mysql);
  845.       DBUG_RETURN(0);
  846.     }
  847.   }
  848.   die("connection '%s' not found in connection pool", name);
  849.   DBUG_RETURN(1); /* Never reached */
  850. }
  853. /* this one now is a hack - we may want to improve in in the
  854.    future to handle quotes. For now we assume that anything that is not
  855.    a comma, a space or ) belongs to the argument. space is a chopper, comma or
  856.    ) are delimiters/terminators
  857. */
  859. char* safe_get_param(char* str, char** arg, const char* msg)
  860. {
  861.   DBUG_ENTER("safe_get_param");
  862.   while(*str && isspace(*str)) str++;
  863.   *arg = str;
  864.   while(*str && *str != ',' && *str != ')')
  865.     {
  866.       if (isspace(*str)) *str = 0;
  867.       str++;
  868.     }
  869.   if (!*str)
  870.     die(msg);
  872.   *str++ = 0;
  873.   DBUG_RETURN(str);
  874. }
  877. int do_connect(struct st_query* q)
  878. {
  879.   char* con_name, *con_user,*con_pass, *con_host, *con_port_str,
  880.     *con_db, *con_sock;
  881.   char* p=q->first_argument;
  882.   char buff[FN_REFLEN];
  883.   DBUG_ENTER("do_connect");
  884.   DBUG_PRINT("enter",("connect: %s",p));
  886.   if (*p != '(')
  887.     die("Syntax error in connect - expected '(' found '%c'", *p);
  888.   p++;
  889.   p = safe_get_param(p, &con_name, "missing connection name");
  890.   p = safe_get_param(p, &con_host, "missing connection host");
  891.   p = safe_get_param(p, &con_user, "missing connection user");
  892.   p = safe_get_param(p, &con_pass, "missing connection password");
  893.   p = safe_get_param(p, &con_db, "missing connection db");
  894.   p = safe_get_param(p, &con_port_str, "missing connection port");
  895.   p = safe_get_param(p, &con_sock, "missing connection socket");
  896.   if (next_con == cons_end)
  897.     die("Connection limit exhausted - increase MAX_CONS in mysqltest.c");
  899.   if (!mysql_init(&next_con->mysql))
  900.     die("Failed on mysql_init()");
  901.   con_sock=fn_format(buff, con_sock, TMPDIR,"",0);
  902.   if (!mysql_real_connect(&next_con->mysql, con_host, con_user, con_pass,
  903.  con_db, atoi(con_port_str), con_sock, 0))
  904.     die("Could not open connection '%s': %s", con_name,
  905. mysql_error(&next_con->mysql));
  907.   if (!(next_con->name = my_strdup(con_name, MYF(MY_WME))))
  908.     die(NullS);
  909.   cur_con = next_con++;
  911.   DBUG_RETURN(0);
  912. }
  914. int do_done(struct st_query* q)
  915. {
  916.   q->type = Q_END_BLOCK;
  917.   if (cur_block == block_stack)
  918.     die("Stray '}' - end of block before beginning");
  919.   if (block_ok)
  920.     parser.current_line = *--cur_block;
  921.   else
  922.     {
  923.       if (!--false_block_depth)
  924. block_ok = 1;
  925.       ++parser.current_line;
  926.     }
  927.   return 0;
  928. }
  930. int do_while(struct st_query* q)
  931. {
  932.   char* p=q->first_argument;
  933.   char* expr_start, *expr_end;
  934.   VAR v;
  935.   if (cur_block == block_stack_end)
  936. die("Nesting too deeply");
  937.   if (!block_ok)
  938.     {
  939.       ++false_block_depth;
  940.       return 0;
  941.     }
  942.   expr_start = strchr(p, '(');
  943.   if (!expr_start)
  944.     die("missing '(' in while");
  945.   expr_end = strrchr(expr_start, ')');
  946.   if (!expr_end)
  947.     die("missing ')' in while");
  948.   eval_expr(&v, ++expr_start, --expr_end);
  949.   *cur_block++ = parser.current_line++;
  950.   if (!v.int_val)
  951.     {
  952.       block_ok = 0;
  953.       false_block_depth = 1;
  954.     }
  955.   return 0;
  956. }
  959. int safe_copy_unescape(char* dest, char* src, int size)
  960. {
  961.   register char* p_dest = dest, *p_src = src;
  962.   register int c, val;
  963.   enum { ST_NORMAL, ST_ESCAPED, ST_HEX2} state = ST_NORMAL ;
  965.   size--; /* just to make life easier */
  967.   for(; p_dest - size < dest && p_src - size < src
  968. && (c = *p_src) != 'n' && c; ++p_src )
  969.     {
  970.       switch(state)
  971. {
  972. case ST_NORMAL:
  973.   if (c == '\')
  974.     {
  975.       state = ST_ESCAPED;
  976.     }
  977.   else
  978.     *p_dest++ = c;
  979.   break;
  980. case ST_ESCAPED:
  981.   if ((val = hex_val(c)) > 0)
  982.     {
  983.       *p_dest = val;
  984.       state = ST_HEX2;
  985.     }
  986.   else
  987.     {
  988.       state = ST_NORMAL;
  989.       *p_dest++ = c;
  990.     }
  991.   break;
  992. case ST_HEX2:
  993.   if ((val = hex_val(c)) > 0)
  994.     {
  995.       *p_dest = (*p_dest << 4) + val;
  996.       p_dest++;
  997.     }
  998.   else
  999.     *p_dest++ = c;
  1001.   state = ST_NORMAL;
  1002.   break;
  1004. }
  1005.     }
  1007.   *p_dest = 0;
  1008.   return (p_dest - dest);
  1009. }
  1012. int read_line(char* buf, int size)
  1013. {
  1014.   int c;
  1015.   char* p = buf, *buf_end = buf + size-1;
  1016.   int no_save = 0;
  1017.   enum {R_NORMAL, R_Q1, R_ESC_Q_Q1, R_ESC_Q_Q2,
  1018. R_ESC_SLASH_Q1, R_ESC_SLASH_Q2,
  1019. R_Q2, R_COMMENT, R_LINE_START} state = R_LINE_START;
  1021.   start_lineno= *lineno;
  1022.   for (; p < buf_end ;)
  1023.   {
  1024.     no_save = 0;
  1025.     c = fgetc(*cur_file);
  1026.     if (feof(*cur_file))
  1027.     {
  1028.       if ((*cur_file) != stdin)
  1029. my_fclose(*cur_file,MYF(0));
  1031.       if (cur_file == file_stack)
  1032. return 1;
  1033.       else
  1034.       {
  1035. cur_file--;
  1036. lineno--;
  1037. continue;
  1038.       }
  1039.     }
  1041.     switch(state) {
  1042.     case R_NORMAL:
  1043.       /*  Only accept '{' in the beginning of a line */
  1044.       if (c == ';')
  1045.       {
  1046. *p = 0;
  1047. return 0;
  1048.       }
  1049.       else if (c == ''')
  1050. state = R_Q1;
  1051.       else if (c == '"')
  1052. state = R_Q2;
  1053.       else if (c == 'n')
  1054.       {
  1055. state = R_LINE_START;
  1056. (*lineno)++;
  1057.       }
  1058.       break;
  1059.     case R_COMMENT:
  1060.       if (c == 'n')
  1061.       {
  1062. *p=0;
  1063. (*lineno)++;
  1064. return 0;
  1065.       }
  1066.       break;
  1067.     case R_LINE_START:
  1068.       if (c == '#' || c == '-')
  1069.       {
  1070. state = R_COMMENT;
  1071.       }
  1072.       else if (isspace(c))
  1073.       {
  1074. if (c == 'n')
  1075.   start_lineno= ++*lineno; /* Query hasn't started yet */
  1076. no_save = 1;
  1077.       }
  1078.       else if (c == '}')
  1079.       {
  1080. *buf++ = '}';
  1081. *buf = 0;
  1082. return 0;
  1083.       }
  1084.       else if (c == ';' || c == '{')
  1085.       {
  1086. *p = 0;
  1087. return 0;
  1088.       }
  1089.       else
  1090. state = R_NORMAL;
  1091.       break;
  1093.     case R_Q1:
  1094.       if (c == ''')
  1095. state = R_ESC_Q_Q1;
  1096.       else if (c == '\')
  1097. state = R_ESC_SLASH_Q1;
  1098.       break;
  1099.     case R_ESC_Q_Q1:
  1100.       if (c == ';')
  1101.       {
  1102. *p = 0;
  1103. return 0;
  1104.       }
  1105.       if (c != ''')
  1106. state = R_NORMAL;
  1107.       else
  1108. state = R_Q1;
  1109.       break;
  1110.     case R_ESC_SLASH_Q1:
  1111.       state = R_Q1;
  1112.       break;
  1114.     case R_Q2:
  1115.       if (c == '"')
  1116. state = R_ESC_Q_Q2;
  1117.       else if (c == '\')
  1118. state = R_ESC_SLASH_Q2;
  1119.       break;
  1120.     case R_ESC_Q_Q2:
  1121.       if (c == ';')
  1122.       {
  1123. *p = 0;
  1124. return 0;
  1125.       }
  1126.       if (c != '"')
  1127. state = R_NORMAL;
  1128.       else
  1129. state = R_Q2;
  1130.       break;
  1131.     case R_ESC_SLASH_Q2:
  1132.       state = R_Q2;
  1133.       break;
  1134.     }
  1136.     if (!no_save)
  1137.       *p++ = c;
  1138.   }
  1139.   *p=0; /* Always end with  */
  1140.   return feof(*cur_file);
  1141. }
  1143. static char read_query_buf[MAX_QUERY];
  1145. int read_query(struct st_query** q_ptr)
  1146. {
  1147.   char *p = read_query_buf, * p1 ;
  1148.   int c, expected_errno;
  1149.   struct st_query* q;
  1151.   if (parser.current_line < parser.read_lines)
  1152.   {
  1153.     get_dynamic(&q_lines, (gptr) q_ptr, parser.current_line) ;
  1154.     return 0;
  1155.   }
  1156.   if (!(*q_ptr=q=(struct st_query*) my_malloc(sizeof(*q), MYF(MY_WME))) ||
  1157.       insert_dynamic(&q_lines, (gptr) &q))
  1158.     die(NullS);
  1160.   q->record_file[0] = 0;
  1161.   q->require_file=0;
  1162.   q->first_word_len = 0;
  1163.   memcpy((gptr) q->expected_errno, (gptr) global_expected_errno,
  1164.  sizeof(global_expected_errno));
  1165.   q->abort_on_error = global_expected_errno[0] == 0;
  1166.   bzero((gptr) global_expected_errno,sizeof(global_expected_errno));
  1167.   q->type = Q_UNKNOWN;
  1168.   q->query=0;
  1169.   if (read_line(read_query_buf, sizeof(read_query_buf)))
  1170.     return 1;
  1172.   if (*p == '#')
  1173.   {
  1174.     q->type = Q_COMMENT;
  1175.   }
  1176.   else if (p[0] == '-' && p[1] == '-')
  1177.   {
  1178.     q->type = Q_COMMENT_WITH_COMMAND;
  1179.     p+=2; /* To calculate first word */
  1180.   }
  1181.   else
  1182.   {
  1183.     if (*p == '!')
  1184.     {
  1185.       q->abort_on_error = 0;
  1186.       p++;
  1187.       if (*p == '$')
  1188.       {
  1189. expected_errno = 0;
  1190. p++;
  1191. for (;isdigit(*p);p++)
  1192.   expected_errno = expected_errno * 10 + *p - '0';
  1193. q->expected_errno[0] = expected_errno;
  1194. q->expected_errno[1] = 0;
  1195.       }
  1196.     }
  1198.     while(*p && isspace(*p)) p++ ;
  1199.     if (*p == '@')
  1200.     {
  1201.       p++;
  1202.       p1 = q->record_file;
  1203.       while(!isspace(c = *p) &&
  1204.     p1 < q->record_file + sizeof(q->record_file) - 1)
  1205. *p1++ = *p++;
  1206.       *p1 = 0;
  1207.     }
  1208.   }
  1209.   while (*p && isspace(*p)) p++;
  1210.   if (!(q->query=my_strdup(p,MYF(MY_WME))))
  1211.     die(NullS);
  1213.   /* Calculate first word and first argument */
  1214.   for (p=q->query; *p && !isspace(*p) ; p++) ;
  1215.   q->first_word_len = (uint) (p - q->query);
  1216.   while (*p && isspace(*p)) p++;
  1217.   q->first_argument=p;
  1219.   parser.read_lines++;
  1220.   return 0;
  1221. }
  1224. struct option long_options[] =
  1225. {
  1226.   {"debug",       optional_argument, 0, '#'},
  1227.   {"database",    required_argument, 0, 'D'},
  1228.   {"help",        no_argument,       0, '?'},
  1229.   {"host",        required_argument, 0, 'h'},
  1230.   {"password",    optional_argument, 0, 'p'},
  1231.   {"port",        required_argument, 0, 'P'},
  1232.   {"quiet",       no_argument,       0, 'q'},
  1233.   {"record",      no_argument,       0, 'r'},
  1234.   {"result-file", required_argument, 0, 'R'},
  1235.   {"silent",      no_argument,       0, 'q'},
  1236.   {"sleep",       required_argument, 0, 'T'},
  1237.   {"socket",      required_argument, 0, 'S'},
  1238.   {"tmpdir",      required_argument, 0, 't'},
  1239.   {"user",        required_argument, 0, 'u'},
  1240.   {"verbose",     no_argument,       0, 'v'},
  1241.   {"version",     no_argument,       0, 'V'},
  1242.   {0, 0, 0, 0}
  1243. };
  1246. static void print_version(void)
  1247. {
  1248.   printf("%s  Ver %s Distrib %s, for %s (%s)n",my_progname,MTEST_VERSION,
  1249.  MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  1250. }
  1252. void usage()
  1253. {
  1254.   print_version();
  1255.   printf("MySQL AB, by Sasha, Matt & Montyn");
  1256.   printf("This software comes with ABSOLUTELY NO WARRANTYnn");
  1257.   printf("Runs a test against the mysql server and compares output with a results file.nn");
  1258.   printf("Usage: %s [OPTIONS] [database] < test_filen", my_progname);
  1259.   printf("n
  1260.   -?, --help               Display this help and exit.n");
  1261. #ifndef DBUG_OFF
  1262.   puts("
  1263.   -#, --debug=[...]        Output debug log. Often this is 'd:t:o,filename`");
  1264. #endif
  1265.   printf("
  1266.   -h, --host=...           Connect to host.n
  1267.   -u, --user=...           User for login.n
  1268.   -p[password], --password[=...]n
  1269.                            Password to use when connecting to server.n
  1270.   -D, --database=...       Database to use.n
  1271.   -P, --port=...           Port number to use for connection.n
  1272.   -S, --socket=...         Socket file to use for connection.n
  1273.   -t, --tmpdir=...    Temporary directory where sockets are putn
  1274.   -T, --sleep=#    Sleep always this many seconds on sleep commandsn
  1275.   -r, --record             Record output of test_file into result file.n
  1276.   -R, --result-file=...    Read/Store result from/in this file.n
  1277.   -v, --verbose            Write more.n
  1278.   -q, --quiet, --silent    Suppress all normal output.n
  1279.   -V, --version            Output version information and exit.n
  1280.   --no-defaults            Don't read default options from any options file.nn");
  1281. }
  1283. int parse_args(int argc, char **argv)
  1284. {
  1285.   int c, option_index = 0;
  1286.   my_bool tty_password=0;
  1288.   load_defaults("my",load_default_groups,&argc,&argv);
  1289.   default_argv= argv;
  1291.   while((c = getopt_long(argc, argv, "h:p::u:P:D:S:R:t:T:#:?rvVq",
  1292.  long_options, &option_index)) != EOF)
  1293.     {
  1294.       switch(c) {
  1295.       case '#':
  1296. DBUG_PUSH(optarg ? optarg : "d:t:O,/tmp/mysqltest.trace");
  1297. break;
  1298.       case 'v':
  1299. verbose = 1;
  1300. break;
  1301.       case 'r':
  1302. record = 1;
  1303. break;
  1304.       case 'u':
  1305. user = optarg;
  1306. break;
  1307.       case 'R':
  1308. result_file = optarg;
  1309. break;
  1310.       case 'p':
  1311. if (optarg)
  1312. {
  1313.   my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  1314.   pass=my_strdup(optarg,MYF(MY_FAE));
  1315.   while (*optarg) *optarg++= 'x'; /* Destroy argument */
  1316. }
  1317. else
  1318.   tty_password=1;
  1319. break;
  1320.       case 'P':
  1321. port = atoi(optarg);
  1322. break;
  1323.       case 'S':
  1324. unix_sock = optarg;
  1325. break;
  1326.       case 'D':
  1327. db = optarg;
  1328. break;
  1329.       case 'h':
  1330. host = optarg;
  1331. break;
  1332.       case 'q':
  1333. silent = 1;
  1334. break;
  1335.       case 't':
  1336. strnmov(TMPDIR,optarg,sizeof(TMPDIR));
  1337. break;
  1338.       case 'T':
  1339. opt_sleep=atoi(optarg);
  1340. break;
  1341.       case 'V':
  1342. print_version();
  1343. exit(0);
  1344.       case '?':
  1345. usage();
  1346. exit(1); /* Unknown option */
  1347.       default:
  1348. usage();
  1349. exit(1);
  1350.       }
  1351.     }
  1353.   argc-=optind;
  1354.   argv+=optind;
  1355.   if (argc > 1)
  1356.   {
  1357.     usage();
  1358.     exit(1);
  1359.   }
  1360.   if (argc == 1)
  1361.     db= *argv;
  1362.   if (tty_password)
  1363.     pass=get_tty_password(NullS);
  1365.   return 0;
  1366. }
  1368. char* safe_str_append(char* buf, const char* str, int size)
  1369. {
  1370.   int i,c ;
  1371.   for(i = 0; (c = *str++) &&  i < size - 1; i++)
  1372.     *buf++ = c;
  1373.   *buf = 0;
  1374.   return buf;
  1375. }
  1377. void str_to_file(const char* fname, char* str, int size)
  1378. {
  1379.   int fd;
  1380.   if ((fd = my_open(fname, O_WRONLY | O_CREAT | O_TRUNC,
  1381.     MYF(MY_WME | MY_FFNF))) < 0)
  1382.     die("Could not open %s: errno = %d", fname, errno);
  1383.   if (my_write(fd, (byte*)str, size, MYF(MY_WME|MY_FNABP)))
  1384.     die("write failed");
  1385.   my_close(fd, MYF(0));
  1386. }
  1388. void reject_dump(const char* record_file, char* buf, int size)
  1389. {
  1390.   char reject_file[FN_REFLEN];
  1391.   str_to_file(fn_format(reject_file, record_file,"",".reject",2), buf, size);
  1392. }
  1395. int run_query(MYSQL* mysql, struct st_query* q, int flags)
  1396. {
  1397.   MYSQL_RES* res = 0;
  1398.   MYSQL_FIELD* fields;
  1399.   MYSQL_ROW row;
  1400.   int num_fields,i, error = 0;
  1401.   unsigned long* lengths;
  1402.   char* val;
  1403.   int len;
  1404.   int q_error = 0 ;
  1405.   DYNAMIC_STRING *ds;
  1406.   DYNAMIC_STRING ds_tmp;
  1407.   DBUG_ENTER("run_query");
  1409.   if ( q->record_file[0])
  1410.   {
  1411.     init_dynamic_string(&ds_tmp, "", 16384, 65536);
  1412.     ds = &ds_tmp;
  1413.   }
  1414.   else
  1415.     ds= &ds_res;
  1416.   
  1417.   if ((flags & QUERY_SEND) &&
  1418.       (q_error = mysql_send_query(mysql, q->query, strlen(q->query))))
  1419.     die("At line %u: unable to send query '%s'", start_lineno, q->query);
  1420.   if(!(flags & QUERY_REAP))
  1421.     return 0;
  1422.   
  1423.   if (mysql_read_query_result(mysql))
  1424.   {
  1425.     if (q->require_file)
  1426.       abort_not_supported_test();
  1427.     if (q->abort_on_error)
  1428.       die("At line %u: query '%s' failed: %d: %s", start_lineno, q->query,
  1429.   mysql_errno(mysql), mysql_error(mysql));
  1430.     else
  1431.     {
  1432.       for (i=0 ; q->expected_errno[i] ; i++)
  1433.       {
  1434. if ((q->expected_errno[i] == mysql_errno(mysql)))
  1435.   goto end; /* Ok */
  1436.       }
  1437.       if (i)
  1438.       {
  1439. verbose_msg("query '%s' failed with wrong errno
  1440.  %d instead of %d...", q->query, mysql_errno(mysql), q->expected_errno[0]);
  1441. goto end;
  1442.       }
  1443.       verbose_msg("query '%s' failed: %d: %s", q->query, mysql_errno(mysql),
  1444.   mysql_error(mysql));
  1445.       /* if we do not abort on error, failure to run the query does
  1446.  not fail the whole test case
  1447.       */
  1448.       goto end;
  1449.     }
  1450.   }
  1452.   if (q->expected_errno[0])
  1453.   {
  1454.     error = 1;
  1455.     verbose_msg("query '%s' succeeded - should have failed with errno %d...",
  1456. q->query, q->expected_errno[0]);
  1457.     goto end;
  1458.   }
  1461.   if (!(res = mysql_store_result(mysql)) && mysql_field_count(mysql))
  1462.   {
  1463.     if (q->require_file)
  1464.       abort_not_supported_test();
  1465.     if (q->abort_on_error)
  1466.       die("At line %u: Failed in mysql_store_result for query '%s' (%d)",
  1467.   start_lineno, q->query, mysql_errno(mysql));
  1468.     else
  1469.     {
  1470.       verbose_msg("failed in mysql_store_result for query '%s' (%d)", q->query,
  1471.   mysql_errno(mysql));
  1472.       error = 1;
  1473.       goto end;
  1474.     }
  1475.   }
  1477.   if (!res) goto end;
  1479.   fields =  mysql_fetch_fields(res);
  1480.   num_fields = mysql_num_fields(res);
  1481.   for( i = 0; i < num_fields; i++)
  1482.   {
  1483.     if (i)
  1484.       dynstr_append_mem(ds, "t", 1);
  1485.     dynstr_append(ds, fields[i].name);
  1486.   }
  1488.   dynstr_append_mem(ds, "n", 1);
  1491.   while((row = mysql_fetch_row(res)))
  1492.   {
  1493.     lengths = mysql_fetch_lengths(res);
  1494.     for(i = 0; i < num_fields; i++)
  1495.     {
  1496.       val = (char*)row[i];
  1497.       len = lengths[i];
  1499.       if (!val)
  1500.       {
  1501. val = (char*)"NULL";
  1502. len = 4;
  1503.       }
  1505.       if (i)
  1506. dynstr_append_mem(ds, "t", 1);
  1507.       if (glob_replace)
  1508.       {
  1509. len=(int) replace_strings(glob_replace, &out_buff, &out_length, val);
  1510. if (len == -1)
  1511.   die("Out of memory in replacen");
  1512. val=out_buff;
  1513.       }
  1514.       dynstr_append_mem(ds, val, len);
  1515.     }
  1517.     dynstr_append_mem(ds, "n", 1);
  1518.   }
  1519.   if (glob_replace)
  1520.     free_replace();
  1522.   if (record)
  1523.   {
  1524.     if (!q->record_file[0] && !result_file)
  1525.       die("At line %u: Missing result file", start_lineno);
  1526.     if (!result_file)
  1527.       str_to_file(q->record_file, ds->str, ds->length);
  1528.   }
  1529.   else if (q->record_file[0])
  1530.   {
  1531.     error = check_result(ds, q->record_file, q->require_file);
  1532.   }
  1534. end:
  1535.   if (res) mysql_free_result(res);
  1536.   if (ds == &ds_tmp)
  1537.     dynstr_free(&ds_tmp);
  1538.   DBUG_RETURN(error);
  1539. }
  1542. void get_query_type(struct st_query* q)
  1543. {
  1544.   char save;
  1545.   uint type;
  1546.   if (*q->query == '}')
  1547.   {
  1548.     q->type = Q_END_BLOCK;
  1549.     return;
  1550.   }
  1551.   if (q->type != Q_COMMENT_WITH_COMMAND)
  1552.     q->type = Q_QUERY;
  1554.   save=q->query[q->first_word_len];
  1555.   q->query[q->first_word_len]=0;
  1556.   type=find_type(q->query, &command_typelib, 1+2);
  1557.   q->query[q->first_word_len]=save;
  1558.   if (type > 0)
  1559.     q->type=type; /* Found command */
  1560. }
  1563. int main(int argc, char** argv)
  1564. {
  1565.   int error = 0;
  1566.   struct st_query* q;
  1567.   my_bool require_file=0,q_send_flag=0;
  1568.   char save_file[FN_REFLEN];
  1569.   MY_INIT(argv[0]);
  1571.   save_file[0]=0;
  1572.   TMPDIR[0]=0;
  1573.   memset(cons, 0, sizeof(cons));
  1574.   cons_end = cons + MAX_CONS;
  1575.   next_con = cons + 1;
  1576.   cur_con = cons;
  1578.   memset(file_stack, 0, sizeof(file_stack));
  1579.   memset(&master_pos, 0, sizeof(master_pos));
  1580.   file_stack_end = file_stack + MAX_INCLUDE_DEPTH;
  1581.   cur_file = file_stack;
  1582.   lineno   = lineno_stack;
  1583.   init_dynamic_array(&q_lines, sizeof(struct st_query*), INIT_Q_LINES,
  1584.      INIT_Q_LINES);
  1585.   memset(block_stack, 0, sizeof(block_stack));
  1586.   block_stack_end = block_stack + BLOCK_STACK_DEPTH;
  1587.   cur_block = block_stack;
  1588.   init_dynamic_string(&ds_res, "", 0, 65536);
  1589.   parse_args(argc, argv);
  1590.   if (!*cur_file)
  1591.     *cur_file = stdin;
  1592.   *lineno=1;
  1594.   if (!( mysql_init(&cur_con->mysql)))
  1595.     die("Failed in mysql_init()");
  1596.   cur_con->name = my_strdup("default", MYF(MY_WME));
  1597.   if (!cur_con->name)
  1598.     die("Out of memory");
  1600.   if (!mysql_real_connect(&cur_con->mysql, host,
  1601.  user, pass, db, port, unix_sock,
  1602.      0))
  1603.     die("Failed in mysql_real_connect(): %s", mysql_error(&cur_con->mysql));
  1605.   while (!read_query(&q))
  1606.   {
  1607.     int current_line_inc = 1, processed = 0;
  1608.     if (q->type == Q_UNKNOWN || q->type == Q_COMMENT_WITH_COMMAND)
  1609.       get_query_type(q);
  1610.     if (block_ok)
  1611.     {
  1612.       processed = 1;
  1613.       switch (q->type) {
  1614.       case Q_CONNECT: do_connect(q); break;
  1615.       case Q_CONNECTION: select_connection(q); break;
  1616.       case Q_DISCONNECT:
  1617.       case Q_DIRTY_CLOSE:
  1618. close_connection(q); break;
  1619.       case Q_SOURCE: do_source(q); break;
  1620.       case Q_SLEEP: do_sleep(q); break;
  1621.       case Q_INC: do_inc(q); break;
  1622.       case Q_DEC: do_dec(q); break;
  1623.       case Q_ECHO: do_echo(q); break;
  1624.       case Q_SYSTEM: do_system(q); break;
  1625.       case Q_LET: do_let(q); break;
  1626.       case Q_QUERY:
  1627.       case Q_REAP:
  1628.       {
  1629. int flags = QUERY_REAP;
  1630. if (q->type == Q_QUERY)
  1631.   flags |= QUERY_SEND;
  1632. if (q_send_flag)
  1633. {
  1634.   flags=QUERY_SEND;
  1635.   q_send_flag=0;
  1636. }
  1637. if (save_file[0])
  1638. {
  1639.   strmov(q->record_file,save_file);
  1640.   q->require_file=require_file;
  1641.   save_file[0]=0;
  1642. }
  1643. error |= run_query(&cur_con->mysql, q, flags);
  1644. break;
  1645.       }
  1646.       case Q_SEND:
  1647. q_send_flag=1;
  1648. break;
  1649.       case Q_RESULT:
  1650. get_file_name(save_file,q);
  1651. require_file=0;
  1652. break;
  1653.       case Q_ERROR:
  1654. get_ints(global_expected_errno,q);
  1655. break;
  1656.       case Q_REQUIRE:
  1657. get_file_name(save_file,q);
  1658. require_file=1;
  1659. break;
  1660.       case Q_REPLACE:
  1661. get_replace(q);
  1662. break;
  1663.       case Q_SAVE_MASTER_POS: do_save_master_pos(q); break;
  1664.       case Q_SYNC_WITH_MASTER: do_sync_with_master(q); break;
  1665.       case Q_COMMENT: /* Ignore row */
  1666.       case Q_COMMENT_WITH_COMMAND:
  1667.       case Q_PING:
  1668. (void) mysql_ping(&cur_con->mysql);
  1669. break;
  1670.       default: processed = 0; break;
  1671.       }
  1672.     }
  1674.     if (!processed)
  1675.     {
  1676.       current_line_inc = 0;
  1677.       switch(q->type)
  1678.       {
  1679.       case Q_WHILE: do_while(q); break;
  1680.       case Q_END_BLOCK: do_done(q); break;
  1681.       default: current_line_inc = 1; break;
  1682.       }
  1683.     }
  1685.     parser.current_line += current_line_inc;
  1686.   }
  1688.   if (result_file && ds_res.length)
  1689.   {
  1690.     if (!record)
  1691.       error |= check_result(&ds_res, result_file, q->require_file);
  1692.     else
  1693.       str_to_file(result_file, ds_res.str, ds_res.length);
  1694.   }
  1695.   dynstr_free(&ds_res);
  1697.   if (!silent) {
  1698.     if(error)
  1699.       printf("not okn");
  1700.     else
  1701.       printf("okn");
  1702.   }
  1704.   free_used_memory();
  1705.   exit(error ? 1 : 0);
  1706.   return error ? 1 : 0; /* Keep compiler happy */
  1707. }
  1710. /****************************************************************************
  1711. * Handle replacement of strings
  1712. ****************************************************************************/
  1714. #define PC_MALLOC 256 /* Bytes for pointers */
  1715. #define PS_MALLOC 512 /* Bytes for data */
  1717. #define SPACE_CHAR 256
  1718. #define START_OF_LINE 257
  1719. #define END_OF_LINE 258
  1720. #define LAST_CHAR_CODE 259
  1722. typedef struct st_replace {
  1723.   bool   found;
  1724.   struct st_replace *next[256];
  1725. } REPLACE;
  1727. typedef struct st_replace_found {
  1728.   bool found;
  1729.   char *replace_string;
  1730.   uint to_offset;
  1731.   int from_offset;
  1732. } REPLACE_STRING;
  1734. #ifndef WORD_BIT
  1735. #define WORD_BIT (8*sizeof(uint))
  1736. #endif
  1739. static int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name)
  1740. {
  1741.   uint i,length,old_count;
  1742.   byte *new_pos;
  1743.   const char **new_array;
  1744.   DBUG_ENTER("insert_pointer_name");
  1746.   if (! pa->typelib.count)
  1747.   {
  1748.     if (!(pa->typelib.type_names=(const char **)
  1749.   my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
  1750.      (sizeof(my_string)+sizeof(*pa->flag))*
  1751.      (sizeof(my_string)+sizeof(*pa->flag))),MYF(MY_WME))))
  1752.       DBUG_RETURN(-1);
  1753.     if (!(pa->str= (byte*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
  1754.      MYF(MY_WME))))
  1755.     {
  1756.       my_free((gptr) pa->typelib.type_names,MYF(0));
  1757.       DBUG_RETURN (-1);
  1758.     }
  1759.     pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(byte*)+
  1760.        sizeof(*pa->flag));
  1761.     pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
  1762.     pa->length=0;
  1763.     pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
  1764.     pa->array_allocs=1;
  1765.   }
  1766.   length=(uint) strlen(name)+1;
  1767.   if (pa->length+length >= pa->max_length)
  1768.   {
  1769.     if (!(new_pos= (byte*) my_realloc((gptr) pa->str,
  1770.       (uint) (pa->max_length+PS_MALLOC),
  1771.       MYF(MY_WME))))
  1772.       DBUG_RETURN(1);
  1773.     if (new_pos != pa->str)
  1774.     {
  1775.       my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
  1776.       for (i=0 ; i < pa->typelib.count ; i++)
  1777. pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
  1778.       char*);
  1779.       pa->str=new_pos;
  1780.     }
  1781.     pa->max_length+=PS_MALLOC;
  1782.   }
  1783.   if (pa->typelib.count >= pa->max_count-1)
  1784.   {
  1785.     int len;
  1786.     pa->array_allocs++;
  1787.     len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
  1788.     if (!(new_array=(const char **) my_realloc((gptr) pa->typelib.type_names,
  1789.        (uint) len/
  1790.  (sizeof(byte*)+sizeof(*pa->flag))*
  1791.  (sizeof(byte*)+sizeof(*pa->flag)),
  1792.  MYF(MY_WME))))
  1793.       DBUG_RETURN(1);
  1794.     pa->typelib.type_names=new_array;
  1795.     old_count=pa->max_count;
  1796.     pa->max_count=len/(sizeof(byte*) + sizeof(*pa->flag));
  1797.     pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
  1798.     memcpy((byte*) pa->flag,(my_string) (pa->typelib.type_names+old_count),
  1799.    old_count*sizeof(*pa->flag));
  1800.   }
  1801.   pa->flag[pa->typelib.count]=0; /* Reset flag */
  1802.   pa->typelib.type_names[pa->typelib.count++]= pa->str+pa->length;
  1803.   pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
  1804.   VOID(strmov(pa->str+pa->length,name));
  1805.   pa->length+=length;
  1806.   DBUG_RETURN(0);
  1807. } /* insert_pointer_name */
  1810. /* free pointer array */
  1812. void free_pointer_array(POINTER_ARRAY *pa)
  1813. {
  1814.   if (pa->typelib.count)
  1815.   {
  1816.     pa->typelib.count=0;
  1817.     my_free((gptr) pa->typelib.type_names,MYF(0));
  1818.     pa->typelib.type_names=0;
  1819.     my_free((gptr) pa->str,MYF(0));
  1820.   }
  1821. } /* free_pointer_array */
  1824. /* Code for replace rutines */
  1826. #define SET_MALLOC_HUNC 64
  1828. typedef struct st_rep_set {
  1829.   uint  *bits; /* Pointer to used sets */
  1830.   short next[LAST_CHAR_CODE]; /* Pointer to next sets */
  1831.   uint found_len; /* Best match to date */
  1832.   int found_offset;
  1833.   uint  table_offset;
  1834.   uint  size_of_bits; /* For convinience */
  1835. } REP_SET;
  1837. typedef struct st_rep_sets {
  1838.   uint count; /* Number of sets */
  1839.   uint extra; /* Extra sets in buffer */
  1840.   uint invisible; /* Sets not chown */
  1841.   uint size_of_bits;
  1842.   REP_SET *set,*set_buffer;
  1843.   uint *bit_buffer;
  1844. } REP_SETS;
  1846. typedef struct st_found_set {
  1847.   uint table_offset;
  1848.   int found_offset;
  1849. } FOUND_SET;
  1851. typedef struct st_follow {
  1852.   int chr;
  1853.   uint table_offset;
  1854.   uint len;
  1855. } FOLLOWS;
  1858. static int init_sets(REP_SETS *sets,uint states);
  1859. static REP_SET *make_new_set(REP_SETS *sets);
  1860. static void make_sets_invisible(REP_SETS *sets);
  1861. static void free_last_set(REP_SETS *sets);
  1862. static void free_sets(REP_SETS *sets);
  1863. static void set_bit(REP_SET *set, uint bit);
  1864. static void clear_bit(REP_SET *set, uint bit);
  1865. static void or_bits(REP_SET *to,REP_SET *from);
  1866. static void copy_bits(REP_SET *to,REP_SET *from);
  1867. static int cmp_bits(REP_SET *set1,REP_SET *set2);
  1868. static int get_next_bit(REP_SET *set,uint lastpos);
  1869. static int find_set(REP_SETS *sets,REP_SET *find);
  1870. static int find_found(FOUND_SET *found_set,uint table_offset,
  1871.   int found_offset);
  1872. static uint start_at_word(my_string pos);
  1873. static uint end_of_word(my_string pos);
  1874. static uint replace_len(my_string pos);
  1876. static uint found_sets=0;
  1879. /* Init a replace structure for further calls */
  1881. REPLACE *init_replace(my_string *from, my_string *to,uint count,
  1882.       my_string word_end_chars)
  1883. {
  1884.   uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
  1885.   int used_sets,chr,default_state;
  1886.   char used_chars[LAST_CHAR_CODE],is_word_end[256];
  1887.   my_string pos,to_pos,*to_array;
  1888.   REP_SETS sets;
  1889.   REP_SET *set,*start_states,*word_states,*new_set;
  1890.   FOLLOWS *follow,*follow_ptr;
  1891.   REPLACE *replace;
  1892.   FOUND_SET *found_set;
  1893.   REPLACE_STRING *rep_str;
  1894.   DBUG_ENTER("init_replace");
  1896.   /* Count number of states */
  1897.   for (i=result_len=max_length=0 , states=2 ; i < count ; i++)
  1898.   {
  1899.     len=replace_len(from[i]);
  1900.     if (!len)
  1901.     {
  1902.       errno=EINVAL;
  1903.       my_message(0,"No to-string for last from-string",MYF(ME_BELL));
  1904.       DBUG_RETURN(0);
  1905.     }
  1906.     states+=len+1;
  1907.     result_len+=(uint) strlen(to[i])+1;
  1908.     if (len > max_length)
  1909.       max_length=len;
  1910.   }
  1911.   bzero((char*) is_word_end,sizeof(is_word_end));
  1912.   for (i=0 ; word_end_chars[i] ; i++)
  1913.     is_word_end[(uchar) word_end_chars[i]]=1;
  1915.   if (init_sets(&sets,states))
  1916.     DBUG_RETURN(0);
  1917.   found_sets=0;
  1918.   if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
  1919.   MYF(MY_WME))))
  1920.   {
  1921.     free_sets(&sets);
  1922.     DBUG_RETURN(0);
  1923.   }
  1924.   VOID(make_new_set(&sets)); /* Set starting set */
  1925.   make_sets_invisible(&sets); /* Hide previus sets */
  1926.   used_sets=-1;
  1927.   word_states=make_new_set(&sets); /* Start of new word */
  1928.   start_states=make_new_set(&sets); /* This is first state */
  1929.   if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
  1930.   {
  1931.     free_sets(&sets);
  1932.     my_free((gptr) found_set,MYF(0));
  1933.     DBUG_RETURN(0);
  1934.   }
  1936. /* Init follow_ptr[] */
  1937.   for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
  1938.   {
  1939.     if (from[i][0] == '\' && from[i][1] == '^')
  1940.     {
  1941.       set_bit(start_states,states+1);
  1942.       if (!from[i][2])
  1943.       {
  1944. start_states->table_offset=i;
  1945. start_states->found_offset=1;
  1946.       }
  1947.     }
  1948.     else if (from[i][0] == '\' && from[i][1] == '$')
  1949.     {
  1950.       set_bit(start_states,states);
  1951.       set_bit(word_states,states);
  1952.       if (!from[i][2] && start_states->table_offset == (uint) ~0)
  1953.       {
  1954. start_states->table_offset=i;
  1955. start_states->found_offset=0;
  1956.       }
  1957.     }
  1958.     else
  1959.     {
  1960.       set_bit(word_states,states);
  1961.       if (from[i][0] == '\' && (from[i][1] == 'b' && from[i][2]))
  1962. set_bit(start_states,states+1);
  1963.       else
  1964. set_bit(start_states,states);
  1965.     }
  1966.     for (pos=from[i], len=0; *pos ; pos++)
  1967.     {
  1968.       if (*pos == '\' && *(pos+1))
  1969.       {
  1970. pos++;
  1971. switch (*pos) {
  1972. case 'b':
  1973.   follow_ptr->chr = SPACE_CHAR;
  1974.   break;
  1975. case '^':
  1976.   follow_ptr->chr = START_OF_LINE;
  1977.   break;
  1978. case '$':
  1979.   follow_ptr->chr = END_OF_LINE;
  1980.   break;
  1981. case 'r':
  1982.   follow_ptr->chr = 'r';
  1983.   break;
  1984. case 't':
  1985.   follow_ptr->chr = 't';
  1986.   break;
  1987. case 'v':
  1988.   follow_ptr->chr = 'v';
  1989.   break;
  1990. default:
  1991.   follow_ptr->chr = (uchar) *pos;
  1992.   break;
  1993. }
  1994.       }
  1995.       else
  1996. follow_ptr->chr= (uchar) *pos;
  1997.       follow_ptr->table_offset=i;
  1998.       follow_ptr->len= ++len;
  1999.       follow_ptr++;
  2000.     }
  2001.     follow_ptr->chr=0;
  2002.     follow_ptr->table_offset=i;
  2003.     follow_ptr->len=len;
  2004.     follow_ptr++;
  2005.     states+=(uint) len+1;
  2006.   }
  2009.   for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
  2010.   {
  2011.     set=sets.set+set_nr;
  2012.     default_state= 0; /* Start from beginning */
  2014.     /* If end of found-string not found or start-set with current set */
  2016.     for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
  2017.     {
  2018.       if (!follow[i].chr)
  2019.       {
  2020. if (! default_state)
  2021.   default_state= find_found(found_set,set->table_offset,
  2022.     set->found_offset+1);
  2023.       }
  2024.     }
  2025.     copy_bits(sets.set+used_sets,set); /* Save set for changes */
  2026.     if (!default_state)
  2027.       or_bits(sets.set+used_sets,sets.set); /* Can restart from start */
  2029.     /* Find all chars that follows current sets */
  2030.     bzero((char*) used_chars,sizeof(used_chars));
  2031.     for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
  2032.     {
  2033.       used_chars[follow[i].chr]=1;
  2034.       if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
  2035.    follow[i].len > 1) || follow[i].chr == END_OF_LINE)
  2036. used_chars[0]=1;
  2037.     }
  2039.     /* Mark word_chars used if b is in state */
  2040.     if (used_chars[SPACE_CHAR])
  2041.       for (pos= word_end_chars ; *pos ; pos++)
  2042. used_chars[(int) (uchar) *pos] = 1;
  2044.     /* Handle other used characters */
  2045.     for (chr= 0 ; chr < 256 ; chr++)
  2046.     {
  2047.       if (! used_chars[chr])
  2048. set->next[chr]= chr ? default_state : -1;
  2049.       else
  2050.       {
  2051. new_set=make_new_set(&sets);
  2052. set=sets.set+set_nr; /* if realloc */
  2053. new_set->table_offset=set->table_offset;
  2054. new_set->found_len=set->found_len;
  2055. new_set->found_offset=set->found_offset+1;
  2056. found_end=0;
  2058. for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
  2059. {
  2060.   if (!follow[i].chr || follow[i].chr == chr ||
  2061.       (follow[i].chr == SPACE_CHAR &&
  2062.        (is_word_end[chr] ||
  2063. (!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
  2064.       (follow[i].chr == END_OF_LINE && ! chr))
  2065.   {
  2066.     if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
  2067. follow[i].len > found_end)
  2068.       found_end=follow[i].len;
  2069.     if (chr && follow[i].chr)
  2070.       set_bit(new_set,i+1); /* To next set */
  2071.     else
  2072.       set_bit(new_set,i);
  2073.   }
  2074. }
  2075. if (found_end)
  2076. {
  2077.   new_set->found_len=0; /* Set for testing if first */
  2078.   bits_set=0;
  2079.   for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
  2080.   {
  2081.     if ((follow[i].chr == SPACE_CHAR ||
  2082.  follow[i].chr == END_OF_LINE) && ! chr)
  2083.       bit_nr=i+1;
  2084.     else
  2085.       bit_nr=i;
  2086.     if (follow[bit_nr-1].len < found_end ||
  2087. (new_set->found_len &&
  2088.  (chr == 0 || !follow[bit_nr].chr)))
  2089.       clear_bit(new_set,i);
  2090.     else
  2091.     {
  2092.       if (chr == 0 || !follow[bit_nr].chr)
  2093.       { /* best match  */
  2094. new_set->table_offset=follow[bit_nr].table_offset;
  2095. if (chr || (follow[i].chr == SPACE_CHAR ||
  2096.     follow[i].chr == END_OF_LINE))
  2097.   new_set->found_offset=found_end; /* New match */
  2098. new_set->found_len=found_end;
  2099.       }
  2100.       bits_set++;
  2101.     }
  2102.   }
  2103.   if (bits_set == 1)
  2104.   {
  2105.     set->next[chr] = find_found(found_set,
  2106. new_set->table_offset,
  2107. new_set->found_offset);
  2108.     free_last_set(&sets);
  2109.   }
  2110.   else
  2111.     set->next[chr] = find_set(&sets,new_set);
  2112. }
  2113. else
  2114.   set->next[chr] = find_set(&sets,new_set);
  2115.       }
  2116.     }
  2117.   }
  2119. /* Alloc replace structure for the replace-state-machine */
  2121.   if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
  2122.     sizeof(REPLACE_STRING)*(found_sets+1)+
  2123.     sizeof(my_string)*count+result_len,
  2124.     MYF(MY_WME | MY_ZEROFILL))))
  2125.   {
  2126.     rep_str=(REPLACE_STRING*) (replace+sets.count);
  2127.     to_array=(my_string*) (rep_str+found_sets+1);
  2128.     to_pos=(my_string) (to_array+count);
  2129.     for (i=0 ; i < count ; i++)
  2130.     {
  2131.       to_array[i]=to_pos;
  2132.       to_pos=strmov(to_pos,to[i])+1;
  2133.     }
  2134.     rep_str[0].found=1;
  2135.     rep_str[0].replace_string=0;
  2136.     for (i=1 ; i <= found_sets ; i++)
  2137.     {
  2138.       pos=from[found_set[i-1].table_offset];
  2139.       rep_str[i].found= !bcmp(pos,"\^",3) ? 2 : 1;
  2140.       rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
  2141.       rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
  2142.       rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
  2143. end_of_word(pos);
  2144.     }
  2145.     for (i=0 ; i < sets.count ; i++)
  2146.     {
  2147.       for (j=0 ; j < 256 ; j++)
  2148. if (sets.set[i].next[j] >= 0)
  2149.   replace[i].next[j]=replace+sets.set[i].next[j];
  2150. else
  2151.   replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
  2152.     }
  2153.   }
  2154.   my_free((gptr) follow,MYF(0));
  2155.   free_sets(&sets);
  2156.   my_free((gptr) found_set,MYF(0));
  2157.   DBUG_PRINT("exit",("Replace table has %d states",sets.count));
  2158.   DBUG_RETURN(replace);
  2159. }
  2162. static int init_sets(REP_SETS *sets,uint states)
  2163. {
  2164.   bzero((char*) sets,sizeof(*sets));
  2165.   sets->size_of_bits=((states+7)/8);
  2166.   if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
  2167.       MYF(MY_WME))))
  2168.     return 1;
  2169.   if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
  2170.    SET_MALLOC_HUNC,MYF(MY_WME))))
  2171.   {
  2172.     my_free((gptr) sets->set,MYF(0));
  2173.     return 1;
  2174.   }
  2175.   return 0;
  2176. }
  2178. /* Make help sets invisible for nicer codeing */
  2180. static void make_sets_invisible(REP_SETS *sets)
  2181. {
  2182.   sets->invisible=sets->count;
  2183.   sets->set+=sets->count;
  2184.   sets->count=0;
  2185. }
  2187. static REP_SET *make_new_set(REP_SETS *sets)
  2188. {
  2189.   uint i,count,*bit_buffer;
  2190.   REP_SET *set;
  2191.   if (sets->extra)
  2192.   {
  2193.     sets->extra--;
  2194.     set=sets->set+ sets->count++;
  2195.     bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
  2196.     bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
  2197.     set->found_offset=0;
  2198.     set->found_len=0;
  2199.     set->table_offset= (uint) ~0;
  2200.     set->size_of_bits=sets->size_of_bits;
  2201.     return set;
  2202.   }
  2203.   count=sets->count+sets->invisible+SET_MALLOC_HUNC;
  2204.   if (!(set=(REP_SET*) my_realloc((gptr) sets->set_buffer,
  2205.    sizeof(REP_SET)*count,
  2206.   MYF(MY_WME))))
  2207.     return 0;
  2208.   sets->set_buffer=set;
  2209.   sets->set=set+sets->invisible;
  2210.   if (!(bit_buffer=(uint*) my_realloc((gptr) sets->bit_buffer,
  2211.       (sizeof(uint)*sets->size_of_bits)*count,
  2212.       MYF(MY_WME))))
  2213.     return 0;
  2214.   sets->bit_buffer=bit_buffer;
  2215.   for (i=0 ; i < count ; i++)
  2216.   {
  2217.     sets->set_buffer[i].bits=bit_buffer;
  2218.     bit_buffer+=sets->size_of_bits;
  2219.   }
  2220.   sets->extra=SET_MALLOC_HUNC;
  2221.   return make_new_set(sets);
  2222. }
  2224. static void free_last_set(REP_SETS *sets)
  2225. {
  2226.   sets->count--;
  2227.   sets->extra++;
  2228.   return;
  2229. }
  2231. static void free_sets(REP_SETS *sets)
  2232. {
  2233.   my_free((gptr)sets->set_buffer,MYF(0));
  2234.   my_free((gptr)sets->bit_buffer,MYF(0));
  2235.   return;
  2236. }
  2238. static void set_bit(REP_SET *set, uint bit)
  2239. {
  2240.   set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
  2241.   return;
  2242. }
  2244. static void clear_bit(REP_SET *set, uint bit)
  2245. {
  2246.   set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
  2247.   return;
  2248. }
  2251. static void or_bits(REP_SET *to,REP_SET *from)
  2252. {
  2253.   reg1 uint i;
  2254.   for (i=0 ; i < to->size_of_bits ; i++)
  2255.     to->bits[i]|=from->bits[i];
  2256.   return;
  2257. }
  2259. static void copy_bits(REP_SET *to,REP_SET *from)
  2260. {
  2261.   memcpy((byte*) to->bits,(byte*) from->bits,
  2262.  (size_t) (sizeof(uint) * to->size_of_bits));
  2263. }
  2265. static int cmp_bits(REP_SET *set1,REP_SET *set2)
  2266. {
  2267.   return bcmp((byte*) set1->bits,(byte*) set2->bits,
  2268.       sizeof(uint) * set1->size_of_bits);
  2269. }
  2272. /* Get next set bit from set. */
  2274. static int get_next_bit(REP_SET *set,uint lastpos)
  2275. {
  2276.   uint pos,*start,*end,bits;
  2278.   start=set->bits+ ((lastpos+1) / WORD_BIT);
  2279.   end=set->bits + set->size_of_bits;
  2280.   bits=start[0] & ~((1 << ((lastpos+1) % WORD_BIT)) -1);
  2282.   while (! bits && ++start < end)
  2283.     bits=start[0];
  2284.   if (!bits)
  2285.     return 0;
  2286.   pos=(uint) (start-set->bits)*WORD_BIT;
  2287.   while (! (bits & 1))
  2288.   {
  2289.     bits>>=1;
  2290.     pos++;
  2291.   }
  2292.   return pos;
  2293. }
  2295. /* find if there is a same set in sets. If there is, use it and
  2296.    free given set, else put in given set in sets and return it's
  2297.    position */
  2299. static int find_set(REP_SETS *sets,REP_SET *find)
  2300. {
  2301.   uint i;
  2302.   for (i=0 ; i < sets->count-1 ; i++)
  2303.   {
  2304.     if (!cmp_bits(sets->set+i,find))
  2305.     {
  2306.       free_last_set(sets);
  2307.       return i;
  2308.     }
  2309.   }
  2310.   return i; /* return new postion */
  2311. }
  2313. /* find if there is a found_set with same table_offset & found_offset
  2314.    If there is return offset to it, else add new offset and return pos.
  2315.    Pos returned is -offset-2 in found_set_structure because it's is
  2316.    saved in set->next and set->next[] >= 0 points to next set and
  2317.    set->next[] == -1 is reserved for end without replaces.
  2318.    */
  2320. static int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
  2321. {
  2322.   int i;
  2323.   for (i=0 ; (uint) i < found_sets ; i++)
  2324.     if (found_set[i].table_offset == table_offset &&
  2325. found_set[i].found_offset == found_offset)
  2326.       return -i-2;
  2327.   found_set[i].table_offset=table_offset;
  2328.   found_set[i].found_offset=found_offset;
  2329.   found_sets++;
  2330.   return -i-2; /* return new postion */
  2331. }
  2333. /* Return 1 if regexp starts with b or ends with b*/
  2335. static uint start_at_word(my_string pos)
  2336. {
  2337.   return (((!bcmp(pos,"\b",2) && pos[2]) || !bcmp(pos,"\^",2)) ? 1 : 0);
  2338. }
  2340. static uint end_of_word(my_string pos)
  2341. {
  2342.   my_string end=strend(pos);
  2343.   return ((end > pos+2 && !bcmp(end-2,"\b",2)) ||
  2344.   (end >= pos+2 && !bcmp(end-2,"\$",2))) ?
  2345.     1 : 0;
  2346. }
  2349. static uint replace_len(my_string str)
  2350. {
  2351.   uint len=0;
  2352.   while (*str)
  2353.   {
  2354.     if (str[0] == '\' && str[1])
  2355.       str++;
  2356.     str++;
  2357.     len++;
  2358.   }
  2359.   return len;
  2360. }
  2363. /* Replace strings;  Return length of result string */
  2365. uint replace_strings(REPLACE *rep, my_string *start,uint *max_length, 
  2366.      my_string from)
  2367. {
  2368.   reg1 REPLACE *rep_pos;
  2369.   reg2 REPLACE_STRING *rep_str;
  2370.   my_string to,end,pos,new;
  2372.   end=(to= *start) + *max_length-1;
  2373.   rep_pos=rep+1;
  2374.   for(;;)
  2375.   {
  2376.     while (!rep_pos->found)
  2377.     {
  2378.       rep_pos= rep_pos->next[(uchar) *from];
  2379.       if (to == end)
  2380.       {
  2381. (*max_length)+=8192;
  2382. if (!(new=my_realloc(*start,*max_length,MYF(MY_WME))))
  2383.   return (uint) -1;
  2384. to=new+(to - *start);
  2385. end=(*start=new)+ *max_length-1;
  2386.       }
  2387.       *to++= *from++;
  2388.     }
  2389.     if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
  2390.       return (uint) (to - *start)-1;
  2391.     to-=rep_str->to_offset;
  2392.     for (pos=rep_str->replace_string; *pos ; pos++)
  2393.     {
  2394.       if (to == end)
  2395.       {
  2396. (*max_length)*=2;
  2397. if (!(new=my_realloc(*start,*max_length,MYF(MY_WME))))
  2398.   return (uint) -1;
  2399. to=new+(to - *start);
  2400. end=(*start=new)+ *max_length-1;
  2401.       }
  2402.       *to++= *pos;
  2403.     }
  2404.     if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
  2405.       return (uint) (to - *start);
  2406.     rep_pos=rep;
  2407.   }
  2408. }
  2410. static int initialize_replace_buffer(void)
  2411. {
  2412.   out_length=8192;
  2413.   if (!(out_buff=my_malloc(out_length,MYF(MY_WME))))
  2414.     return(1);
  2415.   return 0;
  2416. }
  2418. static void free_replace_buffer(void)
  2419. {
  2420.   my_free(out_buff,MYF(MY_WME));
  2421. }