1 /*
2 * Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
3 *
4 * All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, and/or sell copies of the Software, and to permit persons
11 * to whom the Software is furnished to do so, provided that the above
12 * copyright notice(s) and this permission notice appear in all copies of
13 * the Software and that both the above copyright notice(s) and this
14 * permission notice appear in supporting documentation.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
19 * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
20 * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
21 * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
22 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
23 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
24 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 *
26 * Except as contained in this notice, the name of a copyright holder
27 * shall not be used in advertising or otherwise to promote the sale, use
28 * or other dealings in this Software without prior written authorization
29 * of the copyright holder.
30 */
31
32 #pragma ident "%Z%%M% %I% %E% SMI"
33
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <errno.h>
37
38 #include "strngmem.h"
39 #include "freelist.h"
40
41 struct StringMem {
42 unsigned long nmalloc; /* The number of strings allocated with malloc */
43 FreeList *fl; /* The free-list */
44 };
45
46 /*.......................................................................
47 * Create a string free-list container and the first block of its free-list.
48 *
49 * Input:
50 * blocking_factor int The blocking_factor argument specifies how
51 * many strings of length SM_STRLEN
52 * bytes (see stringmem.h) are allocated in each
53 * free-list block.
54 * For example if blocking_factor=64 and
55 * SM_STRLEN=16, then each new
56 * free-list block will take 1K of memory.
57 * Output:
58 * return StringMem * The new free-list container, or NULL on
59 * error.
60 */
_new_StringMem(unsigned blocking_factor)61 StringMem *_new_StringMem(unsigned blocking_factor)
62 {
63 StringMem *sm; /* The container to be returned. */
64 /*
65 * Check arguments.
66 */
67 if(blocking_factor < 1) {
68 errno = EINVAL;
69 return NULL;
70 };
71 /*
72 * Allocate the container.
73 */
74 sm = (StringMem *) malloc(sizeof(StringMem));
75 if(!sm) {
76 errno = ENOMEM;
77 return NULL;
78 };
79 /*
80 * Before attempting any operation that might fail, initialize
81 * the container at least up to the point at which it can safely
82 * be passed to _del_StringMem().
83 */
84 sm->nmalloc = 0;
85 sm->fl = NULL;
86 /*
87 * Allocate the free-list.
88 */
89 sm->fl = _new_FreeList(SM_STRLEN, blocking_factor);
90 if(!sm->fl)
91 return _del_StringMem(sm, 1);
92 /*
93 * Return the free-list container.
94 */
95 return sm;
96 }
97
98 /*.......................................................................
99 * Delete a string free-list.
100 *
101 * Input:
102 * sm StringMem * The string free-list to be deleted, or NULL.
103 * force int If force==0 then _del_StringMem() will complain
104 * and refuse to delete the free-list if any
105 * of nodes have not been returned to the free-list.
106 * If force!=0 then _del_StringMem() will not check
107 * whether any nodes are still in use and will
108 * always delete the list.
109 * Output:
110 * return StringMem * Always NULL (even if the list couldn't be
111 * deleted).
112 */
_del_StringMem(StringMem * sm,int force)113 StringMem *_del_StringMem(StringMem *sm, int force)
114 {
115 if(sm) {
116 /*
117 * Check whether any strings have not been returned to the free-list.
118 */
119 if(!force && (sm->nmalloc > 0 || _busy_FreeListNodes(sm->fl) > 0)) {
120 errno = EBUSY;
121 return NULL;
122 };
123 /*
124 * Delete the free-list.
125 */
126 sm->fl = _del_FreeList(sm->fl, force);
127 /*
128 * Delete the container.
129 */
130 free(sm);
131 };
132 return NULL;
133 }
134
135 /*.......................................................................
136 * Allocate an array of 'length' chars.
137 *
138 * Input:
139 * sm StringMem * The string free-list to allocate from.
140 * length size_t The length of the new string (including '\0').
141 * Output:
142 * return char * The new string or NULL on error.
143 */
_new_StringMemString(StringMem * sm,size_t length)144 char *_new_StringMemString(StringMem *sm, size_t length)
145 {
146 char *string; /* The string to be returned */
147 int was_malloc; /* True if malloc was used to allocate the string */
148 /*
149 * Check arguments.
150 */
151 if(!sm)
152 return NULL;
153 if(length < 1)
154 length = 1;
155 /*
156 * Allocate the new node from the free list if possible.
157 */
158 if(length < SM_STRLEN) {
159 string = (char *)_new_FreeListNode(sm->fl);
160 if(!string)
161 return NULL;
162 was_malloc = 0;
163 } else {
164 string = (char *) malloc(length+1); /* Leave room for the flag byte */
165 if(!string)
166 return NULL;
167 /*
168 * Count malloc allocations.
169 */
170 was_malloc = 1;
171 sm->nmalloc++;
172 };
173 /*
174 * Use the first byte of the string to record whether the string was
175 * allocated with malloc or from the free-list. Then return the rest
176 * of the string for use by the user.
177 */
178 string[0] = (char) was_malloc;
179 return string + 1;
180 }
181
182 /*.......................................................................
183 * Free a string that was previously returned by _new_StringMemString().
184 *
185 * Input:
186 * sm StringMem * The free-list from which the string was originally
187 * allocated.
188 * s char * The string to be returned to the free-list, or NULL.
189 * Output:
190 * return char * Always NULL.
191 */
_del_StringMemString(StringMem * sm,char * s)192 char *_del_StringMemString(StringMem *sm, char *s)
193 {
194 int was_malloc; /* True if the string originally came from malloc() */
195 /*
196 * Is there anything to be deleted?
197 */
198 if(s && sm) {
199 /*
200 * Retrieve the true string pointer. This is one less than the one
201 * returned by _new_StringMemString() because the first byte of the
202 * allocated memory is reserved by _new_StringMemString as a flag byte
203 * to say whether the memory was allocated from the free-list or directly
204 * from malloc().
205 */
206 s--;
207 /*
208 * Get the origination flag.
209 */
210 was_malloc = s[0];
211 if(was_malloc) {
212 free(s);
213 s = NULL;
214 sm->nmalloc--;
215 } else {
216 s = (char *) _del_FreeListNode(sm->fl, s);
217 };
218 };
219 return NULL;
220 }
221