src/wrbuf.c

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