src/wrbuf.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2011 Index Data
   3  * See the file LICENSE for details.
   4  */
   5
   6 /**
   7  * \file wrbuf.c
   8  * \brief Implements WRBUF (growing buffer)
   9  */
  10
  11 #if HAVE_CONFIG_H
  12 #include <config.h>
  13 #endif
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <stdarg.h>
  19
  20 #include <yaz/wrbuf.h>
  21 #include <yaz/snprintf.h>
  22 #include <yaz/yaz-iconv.h>
  23
  24 WRBUF wrbuf_alloc(void)
  25 {
  26     WRBUF n;
  27
  28     if (!(n = (WRBUF)xmalloc(sizeof(*n))))
  29         abort();
  30     n->buf = 0;
  31     n->size = 0;
  32     n->pos = 0;
  33     return n;
  34 }
  35
  36 void wrbuf_destroy(WRBUF b)
  37 {
  38     if (b)
  39     {
  40         xfree(b->buf);
  41         xfree(b);
  42     }
  43 }
  44
  45 void wrbuf_rewind(WRBUF b)
  46 {
  47     b->pos = 0;
  48 }
  49
  50 int wrbuf_grow(WRBUF b, size_t minsize)
  51 {
  52     size_t togrow;
  53
  54     if (!b->size)
  55         togrow = 1024;
  56     else
  57         togrow = b->size;
  58     if (togrow < minsize)
  59         togrow = minsize;
  60     if (b->size && !(b->buf =(char *)xrealloc(b->buf, b->size += togrow)))
  61         abort();
  62     else if (!b->size && !(b->buf = (char *)xmalloc(b->size = togrow)))
  63         abort();
  64     return 0;
  65 }
  66
  67 void wrbuf_write(WRBUF b, const char *buf, size_t size)
  68 {
  69     if (size <= 0)
  70         return;
  71     if (b->pos + size >= b->size)
  72         wrbuf_grow(b, size);
  73     memcpy(b->buf + b->pos, buf, size);
  74     b->pos += size;
  75 }
  76
  77 void wrbuf_puts(WRBUF b, const char *buf)
  78 {
  79     wrbuf_write(b, buf, strlen(buf));
  80 }
  81
  82 void wrbuf_vp_puts(const char *buf, void *client_data)
  83 {
  84     WRBUF b = (WRBUF) client_data;
  85     wrbuf_puts(b, buf);
  86 }
  87
  88 void wrbuf_puts_replace_char(WRBUF b, const char *buf,
  89                             const char from, const char to)
  90 {
  91     while(*buf)
  92     {
  93         if (*buf == from)
  94             wrbuf_putc(b, to);
  95         else
  96             wrbuf_putc(b, *buf);
  97         buf++;
  98     }
  99 }
 100
 101 void wrbuf_chop_right(WRBUF b)
 102 {
 103     while (b->pos && b->buf[b->pos-1] == ' ')
 104     {
 105         (b->pos)--;
 106     }
 107 }
 108
 109 void wrbuf_xmlputs(WRBUF b, const char *cp)
 110 {
 111     wrbuf_xmlputs_n(b, cp, strlen(cp));
 112 }
 113
 114 void wrbuf_xmlputs_n(WRBUF b, const char *cp, size_t size)
 115 {
 116     for (; size; size--)
 117     {
 118         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
 119         if (*cp >= 0 && *cp <= 31)
 120             if (*cp != 9 && *cp != 10 && *cp != 13)
 121             {
 122                 cp++;  /* we silently ignore (delete) these.. */
 123                 continue;
 124             }
 125         switch(*cp)
 126         {
 127         case '<':
 128             wrbuf_puts(b, "&lt;");
 129             break;
 130         case '>':
 131             wrbuf_puts(b, "&gt;");
 132             break;
 133         case '&':
 134             wrbuf_puts(b, "&amp;");
 135             break;
 136         case '"':
 137             wrbuf_puts(b, "&quot;");
 138             break;
 139         case '\'':
 140             wrbuf_puts(b, "&apos;");
 141             break;
 142         default:
 143             wrbuf_putc(b, *cp);
 144         }
 145         cp++;
 146     }
 147 }
 148
 149 void wrbuf_printf(WRBUF b, const char *fmt, ...)
 150 {
 151     va_list ap;
 152     char buf[4096];
 153
 154     va_start(ap, fmt);
 155     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
 156     wrbuf_puts (b, buf);
 157
 158     va_end(ap);
 159 }
 160
 161 int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
 162                         size_t size, int cdata)
 163 {
 164     int ret = 0;
 165     if (cd)
 166     {
 167         char outbuf[128];
 168         size_t inbytesleft = size;
 169         const char *inp = buf;
 170         while (inbytesleft)
 171         {
 172             size_t outbytesleft = sizeof(outbuf);
 173             char *outp = outbuf;
 174             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
 175                                  &outp, &outbytesleft);
 176             if (r == (size_t) (-1))
 177             {
 178                 int e = yaz_iconv_error(cd);
 179                 if (e != YAZ_ICONV_E2BIG)
 180                 {
 181                     ret = -1;
 182                     break;
 183                 }
 184             }
 185             if (cdata)
 186                 wrbuf_xmlputs_n(b, outbuf, outp - outbuf);
 187             else
 188                 wrbuf_write(b, outbuf, outp - outbuf);
 189         }
 190     }
 191     else
 192     {
 193         if (cdata)
 194             wrbuf_xmlputs_n(b, buf, size);
 195         else
 196             wrbuf_write(b, buf, size);
 197     }
 198     return ret;
 199 }
 200
 201 void wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 202 {
 203     wrbuf_iconv_write_x(b, cd, buf, size, 0);
 204 }
 205
 206 void wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
 207 {
 208     wrbuf_iconv_write(b, cd, strz, strlen(strz));
 209 }
 210
 211 void wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
 212 {
 213     char buf[1];
 214     buf[0] = ch;
 215     wrbuf_iconv_write(b, cd, buf, 1);
 216 }
 217
 218 void wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 219 {
 220     wrbuf_iconv_write_x(b, cd, buf, size, 1);
 221 }
 222
 223 void wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
 224 {
 225     wrbuf_iconv_write_x(b, cd, strz, strlen(strz), 1);
 226 }
 227
 228 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
 229 {
 230     if (cd)
 231     {
 232         char outbuf[16];
 233         size_t outbytesleft = sizeof(outbuf);
 234         char *outp = outbuf;
 235         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
 236         if (r != (size_t) (-1))
 237             wrbuf_write(b, outbuf, outp - outbuf);
 238     }
 239 }
 240
 241 const char *wrbuf_cstr(WRBUF b)
 242 {
 243     wrbuf_putc(b, '\0');   /* add '\0' */
 244     (b->pos)--;           /* don't include '\0' in count */
 245     return b->buf;
 246 }
 247
 248 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
 249 {
 250     if (no_to_remove > b->pos)
 251         no_to_remove = b->pos;
 252     b->pos = b->pos - no_to_remove;
 253 }
 254
 255 void wrbuf_puts_escaped(WRBUF b, const char *str)
 256 {
 257     wrbuf_write_escaped(b, str, strlen(str));
 258 }
 259
 260 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
 261 {
 262     size_t i;
 263     for (i = 0; i < len; i++)
 264         if (str[i] < ' ' || str[i] > 126)
 265             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
 266         else
 267             wrbuf_putc(b, str[i]);
 268 }
 269
 270 /*
 271  * Local variables:
 272  * c-basic-offset: 4
 273  * c-file-style: "Stroustrup"
 274  * indent-tabs-mode: nil
 275  * End:
 276  * vim: shiftwidth=4 tabstop=8 expandtab
 277  */
 278