epan/wmem/wmem_strbuf.c

   1 /* wmem_strbuf.c
   2  * Wireshark Memory Manager String Buffer
   3  * Copyright 2012, Evan Huus <eapache@gmail.com>
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29 #include <glib.h>
  30
  31 #include "wmem_core.h"
  32 #include "wmem_strbuf.h"
  33
  34 #define DEFAULT_MINIMUM_LEN 16
  35
  36 /* Holds a wmem-allocated string-buffer.
  37  *  len is the length of the string (not counting the null-terminator) and
  38  *      should be the same as strlen(str) unless the string contains embedded
  39  *      nulls.
  40  *  alloc_len is the length of the raw buffer pointed to by str, regardless of
  41  *      what string is actually being stored (i.e. the buffer contents)
  42  *  max_len is the maximum permitted alloc_len (NOT the maximum permitted len,
  43  *      which must be one shorter than alloc_len to permit null-termination).
  44  *      When max_len is 0 (the default), no maximum is enforced.
  45  */
  46 struct _wmem_strbuf_t {
  47     wmem_allocator_t *allocator;
  48
  49     gchar *str;
  50
  51     gsize len;
  52     gsize alloc_len;
  53     gsize max_len;
  54 };
  55
  56 /* _ROOM accounts for the null-terminator, _RAW_ROOM does not.
  57  * Some functions need one, some functions need the other. */
  58 #define WMEM_STRBUF_ROOM(S) ((S)->alloc_len - (S)->len - 1)
  59 #define WMEM_STRBUF_RAW_ROOM(S) ((S)->alloc_len - (S)->len)
  60
  61 wmem_strbuf_t *
  62 wmem_strbuf_sized_new(wmem_allocator_t *allocator,
  63                       gsize alloc_len, gsize max_len)
  64 {
  65     wmem_strbuf_t *strbuf;
  66
  67     g_assert((max_len == 0) || (alloc_len <= max_len));
  68
  69     strbuf = wmem_new(allocator, wmem_strbuf_t);
  70
  71     strbuf->allocator = allocator;
  72     strbuf->len       = 0;
  73     strbuf->alloc_len = alloc_len ? alloc_len : DEFAULT_MINIMUM_LEN;
  74     strbuf->max_len   = max_len;
  75
  76     strbuf->str    = (gchar *)wmem_alloc(strbuf->allocator, strbuf->alloc_len);
  77     strbuf->str[0] = '\0';
  78
  79     return strbuf;
  80 }
  81
  82 wmem_strbuf_t *
  83 wmem_strbuf_new(wmem_allocator_t *allocator, const gchar *str)
  84 {
  85     wmem_strbuf_t *strbuf;
  86     gsize          len, alloc_len;
  87
  88     len       = str ? strlen(str) : 0;
  89     alloc_len = DEFAULT_MINIMUM_LEN;
  90
  91     /* +1 for the null-terminator */
  92     while (alloc_len < (len + 1)) {
  93         alloc_len *= 2;
  94     }
  95
  96     strbuf = wmem_strbuf_sized_new(allocator, alloc_len, 0);
  97
  98     if (str && len > 0) {
  99         strcpy(strbuf->str, str);
 100         strbuf->len = len;
 101     }
 102
 103     return strbuf;
 104 }
 105
 106 static void
 107 wmem_strbuf_grow(wmem_strbuf_t *strbuf, const gsize to_add)
 108 {
 109     gsize  new_alloc_len, new_len;
 110
 111     new_alloc_len = strbuf->alloc_len;
 112     new_len = strbuf->len + to_add;
 113
 114     /* +1 for the null-terminator */
 115     while (new_alloc_len < (new_len + 1)) {
 116         new_alloc_len *= 2;
 117     }
 118
 119     /* max length only enforced if not 0 */
 120     if (strbuf->max_len && new_alloc_len > strbuf->max_len) {
 121         new_alloc_len = strbuf->max_len;
 122     }
 123
 124     if (new_alloc_len == strbuf->alloc_len) {
 125         return;
 126     }
 127
 128     strbuf->str = (gchar *)wmem_realloc(strbuf->allocator, strbuf->str, new_alloc_len);
 129
 130     strbuf->alloc_len = new_alloc_len;
 131 }
 132
 133 void
 134 wmem_strbuf_append(wmem_strbuf_t *strbuf, const gchar *str)
 135 {
 136     gsize append_len;
 137
 138     if (!str || str[0] == '\0') {
 139         return;
 140     }
 141
 142     append_len = strlen(str);
 143
 144     wmem_strbuf_grow(strbuf, append_len);
 145
 146     g_strlcpy(&strbuf->str[strbuf->len], str, WMEM_STRBUF_RAW_ROOM(strbuf));
 147
 148     strbuf->len = MIN(strbuf->len + append_len, strbuf->alloc_len - 1);
 149 }
 150
 151 static void
 152 wmem_strbuf_append_vprintf(wmem_strbuf_t *strbuf, const gchar *fmt, va_list ap)
 153 {
 154     va_list ap2;
 155     gsize append_len;
 156
 157     G_VA_COPY(ap2, ap);
 158
 159     append_len = g_printf_string_upper_bound(fmt, ap);
 160
 161     /* -1 because g_printf_string_upper_bound counts the null-terminator, but
 162      * wmem_strbuf_grow does not */
 163     wmem_strbuf_grow(strbuf, append_len - 1);
 164
 165     append_len = g_vsnprintf(&strbuf->str[strbuf->len],
 166             (gulong) WMEM_STRBUF_RAW_ROOM(strbuf),
 167             fmt, ap2);
 168
 169     va_end(ap2);
 170
 171     strbuf->len = MIN(strbuf->len + append_len, strbuf->alloc_len - 1);
 172 }
 173
 174 void
 175 wmem_strbuf_append_printf(wmem_strbuf_t *strbuf, const gchar *format, ...)
 176 {
 177     va_list ap;
 178
 179     va_start(ap, format);
 180     wmem_strbuf_append_vprintf(strbuf, format, ap);
 181     va_end(ap);
 182 }
 183
 184 void
 185 wmem_strbuf_append_c(wmem_strbuf_t *strbuf, const gchar c)
 186 {
 187     wmem_strbuf_grow(strbuf, 1);
 188
 189     /* one for the char, one for the null-terminator */
 190     if (WMEM_STRBUF_ROOM(strbuf) >= 1) {
 191         strbuf->str[strbuf->len] = c;
 192         strbuf->len++;
 193         strbuf->str[strbuf->len] = '\0';
 194     }
 195 }
 196
 197 void
 198 wmem_strbuf_append_unichar(wmem_strbuf_t *strbuf, const gunichar c)
 199 {
 200     gchar buf[6];
 201     gsize charlen;
 202
 203     charlen = g_unichar_to_utf8(c, buf);
 204
 205     wmem_strbuf_grow(strbuf, charlen);
 206
 207     if (WMEM_STRBUF_ROOM(strbuf) >= charlen) {
 208         memcpy(&strbuf->str[strbuf->len], buf, charlen);
 209         strbuf->len += charlen;
 210         strbuf->str[strbuf->len] = '\0';
 211     }
 212 }
 213
 214 void
 215 wmem_strbuf_truncate(wmem_strbuf_t *strbuf, const gsize len)
 216 {
 217     if (len >= strbuf->len) {
 218         return;
 219     }
 220
 221     strbuf->str[len] = '\0';
 222     strbuf->len = len;
 223 }
 224
 225 const gchar *
 226 wmem_strbuf_get_str(wmem_strbuf_t *strbuf)
 227 {
 228     return strbuf->str;
 229 }
 230
 231 gsize
 232 wmem_strbuf_get_len(wmem_strbuf_t *strbuf)
 233 {
 234     return strbuf->len;
 235 }
 236
 237 /*
 238  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 239  *
 240  * Local variables:
 241  * c-basic-offset: 4
 242  * tab-width: 8
 243  * indent-tabs-mode: nil
 244  * End:
 245  *
 246  * vi: set shiftwidth=4 tabstop=8 expandtab:
 247  * :indentSize=4:tabSize=8:noTabs=true:
 248  */