mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 12:02:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

WL#5498: Remove dead and unused source code

Browse source 
Remove workarounds for ancient systems.
This commit is contained in:
Davi Arnaut 2010-07-23 17:17:55 -03:00
parent 68cd3bce9c
commit e81506971f
29 changed files with 94 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
include/m_string.h
View file

@ -90,12 +90,6 @@ extern char _dig_vec_lower[];
#ifndef strmov #ifndef strmov
#define strmov_overlapp(A,B) strmov(A,B) #define strmov_overlapp(A,B) strmov(A,B)
#define strmake_overlapp(A,B,C) strmake(A,B,C) #define strmake_overlapp(A,B,C) strmake(A,B,C)
#endif
#ifdef BAD_MEMCPY /* Problem with gcc on Alpha */
#define memcpy_fixed(A,B,C) bmove((A),(B),(C))
#else
#define memcpy_fixed(A,B,C) memcpy((A),(B),(C))
#endif #endif
/* Prototypes for string functions */ /* Prototypes for string functions */

40
include/my_global.h
View file

@ -341,18 +341,6 @@ C_MODE_END
#error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile" #error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile"
#endif #endif
/* Fix a bug in gcc 2.8.0 on IRIX 6.2 */
#if SIZEOF_LONG == 4 && defined(__LONG_MAX__) && (__GNUC__ == 2 && __GNUC_MINOR__ == 8)
#undef __LONG_MAX__ /* Is a longlong value in gcc 2.8.0 ??? */
#define __LONG_MAX__ 2147483647
#endif
/* egcs 1.1.2 has a problem with memcpy on Alpha */
#if defined(__GNUC__) && defined(__alpha__) && ! (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))
#define BAD_MEMCPY
#endif
#if defined(_lint) && !defined(lint) #if defined(_lint) && !defined(lint)
#define lint #define lint
#endif #endif
@ -1263,8 +1251,8 @@ do { doubleget_union _tmp; \
((uchar*) &def_temp)[7]=(M)[0];\ ((uchar*) &def_temp)[7]=(M)[0];\
(V) = def_temp; } while(0) (V) = def_temp; } while(0)
#else #else
#define float4get(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(float)) #define float4get(V,M) memcpy(&V, (M), sizeof(float))
#define float4store(V,M) memcpy_fixed((uchar*) V,(uchar*) (&M),sizeof(float)) #define float4store(V,M) memcpy(V, (&M), sizeof(float))
#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) #if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN)
#define doublestore(T,V) do { *(((char*)T)+0)=(char) ((uchar *) &V)[4];\ #define doublestore(T,V) do { *(((char*)T)+0)=(char) ((uchar *) &V)[4];\
@ -1334,12 +1322,12 @@ do { doubleget_union _tmp; \
*(((char*)T)+1)=(((A) >> 16));\ *(((char*)T)+1)=(((A) >> 16));\
*(((char*)T)+0)=(((A) >> 24)); } while(0) *(((char*)T)+0)=(((A) >> 24)); } while(0)
#define floatget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(float)) #define floatget(V,M) memcpy(&V, (M), sizeof(float))
#define floatstore(T,V) memcpy_fixed((uchar*) (T),(uchar*)(&V),sizeof(float)) #define floatstore(T,V) memcpy((T), (void*) (&V), sizeof(float))
#define doubleget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(double)) #define doubleget(V,M) memcpy(&V, (M), sizeof(double))
#define doublestore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(double)) #define doublestore(T,V) memcpy((T), (void *) &V, sizeof(double))
#define longlongget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(ulonglong)) #define longlongget(V,M) memcpy(&V, (M), sizeof(ulonglong))
#define longlongstore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(ulonglong)) #define longlongstore(T,V) memcpy((T), &V, sizeof(ulonglong))
#else #else
@ -1350,15 +1338,15 @@ do { doubleget_union _tmp; \
#define shortstore(T,V) int2store(T,V) #define shortstore(T,V) int2store(T,V)
#define longstore(T,V) int4store(T,V) #define longstore(T,V) int4store(T,V)
#ifndef floatstore #ifndef floatstore
#define floatstore(T,V) memcpy_fixed((uchar*) (T),(uchar*) (&V),sizeof(float)) #define floatstore(T,V) memcpy((T), (void *) (&V), sizeof(float))
#define floatget(V,M) memcpy_fixed((uchar*) &V, (uchar*) (M), sizeof(float)) #define floatget(V,M) memcpy(&V, (M), sizeof(float))
#endif #endif
#ifndef doubleget #ifndef doubleget
#define doubleget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(double)) #define doubleget(V,M) memcpy(&V, (M), sizeof(double))
#define doublestore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(double)) #define doublestore(T,V) memcpy((T), (void *) &V, sizeof(double))
#endif /* doubleget */ #endif /* doubleget */
#define longlongget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(ulonglong)) #define longlongget(V,M) memcpy(&V, (M), sizeof(ulonglong))
#define longlongstore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(ulonglong)) #define longlongstore(T,V) memcpy((T), &V, sizeof(ulonglong))
#endif /* WORDS_BIGENDIAN */ #endif /* WORDS_BIGENDIAN */

2
mysys/default.c
View file

@ -575,7 +575,7 @@ int my_load_defaults(const char *conf_file, const char **groups,
void free_defaults(char **argv) void free_defaults(char **argv)
{ {
MEM_ROOT ptr; MEM_ROOT ptr;
memcpy_fixed((char*) &ptr,(char *) argv - sizeof(ptr), sizeof(ptr)); memcpy(&ptr, ((char *) argv) - sizeof(ptr), sizeof(ptr));
free_root(&ptr,MYF(0)); free_root(&ptr,MYF(0));
} }

6
mysys/my_pthread.c
View file

@ -138,7 +138,7 @@ void sigwait_setup(sigset_t *set)
sact.sa_flags = 0; sact.sa_flags = 0;
sact.sa_handler = px_handle_sig; sact.sa_handler = px_handle_sig;
memcpy_fixed(&sact.sa_mask,set,sizeof(*set)); /* handler isn't thread_safe */ memcpy(&sact.sa_mask, set, sizeof(*set)); /* handler isn't thread_safe */
sigemptyset(&unblock_mask); sigemptyset(&unblock_mask);
pthread_sigmask(SIG_UNBLOCK,(sigset_t*) 0,&rev_sigwait_set); pthread_sigmask(SIG_UNBLOCK,(sigset_t*) 0,&rev_sigwait_set);
@ -164,7 +164,7 @@ void sigwait_setup(sigset_t *set)
} }
} }
} }
memcpy_fixed(&sigwait_set,set,sizeof(*set)); memcpy(&sigwait_set, set, sizeof(*set));
pthread_sigmask(SIG_BLOCK,(sigset_t*) set,(sigset_t*) 0); pthread_sigmask(SIG_BLOCK,(sigset_t*) set,(sigset_t*) 0);
pthread_sigmask(SIG_UNBLOCK,&unblock_mask,(sigset_t*) 0); pthread_sigmask(SIG_UNBLOCK,&unblock_mask,(sigset_t*) 0);
} }
@ -252,7 +252,7 @@ void *sigwait_thread(void *set_arg)
struct sigaction sact; struct sigaction sact;
sact.sa_flags = 0; sact.sa_flags = 0;
sact.sa_handler = sigwait_handle_sig; sact.sa_handler = sigwait_handle_sig;
memcpy_fixed(&sact.sa_mask,set,sizeof(*set)); /* handler isn't thread_safe */ memcpy(&sact.sa_mask, set, sizeof(*set)); /* handler isn't thread_safe */
sigemptyset(&pending_set); sigemptyset(&pending_set);
for (i = 1; i <= sizeof(pending_set)*8; i++) for (i = 1; i <= sizeof(pending_set)*8; i++)

