lib/libdemangle-sys/str.c

   1 /*
   2  * This file and its contents are supplied under the terms of the
   3  * Common Development and Distribution License ("CDDL"), version 1.0.
   4  * You may only use this file in accordance with the terms of version
   5  * 1.0 of the CDDL.
   6  *
   7  * A full copy of the text of the CDDL should have accompanied this
   8  * source.  A copy of the CDDL is also available via the Internet at
   9  * http://www.illumos.org/license/CDDL.
  10  */
  11
  12 /*
  13  * Copyright 2017 Jason King
  14  */
  15 #include <sys/debug.h>
  16 #include <sys/sysmacros.h>
  17 #include <string.h>
  18 #include "str.h"
  19 #include "demangle_int.h"
  20
  21 #define STR_CHUNK_SZ    (64U)
  22
  23 /* are we storing a reference vs. a dynamically allocated copy? */
  24 #define IS_REF(s) ((s)->str_s != NULL && (s)->str_size == 0)
  25
  26 /*
  27  * Dynamically resizeable strings, with lazy allocation when initialized
  28  * with a constant string value
  29  *
  30  * NOTE: these are not necessairly 0-terminated
  31  *
  32  * Additionally, these can store references instead of copies of strings
  33  * (as indicated by the IS_REF() macro.  However mutation may cause a
  34  * string to convert from a refence to a dynamically allocated copy.
  35  */
  36
  37 void
  38 str_init(str_t *restrict s, sysdem_ops_t *restrict ops)
  39 {
  40         (void) memset(s, 0, sizeof (*s));
  41         s->str_ops = (ops != NULL) ? ops : sysdem_ops_default;
  42 }
  43
  44 void
  45 str_fini(str_t *s)
  46 {
  47         if (s == NULL)
  48                 return;
  49         if (!IS_REF(s))
  50                 xfree(s->str_ops, s->str_s, s->str_size);
  51         (void) memset(s, 0, sizeof (*s));
  52 }
  53
  54 size_t
  55 str_length(const str_t *s)
  56 {
  57         return (s->str_len);
  58 }
  59
  60 /*
  61  * store as a reference instead of a copy
  62  * if len == 0, means store entire copy of 0 terminated string
  63  */
  64 void
  65 str_set(str_t *s, const char *cstr, size_t len)
  66 {
  67         sysdem_ops_t *ops = s->str_ops;
  68
  69         str_fini(s);
  70         s->str_ops = ops;
  71         s->str_s = (char *)cstr;
  72         s->str_len = (len == 0 && cstr != NULL) ? strlen(cstr) : len;
  73 }
  74
  75 boolean_t
  76 str_copy(const str_t *src, str_t *dest)
  77 {
  78         str_fini(dest);
  79         str_init(dest, src->str_ops);
  80
  81         if (src->str_len == 0)
  82                 return (B_TRUE);
  83
  84         size_t len = roundup(src->str_len, STR_CHUNK_SZ);
  85         dest->str_s = zalloc(src->str_ops, len);
  86         if (dest->str_s == NULL)
  87                 return (B_FALSE);
  88
  89         (void) memcpy(dest->str_s, src->str_s, src->str_len);
  90         dest->str_len = src->str_len;
  91         dest->str_size = len;
  92
  93         return (B_TRUE);
  94 }
  95
  96 /*
  97  * ensure s has at least amt bytes free, resizing if necessary
  98  */
  99 static boolean_t
 100 str_reserve(str_t *s, size_t amt)
 101 {
 102         size_t newlen = s->str_len + amt;
 103
 104         /* overflow check */
 105         if (newlen < s->str_len || newlen < amt)
 106                 return (B_FALSE);
 107
 108         if ((amt > 0) && (s->str_len + amt <= s->str_size))
 109                 return (B_TRUE);
 110
 111         size_t newsize = roundup(newlen, STR_CHUNK_SZ);
 112         void *temp;
 113
 114         if (IS_REF(s)) {
 115                 temp = zalloc(s->str_ops, newsize);
 116                 if (temp == NULL)
 117                         return (B_FALSE);
 118
 119                 (void) memcpy(temp, s->str_s, s->str_len);
 120         } else {
 121                 temp = xrealloc(s->str_ops, s->str_s, s->str_size, newsize);
 122                 if (temp == NULL)
 123                         return (B_FALSE);
 124         }
 125
 126         s->str_s = temp;
 127         s->str_size = newsize;
 128
 129         return (B_TRUE);
 130 }
 131
 132 /* append to s, cstrlen == 0 means entire length of string */
 133 boolean_t
 134 str_append(str_t *s, const char *cstr, size_t cstrlen)
 135 {
 136         if (cstr != NULL && cstrlen == 0)
 137                 cstrlen = strlen(cstr);
 138
 139         const str_t src = {
 140                 .str_s = (char *)cstr,
 141                 .str_len = cstrlen,
 142                 .str_ops = s->str_ops
 143         };
 144
 145         return (str_append_str(s, &src));
 146 }
 147
 148 boolean_t
 149 str_append_str(str_t *dest, const str_t *src)
 150 {
 151         /* empty string is a noop */
 152         if (src->str_s == NULL || src->str_len == 0)
 153                 return (B_TRUE);
 154
 155         /* if src is a reference, we can just copy that */
 156         if (dest->str_s == NULL && IS_REF(src)) {
 157                 *dest = *src;
 158                 return (B_TRUE);
 159         }
 160
 161         if (!str_reserve(dest, src->str_len))
 162                 return (B_FALSE);
 163
 164         (void) memcpy(dest->str_s + dest->str_len, src->str_s, src->str_len);
 165         dest->str_len += src->str_len;
 166         return (B_TRUE);
 167 }
 168
 169 boolean_t
 170 str_append_c(str_t *s, char c)
 171 {
 172         if (!str_reserve(s, 1))
 173                 return (B_FALSE);
 174
 175         s->str_s[s->str_len++] = c;
 176         return (B_TRUE);
 177 }
 178
 179 boolean_t
 180 str_insert(str_t *s, size_t idx, const char *cstr, size_t cstrlen)
 181 {
 182         if (cstr == NULL)
 183                 return (B_TRUE);
 184
 185         if (cstrlen == 0)
 186                 cstrlen = strlen(cstr);
 187
 188         str_t src = {
 189                 .str_s = (char *)cstr,
 190                 .str_len = cstrlen,
 191                 .str_ops = s->str_ops,
 192                 .str_size = 0
 193         };
 194
 195         return (str_insert_str(s, idx, &src));
 196 }
 197
 198 boolean_t
 199 str_insert_str(str_t *dest, size_t idx, const str_t *src)
 200 {
 201         ASSERT3U(idx, <=, dest->str_len);
 202
 203         if (idx == dest->str_len)
 204                 return (str_append_str(dest, src));
 205
 206         if (idx == 0 && dest->str_s == NULL && IS_REF(src)) {
 207                 sysdem_ops_t *ops = dest->str_ops;
 208                 *dest = *src;
 209                 dest->str_ops = ops;
 210                 return (B_TRUE);
 211         }
 212
 213         if (!str_reserve(dest, src->str_len))
 214                 return (B_FALSE);
 215
 216         /*
 217          * Shift the contents of dest over at the insertion point.  Since
 218          * src and dest ranges will overlap, and unlike some programmers,
 219          * *I* can read man pages - memmove() is the appropriate function
 220          * to this.
 221          */
 222         (void) memmove(dest->str_s + idx + src->str_len, dest->str_s + idx,
 223             dest->str_len - idx);
 224
 225         /*
 226          * However the content to insert does not overlap with the destination
 227          * so memcpy() is fine here.
 228          */
 229         (void) memcpy(dest->str_s + idx, src->str_s, src->str_len);
 230         dest->str_len += src->str_len;
 231
 232         return (B_TRUE);
 233 }
 234
 235 boolean_t
 236 str_erase(str_t *s, size_t pos, size_t len)
 237 {
 238         ASSERT3U(pos, <, s->str_len);
 239         ASSERT3U(pos + len, <=, s->str_len);
 240
 241         if (IS_REF(s)) {
 242                 if (!str_reserve(s, 0))
 243                         return (B_FALSE);
 244         }
 245
 246         (void) memmove(s->str_s + pos, s->str_s + pos + len, s->str_len - len);
 247         s->str_len -= len;
 248         return (B_TRUE);
 249 }
 250
 251 str_pair_t *
 252 str_pair_init(str_pair_t *sp, sysdem_ops_t *ops)
 253 {
 254         (void) memset(sp, 0, sizeof (*sp));
 255         str_init(&sp->strp_l, ops);
 256         str_init(&sp->strp_r, ops);
 257         return (sp);
 258 }
 259
 260 void
 261 str_pair_fini(str_pair_t *sp)
 262 {
 263         str_fini(&sp->strp_l);
 264         str_fini(&sp->strp_r);
 265 }
 266
 267 /* combine left and right parts and put result into left part */
 268 boolean_t
 269 str_pair_merge(str_pair_t *sp)
 270 {
 271         /* if right side is empty, don't need to do anything */
 272         if (str_length(&sp->strp_r) == 0)
 273                 return (B_TRUE);
 274
 275         /* if left side is empty, just move right to left */
 276         if (str_length(&sp->strp_l) == 0) {
 277                 str_fini(&sp->strp_l);
 278                 sp->strp_l = sp->strp_r;
 279                 sp->strp_r.str_s = NULL;
 280                 sp->strp_r.str_len = sp->strp_r.str_size = 0;
 281                 return (B_TRUE);
 282         }
 283
 284         if (!str_append_str(&sp->strp_l, &sp->strp_r))
 285                 return (B_FALSE);
 286
 287         str_fini(&sp->strp_r);
 288         str_init(&sp->strp_r, sp->strp_l.str_ops);
 289         return (B_TRUE);
 290 }
 291
 292 boolean_t
 293 str_pair_copy(const str_pair_t *src, str_pair_t *dest)
 294 {
 295         boolean_t ok = B_TRUE;
 296
 297         ok &= str_copy(&src->strp_l, &dest->strp_l);
 298         ok &= str_copy(&src->strp_r, &dest->strp_r);
 299
 300         if (!ok) {
 301                 str_fini(&dest->strp_l);
 302                 str_fini(&dest->strp_r);
 303                 return (B_FALSE);
 304         }
 305
 306         return (B_TRUE);
 307 }
 308
 309 size_t
 310 str_pair_len(const str_pair_t *sp)
 311 {
 312         return (str_length(&sp->strp_l) + str_length(&sp->strp_r));
 313 }