version 2 check
[yaz-moved-to-github.git] / 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             if (cdata)
197                 wrbuf_xmlputs_n(b, outbuf, outp - outbuf);
198             else
199                 wrbuf_write(b, outbuf, outp - outbuf);
200         }
201     }
202     else
203     {
204         if (cdata)
205             wrbuf_xmlputs_n(b, buf, size);
206         else
207             wrbuf_write(b, buf, size);
208     }
209     return ret;
210 }
211
212 void wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
213 {
214     wrbuf_iconv_write_x(b, cd, buf, size, 0);
215 }
216
217 void wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
218 {
219     wrbuf_iconv_write(b, cd, strz, strlen(strz));
220 }
221
222 void wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
223 {
224     char buf[1];
225     buf[0] = ch;
226     wrbuf_iconv_write(b, cd, buf, 1);
227 }
228
229 void wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
230 {
231     wrbuf_iconv_write_x(b, cd, buf, size, 1);
232 }
233
234 void wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
235 {
236     wrbuf_iconv_write_x(b, cd, strz, strlen(strz), 1);
237 }
238
239 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
240 {
241     if (cd)
242     {
243         char outbuf[16];
244         size_t outbytesleft = sizeof(outbuf);
245         char *outp = outbuf;
246         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
247         if (r != (size_t) (-1))
248             wrbuf_write(b, outbuf, outp - outbuf);
249     }
250 }
251
252 const char *wrbuf_cstr(WRBUF b)
253 {
254     wrbuf_putc(b, '\0');   /* add '\0' */
255     (b->pos)--;           /* don't include '\0' in count */
256     return b->buf;
257 }
258
259 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
260 {
261     if (no_to_remove > b->pos)
262         no_to_remove = b->pos;
263     b->pos = b->pos - no_to_remove;
264 }
265
266 void wrbuf_puts_escaped(WRBUF b, const char *str)
267 {
268     wrbuf_write_escaped(b, str, strlen(str));
269 }
270
271 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
272 {
273     size_t i;
274     for (i = 0; i < len; i++)
275         if (str[i] < ' ' || str[i] > 126)
276             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
277         else
278             wrbuf_putc(b, str[i]);
279 }
280
281 /*
282  * Local variables:
283  * c-basic-offset: 4
284  * c-file-style: "Stroustrup"
285  * indent-tabs-mode: nil
286  * End:
287  * vim: shiftwidth=4 tabstop=8 expandtab
288  */
289