← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/mysqltest.cc

  • Committer: Brian Aker
  • Date: 2008-07-08 21:36:11 UTC
  • mfrom: (77.1.34 codestyle)
  • Revision ID: brian@tangent.org-20080708213611-b0k2zy8eldttqct3
Merging up Monty's changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/mysqltest.cc
32
32
*/
33
33
 
34
34
#define MTEST_VERSION "3.3"
 
35
#include <pcrecpp.h>
35
36
 
36
37
#include "client_priv.h"
37
38
#include <mysql_version.h>
41
42
#include <hash.h>
42
43
#include <stdarg.h>
43
44
#include <violite.h>
44
 
#include "my_regex.h" /* Our own version of regex */
45
45
#ifdef HAVE_SYS_WAIT_H
46
46
#include <sys/wait.h>
47
47
#endif
152
152
 
153
153
static ulonglong progress_start= 0;
154
154
 
155
 
static void free_re(void);
156
 
 
157
155
DYNAMIC_ARRAY q_lines;
158
156
 
159
 
struct
160
 
{
 
157
typedef struct {
161
158
  int read_lines,current_line;
162
 
} parser;
 
159
} parser_st;
 
160
parser_st parser;
163
161
 
164
 
struct
 
162
typedef struct
165
163
{
166
164
  char file[FN_REFLEN];
167
165
  ulong pos;
168
 
} master_pos;
 
166
} master_pos_st;
 
167
 
 
168
master_pos_st master_pos;
169
169
 
170
170
/* if set, all results are concated and compared against this file */
171
171
const char *result_file_name= 0;
888
888
  free_all_replace();
889
889
  my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
890
890
  free_defaults(default_argv);
891
 
  free_re();
892
891
 
893
892
  /* Only call mysql_server_end if mysql_server_init has been called */
894
893
  if (server_initialized)
1633
1632
  tmp_var->name = (name) ? (char*) tmp_var + sizeof(*tmp_var) : 0;
1634
1633
  tmp_var->alloced = (v == 0);
1635
1634
 
1636
 
  if (!(tmp_var->str_val = my_malloc(val_alloc_len+1, MYF(MY_WME))))
 
1635
  if (!(tmp_var->str_val = (char *)my_malloc(val_alloc_len+1, MYF(MY_WME))))
1637
1636
    die("Out of memory");
1638
1637
 
1639
1638
  memcpy(tmp_var->name, name, name_len);
2045
2044
  /* Alloc/realloc data for str_val in dest */
2046
2045
  if (dest->alloced_len < src->alloced_len &&
2047
2046
      !(dest->str_val= dest->str_val
2048
 
        ? my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
2049
 
        : my_malloc(src->alloced_len, MYF(MY_WME))))
 
2047
        ? (char *)my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
 
2048
        : (char *)my_malloc(src->alloced_len, MYF(MY_WME))))
2050
2049
    die("Out of memory");
2051
2050
  else
2052
2051
    dest->alloced_len= src->alloced_len;
2104
2103
      v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
2105
2104
        MIN_VAR_ALLOC : new_val_len + 1;
2106
2105
      if (!(v->str_val =
2107
 
            v->str_val ? my_realloc(v->str_val, v->alloced_len+1,
 
2106
            v->str_val ? (char *)my_realloc(v->str_val, v->alloced_len+1,
2108
2107
                                    MYF(MY_WME)) :
2109
 
            my_malloc(v->alloced_len+1, MYF(MY_WME))))
 
2108
            (char *)my_malloc(v->alloced_len+1, MYF(MY_WME))))
2110
2109
        die("Out of memory");
2111
2110
    }
2112
2111
    v->str_val_len = new_val_len;
2379
2378
*/
2380
2379
 
2381
2380
static int do_modify_var(struct st_command *command,
2382
 
                         enum enum_operator operator)
 
2381
                         enum enum_operator op)
