source: trunk/lib/void_stack.c @ 57

Last change on this file since 57 was 52, checked in by tim, 19 years ago

fixed a double-free bug which FreeBSD (but not Linux) catches and bails on.

other minor tweaks

  • Property svn:keywords set to Id
File size: 3.5 KB
Line 
1/*
2 * This is a really simple implementation of a stack which stores chunks
3 * of memory of any type.  It still needs work to eliminate memory
4 * leaks.
5 *
6 * Copyright (C) 2005 Timothy D. Morgan
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
20 *
21 * $Id: void_stack.c 52 2005-08-09 00:43:07Z tim $
22 */
23
24#include "../include/void_stack.h"
25
26void_stack* void_stack_new(unsigned short max_size)
27{
28  void_stack* ret_val = (void_stack*)malloc(sizeof(void_stack));
29
30  if (ret_val != NULL)
31  {
32    memset(ret_val, 0, sizeof(*ret_val));
33    ret_val->elements = (void**)malloc(max_size*sizeof(void*));
34    if (ret_val->elements == NULL)
35    {
36      free(ret_val);
37      ret_val = NULL;
38    }
39    else
40    {
41      memset(ret_val->elements, 0, max_size*sizeof(void*));
42   
43      ret_val->max_size = max_size;
44      ret_val->top = 0;
45    }
46  }
47
48  return ret_val;
49}
50
51
52void_stack* void_stack_copy(const void_stack* v)
53{
54  unsigned int i;
55  void_stack* ret_val;
56  if(v == NULL)
57    return NULL;
58
59  ret_val = void_stack_new(v->max_size);
60  if(ret_val == NULL)
61    return NULL;
62
63  for(i = 0; i < v->top; i++)
64    ret_val->elements[i] = v->elements[i];
65  ret_val->top = v->top;
66
67  return ret_val;
68}
69
70
71void_stack* void_stack_copy_reverse(const void_stack* v)
72{
73  unsigned int i;
74  void_stack* ret_val;
75  if(v == NULL)
76    return NULL;
77
78  ret_val = void_stack_new(v->max_size);
79  if(ret_val == NULL)
80    return NULL;
81
82  for(i = 0; i < v->top; i++)
83    ret_val->elements[i] = v->elements[v->top-i-1];
84  ret_val->top = v->top;
85
86  return ret_val;
87}
88
89
90void void_stack_destroy(void_stack* stack)
91{
92  free(stack->elements);
93  free(stack);
94}
95
96
97void void_stack_destroy_deep(void_stack* stack)
98{
99  unsigned short i;
100  for(i=0; i < stack->top; i++)
101    free(stack->elements[i]);
102  free(stack->elements);
103  free(stack);
104}
105
106
107unsigned short void_stack_size(void_stack* stack)
108{
109  return stack->top;
110}
111
112
113bool void_stack_push(void_stack* stack, void* e)
114{
115  if(stack->top < stack->max_size)
116  {
117    stack->elements[stack->top++] = e;
118    return true;
119  }
120  else
121    return false;
122}
123
124
125void* void_stack_pop(void_stack* stack)
126{
127  void* ret_val = NULL;
128
129  if(stack->top > 0)
130  {
131    ret_val = stack->elements[--(stack->top)];
132    stack->elements[stack->top] = NULL;
133  }
134  else
135    ret_val = NULL;
136
137  return ret_val;
138}
139
140
141const void* void_stack_cur(void_stack* stack)
142{
143  void* ret_val = NULL;
144
145  if(stack->top > 0)
146    ret_val = stack->elements[stack->top-1];
147  else
148    ret_val = NULL;
149
150  return ret_val;
151}
152
153
154void_stack_iterator* void_stack_iterator_new(void_stack* stack)
155{
156  void_stack_iterator* ret_val = NULL;
157 
158  ret_val = (void_stack_iterator*)malloc(sizeof(void_stack_iterator));
159  if (ret_val != NULL)
160  {
161    ret_val->stack = stack;
162    ret_val->cur = 0;
163  }
164
165  return ret_val;
166}
167
168
169void void_stack_iterator_destroy(void_stack_iterator* iter)
170{
171  free(iter);
172}
173
174
175const void* void_stack_iterator_next(void_stack_iterator* iter)
176{
177  if(iter->cur < iter->stack->top)
178    return iter->stack->elements[iter->cur++];
179  else
180    return NULL;
181}
Note: See TracBrowser for help on using the repository browser.