src/pulsecore/strbuf.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   Copyright 2004-2006 Lennart Poettering
   7
   8   PulseAudio is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU Lesser General Public License as published
  10   by the Free Software Foundation; either version 2 of the License,
  11   or (at your option) any later version.
  12
  13   PulseAudio is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with PulseAudio; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21   USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33
  34 #include <pulse/xmalloc.h>
  35 #include <pulsecore/macro.h>
  36
  37 #include "strbuf.h"
  38
  39 /* A chunk of the linked list that makes up the string */
  40 struct chunk {
  41     struct chunk *next;
  42     size_t length;
  43 };
  44
  45 #define CHUNK_TO_TEXT(c) ((char*) (c) + PA_ALIGN(sizeof(struct chunk)))
  46
  47 struct pa_strbuf {
  48     size_t length;
  49     struct chunk *head, *tail;
  50 };
  51
  52 pa_strbuf *pa_strbuf_new(void) {
  53
  54     pa_strbuf *sb = pa_xnew(pa_strbuf, 1);
  55     sb->length = 0;
  56     sb->head = sb->tail = NULL;
  57
  58     return sb;
  59 }
  60
  61 void pa_strbuf_free(pa_strbuf *sb) {
  62     pa_assert(sb);
  63
  64     while (sb->head) {
  65         struct chunk *c = sb->head;
  66         sb->head = sb->head->next;
  67         pa_xfree(c);
  68     }
  69
  70     pa_xfree(sb);
  71 }
  72
  73 /* Make a C string from the string buffer. The caller has to free
  74  * string with pa_xfree(). */
  75 char *pa_strbuf_tostring(pa_strbuf *sb) {
  76     char *t, *e;
  77     struct chunk *c;
  78
  79     pa_assert(sb);
  80
  81     e = t = pa_xnew(char, sb->length+1);
  82
  83     for (c = sb->head; c; c = c->next) {
  84         assert((size_t) (e-t) <= sb->length);
  85         memcpy(e, CHUNK_TO_TEXT(c), c->length);
  86         e += c->length;
  87     }
  88
  89     /* Trailing NUL */
  90     *e = 0;
  91
  92     assert(e == t+sb->length);
  93
  94     return t;
  95 }
  96
  97 /* Combination of pa_strbuf_free() and pa_strbuf_tostring() */
  98 char *pa_strbuf_tostring_free(pa_strbuf *sb) {
  99     char *t;
 100
 101     pa_assert(sb);
 102     t = pa_strbuf_tostring(sb);
 103     pa_strbuf_free(sb);
 104
 105     return t;
 106 }
 107
 108 /* Append a string to the string buffer */
 109 void pa_strbuf_puts(pa_strbuf *sb, const char *t) {
 110
 111     pa_assert(sb);
 112     pa_assert(t);
 113
 114     pa_strbuf_putsn(sb, t, strlen(t));
 115 }
 116
 117 /* Append a new chunk to the linked list */
 118 static void append(pa_strbuf *sb, struct chunk *c) {
 119     pa_assert(sb);
 120     pa_assert(c);
 121
 122     if (sb->tail) {
 123         pa_assert(sb->head);
 124         sb->tail->next = c;
 125     } else {
 126         pa_assert(!sb->head);
 127         sb->head = c;
 128     }
 129
 130     sb->tail = c;
 131     sb->length += c->length;
 132     c->next = NULL;
 133 }
 134
 135 /* Append up to l bytes of a string to the string buffer */
 136 void pa_strbuf_putsn(pa_strbuf *sb, const char *t, size_t l) {
 137     struct chunk *c;
 138
 139     pa_assert(sb);
 140     pa_assert(t);
 141
 142     if (!l)
 143        return;
 144
 145     c = pa_xmalloc(PA_ALIGN(sizeof(struct chunk)) + l);
 146     c->length = l;
 147     memcpy(CHUNK_TO_TEXT(c), t, l);
 148
 149     append(sb, c);
 150 }
 151
 152 /* Append a printf() style formatted string to the string buffer. */
 153 /* The following is based on an example from the GNU libc documentation */
 154 int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) {
 155     int size = 100;
 156     struct chunk *c = NULL;
 157
 158     pa_assert(sb);
 159     pa_assert(format);
 160
 161     for(;;) {
 162         va_list ap;
 163         int r;
 164
 165         c = pa_xrealloc(c, PA_ALIGN(sizeof(struct chunk)) + size);
 166
 167         va_start(ap, format);
 168         r = vsnprintf(CHUNK_TO_TEXT(c), size, format, ap);
 169         CHUNK_TO_TEXT(c)[size-1] = 0;
 170         va_end(ap);
 171
 172         if (r > -1 && r < size) {
 173             c->length = r;
 174             append(sb, c);
 175             return r;
 176         }
 177
 178         if (r > -1)    /* glibc 2.1 */
 179             size = r+1;
 180         else           /* glibc 2.0 */
 181             size *= 2;
 182     }
 183 }