38
sql/field.cc
View file

@ -4143,7 +4143,7 @@ int Field_float::store(double nr)
} }
else else
#endif #endif
memcpy_fixed(ptr,(uchar*) &j,sizeof(j)); memcpy(ptr, &j, sizeof(j));
return error; return error;
} }
@ -4166,7 +4166,7 @@ double Field_float::val_real(void)
} }
else else
#endif #endif
memcpy_fixed((uchar*) &j,ptr,sizeof(j)); memcpy(&j, ptr, sizeof(j));
return ((double) j); return ((double) j);
} }
@ -4180,7 +4180,7 @@ longlong Field_float::val_int(void)
} }
else else
#endif #endif
memcpy_fixed((uchar*) &j,ptr,sizeof(j)); memcpy(&j, ptr, sizeof(j));
return (longlong) rint(j); return (longlong) rint(j);
} }
@ -4197,7 +4197,7 @@ String *Field_float::val_str(String *val_buffer,
} }
else else
#endif #endif
memcpy_fixed((uchar*) &nr,ptr,sizeof(nr)); memcpy(&nr, ptr, sizeof(nr));
uint to_length=max(field_length,70); uint to_length=max(field_length,70);
val_buffer->alloc(to_length); val_buffer->alloc(to_length);
@ -4235,8 +4235,8 @@ int Field_float::cmp(const uchar *a_ptr, const uchar *b_ptr)
else else
#endif #endif
{ {
memcpy_fixed(&a,a_ptr,sizeof(float)); memcpy(&a, a_ptr, sizeof(float));
memcpy_fixed(&b,b_ptr,sizeof(float)); memcpy(&b, b_ptr, sizeof(float));
} }
return (a < b) ? -1 : (a > b) ? 1 : 0; return (a < b) ? -1 : (a > b) ? 1 : 0;
} }
@ -4253,7 +4253,7 @@ void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
} }
else else
#endif #endif
memcpy_fixed(&nr,ptr,sizeof(float)); memcpy(&nr, ptr, sizeof(float));
uchar *tmp= to; uchar *tmp= to;
if (nr == (float) 0.0) if (nr == (float) 0.0)
@ -4264,7 +4264,7 @@ void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
else else
{ {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
memcpy_fixed(tmp,&nr,sizeof(nr)); memcpy(tmp, &nr, sizeof(nr));
#else #else
tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0]; tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
#endif #endif
@ -7442,7 +7442,7 @@ double Field_blob::val_real(void)
uint32 length; uint32 length;
CHARSET_INFO *cs; CHARSET_INFO *cs;
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy(&blob, ptr+packlength, sizeof(char*));
if (!blob) if (!blob)
return 0.0; return 0.0;
length= get_length(ptr); length= get_length(ptr);
@ -7456,7 +7456,7 @@ longlong Field_blob::val_int(void)
ASSERT_COLUMN_MARKED_FOR_READ; ASSERT_COLUMN_MARKED_FOR_READ;
int not_used; int not_used;
char *blob; char *blob;
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy(&blob, ptr+packlength, sizeof(char*));
if (!blob) if (!blob)
return 0; return 0;
uint32 length=get_length(ptr); uint32 length=get_length(ptr);
@ -7468,7 +7468,7 @@ String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
{ {
ASSERT_COLUMN_MARKED_FOR_READ; ASSERT_COLUMN_MARKED_FOR_READ;
char *blob; char *blob;
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy(&blob, ptr+packlength, sizeof(char*));
if (!blob) if (!blob)
val_ptr->set("",0,charset()); // A bit safer than ->length(0) val_ptr->set("",0,charset()); // A bit safer than ->length(0)
else else
@ -7482,7 +7482,7 @@ my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
ASSERT_COLUMN_MARKED_FOR_READ; ASSERT_COLUMN_MARKED_FOR_READ;
const char *blob; const char *blob;
size_t length; size_t length;
memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*)); memcpy(&blob, ptr+packlength, sizeof(const uchar*));
if (!blob) if (!blob)
{ {
blob= ""; blob= "";
@ -7510,8 +7510,8 @@ int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
uint max_length) uint max_length)
{ {
uchar *blob1,*blob2; uchar *blob1,*blob2;
memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*)); memcpy(&blob1, a_ptr+packlength, sizeof(char*));
memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*)); memcpy(&blob2, b_ptr+packlength, sizeof(char*));
uint a_len= get_length(a_ptr), b_len= get_length(b_ptr); uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
set_if_smaller(a_len, max_length); set_if_smaller(a_len, max_length);
set_if_smaller(b_len, max_length); set_if_smaller(b_len, max_length);
@ -7525,8 +7525,8 @@ int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
char *a,*b; char *a,*b;
uint diff; uint diff;
uint32 a_length,b_length; uint32 a_length,b_length;
memcpy_fixed(&a,a_ptr+packlength,sizeof(char*)); memcpy(&a, a_ptr+packlength, sizeof(char*));
memcpy_fixed(&b,b_ptr+packlength,sizeof(char*)); memcpy(&b, b_ptr+packlength, sizeof(char*));
a_length=get_length(a_ptr); a_length=get_length(a_ptr);
if (a_length > max_length) if (a_length > max_length)
a_length=max_length; a_length=max_length;
@ -7607,7 +7607,7 @@ int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
{ {
uchar *blob1; uchar *blob1;
uint blob_length=get_length(ptr); uint blob_length=get_length(ptr);
memcpy_fixed(&blob1,ptr+packlength,sizeof(char*)); memcpy(&blob1, ptr+packlength, sizeof(char*));
CHARSET_INFO *cs= charset(); CHARSET_INFO *cs= charset();
uint local_char_length= max_key_length / cs->mbmaxlen; uint local_char_length= max_key_length / cs->mbmaxlen;
local_char_length= my_charpos(cs, blob1, blob1+blob_length, local_char_length= my_charpos(cs, blob1, blob1+blob_length,
@ -7685,7 +7685,7 @@ void Field_blob::sort_string(uchar *to,uint length)
break; break;
} }
} }
memcpy_fixed(&blob,ptr+packlength,sizeof(char*)); memcpy(&blob, ptr+packlength, sizeof(char*));
blob_length=my_strnxfrm(field_charset, blob_length=my_strnxfrm(field_charset,
to, length, blob, blob_length); to, length, blob, blob_length);
@ -8654,7 +8654,7 @@ String *Field_bit::val_str(String *val_buffer,
mi_int8store(buff,bits); mi_int8store(buff,bits);
val_buffer->alloc(length); val_buffer->alloc(length);
memcpy_fixed((char*) val_buffer->ptr(), buff+8-length, length); memcpy((char *) val_buffer->ptr(), buff+8-length, length);
val_buffer->length(length); val_buffer->length(length);
val_buffer->set_charset(&my_charset_bin); val_buffer->set_charset(&my_charset_bin);
return val_buffer; return val_buffer;

10
sql/field.h
View file

@ -1762,22 +1762,22 @@ public:
void put_length(uchar *pos, uint32 length); void put_length(uchar *pos, uint32 length);
inline void get_ptr(uchar **str) inline void get_ptr(uchar **str)
{ {
memcpy_fixed((uchar*) str,ptr+packlength,sizeof(uchar*)); memcpy(str, ptr+packlength, sizeof(uchar*));
} }
inline void get_ptr(uchar **str, uint row_offset) inline void get_ptr(uchar **str, uint row_offset)
{ {
memcpy_fixed((uchar*) str,ptr+packlength+row_offset,sizeof(char*)); memcpy(str, ptr+packlength+row_offset, sizeof(char*));
} }
inline void set_ptr(uchar *length, uchar *data) inline void set_ptr(uchar *length, uchar *data)
{ {
memcpy(ptr,length,packlength); memcpy(ptr,length,packlength);
memcpy_fixed(ptr+packlength,&data,sizeof(char*)); memcpy(ptr+packlength, &data,sizeof(char*));
} }
void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32 length, uchar *data) void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32 length, uchar *data)
{ {
uchar *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,uchar*); uchar *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,uchar*);
store_length(ptr_ofs, packlength, length); store_length(ptr_ofs, packlength, length);
memcpy_fixed(ptr_ofs+packlength,&data,sizeof(char*)); memcpy(ptr_ofs+packlength, &data, sizeof(char*));
} }
inline void set_ptr(uint32 length, uchar *data) inline void set_ptr(uint32 length, uchar *data)
{ {
@ -1796,7 +1796,7 @@ public:
return 1; return 1;
} }
tmp=(uchar*) value.ptr(); tmp=(uchar*) value.ptr();
memcpy_fixed(ptr+packlength,&tmp,sizeof(char*)); memcpy(ptr+packlength, &tmp, sizeof(char*));
return 0; return 0;
} }
virtual uchar *pack(uchar *to, const uchar *from, virtual uchar *pack(uchar *to, const uchar *from,

2
sql/field_conv.cc
View file

@ -286,7 +286,7 @@ static void do_copy_blob(Copy_field *copy)
{ {
ulong length=((Field_blob*) copy->from_field)->get_length(); ulong length=((Field_blob*) copy->from_field)->get_length();
((Field_blob*) copy->to_field)->store_length(length); ((Field_blob*) copy->to_field)->store_length(length);
memcpy_fixed(copy->to_ptr,copy->from_ptr,sizeof(char*)); memcpy(copy->to_ptr, copy->from_ptr, sizeof(char*));
} }
static void do_conv_blob(Copy_field *copy) static void do_conv_blob(Copy_field *copy)

2
sql/filesort.cc
View file

@ -1665,7 +1665,7 @@ void change_double_for_sort(double nr,uchar *to)
else else
{ {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
memcpy_fixed(tmp,&nr,sizeof(nr)); memcpy(tmp, &nr, sizeof(nr));
#else #else
{ {
uchar *ptr= (uchar*) &nr; uchar *ptr= (uchar*) &nr;

4
sql/hostname.cc
View file

@ -126,7 +126,7 @@ static void prepare_hostname_cache_key(const char *ip_string,
DBUG_ASSERT(ip_string_length < HOST_ENTRY_KEY_SIZE); DBUG_ASSERT(ip_string_length < HOST_ENTRY_KEY_SIZE);
memset(ip_key, 0, HOST_ENTRY_KEY_SIZE); memset(ip_key, 0, HOST_ENTRY_KEY_SIZE);
memcpy_fixed(ip_key, ip_string, ip_string_length); memcpy(ip_key, ip_string, ip_string_length);
} }
static inline Host_entry *hostname_cache_search(const char *ip_key) static inline Host_entry *hostname_cache_search(const char *ip_key)
@ -148,7 +148,7 @@ static bool add_hostname_impl(const char *ip_key, const char *hostname)
char *hostname_copy; char *hostname_copy;
memcpy_fixed(&entry->ip_key, ip_key, HOST_ENTRY_KEY_SIZE); memcpy(&entry->ip_key, ip_key, HOST_ENTRY_KEY_SIZE);
if (hostname_size) if (hostname_size)
{ {

3
sql/udf_example.c
View file

@ -133,7 +133,6 @@ typedef long long longlong;
#include <string.h> #include <string.h>
#define strmov(a,b) stpcpy(a,b) #define strmov(a,b) stpcpy(a,b)
#define bzero(a,b) memset(a,0,b) #define bzero(a,b) memset(a,0,b)
#define memcpy_fixed(a,b,c) memcpy(a,b,c)
#endif #endif
#endif #endif
#include <mysql.h> #include <mysql.h>
@ -778,7 +777,7 @@ char *lookup(UDF_INIT *initid __attribute__((unused)), UDF_ARGS *args,
} }
pthread_mutex_unlock(&LOCK_hostname); pthread_mutex_unlock(&LOCK_hostname);
#endif #endif
memcpy_fixed((char*) &in,(char*) *hostent->h_addr_list, sizeof(in.s_addr)); memcpy(&in, *hostent->h_addr_list, sizeof(in.s_addr));
*res_length= (ulong) (strmov(result, inet_ntoa(in)) - result); *res_length= (ulong) (strmov(result, inet_ntoa(in)) - result);
return result; return result;
} }

4
storage/csv/ha_tina.cc
View file

@ -810,12 +810,12 @@ int ha_tina::find_current_row(uchar *buf)
packlength= blob->pack_length_no_ptr(); packlength= blob->pack_length_no_ptr();
length= blob->get_length(blob->ptr); length= blob->get_length(blob->ptr);
memcpy_fixed(&src, blob->ptr + packlength, sizeof(char*)); memcpy(&src, blob->ptr + packlength, sizeof(char*));
if (src) if (src)
{ {
tgt= (uchar*) alloc_root(&blobroot, length); tgt= (uchar*) alloc_root(&blobroot, length);
bmove(tgt, src, length); bmove(tgt, src, length);
memcpy_fixed(blob->ptr + packlength, &tgt, sizeof(char*)); memcpy(blob->ptr + packlength, &tgt, sizeof(char*));
} }
} }
} }

