← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Removing redundant use of casts in drizzled/ for memcmp(), memcpy(), memset(), and memmove().
Adding non-const version of String::ptr() to provide covariance on const:ness.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
179
179
                       &path_buff, path_length + 1,
180
180
                       NULL))
181
181
  {
182
 
    memset((char*) share, 0, sizeof(*share));
 
182
    memset(share, 0, sizeof(*share));
183
183
 
184
184
    share->set_table_cache_key(key_buff, key, key_length);
185
185
 
208
208
    share->table_map_id= ~0UL;
209
209
    share->cached_row_logging_check= -1;
210
210
 
211
 
    memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
 
211
    memcpy(&share->mem_root, &mem_root, sizeof(mem_root));
212
212
    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
213
213
    pthread_cond_init(&share->cond, NULL);
214
214
  }
244
244
                          const char *path)
245
245
{
246
246
 
247
 
  memset((char*) share, 0, sizeof(*share));
 
247
  memset(share, 0, sizeof(*share));
248
248
  init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
249
249
  share->table_category=         TABLE_CATEGORY_TEMPORARY;
250
250
  share->tmp_table=              INTERNAL_TMP_TABLE;
314
314
  share->db_plugin= NULL;
315
315
 
316
316
  /* We must copy mem_root from share because share is allocated through it */
317
 
  memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
 
317
  memcpy(&mem_root, &share->mem_root, sizeof(mem_root));
318
318
  free_root(&mem_root, MYF(0));                 // Free's share
319
319
  return;
320
320
}
582
582
  if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
583
583
                                    n_length + uint2korr(disk_buff+4))))
584
584
    goto err;                                   /* purecov: inspected */
585
 
  memset((char*) keyinfo, 0, n_length);
 
585
  memset(keyinfo, 0, n_length);
586
586
  share->key_info= keyinfo;
587
587
  key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
588
588
  strpos=disk_buff+6;
822
822
  names= (char*) (interval_array+share->fields+interval_parts+keys+3);
823
823
  if (!interval_count)
824
824
    share->intervals= 0;                        // For better debugging
825
 
  memcpy((char*) names, strpos+(share->fields*field_pack_length),
 
825
  memcpy(names, strpos+(share->fields*field_pack_length),
826
826
         (uint) (n_length+int_length));
827
827
  comment_pos= names+(n_length+int_length);
828
828
  memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
959
959
      }
960
960
      else
961
961
        charset= share->table_charset;
962
 
      memset((char*) &comment, 0, sizeof(comment));
 
962
      memset(&comment, 0, sizeof(comment));
963
963
    }
964
964
 
965
965
    if (interval_nr && charset->mbminlen > 1)
1338
1338
  assert(thd->lex->is_lex_started);
1339
1339
 
1340
1340
  error= 1;
1341
 
  memset((char*) outparam, 0, sizeof(*outparam));
 
1341
  memset(outparam, 0, sizeof(*outparam));
1342
1342
  outparam->in_use= thd;
1343
1343
  outparam->s= share;
1344
1344
  outparam->db_stat= db_stat;
1546
1546
  }
1547
1547
 
1548
1548
#if defined(HAVE_purify) 
1549
 
  memset((char*) bitmaps, 0, bitmap_size*3);
 
1549
  memset(bitmaps, 0, bitmap_size*3);
1550
1550
#endif
1551
1551
 
1552
1552
  outparam->no_replicate= outparam->file &&
1655
1655
      my_free((uchar*) buf,MYF(0));
1656
1656
  }
1657
1657
  else if (!names)
1658
 
    memset((char*) save_names, 0, sizeof(save_names));
 
1658
    memset(save_names, 0, sizeof(save_names));
1659
1659
  else
1660
1660
  {
1661
1661
    char *str;
2040
2040
  {
2041
2041
    uint key_length, tmp_key_length;
2042
2042
    uint tmp;
2043
 
    memset((char*) fileinfo, 0, 64);
 
2043
    memset(fileinfo, 0, 64);
2044
2044
    /* header */
2045
2045
    fileinfo[0]=(uchar) 254;
2046
2046
    fileinfo[1]= 1;
3179
3179
    bitmap_clear_all(&table->def_read_set);
3180
3180
    bitmap_clear_all(&table->def_write_set);
3181
3181
  */
3182
 
  memset((char*) def_read_set.bitmap, 0, s->column_bitmap_size*2);
 
3182
  memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);
3183
3183
  column_bitmaps_set(&def_read_set, &def_write_set);
3184
3184
}
3185
3185