source: releases/0.11.0/lib/void_stack.c @ 289

Last change on this file since 289 was 150, checked in by tim, 16 years ago

integrated talloc into most of the rest of the regfi library
fixed a length validation issue

  • Property svn:keywords set to Id
File size: 3.4 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,2007,2009 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 3 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 150 2009-03-02 02:17:46Z tim $
22 */
23
24#include "void_stack.h"
25
26void_stack* void_stack_new(unsigned short max_size)
27{
28  void_stack* ret_val = talloc(NULL, void_stack);
29
30  if (ret_val != NULL)
31  {
32    memset(ret_val, 0, sizeof(*ret_val));
33    ret_val->elements = talloc_array(ret_val, void*, max_size);
34    if (ret_val->elements == NULL)
35    {
36      talloc_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_free(void_stack* stack)
91{
92  talloc_free(stack);
93}
94
95
96void void_stack_free_deep(void_stack* stack)
97{
98  unsigned short i;
99  for(i=0; i < stack->top; i++)
100    free(stack->elements[i]);
101  talloc_free(stack);
102}
103
104
105unsigned short void_stack_size(const void_stack* stack)
106{
107  return stack->top;
108}
109
110
111void* void_stack_pop(void_stack* stack)
112{
113  void* ret_val = NULL;
114
115  if(stack->top > 0)
116  {
117    ret_val = stack->elements[--(stack->top)];
118    stack->elements[stack->top] = NULL;
119  }
120
121  return ret_val;
122}
123
124
125bool void_stack_push(void_stack* stack, void* e)
126{
127  if(stack->top < stack->max_size)
128  {
129    stack->elements[stack->top++] = e;
130    return true;
131  }
132  else
133    return false;
134}
135
136
137const void* void_stack_cur(const void_stack* stack)
138{
139  void* ret_val = NULL;
140
141  if(stack->top > 0)
142    ret_val = stack->elements[stack->top-1];
143
144  return ret_val;
145}
146
147
148void_stack_iterator* void_stack_iterator_new(const void_stack* stack)
149{
150  void_stack_iterator* ret_val = NULL;
151 
152  if(stack != NULL)
153  {
154    ret_val = talloc(stack, void_stack_iterator);
155    if (ret_val != NULL)
156    {
157      ret_val->stack = stack;
158      ret_val->cur = 0;
159    }
160  }
161
162  return ret_val;
163}
164
165
166void void_stack_iterator_free(void_stack_iterator* iter)
167{
168  talloc_free(iter);
169}
170
171
172const void* void_stack_iterator_next(void_stack_iterator* iter)
173{
174  if(iter->cur < iter->stack->top)
175    return iter->stack->elements[iter->cur++];
176  else
177    return NULL;
178}
Note: See TracBrowser for help on using the repository browser.