8
storage/federated/ha_federated.cc
View file

@ -2752,9 +2752,9 @@ void ha_federated::position(const uchar *record __attribute__ ((unused)))
position_called= TRUE; position_called= TRUE;
/* Store result set address. */ /* Store result set address. */
memcpy_fixed(ref, &stored_result, sizeof(MYSQL_RES *)); memcpy(ref, &stored_result, sizeof(MYSQL_RES *));
/* Store data cursor position. */ /* Store data cursor position. */
memcpy_fixed(ref + sizeof(MYSQL_RES *), &current_position, memcpy(ref + sizeof(MYSQL_RES *), &current_position,
sizeof(MYSQL_ROW_OFFSET)); sizeof(MYSQL_ROW_OFFSET));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -2780,10 +2780,10 @@ int ha_federated::rnd_pos(uchar *buf, uchar *pos)
ha_statistic_increment(&SSV::ha_read_rnd_count); ha_statistic_increment(&SSV::ha_read_rnd_count);
/* Get stored result set. */ /* Get stored result set. */
memcpy_fixed(&result, pos, sizeof(MYSQL_RES *)); memcpy(&result, pos, sizeof(MYSQL_RES *));
DBUG_ASSERT(result); DBUG_ASSERT(result);
/* Set data cursor position. */ /* Set data cursor position. */
memcpy_fixed(&result->data_cursor, pos + sizeof(MYSQL_RES *), memcpy(&result->data_cursor, pos + sizeof(MYSQL_RES *),
sizeof(MYSQL_ROW_OFFSET)); sizeof(MYSQL_ROW_OFFSET));
/* Read a row. */ /* Read a row. */
ret_val= read_next(buf, result); ret_val= read_next(buf, result);

