← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/array.cc

  • Committer: Brian Aker
  • Date: 2009-05-11 17:50:22 UTC
  • Revision ID: brian@gaz-20090511175022-y35q9ky6uh9ldcjt
Replacing Sun employee copyright headers (aka... anything done by a Sun
employee is copyright by Sun).

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/array.cc
15
15
 
16
16
/* Handling of arrays that can grow dynamicly. */
17
17
 
18
 
#include "mysys_priv.h"
 
18
#include "mysys/mysys_priv.h"
19
19
#include <mystrings/m_string.h>
20
20
 
21
21
/*
30
30
      alloc_increment   Increment for adding new elements
31
31
 
32
32
  DESCRIPTION
33
 
    init_dynamic_array() initiates array and allocate space for 
34
 
    init_alloc eilements. 
 
33
    init_dynamic_array() initiates array and allocate space for
 
34
    init_alloc eilements.
35
35
    Array is usable even if space allocation failed.
36
36
    Static buffers must begin immediately after the array structure.
37
37
 
38
38
  RETURN VALUE
39
 
    true        my_malloc_ci() failed
 
39
    true        malloc() failed
40
40
    false       Ok
41
41
*/
42
42
 
43
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)
 
44
                            void *init_buffer, uint32_t init_alloc,
 
45
                            uint32_t alloc_increment)
46
46
{
47
47
  if (!alloc_increment)
48
48
  {
60
60
  array->max_element=init_alloc;
61
61
  array->alloc_increment=alloc_increment;
62
62
  array->size_of_element=element_size;
63
 
  if ((array->buffer= init_buffer))
 
63
  if ((array->buffer= (unsigned char*) init_buffer))
64
64
    return(false);
65
 
  if (!(array->buffer=(unsigned char*) my_malloc_ci(element_size*init_alloc,
66
 
                                            MYF(MY_WME))))
 
65
  if (!(array->buffer=(unsigned char*) malloc(element_size*init_alloc)))
67
66
  {
68
67
    array->max_element=0;
69
68
    return(true);
70
69
  }
71
70
  return(false);
72
 
} 
 
71
}
73
72
 
74
73
bool init_dynamic_array(DYNAMIC_ARRAY *array, uint32_t element_size,
75
 
                           uint32_t init_alloc, 
76
 
                           uint32_t alloc_increment CALLER_INFO_PROTO)
 
74
                           uint32_t init_alloc,
 
75
                           uint32_t alloc_increment)
77
76
{
78
77
  /* placeholder to preserve ABI */
79
 
  return my_init_dynamic_array_ci(array, element_size, init_alloc, 
 
78
  return my_init_dynamic_array_ci(array, element_size, init_alloc,
80
79
                                  alloc_increment);
81
80
}
82
81
/*
111
110
 
112
111
 
113
112
/*
114
 
  Alloc space for next element(s) 
 
113
  Alloc space for next element(s)
115
114
 
116
115
  SYNOPSIS
117
116
    alloc_dynamic()
138
137
        In this senerio, the buffer is statically preallocated,
139
138
        so we have to create an all-new malloc since we overflowed
140
139
      */
141
 
      if (!(new_ptr= (char *) my_malloc((array->max_element+
142
 
                                         array->alloc_increment) *
143
 
                                        array->size_of_element,
144
 
                                        MYF(MY_WME))))
 
140
      if (!(new_ptr= (char *) malloc((array->max_element+
 
141
                                     array->alloc_increment) *
 
142
                                     array->size_of_element)))
145
143
        return 0;
146
 
      memcpy(new_ptr, array->buffer, 
 
144
      memcpy(new_ptr, array->buffer,
147
145
             array->elements * array->size_of_element);
148
146
    }
149
 
    else
150
 
    if (!(new_ptr=(char*) my_realloc(array->buffer,(array->max_element+
151
 
                                     array->alloc_increment)*
152
 
                                     array->size_of_element,
153
 
                                     MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
 
147
    else if (!(new_ptr= (char*) realloc(array->buffer,
 
148
                                        (array->max_element+
 
149
                                         array->alloc_increment)*
 
150
                                        array->size_of_element)))
154
151
      return 0;
155
152
    array->buffer= (unsigned char*) new_ptr;
156
153
    array->max_element+=array->alloc_increment;
165
162
  SYNOPSIS
166
163
    pop_dynamic()
167
164
      array
168
 
  
169
 
  RETURN VALUE    
 
165
 
 
166
  RETURN VALUE
170
167
    pointer     Ok
171
168
    0           Array is empty
172
169
*/
188
185
      idx       Index where element is to be inserted
189
186
 
190
187
  DESCRIPTION
191
 
    set_dynamic() replaces element in array. 
192
 
    If idx > max_element insert new element. Allocate memory if needed. 
193
 
 
 
188
    set_dynamic() replaces element in array.
 
189
    If idx > max_element insert new element. Allocate memory if needed.
 
190
 
194
191
  RETURN VALUE
195
192
    true        Idx was out of range and allocation of new memory failed
196
193
    false       Ok
242
239
         In this senerio, the buffer is statically preallocated,
243
240
         so we have to create an all-new malloc since we overflowed
244
241
       */
245
 
       if (!(new_ptr= (unsigned char *) my_malloc(size *
246
 
                                         array->size_of_element,
247
 
                                         MYF(MY_WME))))
 
242
       if (!(new_ptr= (unsigned char *) malloc(size *
 
243
                                               array->size_of_element)))
248
244
         return 0;
249
 
       memcpy(new_ptr, array->buffer, 
 
245
       memcpy(new_ptr, array->buffer,
250
246
              array->elements * array->size_of_element);
251
247
     }
252
248
     else
253
249
 
254
250
 
255
 
    if (!(new_ptr= (unsigned char*) my_realloc(array->buffer,size*
256
 
                                       array->size_of_element,
257
 
                                       MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
 
251
    if (!(new_ptr=(unsigned char*) realloc(array->buffer,
 
252
                                        size* array->size_of_element)))
258
253
      return true;
259
254
    array->buffer= new_ptr;
260
255
    array->max_element= size;
268
263
 
269
264
  SYNOPSIS
270
265
    get_dynamic()
271
 
      array     
 
266
      array
272
267
      unsigned char*    Element to be returned. If idx > elements contain zeroes.
273
 
      idx       Index of element wanted. 
 
268
      idx       Index of element wanted.
274
269
*/
275
270
 
276
271
void get_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
345
340
  */
346
341
  if (array->buffer == (unsigned char *)(array + 1))
347
342
    return;
348
 
    
 
343
 
349
344
  if (array->buffer && array->max_element != elements)
350
345
  {
351
 
    array->buffer=(unsigned char*) my_realloc(array->buffer,
352
 
                                     elements*array->size_of_element,
353
 
                                     MYF(MY_WME));
 
346
    array->buffer=(unsigned char*) realloc(array->buffer,
 
347
                                     elements*array->size_of_element);
354
348
    array->max_element=elements;
355
349
  }
356
350
}
362
356
  SYNOPSIS
363
357
    get_index_dynamic()
364
358
     array      Array
365
 
     element Whose element index 
 
359
     element Whose element index
366
360
 
367
361
*/
368
362