contrib/elftoolchain/libelftc/libelftc_vstr.c

   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 2065 2011-10-26 15:24:47Z jkoshy $");
  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 = v->capacity * BUFFER_GROWFACTOR;
 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 = (dst->size + org->size) * BUFFER_GROWFACTOR;
 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 Get new allocated flat string from vector between begin and end.
 285  *
 286  * If r_len is not NULL, string length will be returned.
 287  * @return NULL at failed or NUL terminated new allocated string.
 288  */
 289 char *
 290 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
 291     size_t *r_len)
 292 {
 293         size_t cur, i, len;
 294         char *rtn;
 295
 296         if (v == NULL || begin > end)
 297                 return (NULL);
 298
 299         len = 0;
 300         for (i = begin; i < end + 1; ++i)
 301                 len += strlen(v->container[i]);
 302
 303         if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
 304                 return (NULL);
 305
 306         if (r_len != NULL)
 307                 *r_len = len;
 308
 309         cur = 0;
 310         for (i = begin; i < end + 1; ++i) {
 311                 len = strlen(v->container[i]);
 312                 memcpy(rtn + cur, v->container[i], len);
 313                 cur += len;
 314         }
 315         rtn[cur] = '\0';
 316
 317         return (rtn);
 318 }