2
storage/heap/ha_heap.cc
View file

@ -390,7 +390,7 @@ int ha_heap::rnd_pos(uchar * buf, uchar *pos)
MYSQL_READ_ROW_START(table_share->db.str, table_share->table_name.str, MYSQL_READ_ROW_START(table_share->db.str, table_share->table_name.str,
FALSE); FALSE);
ha_statistic_increment(&SSV::ha_read_rnd_count); ha_statistic_increment(&SSV::ha_read_rnd_count);
memcpy_fixed((char*) &heap_position, pos, sizeof(HEAP_PTR)); memcpy(&heap_position, pos, sizeof(HEAP_PTR));
error=heap_rrnd(file, buf, heap_position); error=heap_rrnd(file, buf, heap_position);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
MYSQL_READ_ROW_DONE(error); MYSQL_READ_ROW_DONE(error);

2
storage/myisam/ft_parser.c
View file

@ -39,7 +39,7 @@ static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat)
{ {
word->weight=LWS_IN_USE; word->weight=LWS_IN_USE;
docstat->sum+=word->weight; docstat->sum+=word->weight;
memcpy_fixed((docstat->list)++,word,sizeof(FT_WORD)); memcpy((docstat->list)++, word, sizeof(FT_WORD));
return 0; return 0;
} }

