src/wrbuf.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 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 #include <assert.h>
  20
  21 #include <yaz/wrbuf.h>
  22 #include <yaz/snprintf.h>
  23 #include <yaz/yaz-iconv.h>
  24
  25 WRBUF wrbuf_alloc(void)
  26 {
  27     WRBUF n;
  28
  29     if (!(n = (WRBUF)xmalloc(sizeof(*n))))
  30         abort();
  31     n->buf = 0;
  32     n->size = 0;
  33     n->pos = 0;
  34     wrbuf_grow(n, 1);
  35     return n;
  36 }
  37
  38 void wrbuf_destroy(WRBUF b)
  39 {
  40     if (b)
  41     {
  42         xfree(b->buf);
  43         xfree(b);
  44     }
  45 }
  46
  47 void wrbuf_rewind(WRBUF b)
  48 {
  49     b->pos = 0;
  50 }
  51
  52 int wrbuf_grow(WRBUF b, size_t minsize)
  53 {
  54     size_t togrow;
  55
  56     if (!b->size)
  57         togrow = 1024;
  58     else
  59         togrow = b->size;
  60     if (togrow < minsize)
  61         togrow = minsize;
  62     b->buf = (char *) xrealloc(b->buf, 1 + (b->size += togrow));
  63     if (!b->buf)
  64         abort();
  65     return 0;
  66 }
  67
  68 void wrbuf_write(WRBUF b, const char *buf, size_t size)
  69 {
  70     if (size <= 0)
  71         return;
  72     if (b->pos + size >= b->size)
  73         wrbuf_grow(b, size);
  74     memcpy(b->buf + b->pos, buf, size);
  75     b->pos += size;
  76 }
  77
  78 void wrbuf_insert(WRBUF b, size_t pos, const char *buf, size_t size)
  79 {
  80     if (size <= 0 || pos > b->pos)
  81         return;
  82     if (b->pos + size >= b->size)
  83         wrbuf_grow(b, size);
  84     memmove(b->buf + pos + size, b->buf + pos, b->pos - pos);
  85     memcpy(b->buf + pos, buf, size);
  86     b->pos += size;
  87 }
  88
  89 void wrbuf_puts(WRBUF b, const char *buf)
  90 {
  91     wrbuf_write(b, buf, strlen(buf));
  92 }
  93
  94 void wrbuf_vp_puts(const char *buf, void *client_data)
  95 {
  96     WRBUF b = (WRBUF) client_data;
  97     wrbuf_puts(b, buf);
  98 }
  99
 100 void wrbuf_puts_replace_char(WRBUF b, const char *buf,
 101                             const char from, const char to)
 102 {
 103     while(*buf)
 104     {
 105         if (*buf == from)
 106             wrbuf_putc(b, to);
 107         else
 108             wrbuf_putc(b, *buf);
 109         buf++;
 110     }
 111 }
 112
 113 void wrbuf_chop_right(WRBUF b)
 114 {
 115     while (b->pos && b->buf[b->pos-1] == ' ')
 116     {
 117         (b->pos)--;
 118     }
 119 }
 120
 121 void wrbuf_xmlputs(WRBUF b, const char *cp)
 122 {
 123     wrbuf_xmlputs_n(b, cp, strlen(cp));
 124 }
 125
 126 void wrbuf_xmlputs_n(WRBUF b, const char *cp, size_t size)
 127 {
 128     for (; size; size--)
 129     {
 130         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
 131         if (*cp >= 0 && *cp <= 31)
 132             if (*cp != 9 && *cp != 10 && *cp != 13)
 133             {
 134                 cp++;  /* we silently ignore (delete) these.. */
 135                 continue;
 136             }
 137         switch(*cp)
 138         {
 139         case '<':
 140             wrbuf_puts(b, "&lt;");
 141             break;
 142         case '>':
 143             wrbuf_puts(b, "&gt;");
 144             break;
 145         case '&':
 146             wrbuf_puts(b, "&amp;");
 147             break;
 148         case '"':
 149             wrbuf_puts(b, "&quot;");
 150             break;
 151         case '\'':
 152             wrbuf_puts(b, "&apos;");
 153             break;
 154         default:
 155             wrbuf_putc(b, *cp);
 156         }
 157         cp++;
 158     }
 159 }
 160
 161 void wrbuf_printf(WRBUF b, const char *fmt, ...)
 162 {
 163     va_list ap;
 164     char buf[4096];
 165
 166     va_start(ap, fmt);
 167     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
 168     wrbuf_puts (b, buf);
 169
 170     va_end(ap);
 171 }
 172
 173 int wrbuf_iconv_write2(WRBUF b, yaz_iconv_t cd, const char *buf,
 174                        size_t size,
 175                        void (*wfunc)(WRBUF, const char *, size_t))
 176 {
 177     int ret = 0;
 178     if (cd)
 179     {
 180         char outbuf[128];
 181         size_t inbytesleft = size;
 182         const char *inp = buf;
 183         while (inbytesleft)
 184         {
 185             size_t outbytesleft = sizeof(outbuf);
 186             char *outp = outbuf;
 187             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
 188                                  &outp, &outbytesleft);
 189             if (r == (size_t) (-1))
 190             {
 191                 int e = yaz_iconv_error(cd);
 192                 if (e != YAZ_ICONV_E2BIG)
 193                 {
 194                     ret = -1;
 195                     break;
 196                 }
 197             }
 198             (*wfunc)(b, outbuf, outp - outbuf);
 199         }
 200     }
 201     else
 202         (*wfunc)(b, buf, size);
 203     return ret;
 204 }
 205
 206 int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
 207                         size_t size, int cdata)
 208 {
 209     return wrbuf_iconv_write2(b, cd, buf, size,
 210                               cdata ? wrbuf_xmlputs_n : wrbuf_write);
 211 }
 212
 213 void wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 214 {
 215     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_write);
 216 }
 217
 218 void wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
 219 {
 220     wrbuf_iconv_write(b, cd, strz, strlen(strz));
 221 }
 222
 223 void wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
 224 {
 225     char buf[1];
 226     buf[0] = ch;
 227     wrbuf_iconv_write(b, cd, buf, 1);
 228 }
 229
 230 void wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 231 {
 232     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_xmlputs_n);
 233 }
 234
 235 void wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
 236 {
 237     wrbuf_iconv_write2(b, cd, strz, strlen(strz), wrbuf_xmlputs_n);
 238 }
 239
 240 void wrbuf_iconv_json_write(WRBUF b, yaz_iconv_t cd,
 241                             const char *buf, size_t size)
 242 {
 243     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_json_write);
 244 }
 245
 246 void wrbuf_iconv_json_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
 247 {
 248     wrbuf_iconv_write2(b, cd, strz, strlen(strz), wrbuf_json_write);
 249 }
 250
 251 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
 252 {
 253     if (cd)
 254     {
 255         char outbuf[16];
 256         size_t outbytesleft = sizeof(outbuf);
 257         char *outp = outbuf;
 258         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
 259         if (r != (size_t) (-1))
 260             wrbuf_write(b, outbuf, outp - outbuf);
 261     }
 262 }
 263
 264 const char *wrbuf_cstr(WRBUF b)
 265 {
 266     assert(b && b->pos <= b->size);
 267     b->buf[b->pos] = '\0';
 268     return b->buf;
 269 }
 270
 271 const char *wrbuf_cstr_null(WRBUF b)
 272 {
 273     if (!b || b->pos == 0)
 274         return 0;
 275     assert(b->pos <= b->size);
 276     b->buf[b->pos] = '\0';
 277     return b->buf;
 278 }
 279
 280 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
 281 {
 282     if (no_to_remove > b->pos)
 283         no_to_remove = b->pos;
 284     b->pos = b->pos - no_to_remove;
 285 }
 286
 287 void wrbuf_puts_escaped(WRBUF b, const char *str)
 288 {
 289     wrbuf_write_escaped(b, str, strlen(str));
 290 }
 291
 292 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
 293 {
 294     size_t i;
 295     for (i = 0; i < len; i++)
 296         if (str[i] < ' ' || str[i] > 126)
 297             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
 298         else
 299             wrbuf_putc(b, str[i]);
 300 }
 301
 302 void wrbuf_json_write(WRBUF b, const char *cp, size_t sz)
 303 {
 304     size_t i;
 305     for (i = 0; i < sz; i++)
 306     {
 307         if (cp[i] > 0 && cp[i] < 32)
 308         {
 309             wrbuf_putc(b, '\\');
 310             switch (cp[i])
 311             {
 312             case '\b': wrbuf_putc(b, 'b'); break;
 313             case '\f': wrbuf_putc(b, 'f'); break;
 314             case '\n': wrbuf_putc(b, 'n'); break;
 315             case '\r': wrbuf_putc(b, 'r'); break;
 316             case '\t': wrbuf_putc(b, 't'); break;
 317             default:
 318                 wrbuf_printf(b, "u%04x", cp[i]);
 319             }
 320         }
 321         else if (cp[i] == '"')
 322         {
 323             wrbuf_putc(b, '\\'); wrbuf_putc(b, '"');
 324         }
 325         else if (cp[i] == '\\')
 326         {
 327             wrbuf_putc(b, '\\'); wrbuf_putc(b, '\\');
 328         }
 329         else
 330         {   /* leave encoding as raw UTF-8 */
 331             wrbuf_putc(b, cp[i]);
 332         }
 333     }
 334
 335 }
 336
 337 void wrbuf_json_puts(WRBUF b, const char *str)
 338 {
 339     wrbuf_json_write(b, str, strlen(str));
 340 }
 341
 342 /*
 343  * Local variables:
 344  * c-basic-offset: 4
 345  * c-file-style: "Stroustrup"
 346  * indent-tabs-mode: nil
 347  * End:
 348  * vim: shiftwidth=4 tabstop=8 expandtab
 349  */
 350