← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/tree.c

  • Committer: Brian Aker
  • Date: 2008-07-18 22:05:16 UTC
  • Revision ID: brian@tangent.org-20080718220516-dzyjle0iqqjssphx
Dead debug code removal (and a compatible "never used") bit in the
optimizer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/tree.c
54
54
*/
55
55
 
56
56
#include "mysys_priv.h"
57
 
#include <mystrings/m_string.h>
58
 
#include <mysys/my_tree.h>
 
57
#include <m_string.h>
 
58
#include <my_tree.h>
 
59
#include "my_base.h"
59
60
 
60
61
#define BLACK           1
61
62
#define RED             0
74
75
static void rb_delete_fixup(TREE *tree,TREE_ELEMENT ***parent);
75
76
 
76
77
 
77
 
void init_tree(TREE *tree, uint32_t default_alloc_size, uint32_t memory_limit,
 
78
void init_tree(TREE *tree, ulong default_alloc_size, ulong memory_limit,
78
79
               int size, qsort_cmp2 compare, bool with_delete,
79
80
               tree_element_free free_element, void *custom_arg)
80
81
{
81
82
  if (default_alloc_size < DEFAULT_ALLOC_SIZE)
82
83
    default_alloc_size= DEFAULT_ALLOC_SIZE;
83
84
  default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
84
 
  memset(&tree->null_element, 0, sizeof(tree->null_element));
 
85
  bzero((uchar*) &tree->null_element,sizeof(tree->null_element));
85
86
  tree->root= &tree->null_element;
86
87
  tree->compare=compare;
87
88
  tree->size_of_element=size > 0 ? (uint) size : 0;
149
150
 
150
151
void delete_tree(TREE* tree)
151
152
{
152
 
  free_tree(tree, MYF(0)); /* free() mem_root if applicable */
 
153
  free_tree(tree, MYF(0)); /* my_free() mem_root if applicable */
153
154
}
154
155
 
155
156
void reset_tree(TREE* tree)
168
169
      (*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
169
170
    delete_tree_element(tree,element->right);
170
171
    if (tree->with_delete)
171
 
      free((char*) element);
 
172
      my_free((char*) element,MYF(0));
172
173
  }
173
174
}
174
175
 
181
182
    parent[0] = & parent[-1][0]->right
182
183
*/
183
184
 
184
 
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint32_t key_size, 
 
185
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size, 
185
186
                          void* custom_arg)
186
187
{
187
188
  int cmp;
206
207
  }
207
208
  if (element == &tree->null_element)
208
209
  {
209
 
    uint32_t alloc_size=sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
 
210
    uint alloc_size=sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
210
211
    tree->allocated+=alloc_size;
211
212
 
212
213
    if (tree->memory_limit && tree->elements_in_tree
232
233
      else
233
234
      {
234
235
        *((void**) (element+1))= (void*) ((void **) (element+1)+1);
235
 
        memcpy(*((void **) (element+1)),key, key_size - sizeof(void*));
 
236
        memcpy((uchar*) *((void **) (element+1)),key,
 
237
               (size_t) (key_size-sizeof(void*)));
236
238
      }
237
239
    }
238
240
    else
239
 
      memcpy((unsigned char*) element + tree->offset_to_key, key, key_size);
 
241
      memcpy((uchar*) element+tree->offset_to_key,key,(size_t) key_size);
240
242
    element->count=1;                   /* May give warning in purify */
241
243
    tree->elements_in_tree++;
242
244
    rb_insert(tree,parent,element);     /* rebalance tree */
253
255
  return element;
254
256
}
255
257
 
256
 
int tree_delete(TREE *tree, void *key, uint32_t key_size, void *custom_arg)
 
258
int tree_delete(TREE *tree, void *key, uint key_size, void *custom_arg)
257
259
{
258
260
  int cmp,remove_colour;
259
261
  TREE_ELEMENT *element,***parent, ***org_parent, *nod;
309
311
  if (tree->free)
310
312
    (*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
311
313
  tree->allocated-= sizeof(TREE_ELEMENT) + tree->size_of_element + key_size;
312
 
  free((unsigned char*) element);
 
314
  my_free((uchar*) element,MYF(0));
313
315
  tree->elements_in_tree--;
314
316
  return 0;
315
317
}