3
storage/myisam/ft_update.c
View file

@ -83,8 +83,7 @@ uint _mi_ft_segiterator(register FT_SEG_ITERATOR *ftsi)
if (ftsi->seg->flag & HA_BLOB_PART) if (ftsi->seg->flag & HA_BLOB_PART)
{ {
ftsi->len=_mi_calc_blob_length(ftsi->seg->bit_start,ftsi->pos); ftsi->len=_mi_calc_blob_length(ftsi->seg->bit_start,ftsi->pos);
memcpy_fixed((char*) &ftsi->pos, ftsi->pos+ftsi->seg->bit_start, memcpy(&ftsi->pos, ftsi->pos+ftsi->seg->bit_start, sizeof(char*));
sizeof(char*));
DBUG_RETURN(1); DBUG_RETURN(1);
} }
ftsi->len=ftsi->seg->length; ftsi->len=ftsi->seg->length;

6
storage/myisam/mi_dynrec.c
View file

@ -995,7 +995,7 @@ uint _mi_rec_pack(MI_INFO *info, register uchar *to,
char *temp_pos; char *temp_pos;
size_t tmp_length=length-portable_sizeof_char_ptr; size_t tmp_length=length-portable_sizeof_char_ptr;
memcpy((uchar*) to,from,tmp_length); memcpy((uchar*) to,from,tmp_length);
memcpy_fixed(&temp_pos,from+tmp_length,sizeof(char*)); memcpy(&temp_pos,from+tmp_length,sizeof(char*));
memcpy(to+tmp_length,temp_pos,(size_t) blob->length); memcpy(to+tmp_length,temp_pos,(size_t) blob->length);
to+=tmp_length+blob->length; to+=tmp_length+blob->length;
} }
@ -1310,9 +1310,9 @@ ulong _mi_rec_unpack(register MI_INFO *info, register uchar *to, uchar *from,
from_left - size_length < blob_length || from_left - size_length < blob_length ||
from_left - size_length - blob_length < min_pack_length) from_left - size_length - blob_length < min_pack_length)
goto err; goto err;
memcpy((uchar*) to,(uchar*) from,(size_t) size_length); memcpy(to, from, (size_t) size_length);
from+=size_length; from+=size_length;
memcpy_fixed((uchar*) to+size_length,(uchar*) &from,sizeof(char*)); memcpy(to+size_length, &from, sizeof(char*));
from+=blob_length; from+=blob_length;
} }
else else

