test_record_conv: missing yaz_record_conv_destroy
[yaz-moved-to-github.git] / src / wrbuf.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 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 #include <assert.h>
20
21 #include <yaz/wrbuf.h>
22 #include <yaz/snprintf.h>
23 #include <yaz/yaz-iconv.h>
24
25 WRBUF wrbuf_alloc(void)
26 {
27     WRBUF n;
28
29     if (!(n = (WRBUF)xmalloc(sizeof(*n))))
30         abort();
31     n->buf = 0;
32     n->size = 0;
33     n->pos = 0;
34     wrbuf_grow(n, 1);
35     return n;
36 }
37
38 void wrbuf_destroy(WRBUF b)
39 {
40     if (b)
41     {
42         xfree(b->buf);
43         xfree(b);
44     }
45 }
46
47 void wrbuf_rewind(WRBUF b)
48 {
49     b->pos = 0;
50 }
51
52 int wrbuf_grow(WRBUF b, size_t minsize)
53 {
54     size_t togrow;
55
56     if (!b->size)
57         togrow = 1024;
58     else
59         togrow = b->size;
60     if (togrow < minsize)
61         togrow = minsize;
62     b->buf = (char *) xrealloc(b->buf, 1 + (b->size += togrow));
63     if (!b->buf)
64         abort();
65     return 0;
66 }
67
68 void wrbuf_write(WRBUF b, const char *buf, size_t size)
69 {
70     if (size <= 0)
71         return;
72     if (b->pos + size >= b->size)
73         wrbuf_grow(b, size);
74     memcpy(b->buf + b->pos, buf, size);
75     b->pos += size;
76 }
77
78 void wrbuf_insert(WRBUF b, size_t pos, const char *buf, size_t size)
79 {
80     if (size <= 0 || pos > b->pos)
81         return;
82     if (b->pos + size >= b->size)
83         wrbuf_grow(b, size);
84     memmove(b->buf + pos + size, b->buf + pos, b->pos - pos);
85     memcpy(b->buf + pos, buf, size);
86     b->pos += size;
87 }
88
89 void wrbuf_puts(WRBUF b, const char *buf)
90 {
91     wrbuf_write(b, buf, strlen(buf));
92 }
93
94 void wrbuf_vp_puts(const char *buf, void *client_data)
95 {
96     WRBUF b = (WRBUF) client_data;
97     wrbuf_puts(b, buf);
98 }
99
100 void wrbuf_puts_replace_char(WRBUF b, const char *buf,
101                             const char from, const char to)
102 {
103     while(*buf)
104     {
105         if (*buf == from)
106             wrbuf_putc(b, to);
107         else
108             wrbuf_putc(b, *buf);
109         buf++;
110     }
111 }
112
113 void wrbuf_chop_right(WRBUF b)
114 {
115     while (b->pos && b->buf[b->pos-1] == ' ')
116     {
117         (b->pos)--;
118     }
119 }
120
121 void wrbuf_xmlputs(WRBUF b, const char *cp)
122 {
123     wrbuf_xmlputs_n(b, cp, strlen(cp));
124 }
125
126 void wrbuf_xmlputs_n(WRBUF b, const char *cp, size_t size)
127 {
128     for (; size; size--)
129     {
130         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
131         if (*cp >= 0 && *cp <= 31)
132             if (*cp != 9 && *cp != 10 && *cp != 13)
133             {
134                 cp++;  /* we silently ignore (delete) these.. */
135                 continue;
136             }
137         switch(*cp)
138         {
139         case '<':
140             wrbuf_puts(b, "&lt;");
141             break;
142         case '>':
143             wrbuf_puts(b, "&gt;");
144             break;
145         case '&':
146             wrbuf_puts(b, "&amp;");
147             break;
148         case '"':
149             wrbuf_puts(b, "&quot;");
150             break;
151         case '\'':
152             wrbuf_puts(b, "&apos;");
153             break;
154         default:
155             wrbuf_putc(b, *cp);
156         }
157         cp++;
158     }
159 }
160
161 void wrbuf_printf(WRBUF b, const char *fmt, ...)
162 {
163     va_list ap;
164     char buf[4096];
165
166     va_start(ap, fmt);
167     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
168     wrbuf_puts (b, buf);
169
170     va_end(ap);
171 }
172
173 int wrbuf_iconv_write2(WRBUF b, yaz_iconv_t cd, const char *buf,
174                        size_t size,
175                        void (*wfunc)(WRBUF, const char *, size_t))
176 {
177     int ret = 0;
178     if (cd)
179     {
180         char outbuf[128];
181         size_t inbytesleft = size;
182         const char *inp = buf;
183         while (inbytesleft)
184         {
185             size_t outbytesleft = sizeof(outbuf);
186             char *outp = outbuf;
187             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
188                                  &outp, &outbytesleft);
189             if (r == (size_t) (-1))
190             {
191                 int e = yaz_iconv_error(cd);
192                 if (e != YAZ_ICONV_E2BIG)
193                 {
194                     ret = -1;
195                     break;
196                 }
197             }
198             (*wfunc)(b, outbuf, outp - outbuf);
199         }
200     }
201     else
202         (*wfunc)(b, buf, size);
203     return ret;
204 }
205
206 int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
207                         size_t size, int cdata)
208 {
209     return wrbuf_iconv_write2(b, cd, buf, size,
210                               cdata ? wrbuf_xmlputs_n : wrbuf_write);
211 }
212
213 void wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
214 {
215     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_write);
216 }
217
218 void wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
219 {
220     wrbuf_iconv_write(b, cd, strz, strlen(strz));
221 }
222
223 void wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
224 {
225     char buf[1];
226     buf[0] = ch;
227     wrbuf_iconv_write(b, cd, buf, 1);
228 }
229
230 void wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, size_t size)
231 {
232     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_xmlputs_n);
233 }
234
235 void wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
236 {
237     wrbuf_iconv_write2(b, cd, strz, strlen(strz), wrbuf_xmlputs_n);
238 }
239
240 void wrbuf_iconv_json_write(WRBUF b, yaz_iconv_t cd,
241                             const char *buf, size_t size)
242 {
243     wrbuf_iconv_write2(b, cd, buf, size, wrbuf_json_write);
244 }
245
246 void wrbuf_iconv_json_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
247 {
248     wrbuf_iconv_write2(b, cd, strz, strlen(strz), wrbuf_json_write);
249 }
250
251 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
252 {
253     if (cd)
254     {
255         char outbuf[16];
256         size_t outbytesleft = sizeof(outbuf);
257         char *outp = outbuf;
258         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
259         if (r != (size_t) (-1))
260             wrbuf_write(b, outbuf, outp - outbuf);
261     }
262 }
263
264 const char *wrbuf_cstr(WRBUF b)
265 {
266     assert(b && b->pos <= b->size);
267     b->buf[b->pos] = '\0';
268     return b->buf;
269 }
270
271 const char *wrbuf_cstr_null(WRBUF b)
272 {
273     if (!b || b->pos == 0)
274         return 0;
275     assert(b->pos <= b->size);
276     b->buf[b->pos] = '\0';
277     return b->buf;
278 }
279
280 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
281 {
282     if (no_to_remove > b->pos)
283         no_to_remove = b->pos;
284     b->pos = b->pos - no_to_remove;
285 }
286
287 void wrbuf_puts_escaped(WRBUF b, const char *str)
288 {
289     wrbuf_write_escaped(b, str, strlen(str));
290 }
291
292 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
293 {
294     size_t i;
295     for (i = 0; i < len; i++)
296         if (str[i] < ' ' || str[i] > 126)
297             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
298         else
299             wrbuf_putc(b, str[i]);
300 }
301
302 void wrbuf_json_write(WRBUF b, const char *cp, size_t sz)
303 {
304     size_t i;
305     for (i = 0; i < sz; i++)
306     {
307         if (cp[i] > 0 && cp[i] < 32)
308         {
309             wrbuf_putc(b, '\\');
310             switch (cp[i])
311             {
312             case '\b': wrbuf_putc(b, 'b'); break;
313             case '\f': wrbuf_putc(b, 'f'); break;
314             case '\n': wrbuf_putc(b, 'n'); break;
315             case '\r': wrbuf_putc(b, 'r'); break;
316             case '\t': wrbuf_putc(b, 't'); break;
317             default:
318                 wrbuf_printf(b, "u%04x", cp[i]);
319             }
320         }
321         else if (cp[i] == '"')
322         {
323             wrbuf_putc(b, '\\'); wrbuf_putc(b, '"');
324         }
325         else if (cp[i] == '\\')
326         {
327             wrbuf_putc(b, '\\'); wrbuf_putc(b, '\\');
328         }
329         else
330         {   /* leave encoding as raw UTF-8 */
331             wrbuf_putc(b, cp[i]);
332         }
333     }
334
335 }
336
337 void wrbuf_json_puts(WRBUF b, const char *str)
338 {
339     wrbuf_json_write(b, str, strlen(str));
340 }
341
342 /*
343  * Local variables:
344  * c-basic-offset: 4
345  * c-file-style: "Stroustrup"
346  * indent-tabs-mode: nil
347  * End:
348  * vim: shiftwidth=4 tabstop=8 expandtab
349  */
350