← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzletest.cc

  • Committer: Brian Aker
  • Date: 2008-08-05 04:10:42 UTC
  • mfrom: (261.2.8 codestyle)
  • mto: This revision was merged to the branch mainline in revision 263.
  • Revision ID: brian@tangent.org-20080805041042-1l4893r3bwy2lxz2
Merge from Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzletest.cc
6158
6158
 
6159
6159
  free_replace();
6160
6160
 
6161
 
  memset((char*) &to_array, 0, sizeof(to_array));
6162
 
  memset((char*) &from_array, 0, sizeof(from_array));
 
6161
  memset(&to_array, 0, sizeof(to_array));
 
6162
  memset(&from_array, 0, sizeof(from_array));
6163
6163
  if (!*from)
6164
6164
    die("Missing argument in %s", command->query);
6165
6165
  start= buff= (char *)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6665
6665
    if (len > max_length)
6666
6666
      max_length=len;
6667
6667
  }
6668
 
  memset((char*) is_word_end, 0, sizeof(is_word_end));
 
6668
  memset(is_word_end, 0, sizeof(is_word_end));
6669
6669
  for (i=0 ; word_end_chars[i] ; i++)
6670
6670
    is_word_end[(uchar) word_end_chars[i]]=1;
6671
6671
 
6784
6784
      or_bits(sets.set+used_sets,sets.set);  /* Can restart from start */
6785
6785
 
6786
6786
    /* Find all chars that follows current sets */
6787
 
    memset((char*) used_chars, 0, sizeof(used_chars));
 
6787
    memset(used_chars, 0, sizeof(used_chars));
6788
6788
    for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
6789
6789
    {
6790
6790
      used_chars[follow[i].chr]=1;
6893
6893
    for (i=1 ; i <= found_sets ; i++)
6894
6894
    {
6895
6895
      pos=from[found_set[i-1].table_offset];
6896
 
      rep_str[i].found= !memcmp((const uchar*) pos,
6897
 
                                (const uchar*) "\\^", 3) ? 2 : 1;
 
6896
      rep_str[i].found= !memcmp(pos, "\\^", 3) ? 2 : 1;
6898
6897
      rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
6899
6898
      rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
6900
6899
      rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
6918
6917
 
6919
6918
int init_sets(REP_SETS *sets,uint states)
6920
6919
{
6921
 
  memset((char*) sets, 0, sizeof(*sets));
 
6920
  memset(sets, 0, sizeof(*sets));
6922
6921
  sets->size_of_bits=((states+7)/8);
6923
6922
  if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
6924
6923
                MYF(MY_WME))))
6949
6948
  {
6950
6949
    sets->extra--;
6951
6950
    set=sets->set+ sets->count++;
6952
 
    memset((char*) set->bits, 0, sizeof(uint)*sets->size_of_bits);
6953
 
    memset((char*) &set->next[0], 0, sizeof(set->next[0])*LAST_CHAR_CODE);
 
6951
    memset(set->bits, 0, sizeof(uint)*sets->size_of_bits);
 
6952
    memset(&set->next[0], 0, sizeof(set->next[0])*LAST_CHAR_CODE);
6954
6953
    set->found_offset=0;
6955
6954
    set->found_len=0;
6956
6955
    set->table_offset= (uint) ~0;
7015
7014
 
7016
7015
void copy_bits(REP_SET *to,REP_SET *from)
7017
7016
{
7018
 
  memcpy((uchar*) to->bits,(uchar*) from->bits,
 
7017
  memcpy(to->bits,from->bits,
7019
7018
   (size_t) (sizeof(uint) * to->size_of_bits));
7020
7019
}
7021
7020
 
7022
7021
int cmp_bits(REP_SET *set1,REP_SET *set2)
7023
7022
{
7024
 
  return memcmp((uchar*) set1->bits,(uchar*) set2->bits,
7025
 
                sizeof(uint) * set1->size_of_bits);
 
7023
  return memcmp(set1->bits,set2->bits, sizeof(uint) * set1->size_of_bits);
7026
7024
}
7027
7025
 
7028
7026
 
7091
7089
 
7092
7090
uint start_at_word(char * pos)
7093
7091
{
7094
 
  return (((!memcmp((const uchar*) pos, (const uchar*) "\\b",2) && pos[2]) ||
7095
 
           !memcmp((const uchar*) pos, (const uchar*) "\\^", 2)) ? 1 : 0);
 
7092
  return (((!memcmp(pos, "\\b",2) && pos[2]) ||
 
7093
           !memcmp(pos, "\\^", 2)) ? 1 : 0);
7096
7094
}
7097
7095
 
7098
7096
uint end_of_word(char * pos)
7099
7097
{
7100
7098
  char * end=strend(pos);
7101
 
  return ((end > pos+2 && !memcmp((const uchar*) end-2,
7102
 
                                  (const uchar*) "\\b", 2)) ||
7103
 
    (end >= pos+2 && !memcmp((const uchar*) end-2,
7104
 
                                (const uchar*) "\\$",2))) ? 1 : 0;
 
7099
  return ((end > pos+2 && !memcmp(end-2, "\\b", 2)) ||
 
7100
          (end >= pos+2 && !memcmp(end-2, "\\$",2))) ? 1 : 0;
7105
7101
}
7106
7102
 
7107
7103
/****************************************************************************
7170
7166
    old_count=pa->max_count;
7171
7167
    pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
7172
7168
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
7173
 
    memcpy((uchar*) pa->flag,(char *) (pa->typelib.type_names+old_count),
7174
 
     old_count*sizeof(*pa->flag));
 
7169
    memcpy(pa->flag, pa->typelib.type_names+old_count,
 
7170
           old_count*sizeof(*pa->flag));
7175
7171
  }
7176
7172
  pa->flag[pa->typelib.count]=0;      /* Reset flag */
7177
7173
  pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;