2
storage/myisam/mi_key.c
View file

@ -139,7 +139,7 @@ uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
else if (keyseg->flag & HA_BLOB_PART) else if (keyseg->flag & HA_BLOB_PART)
{ {
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos); uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy_fixed((uchar*) &pos,pos+keyseg->bit_start,sizeof(char*)); memcpy(&pos,pos+keyseg->bit_start,sizeof(char*));
set_if_smaller(length,tmp_length); set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length); FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length); store_key_length_inc(key,char_length);

2
storage/myisam/mi_log.c
View file

@ -149,7 +149,7 @@ void _myisam_log_record(enum myisam_log_commands command, MI_INFO *info,
blob != end ; blob != end ;
blob++) blob++)
{ {
memcpy_fixed((uchar*) &pos, record+blob->offset+blob->pack_length, memcpy(&pos, record+blob->offset+blob->pack_length,
sizeof(char*)); sizeof(char*));
(void) mysql_file_write(myisam_log_file, pos, blob->length, MYF(0)); (void) mysql_file_write(myisam_log_file, pos, blob->length, MYF(0));
} }

4
storage/myisam/mi_open.c
View file

@ -858,7 +858,7 @@ uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
key_blocks=state->header.max_block_size_index; key_blocks=state->header.max_block_size_index;
DBUG_ENTER("mi_state_info_write"); DBUG_ENTER("mi_state_info_write");
memcpy_fixed(ptr,&state->header,sizeof(state->header)); memcpy(ptr, &state->header, sizeof(state->header));
ptr+=sizeof(state->header); ptr+=sizeof(state->header);
/* open_count must be first because of _mi_mark_file_changed ! */ /* open_count must be first because of _mi_mark_file_changed ! */
@ -917,7 +917,7 @@ uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state) uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
{ {
uint i,keys,key_parts,key_blocks; uint i,keys,key_parts,key_blocks;
memcpy_fixed(&state->header,ptr, sizeof(state->header)); memcpy(&state->header, ptr, sizeof(state->header));
ptr +=sizeof(state->header); ptr +=sizeof(state->header);
keys=(uint) state->header.keys; keys=(uint) state->header.keys;
key_parts=mi_uint2korr(state->header.key_parts); key_parts=mi_uint2korr(state->header.key_parts);

3
storage/myisam/mi_packrec.c
View file

@ -1051,8 +1051,7 @@ static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
} }
decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length); decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
_my_store_blob_length((uchar*) to,pack_length,length); _my_store_blob_length((uchar*) to,pack_length,length);
memcpy_fixed((char*) to+pack_length,(char*) &bit_buff->blob_pos, memcpy((char*) to+pack_length, &bit_buff->blob_pos, sizeof(char*));
sizeof(char*));
bit_buff->blob_pos+=length; bit_buff->blob_pos+=length;
} }
} }

12
storage/myisam/mi_test1.c
View file

@ -411,7 +411,7 @@ static void create_record(uchar *record,uint rownr)
tmp=strlen((char*) blob_key); tmp=strlen((char*) blob_key);
int4store(pos,tmp); int4store(pos,tmp);
ptr=blob_key; ptr=blob_key;
memcpy_fixed(pos+4,&ptr,sizeof(char*)); memcpy(pos+4, &ptr, sizeof(char*));
pos+=recinfo[1].length; pos+=recinfo[1].length;
} }
else if (recinfo[1].type == FIELD_VARCHAR) else if (recinfo[1].type == FIELD_VARCHAR)
@ -439,7 +439,7 @@ static void create_record(uchar *record,uint rownr)
tmp=strlen((char*) blob_record); tmp=strlen((char*) blob_record);
int4store(pos,tmp); int4store(pos,tmp);
ptr=blob_record; ptr=blob_record;
memcpy_fixed(pos+4,&ptr,sizeof(char*)); memcpy(pos+4, &ptr, sizeof(char*));
} }
else if (recinfo[2].type == FIELD_VARCHAR) else if (recinfo[2].type == FIELD_VARCHAR)
{ {
@ -468,10 +468,10 @@ static void update_record(uchar *record)
uchar *column,*ptr; uchar *column,*ptr;
int length; int length;
length=uint4korr(pos); /* Long blob */ length=uint4korr(pos); /* Long blob */
memcpy_fixed(&column,pos+4,sizeof(char*)); memcpy(&column, pos+4, sizeof(char*));
memcpy(blob_key,column,length); /* Move old key */ memcpy(blob_key,column,length); /* Move old key */
ptr=blob_key; ptr=blob_key;
memcpy_fixed(pos+4,&ptr,sizeof(char*)); /* Store pointer to new key */ memcpy(pos+4, &ptr, sizeof(char*)); /* Store pointer to new key */
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM) if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
default_charset_info->cset->casedn(default_charset_info, default_charset_info->cset->casedn(default_charset_info,
(char*) blob_key, length, (char*) blob_key, length,
@ -501,13 +501,13 @@ static void update_record(uchar *record)
uchar *column; uchar *column;
int length; int length;
length=uint4korr(pos); length=uint4korr(pos);
memcpy_fixed(&column,pos+4,sizeof(char*)); memcpy(&column, pos+4, sizeof(char*));
memcpy(blob_record,column,length); memcpy(blob_record,column,length);
bfill(blob_record+length,20,'.'); /* Make it larger */ bfill(blob_record+length,20,'.'); /* Make it larger */
length+=20; length+=20;
int4store(pos,length); int4store(pos,length);
column= blob_record; column= blob_record;
memcpy_fixed(pos+4,&column,sizeof(char*)); memcpy(pos+4, &column, sizeof(char*));
} }
else if (recinfo[2].type == FIELD_VARCHAR) else if (recinfo[2].type == FIELD_VARCHAR)
{ {

2
storage/myisam/mi_test2.c
View file

@ -1030,7 +1030,7 @@ static void put_blob_in_record(uchar *blob_pos, char **blob_buffer)
for (i=0 ; i < length ; i++) for (i=0 ; i < length ; i++)
(*blob_buffer)[i]=(char) (length+i); (*blob_buffer)[i]=(char) (length+i);
int4store(blob_pos,length); int4store(blob_pos,length);
memcpy_fixed(blob_pos+4,(char*) blob_buffer,sizeof(char*)); memcpy(blob_pos+4, blob_buffer, sizeof(char*));
} }
else else
{ {

2
storage/myisam/mi_test3.c
View file

@ -458,7 +458,7 @@ int test_update(MI_INFO *file,int id,int lock_type)
} }
} }
} }
memcpy_fixed(new_record.id,record.id,sizeof(record.id)); memcpy(new_record.id, record.id, sizeof(record.id));
tmp=rnd(20000)+40000; tmp=rnd(20000)+40000;
int4store(new_record.nr,tmp); int4store(new_record.nr,tmp);
if (!mi_update(file,record.id,new_record.id)) if (!mi_update(file,record.id,new_record.id))