2383
2382
{
2384
2383
  const char *p= command->first_argument;
2385
2384
  VAR* v;
2389
2388
    die("The argument to %.*s must be a variable (start with $)",
2390
2389
        command->first_word_len, command->query);
2391
2390
  v= var_get(p, &p, 1, 0);
2392
 
  switch (operator) {
 
2391
  switch (op) {
2393
2392
  case DO_DEC:
2394
2393
    v->int_val--;
2395
2394
    break;
5209
5208
              ds_warning_messages.str, ds_warning_messages.length);
5210
5209
}
5211
5210
 
5212
 
static void check_regerr(my_regex_t* r, int err)
5213
 
{
5214
 
  char err_buf[1024];
5215
 
 
5216
 
  if (err)
5217
 
  {
5218
 
    my_regerror(err,r,err_buf,sizeof(err_buf));
5219
 
    die("Regex error: %s\n", err_buf);
5220
 
  }
5221
 
}
5222
5211
 
5223
5212
/*
5224
5213
  Append the result for one field to the dynamic string ds
5807
5796
  DBUG_VOID_RETURN;
5808
5797
}
5809
5798
 
5810
 
/****************************************************************************/
5811
 
/*
5812
 
  Functions to detect different SQL statements
5813
 
*/
5814
 
 
5815
 
void free_re(void)
5816
 
{
5817
 
  my_regex_end();
5818
 
}
5819
5799
 
5820
5800
/****************************************************************************/
5821
5801
 
6461
6441
    die("Missing argument in %s", command->query);
6462
6442
 
6463
6443
  /* Allocate a buffer for results */
6464
 
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
 
6444
  start= buff= (char *)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6465
6445
  while (*from)
6466
6446
  {
6467
6447
    char *to;
6544
6524
  bzero((char*) &from_array,sizeof(from_array));
6545
6525
  if (!*from)
6546
6526
    die("Missing argument in %s", command->query);
6547
 
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
 
6527
  start= buff= (char *)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6548
6528
  while (*from)
6549
6529
  {
6550
6530
    char *to= buff;
6926
6906
  icase - flag, if set to 1 the match is case insensitive
6927
6907
*/
6928
6908
int reg_replace(char** buf_p, int* buf_len_p, char *pattern,
6929
 
                char *replace, char *string, int icase)
 
6909
                char *replace, char *in_string, int icase)
6930
6910
{
6931
 
  my_regex_t r;
6932
 
  my_regmatch_t *subs;
6933
 
  char *replace_end;
6934
 
  char *buf= *buf_p;
6935
 
  int len;
6936
 
  int buf_len, need_buf_len;
6937
 
  int cflags= REG_EXTENDED;
6938
 
  int err_code;
6939
 
  char *res_p,*str_p,*str_end;
6940
 
 
6941
 
  buf_len= *buf_len_p;
6942
 
  len= strlen(string);
6943
 
  str_end= string + len;
6944
 
 
6945
 
  /* start with a buffer of a reasonable size that hopefully will not
6946
 
     need to be reallocated
6947
 
  */
6948
 
  need_buf_len= len * 2 + 1;
6949
 
  res_p= buf;
6950
 
 
6951
 
  SECURE_REG_BUF
 
6911
  string string_to_match(in_string);
 
6912
  pcrecpp::RE_Options opt;
6952
6913
 
6953
6914
  if (icase)
6954
 
    cflags|= REG_ICASE;
6955
 
 
6956
 
  if ((err_code= my_regcomp(&r,pattern,cflags,&my_charset_latin1)))
6957
 
  {
6958
 
    check_regerr(&r,err_code);
6959
 
    return 1;
6960
 
  }
6961
 
 
6962
 
  subs= (my_regmatch_t*)my_malloc(sizeof(my_regmatch_t) * (r.re_nsub+1),
6963
 
                                  MYF(MY_WME+MY_FAE));
6964
 
 
6965
 
  *res_p= 0;
6966
 
  str_p= string;
6967
 
  replace_end= replace + strlen(replace);
6968
 
 
6969
 
  /* for each pattern match instance perform a replacement */
6970
 
  while (!err_code)
6971
 
  {
6972
 
    /* find the match */
6973
 
    err_code= my_regexec(&r,str_p, r.re_nsub+1, subs,
6974
 
                         (str_p == string) ? REG_NOTBOL : 0);
6975
 
 
6976
 
    /* if regular expression error (eg. bad syntax, or out of memory) */
6977
 
    if (err_code && err_code != REG_NOMATCH)
6978
 
    {
6979
 
      check_regerr(&r,err_code);
6980
 
      my_regfree(&r);
6981
 
      return 1;
6982
 
    }
6983
 
 
6984
 
    /* if match found */
6985
 
    if (!err_code)
6986
 
    {
6987
 
      char* expr_p= replace;
6988
 
      int c;
6989
 
 
6990
 
      /*
6991
 
        we need at least what we have so far in the buffer + the part
6992
 
        before this match
6993
 
      */
6994
 
      need_buf_len= (res_p - buf) + (int) subs[0].rm_so;
6995
 
 
6996
 
      /* on this pass, calculate the memory for the result buffer */
6997
 
      while (expr_p < replace_end)
6998
 
      {
6999
 
        int back_ref_num= -1;
7000
 
        c= *expr_p;
7001
 
 
7002
 
        if (c == '\\' && expr_p + 1 < replace_end)
7003
 
        {
7004
 
          back_ref_num= (int) (expr_p[1] - '0');
7005
 
        }
7006
 
 
7007
 
        /* found a valid back_ref (eg. \1)*/
7008
 
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
7009
 
        {
7010
 
          regoff_t start_off, end_off;
7011
 
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
7012
 
              (end_off=subs[back_ref_num].rm_eo) > -1)
7013
 
          {
7014
 
            need_buf_len += (int) (end_off - start_off);
7015
 
          }
7016
 
          expr_p += 2;
7017
 
        }
7018
 
        else
7019
 
        {
7020
 
          expr_p++;
7021
 
          need_buf_len++;
7022
 
        }
7023
 
      }
7024
 
      need_buf_len++;
7025
 
      /*
7026
 
        now that we know the size of the buffer,
7027
 
        make sure it is big enough
7028
 
      */
7029
 
      SECURE_REG_BUF
7030
 
 
7031
 
        /* copy the pre-match part */
7032
 
        if (subs[0].rm_so)
7033
 
        {
7034
 
          memcpy(res_p, str_p, (size_t) subs[0].rm_so);
7035
 
          res_p+= subs[0].rm_so;
7036
 
        }
7037
 
 
7038
 
      expr_p= replace;
7039
 
 
7040
 
      /* copy the match and expand back_refs */
7041
 
      while (expr_p < replace_end)
7042
 
      {
7043
 
        int back_ref_num= -1;
7044
 
        c= *expr_p;
7045
 
 
7046
 
        if (c == '\\' && expr_p + 1 < replace_end)
7047
 
        {
7048
 
          back_ref_num= expr_p[1] - '0';
7049
 
        }
7050
 
 
7051
 
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
7052
 
        {
7053
 
          regoff_t start_off, end_off;
7054
 
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
7055
 
              (end_off=subs[back_ref_num].rm_eo) > -1)
7056
 
          {
7057
 
            int block_len= (int) (end_off - start_off);
7058
 
            memcpy(res_p,str_p + start_off, block_len);
7059
 
            res_p += block_len;
7060
 
          }
7061
 
          expr_p += 2;
7062
 
        }
7063
 
        else
7064
 
        {
7065
 
          *res_p++ = *expr_p++;
7066
 
        }
7067
 
      }
7068
 
 
7069
 
      /* handle the post-match part */
7070
 
      if (subs[0].rm_so == subs[0].rm_eo)
7071
 
      {
7072
 
        if (str_p + subs[0].rm_so >= str_end)
7073
 
          break;
7074
 
        str_p += subs[0].rm_eo ;
7075
 
        *res_p++ = *str_p++;
7076
 
      }
7077
 
      else
7078
 
      {
7079
 
        str_p += subs[0].rm_eo;
7080
 
      }
7081
 
    }
7082
 
    else /* no match this time, just copy the string as is */
7083
 
    {
7084
 
      int left_in_str= str_end-str_p;
7085
 
      need_buf_len= (res_p-buf) + left_in_str;
7086
 
      SECURE_REG_BUF
7087
 
        memcpy(res_p,str_p,left_in_str);
7088
 
      res_p += left_in_str;
7089
 
      str_p= str_end;
7090
 
    }
7091
 
  }
7092
 
  my_free(subs, MYF(0));
7093
 
  my_regfree(&r);
7094
 
  *res_p= 0;
7095
 
  *buf_p= buf;
7096
 
  *buf_len_p= buf_len;
 
6915
    opt.set_caseless(true);
 
6916
 
 
6917
  if (!pcrecpp::RE(pattern, opt).Replace(replace,&string_to_match)){
 
6918
    return 1;
 
6919
  }
 
6920
 
 
6921
  const char * new_str= string_to_match.c_str();
 
6922
  *buf_len_p= strlen(new_str);
 
6923
  char * new_buf = (char *)malloc(*buf_len_p+1);
 
6924
  if (new_buf == NULL)
 
6925
  {
 
6926
    return 1;
 
6927
  }
 
6928
  strcpy(new_buf, new_str);
 
6929
  buf_p= &new_buf;
 
6930
 
7097
6931
  return 0;
7098
6932
}
7099
6933