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_puts_replace_char(WRBUF b, const char *buf,
  83                             const char from, const char to)
  84 {
  85     while(*buf)
  86     {
  87         if (*buf == from)
  88             wrbuf_putc(b, to);
  89         else
  90             wrbuf_putc(b, *buf);
  91         buf++;
  92     }
  93 }
  94
  95 void wrbuf_chop_right(WRBUF b)
  96 {
  97     while (b->pos && b->buf[b->pos-1] == ' ')
  98     {
  99         (b->pos)--;
 100     }
 101 }
 102
 103 void wrbuf_xmlputs(WRBUF b, const char *cp)
 104 {
 105     wrbuf_xmlputs_n(b, cp, strlen(cp));
 106 }
 107
 108 void wrbuf_xmlputs_n(WRBUF b, const char *cp, size_t size)
 109 {
 110     for (; size; size--)
 111     {
 112         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
 113         if (*cp >= 0 && *cp <= 31)
 114             if (*cp != 9 && *cp != 10 && *cp != 13)
 115             {
 116                 cp++;  /* we silently ignore (delete) these.. */
 117                 continue;
 118             }
 119         switch(*cp)
 120         {
 121         case '<':
 122             wrbuf_puts(b, "&lt;");
 123             break;
 124         case '>':
 125             wrbuf_puts(b, "&gt;");
 126             break;
 127         case '&':
 128             wrbuf_puts(b, "&amp;");
 129             break;
 130         case '"':
 131             wrbuf_puts(b, "&quot;");
 132             break;
 133         case '\'':
 134             wrbuf_puts(b, "&apos;");
 135             break;
 136         default:
 137             wrbuf_putc(b, *cp);
 138         }
 139         cp++;
 140     }
 141 }
 142
 143 void wrbuf_printf(WRBUF b, const char *fmt, ...)
 144 {
 145     va_list ap;
 146     char buf[4096];
 147
 148     va_start(ap, fmt);
 149     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
 150     wrbuf_puts (b, buf);
 151
 152     va_end(ap);
 153 }
 154
 155 int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
 156                         size_t size, int cdata)
 157 {
 158     int ret = 0;
 159     if (cd)
 160     {
 161         char outbuf[128];
 162         size_t inbytesleft = size;
 163         const char *inp = buf;
 164         while (inbytesleft)
 165         {
 166             size_t outbytesleft = sizeof(outbuf);
 167             char *outp = outbuf;
 168             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
 169                                  &outp, &outbytesleft);
 170             if (r == (size_t) (-1))
 171             {
 172                 int e = yaz_iconv_error(cd);
 173                 if (e != YAZ_ICONV_E2BIG)
 174                 {
 175                     ret = -1;
 176                     break;
 177                 }
 178             }
 179             if (cdata)
 180                 wrbuf_xmlputs_n(b, outbuf, outp - outbuf);
 181             else
 182                 wrbuf_write(b, outbuf, outp - outbuf);
 183         }
 184     }
 185     else
 186     {
 187         if (cdata)
 188             wrbuf_xmlputs_n(b, buf, size);
 189         else
 190             wrbuf_write(b, buf, size);
 191     }
 192     return ret;
 193 }
 194
 195 void wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 196 {
 197     wrbuf_iconv_write_x(b, cd, buf, size, 0);
 198 }
 199
 200 void wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
 201 {
 202     wrbuf_iconv_write(b, cd, strz, strlen(strz));
 203 }
 204
 205 void wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
 206 {
 207     char buf[1];
 208     buf[0] = ch;
 209     wrbuf_iconv_write(b, cd, buf, 1);
 210 }
 211
 212 void wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
 213 {
 214     wrbuf_iconv_write_x(b, cd, buf, size, 1);
 215 }
 216
 217 void wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
 218 {
 219     wrbuf_iconv_write_x(b, cd, strz, strlen(strz), 1);
 220 }
 221
 222 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
 223 {
 224     if (cd)
 225     {
 226         char outbuf[16];
 227         size_t outbytesleft = sizeof(outbuf);
 228         char *outp = outbuf;
 229         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
 230         if (r != (size_t) (-1))
 231             wrbuf_write(b, outbuf, outp - outbuf);
 232     }
 233 }
 234
 235 const char *wrbuf_cstr(WRBUF b)
 236 {
 237     wrbuf_putc(b, '\0');   /* add '\0' */
 238     (b->pos)--;           /* don't include '\0' in count */
 239     return b->buf;
 240 }
 241
 242 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
 243 {
 244     if (no_to_remove > b->pos)
 245         no_to_remove = b->pos;
 246     b->pos = b->pos - no_to_remove;
 247 }
 248
 249 void wrbuf_puts_escaped(WRBUF b, const char *str)
 250 {
 251     wrbuf_write_escaped(b, str, strlen(str));
 252 }
 253
 254 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
 255 {
 256     size_t i;
 257     for (i = 0; i < len; i++)
 258         if (str[i] < ' ' || str[i] > 126)
 259             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
 260         else
 261             wrbuf_putc(b, str[i]);
 262 }
 263
 264 /*
 265  * Local variables:
 266  * c-basic-offset: 4
 267  * c-file-style: "Stroustrup"
 268  * indent-tabs-mode: nil
 269  * End:
 270  * vim: shiftwidth=4 tabstop=8 expandtab
 271  */
 272