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.19 2007-03-20 21:37:32 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_free(WRBUF b, int x)
  39 {
  40     wrbuf_destroy(b);
  41 }
  42
  43 void wrbuf_destroy(WRBUF b)
  44 {
  45     xfree(b->buf);
  46     xfree(b);
  47 }
  48
  49 void wrbuf_rewind(WRBUF b)
  50 {
  51     b->pos = 0;
  52 }
  53
  54 int wrbuf_grow(WRBUF b, int minsize)
  55 {
  56     int togrow;
  57
  58     if (!b->size)
  59         togrow = 1024;
  60     else
  61         togrow = b->size;
  62     if (togrow < minsize)
  63         togrow = minsize;
  64     if (b->size && !(b->buf =(char *)xrealloc(b->buf, b->size += togrow)))
  65         abort();
  66     else if (!b->size && !(b->buf = (char *)xmalloc(b->size = togrow)))
  67         abort();
  68     return 0;
  69 }
  70
  71 int wrbuf_write(WRBUF b, const char *buf, int size)
  72 {
  73     if (size <= 0)
  74         return 0;
  75     if (b->pos + size >= b->size)
  76         wrbuf_grow(b, size);
  77     memcpy(b->buf + b->pos, buf, size);
  78     b->pos += size;
  79     return 0;
  80 }
  81
  82 int wrbuf_puts(WRBUF b, const char *buf)
  83 {
  84     wrbuf_write(b, buf, strlen(buf) + 1);
  85     (b->pos)--;           /* don't include '\0' in count */
  86     return 0;
  87 }
  88
  89 int wrbuf_puts_replace_char(WRBUF b, const char *buf,
  90                             const char from, const char to)
  91 {
  92     while(*buf)
  93     {
  94         if (*buf == from)
  95             wrbuf_putc(b, to);
  96         else
  97             wrbuf_putc(b, *buf);
  98         buf++;
  99     }
 100     return 0;
 101 }
 102
 103 void wrbuf_chop_right(WRBUF b)
 104 {
 105     while (b->pos && b->buf[b->pos-1] == ' ')
 106     {
 107         (b->pos)--;
 108     }
 109 }
 110
 111 int wrbuf_xmlputs(WRBUF b, const char *cp)
 112 {
 113     return wrbuf_xmlputs_n(b, cp, strlen(cp));
 114 }
 115
 116 int wrbuf_xmlputs_n(WRBUF b, const char *cp, int size)
 117 {
 118     while (--size >= 0)
 119     {
 120         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
 121         if (*cp >= 0 && *cp <= 31)
 122             if (*cp != 9 && *cp != 10 && *cp != 13)
 123             {
 124                 cp++;  /* we silently ignore (delete) these.. */
 125                 continue;
 126             }
 127         switch(*cp)
 128         {
 129         case '<':
 130             wrbuf_puts(b, "&lt;");
 131             break;
 132         case '>':
 133             wrbuf_puts(b, "&gt;");
 134             break;
 135         case '&':
 136             wrbuf_puts(b, "&amp;");
 137             break;
 138         case '"':
 139             wrbuf_puts(b, "&quot;");
 140             break;
 141         case '\'':
 142             wrbuf_puts(b, "&apos;");
 143             break;
 144         default:
 145             wrbuf_putc(b, *cp);
 146         }
 147         cp++;
 148     }
 149     return 0;
 150 }
 151
 152 void wrbuf_printf(WRBUF b, const char *fmt, ...)
 153 {
 154     va_list ap;
 155     char buf[4096];
 156
 157     va_start(ap, fmt);
 158     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
 159     wrbuf_puts (b, buf);
 160
 161     va_end(ap);
 162 }
 163
 164 static int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
 165                                int size, int cdata)
 166 {
 167     if (cd)
 168     {
 169         char outbuf[12];
 170         size_t inbytesleft = size;
 171         const char *inp = buf;
 172         while (inbytesleft)
 173         {
 174             size_t outbytesleft = sizeof(outbuf);
 175             char *outp = outbuf;
 176             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
 177                                  &outp, &outbytesleft);
 178             if (r == (size_t) (-1))
 179             {
 180                 int e = yaz_iconv_error(cd);
 181                 if (e != YAZ_ICONV_E2BIG)
 182                     break;
 183             }
 184             if (cdata)
 185                 wrbuf_xmlputs_n(b, outbuf, outp - outbuf);
 186             else
 187                 wrbuf_write(b, outbuf, outp - outbuf);
 188         }
 189     }
 190     else
 191     {
 192         if (cdata)
 193             wrbuf_xmlputs_n(b, buf, size);
 194         else
 195             wrbuf_write(b, buf, size);
 196     }
 197     return wrbuf_len(b);
 198 }
 199
 200 int wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, int size)
 201 {
 202     return wrbuf_iconv_write_x(b, cd, buf, size, 0);
 203 }
 204
 205 int wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
 206 {
 207     return wrbuf_iconv_write(b, cd, strz, strlen(strz));
 208 }
 209
 210 int wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
 211 {
 212     char buf[1];
 213     buf[0] = ch;
 214     return wrbuf_iconv_write(b, cd, buf, 1);
 215 }
 216
 217 int wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, int size)
 218 {
 219     return wrbuf_iconv_write_x(b, cd, buf, size, 1);
 220 }
 221
 222 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
 223 {
 224     if (cd)
 225     {
 226         char outbuf[12];
 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 /*
 250  * Local variables:
 251  * c-basic-offset: 4
 252  * indent-tabs-mode: nil
 253  * End:
 254  * vim: shiftwidth=4 tabstop=8 expandtab
 255  */
 256