1 /*-
2  * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer
10  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include <sys/types.h>
28 #include <assert.h>
29 #include <libelftc.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 
34 #include "_libelftc.h"
35 
36 ELFTC_VCSID("$Id: libelftc_vstr.c 3531 2017-06-05 05:08:43Z kaiwang27 $");
37 
38 /**
39  * @file vector_str.c
40  * @brief Dynamic vector data for string implementation.
41  *
42  * Resemble to std::vector<std::string> in C++.
43  */
44 
45 static size_t	get_strlen_sum(const struct vector_str *v);
46 static bool	vector_str_grow(struct vector_str *v);
47 
48 static size_t
49 get_strlen_sum(const struct vector_str *v)
50 {
51 	size_t i, len = 0;
52 
53 	if (v == NULL)
54 		return (0);
55 
56 	assert(v->size > 0);
57 
58 	for (i = 0; i < v->size; ++i)
59 		len += strlen(v->container[i]);
60 
61 	return (len);
62 }
63 
64 /**
65  * @brief Deallocate resource in vector_str.
66  */
67 void
68 vector_str_dest(struct vector_str *v)
69 {
70 	size_t i;
71 
72 	if (v == NULL)
73 		return;
74 
75 	for (i = 0; i < v->size; ++i)
76 		free(v->container[i]);
77 
78 	free(v->container);
79 }
80 
81 /**
82  * @brief Find string in vector_str.
83  * @param v Destination vector.
84  * @param o String to find.
85  * @param l Length of the string.
86  * @return -1 at failed, 0 at not found, 1 at found.
87  */
88 int
89 vector_str_find(const struct vector_str *v, const char *o, size_t l)
90 {
91 	size_t i;
92 
93 	if (v == NULL || o == NULL)
94 		return (-1);
95 
96 	for (i = 0; i < v->size; ++i)
97 		if (strncmp(v->container[i], o, l) == 0)
98 			return (1);
99 
100 	return (0);
101 }
102 
103 /**
104  * @brief Get new allocated flat string from vector.
105  *
106  * If l is not NULL, return length of the string.
107  * @param v Destination vector.
108  * @param l Length of the string.
109  * @return NULL at failed or NUL terminated new allocated string.
110  */
111 char *
112 vector_str_get_flat(const struct vector_str *v, size_t *l)
113 {
114 	ssize_t elem_pos, elem_size, rtn_size;
115 	size_t i;
116 	char *rtn;
117 
118 	if (v == NULL || v->size == 0)
119 		return (NULL);
120 
121 	if ((rtn_size = get_strlen_sum(v)) == 0)
122 		return (NULL);
123 
124 	if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
125 		return (NULL);
126 
127 	elem_pos = 0;
128 	for (i = 0; i < v->size; ++i) {
129 		elem_size = strlen(v->container[i]);
130 
131 		memcpy(rtn + elem_pos, v->container[i], elem_size);
132 
133 		elem_pos += elem_size;
134 	}
135 
136 	rtn[rtn_size] = '\0';
137 
138 	if (l != NULL)
139 		*l = rtn_size;
140 
141 	return (rtn);
142 }
143 
144 static bool
145 vector_str_grow(struct vector_str *v)
146 {
147 	size_t i, tmp_cap;
148 	char **tmp_ctn;
149 
150 	if (v == NULL)
151 		return (false);
152 
153 	assert(v->capacity > 0);
154 
155 	tmp_cap = BUFFER_GROW(v->capacity);
156 
157 	assert(tmp_cap > v->capacity);
158 
159 	if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
160 		return (false);
161 
162 	for (i = 0; i < v->size; ++i)
163 		tmp_ctn[i] = v->container[i];
164 
165 	free(v->container);
166 
167 	v->container = tmp_ctn;
168 	v->capacity = tmp_cap;
169 
170 	return (true);
171 }
172 
173 /**
174  * @brief Initialize vector_str.
175  * @return false at failed, true at success.
176  */
177 bool
178 vector_str_init(struct vector_str *v)
179 {
180 
181 	if (v == NULL)
182 		return (false);
183 
184 	v->size = 0;
185 	v->capacity = VECTOR_DEF_CAPACITY;
186 
187 	assert(v->capacity > 0);
188 
189 	if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
190 		return (false);
191 
192 	assert(v->container != NULL);
193 
194 	return (true);
195 }
196 
197 /**
198  * @brief Remove last element in vector_str.
199  * @return false at failed, true at success.
200  */
201 bool
202 vector_str_pop(struct vector_str *v)
203 {
204 
205 	if (v == NULL)
206 		return (false);
207 
208 	if (v->size == 0)
209 		return (true);
210 
211 	--v->size;
212 
213 	free(v->container[v->size]);
214 	v->container[v->size] = NULL;
215 
216 	return (true);
217 }
218 
219 /**
220  * @brief Push back string to vector.
221  * @return false at failed, true at success.
222  */
223 bool
224 vector_str_push(struct vector_str *v, const char *str, size_t len)
225 {
226 
227 	if (v == NULL || str == NULL)
228 		return (false);
229 
230 	if (v->size == v->capacity && vector_str_grow(v) == false)
231 		return (false);
232 
233 	if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
234 		return (false);
235 
236 	snprintf(v->container[v->size], len + 1, "%s", str);
237 
238 	++v->size;
239 
240 	return (true);
241 }
242 
243 /**
244  * @brief Push front org vector to det vector.
245  * @return false at failed, true at success.
246  */
247 bool
248 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
249 {
250 	size_t i, j, tmp_cap;
251 	char **tmp_ctn;
252 
253 	if (dst == NULL || org == NULL)
254 		return (false);
255 
256 	tmp_cap = BUFFER_GROW(dst->size + org->size);
257 
258 	if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
259 		return (false);
260 
261 	for (i = 0; i < org->size; ++i)
262 		if ((tmp_ctn[i] = strdup(org->container[i])) == NULL) {
263 			for (j = 0; j < i; ++j)
264 				free(tmp_ctn[j]);
265 
266 			free(tmp_ctn);
267 
268 			return (false);
269 		}
270 
271 	for (i = 0; i < dst->size; ++i)
272 		tmp_ctn[i + org->size] = dst->container[i];
273 
274 	free(dst->container);
275 
276 	dst->container = tmp_ctn;
277 	dst->capacity = tmp_cap;
278 	dst->size += org->size;
279 
280 	return (true);
281 }
282 
283 /**
284  * @brief Push org vector to the tail of det vector.
285  * @return false at failed, true at success.
286  */
287 bool
288 vector_str_push_vector(struct vector_str *dst, struct vector_str *org)
289 {
290 	size_t i, j, tmp_cap;
291 	char **tmp_ctn;
292 
293 	if (dst == NULL || org == NULL)
294 		return (false);
295 
296 	tmp_cap = BUFFER_GROW(dst->size + org->size);
297 
298 	if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
299 		return (false);
300 
301 	for (i = 0; i < dst->size; ++i)
302 		tmp_ctn[i] = dst->container[i];
303 
304 	for (i = 0; i < org->size; ++i)
305 		if ((tmp_ctn[i + dst->size] = strdup(org->container[i])) ==
306 		    NULL) {
307 			for (j = 0; j < i + dst->size; ++j)
308 				free(tmp_ctn[j]);
309 
310 			free(tmp_ctn);
311 
312 			return (false);
313 		}
314 
315 	free(dst->container);
316 
317 	dst->container = tmp_ctn;
318 	dst->capacity = tmp_cap;
319 	dst->size += org->size;
320 
321 	return (true);
322 }
323 
324 /**
325  * @brief Get new allocated flat string from vector between begin and end.
326  *
327  * If r_len is not NULL, string length will be returned.
328  * @return NULL at failed or NUL terminated new allocated string.
329  */
330 char *
331 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
332     size_t *r_len)
333 {
334 	size_t cur, i, len;
335 	char *rtn;
336 
337 	if (v == NULL || begin > end)
338 		return (NULL);
339 
340 	len = 0;
341 	for (i = begin; i < end + 1; ++i)
342 		len += strlen(v->container[i]);
343 
344 	if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
345 		return (NULL);
346 
347 	if (r_len != NULL)
348 		*r_len = len;
349 
350 	cur = 0;
351 	for (i = begin; i < end + 1; ++i) {
352 		len = strlen(v->container[i]);
353 		memcpy(rtn + cur, v->container[i], len);
354 		cur += len;
355 	}
356 	rtn[cur] = '\0';
357 
358 	return (rtn);
359 }
360