src/wrbuf.c

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