← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/array.c

Merged in changes from Andrey.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/array.c
40
40
    false       Ok
41
41
*/
42
42
 
43
 
bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint element_size,
44
 
                            void *init_buffer, uint init_alloc, 
45
 
                            uint alloc_increment CALLER_INFO_PROTO)
 
43
bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint32_t element_size,
 
44
                            void *init_buffer, uint32_t init_alloc, 
 
45
                            uint32_t alloc_increment CALLER_INFO_PROTO)
46
46
{
47
47
  if (!alloc_increment)
48
48
  {
49
 
    alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16);
 
49
    alloc_increment=cmax((8192-MALLOC_OVERHEAD)/element_size,16);
50
50
    if (init_alloc > 8 && alloc_increment > init_alloc * 2)
51
51
      alloc_increment=init_alloc*2;
52
52
  }
62
62
  array->size_of_element=element_size;
63
63
  if ((array->buffer= init_buffer))
64
64
    return(false);
65
 
  if (!(array->buffer=(uchar*) my_malloc_ci(element_size*init_alloc,
 
65
  if (!(array->buffer=(unsigned char*) my_malloc_ci(element_size*init_alloc,
66
66
                                            MYF(MY_WME))))
67
67
  {
68
68
    array->max_element=0;
71
71
  return(false);
72
72
} 
73
73
 
74
 
bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
75
 
                           uint init_alloc, 
76
 
                           uint alloc_increment CALLER_INFO_PROTO)
 
74
bool init_dynamic_array(DYNAMIC_ARRAY *array, uint32_t element_size,
 
75
                           uint32_t init_alloc, 
 
76
                           uint32_t alloc_increment CALLER_INFO_PROTO)
77
77
{
78
78
  /* placeholder to preserve ABI */
79
79
  return my_init_dynamic_array_ci(array, element_size, init_alloc, 
92
92
    false       Ok
93
93
*/
94
94
 
95
 
bool insert_dynamic(DYNAMIC_ARRAY *array, uchar* element)
 
95
bool insert_dynamic(DYNAMIC_ARRAY *array, unsigned char* element)
96
96
{
97
 
  uchar* buffer;
 
97
  unsigned char* buffer;
98
98
  if (array->elements == array->max_element)
99
99
  {                                             /* Call only when nessesary */
100
100
    if (!(buffer=alloc_dynamic(array)))
127
127
    0           Error
128
128
*/
129
129
 
130
 
uchar *alloc_dynamic(DYNAMIC_ARRAY *array)
 
130
unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array)
131
131
{
132
132
  if (array->elements == array->max_element)
133
133
  {
134
134
    char *new_ptr;
135
 
    if (array->buffer == (uchar *)(array + 1))
 
135
    if (array->buffer == (unsigned char *)(array + 1))
136
136
    {
137
137
      /*
138
138
        In this senerio, the buffer is statically preallocated,
152
152
                                     array->size_of_element,
153
153
                                     MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
154
154
      return 0;
155
 
    array->buffer= (uchar*) new_ptr;
 
155
    array->buffer= (unsigned char*) new_ptr;
156
156
    array->max_element+=array->alloc_increment;
157
157
  }
158
158
  return array->buffer+(array->elements++ * array->size_of_element);
171
171
    0           Array is empty
172
172
*/
173
173
 
174
 
uchar *pop_dynamic(DYNAMIC_ARRAY *array)
 
174
unsigned char *pop_dynamic(DYNAMIC_ARRAY *array)
175
175
{
176
176
  if (array->elements)
177
177
    return array->buffer+(--array->elements * array->size_of_element);
196
196
    false       Ok
197
197
*/
198
198
 
199
 
bool set_dynamic(DYNAMIC_ARRAY *array, uchar* element, uint idx)
 
199
bool set_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
200
200
{
201
201
  if (idx >= array->elements)
202
202
  {
228
228
    true        Allocation of new memory failed
229
229
*/
230
230
 
231
 
bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
 
231
bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements)
232
232
{
233
233
  if (max_elements >= array->max_element)
234
234
  {
235
 
    uint size;
236
 
    uchar *new_ptr;
 
235
    uint32_t size;
 
236
    unsigned char *new_ptr;
237
237
    size= (max_elements + array->alloc_increment)/array->alloc_increment;
238
238
    size*= array->alloc_increment;
239
 
    if (array->buffer == (uchar *)(array + 1))
 
239
    if (array->buffer == (unsigned char *)(array + 1))
240
240
    {
241
241
       /*
242
242
         In this senerio, the buffer is statically preallocated,
243
243
         so we have to create an all-new malloc since we overflowed
244
244
       */
245
 
       if (!(new_ptr= (uchar *) my_malloc(size *
 
245
       if (!(new_ptr= (unsigned char *) my_malloc(size *
246
246
                                         array->size_of_element,
247
247
                                         MYF(MY_WME))))
248
248
         return 0;
252
252
     else
253
253
 
254
254
 
255
 
    if (!(new_ptr= (uchar*) my_realloc(array->buffer,size*
 
255
    if (!(new_ptr= (unsigned char*) my_realloc(array->buffer,size*
256
256
                                       array->size_of_element,
257
257
                                       MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
258
258
      return true;
269
269
  SYNOPSIS
270
270
    get_dynamic()
271
271
      array     
272
 
      uchar*    Element to be returned. If idx > elements contain zeroes.
 
272
      unsigned char*    Element to be returned. If idx > elements contain zeroes.
273
273
      idx       Index of element wanted. 
274
274
*/
275
275
 
276
 
void get_dynamic(DYNAMIC_ARRAY *array, uchar* element, uint idx)
 
276
void get_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
277
277
{
278
278
  if (idx >= array->elements)
279
279
  {
298
298
  /*
299
299
    Just mark as empty if we are using a static buffer
300
300
  */
301
 
  if (array->buffer == (uchar *)(array + 1))
 
301
  if (array->buffer == (unsigned char *)(array + 1))
302
302
    array->elements= 0;
303
303
  else
304
304
  if (array->buffer)
305
305
  {
306
 
    my_free(array->buffer,MYF(MY_WME));
 
306
    free(array->buffer);
307
307
    array->buffer=0;
308
308
    array->elements=array->max_element=0;
309
309
  }
318
318
      idx        Index of element to be deleted
319
319
*/
320
320
 
321
 
void delete_dynamic_element(DYNAMIC_ARRAY *array, uint idx)
 
321
void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t idx)
322
322
{
323
323
  char *ptr= (char*) array->buffer+array->size_of_element*idx;
324
324
  array->elements--;
338
338
 
339
339
void freeze_size(DYNAMIC_ARRAY *array)
340
340
{
341
 
  uint elements=max(array->elements,1);
 
341
  uint32_t elements=cmax(array->elements,1);
342
342
 
343
343
  /*
344
344
    Do nothing if we are using a static buffer
345
345
  */
346
 
  if (array->buffer == (uchar *)(array + 1))
 
346
  if (array->buffer == (unsigned char *)(array + 1))
347
347
    return;
348
348
    
349
349
  if (array->buffer && array->max_element != elements)
350
350
  {
351
 
    array->buffer=(uchar*) my_realloc(array->buffer,
 
351
    array->buffer=(unsigned char*) my_realloc(array->buffer,
352
352
                                     elements*array->size_of_element,
353
353
                                     MYF(MY_WME));
354
354
    array->max_element=elements;
366
366
 
367
367
*/
368
368
 
369
 
int get_index_dynamic(DYNAMIC_ARRAY *array, uchar* element)
 
369
int get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char* element)
370
370
{
371
 
  uint ret;
 
371
  uint32_t ret;
372
372
  if (array->buffer > element)
373
373
    return -1;
374
374