6
storage/myisam/mi_unique.c
View file

@ -111,7 +111,7 @@ ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const uchar *record)
else if (keyseg->flag & HA_BLOB_PART) else if (keyseg->flag & HA_BLOB_PART)
{ {
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos); uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy_fixed((uchar*) &pos,pos+keyseg->bit_start,sizeof(char*)); memcpy(&pos, pos+keyseg->bit_start, sizeof(char*));
if (!length || length > tmp_length) if (!length || length > tmp_length)
length=tmp_length; /* The whole blob */ length=tmp_length; /* The whole blob */
} }
@ -206,8 +206,8 @@ int mi_unique_comp(MI_UNIQUEDEF *def, const uchar *a, const uchar *b,
set_if_smaller(a_length, keyseg->length); set_if_smaller(a_length, keyseg->length);
set_if_smaller(b_length, keyseg->length); set_if_smaller(b_length, keyseg->length);
} }
memcpy_fixed((uchar*) &pos_a,pos_a+keyseg->bit_start,sizeof(char*)); memcpy(&pos_a, pos_a+keyseg->bit_start, sizeof(char*));
memcpy_fixed((uchar*) &pos_b,pos_b+keyseg->bit_start,sizeof(char*)); memcpy(&pos_b, pos_b+keyseg->bit_start, sizeof(char*));
} }
if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 || if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
type == HA_KEYTYPE_VARTEXT2) type == HA_KEYTYPE_VARTEXT2)

4
storage/myisam/myisamlog.c
View file

@ -619,7 +619,7 @@ static int examine_log(char * file_name, char **table_names)
case MI_LOG_LOCK: case MI_LOG_LOCK:
if (my_b_read(&cache,(uchar*) head,sizeof(lock_command))) if (my_b_read(&cache,(uchar*) head,sizeof(lock_command)))
goto err; goto err;
memcpy_fixed(&lock_command,head,sizeof(lock_command)); memcpy(&lock_command, head, sizeof(lock_command));
if (verbose && !record_pos_file && if (verbose && !record_pos_file &&
(!table_names[0] || (curr_file_info && curr_file_info->used))) (!table_names[0] || (curr_file_info && curr_file_info->used)))
printf_log("%s: %s(%d) -> %d\n",FILENAME(curr_file_info), printf_log("%s: %s(%d) -> %d\n",FILENAME(curr_file_info),
@ -728,7 +728,7 @@ static void fix_blob_pointers(MI_INFO *info, uchar *record)
blob != end ; blob != end ;
blob++) blob++)
{ {
memcpy_fixed(record+blob->offset+blob->pack_length,&pos,sizeof(char*)); memcpy(record+blob->offset+blob->pack_length, &pos, sizeof(char*));
pos+=_mi_calc_blob_length(blob->pack_length,record+blob->offset); pos+=_mi_calc_blob_length(blob->pack_length,record+blob->offset);
} }
} }

9
storage/myisam/myisampack.c
View file

