← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/queues.c

  • Committer: Brian Aker
  • Date: 2008-07-18 20:10:26 UTC
  • mfrom: (51.3.29 remove-dbug)
  • Revision ID: brian@tangent.org-20080718201026-tto5golt0xhwqe4a
Merging in Jay's final patch on dbug.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/queues.c
52
52
               bool max_at_top, int (*compare) (void *, uchar *, uchar *),
53
53
               void *first_cmp_arg)
54
54
{
55
 
  DBUG_ENTER("init_queue");
56
55
  if ((queue->root= (uchar **) my_malloc((max_elements+1)*sizeof(void*),
57
56
                                         MYF(MY_WME))) == 0)
58
 
    DBUG_RETURN(1);
 
57
    return(1);
59
58
  queue->elements=0;
60
59
  queue->compare=compare;
61
60
  queue->first_cmp_arg=first_cmp_arg;
62
61
  queue->max_elements=max_elements;
63
62
  queue->offset_to_key=offset_to_key;
64
63
  queue_set_max_at_top(queue, max_at_top);
65
 
  DBUG_RETURN(0);
 
64
  return(0);
66
65
}
67
66
 
68
67
 
96
95
               void *first_cmp_arg, uint auto_extent)
97
96
{
98
97
  int ret;
99
 
  DBUG_ENTER("init_queue_ex");
100
98
 
101
99
  if ((ret= init_queue(queue, max_elements, offset_to_key, max_at_top, compare,
102
100
                       first_cmp_arg)))
103
 
    DBUG_RETURN(ret);
 
101
    return(ret);
104
102
  
105
103
  queue->auto_extent= auto_extent;
106
 
  DBUG_RETURN(0);
 
104
  return(0);
107
105
}
108
106
 
109
107
/*
132
130
                 bool max_at_top, int (*compare) (void *, uchar *, uchar *),
133
131
                 void *first_cmp_arg)
134
132
{
135
 
  DBUG_ENTER("reinit_queue");
136
133
  queue->elements=0;
137
134
  queue->compare=compare;
138
135
  queue->first_cmp_arg=first_cmp_arg;
139
136
  queue->offset_to_key=offset_to_key;
140
137
  queue_set_max_at_top(queue, max_at_top);
141
138
  resize_queue(queue, max_elements);
142
 
  DBUG_RETURN(0);
 
139
  return(0);
143
140
}
144
141
 
145
142
 
163
160
int resize_queue(QUEUE *queue, uint max_elements)
164
161
{
165
162
  uchar **new_root;
166
 
  DBUG_ENTER("resize_queue");
167
163
  if (queue->max_elements == max_elements)
168
 
    DBUG_RETURN(0);
 
164
    return(0);
169
165
  if ((new_root= (uchar **) my_realloc((void *)queue->root,
170
166
                                      (max_elements+1)*sizeof(void*),
171
167
                                      MYF(MY_WME))) == 0)
172
 
    DBUG_RETURN(1);
 
168
    return(1);
173
169
  set_if_smaller(queue->elements, max_elements);
174
170
  queue->max_elements= max_elements;
175
171
  queue->root= new_root;
176
 
  DBUG_RETURN(0);
 
172
  return(0);
177
173
}
178
174
 
179
175
 
193
189
 
194
190
void delete_queue(QUEUE *queue)
195
191
{
196
 
  DBUG_ENTER("delete_queue");
197
192
  if (queue->root)
198
193
  {
199
194
    my_free((uchar*) queue->root,MYF(0));
200
195
    queue->root=0;
201
196
  }
202
 
  DBUG_VOID_RETURN;
 
197
  return;
203
198
}
204
199
 
205
200
 
208
203
void queue_insert(register QUEUE *queue, uchar *element)
209
204
{
210
205
  register uint idx, next;
211
 
  DBUG_ASSERT(queue->elements < queue->max_elements);
 
206
  assert(queue->elements < queue->max_elements);
212
207
  queue->root[0]= element;
213
208
  idx= ++queue->elements;
214
209
  /* max_at_top swaps the comparison if we want to order by desc */
254
249
uchar *queue_remove(register QUEUE *queue, uint idx)
255
250
{
256
251
  uchar *element;
257
 
  DBUG_ASSERT(idx < queue->max_elements);
 
252
  assert(idx < queue->max_elements);
258
253
  element= queue->root[++idx];  /* Intern index starts from 1 */
259
254
  queue->root[idx]= queue->root[queue->elements--];
260
255
  _downheap(queue, idx);