src/wrbuf.c

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