@ -1040,7 +1040,7 @@ static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
{ {
uint field_length=count->field_length -portable_sizeof_char_ptr; uint field_length=count->field_length -portable_sizeof_char_ptr;
ulong blob_length= _mi_calc_blob_length(field_length, start_pos); ulong blob_length= _mi_calc_blob_length(field_length, start_pos);
memcpy_fixed((char*) &pos, start_pos+field_length,sizeof(char*)); memcpy(&pos, start_pos+field_length, sizeof(char*));
end_pos=pos+blob_length; end_pos=pos+blob_length;
tot_blob_length+=blob_length; tot_blob_length+=blob_length;
set_if_bigger(count->max_length,blob_length); set_if_bigger(count->max_length,blob_length);
@ -1889,7 +1889,7 @@ static uint join_same_trees(HUFF_COUNTS *huff_counts, uint trees)
i->tree->tree_pack_length+j->tree->tree_pack_length+ i->tree->tree_pack_length+j->tree->tree_pack_length+
ALLOWED_JOIN_DIFF) ALLOWED_JOIN_DIFF)
{ {
memcpy_fixed((uchar*) i->counts,(uchar*) count.counts, memcpy(i->counts, count.counts,
sizeof(count.counts[0])*256); sizeof(count.counts[0])*256);
my_free(j->tree->element_buffer); my_free(j->tree->element_buffer);
j->tree->element_buffer=0; j->tree->element_buffer=0;
@ -2040,7 +2040,7 @@ static int write_header(PACK_MRG_INFO *mrg,uint head_length,uint trees,
uchar *buff= (uchar*) file_buffer.pos; uchar *buff= (uchar*) file_buffer.pos;
bzero(buff,HEAD_LENGTH); bzero(buff,HEAD_LENGTH);
memcpy_fixed(buff,myisam_pack_file_magic,4); memcpy(buff,myisam_pack_file_magic,4);
int4store(buff+4,head_length); int4store(buff+4,head_length);
int4store(buff+8, mrg->min_pack_length); int4store(buff+8, mrg->min_pack_length);
int4store(buff+12,mrg->max_pack_length); int4store(buff+12,mrg->max_pack_length);
@ -2697,8 +2697,7 @@ static int compress_isam_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts)
DBUG_PRINT("fields", ("FIELD_BLOB %lu bytes, bits: %2u", DBUG_PRINT("fields", ("FIELD_BLOB %lu bytes, bits: %2u",
blob_length, count->length_bits)); blob_length, count->length_bits));
write_bits(blob_length,count->length_bits); write_bits(blob_length,count->length_bits);
memcpy_fixed(&blob,end_pos-portable_sizeof_char_ptr, memcpy(&blob, end_pos-portable_sizeof_char_ptr, sizeof(char*));
sizeof(char*));
blob_end=blob+blob_length; blob_end=blob+blob_length;
/* Encode the blob bytes. */ /* Encode the blob bytes. */
for ( ; blob < blob_end ; blob++) for ( ; blob < blob_end ; blob++)

2
storage/myisam/sp_key.c
View file

@ -47,7 +47,7 @@ uint sp_make_key(register MI_INFO *info, uint keynr, uchar *key,
pos = (uchar*)record + keyseg->start; pos = (uchar*)record + keyseg->start;
dlen = _mi_calc_blob_length(keyseg->bit_start, pos); dlen = _mi_calc_blob_length(keyseg->bit_start, pos);
memcpy_fixed(&dptr, pos + keyseg->bit_start, sizeof(char*)); memcpy(&dptr, pos + keyseg->bit_start, sizeof(char*));
if (!dptr) if (!dptr)
{ {
my_errno= HA_ERR_NULL_IN_SPATIAL; my_errno= HA_ERR_NULL_IN_SPATIAL;

4
storage/myisam/sp_test.c
View file

@ -310,7 +310,7 @@ static void print_record(uchar * record, my_off_t offs,const char * tail)
len=sint4korr(pos); len=sint4korr(pos);
pos+=4; pos+=4;
printf(" len=%d ",len); printf(" len=%d ",len);
memcpy_fixed(&ptr,pos,sizeof(char*)); memcpy(&ptr, pos, sizeof(char*));
if (ptr) if (ptr)
rtree_PrintWKB((uchar*) ptr,SPDIMS); rtree_PrintWKB((uchar*) ptr,SPDIMS);
else else
@ -344,7 +344,7 @@ static void create_linestring(uchar *record,uint rownr)
pos+=4; pos+=4;
ptr=blob_key; ptr=blob_key;
memcpy_fixed(pos,&ptr,sizeof(char*)); memcpy(pos, &ptr, sizeof(char*));
} }

3
storage/perfschema/pfs_events_waits.cc
View file

@ -95,8 +95,7 @@ static void copy_events_waits(PFS_events_waits *dest,
/* Signal readers they are about to read garbage ... */ /* Signal readers they are about to read garbage ... */
dest->m_wait_class= NO_WAIT_CLASS; dest->m_wait_class= NO_WAIT_CLASS;
/* ... that this can generate. */ /* ... that this can generate. */
memcpy_fixed(dest_body, memcpy(dest_body, source_body,
source_body,
sizeof(PFS_events_waits) - sizeof(events_waits_class)); sizeof(PFS_events_waits) - sizeof(events_waits_class));
/* Signal readers the record is now clean again. */ /* Signal readers the record is now clean again. */
dest->m_wait_class= source->m_wait_class; dest->m_wait_class= source->m_wait_class;