commit 876bebd
default
·
2023-01-28 16:49:02 +0000 UTC
parent 5163f93
Backport from xs.
M
xs.h
+191,
-130
1@@ -14,25 +14,31 @@
2 #include <errno.h>
3
4 typedef enum {
5- XSTYPE_NULL = 0x18,
6- XSTYPE_TRUE = 0x06,
7- XSTYPE_FALSE = 0x15,
8- XSTYPE_LIST = 0x11,
9- XSTYPE_LITEM = 0x1f,
10- XSTYPE_EOL = 0x12,
11- XSTYPE_DICT = 0x13,
12- XSTYPE_DITEM = 0x1e,
13- XSTYPE_EOD = 0x14,
14- XSTYPE_NUMBER = 0x17,
15- XSTYPE_STRING = 0x02
16+ XSTYPE_STRING = 0x02, /* C string (\0 delimited) (NOT STORED) */
17+ XSTYPE_NUMBER = 0x17, /* C string (\0 delimited) */
18+ XSTYPE_NULL = 0x18, /* Special NULL value */
19+ XSTYPE_TRUE = 0x06, /* Boolean */
20+ XSTYPE_FALSE = 0x15, /* Boolean */
21+ XSTYPE_LIST = 0x1d, /* Sequence of LITEMs up to EOM (with 24bit size) */
22+ XSTYPE_LITEM = 0x1f, /* Element of a list (any type) */
23+ XSTYPE_DICT = 0x1c, /* Sequence of DITEMs up to EOM (with 24bit size) */
24+ XSTYPE_DITEM = 0x1e, /* Element of a dict (STRING key + any type) */
25+ XSTYPE_EOM = 0x19 /* End of Multiple (LIST or DICT) */
26 } xstype;
27
28
29 /* dynamic strings */
30 typedef char d_char;
31
32+/* types */
33+typedef char xs_val;
34+typedef char xs_str;
35+typedef char xs_list;
36+typedef char xs_dict;
37+typedef char xs_number;
38+
39 /* auto-destroyable strings */
40-#define xs __attribute__ ((__cleanup__ (_xs_destroy))) d_char
41+#define xs __attribute__ ((__cleanup__ (_xs_destroy))) xs_val
42
43 /* not really all, just very much */
44 #define XS_ALL 0xfffffff
45@@ -43,60 +49,75 @@ void *_xs_realloc(void *ptr, size_t size, const char *file, int line, const char
46 int _xs_blk_size(int sz);
47 void _xs_destroy(char **var);
48 #define xs_debug() raise(SIGTRAP)
49-xstype xs_type(const char *data);
50-int xs_size(const char *data);
51-int xs_is_null(const char *data);
52-d_char *xs_dup(const char *data);
53-d_char *xs_expand(d_char *data, int offset, int size);
54-d_char *xs_collapse(d_char *data, int offset, int size);
55-d_char *xs_insert_m(d_char *data, int offset, const char *mem, int size);
56+xstype xs_type(const xs_val *data);
57+int xs_size(const xs_val *data);
58+int xs_is_null(const xs_val *data);
59+xs_val *xs_dup(const xs_val *data);
60+xs_val *xs_expand(xs_val *data, int offset, int size);
61+xs_val *xs_collapse(xs_val *data, int offset, int size);
62+xs_val *xs_insert_m(xs_val *data, int offset, const char *mem, int size);
63 #define xs_insert(data, offset, data2) xs_insert_m(data, offset, data2, xs_size(data2))
64 #define xs_append_m(data, mem, size) xs_insert_m(data, xs_size(data) - 1, mem, size)
65-d_char *xs_str_new(const char *str);
66-d_char *xs_str_wrap_i(const char *prefix, d_char *str, const char *suffix);
67+
68+xs_str *xs_str_new(const char *str);
69+xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix);
70 #define xs_str_prepend_i(str, prefix) xs_str_wrap_i(prefix, str, NULL)
71 #define xs_str_cat(str, suffix) xs_str_wrap_i(NULL, str, suffix)
72-d_char *xs_replace_i(d_char *str, const char *sfrom, const char *sto);
73+xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto);
74 #define xs_replace(str, sfrom, sto) xs_replace_i(xs_dup(str), sfrom, sto)
75-d_char *xs_fmt(const char *fmt, ...);
76+xs_str *xs_fmt(const char *fmt, ...);
77 int xs_str_in(const char *haystack, const char *needle);
78 int xs_startswith(const char *str, const char *prefix);
79 int xs_endswith(const char *str, const char *postfix);
80-d_char *xs_crop_i(d_char *str, int start, int end);
81-d_char *xs_strip_chars_i(d_char *str, const char *chars);
82+xs_str *xs_crop_i(xs_str *str, int start, int end);
83+xs_str *xs_strip_chars_i(xs_str *str, const char *chars);
84 #define xs_strip_i(str) xs_strip_chars_i(str, " \r\n\t\v\f")
85-d_char *xs_tolower_i(d_char *str);
86-d_char *xs_list_new(void);
87-d_char *xs_list_append_m(d_char *list, const char *mem, int dsz);
88+xs_str *xs_tolower_i(xs_str *str);
89+
90+xs_list *xs_list_new(void);
91+xs_list *xs_list_append_m(xs_list *list, const char *mem, int dsz);
92 #define xs_list_append(list, data) xs_list_append_m(list, data, xs_size(data))
93-int xs_list_iter(char **list, char **value);
94-int xs_list_len(char *list);
95-char *xs_list_get(char *list, int num);
96-d_char *xs_list_del(d_char *list, int num);
97-d_char *xs_list_insert(d_char *list, int num, const char *data);
98-d_char *xs_list_insert_sorted(d_char *list, const char *str);
99-d_char *xs_list_set(d_char *list, int num, const char *data);
100-d_char *xs_list_dequeue(d_char *list, char **data, int last);
101+int xs_list_iter(xs_list **list, xs_val **value);
102+int xs_list_len(xs_list *list);
103+char *xs_list_get(xs_list *list, int num);
104+xs_list *xs_list_del(xs_list *list, int num);
105+xs_list *xs_list_insert(xs_list *list, int num, const xs_val *data);
106+xs_list *xs_list_insert_sorted(xs_list *list, const char *str);
107+xs_list *xs_list_set(xs_list *list, int num, const xs_val *data);
108+xs_list *xs_list_dequeue(xs_list *list, xs_val **data, int last);
109 #define xs_list_pop(list, data) xs_list_dequeue(list, data, 1)
110 #define xs_list_shift(list, data) xs_list_dequeue(list, data, 0)
111-int xs_list_in(char *list, const char *val);
112-d_char *xs_join(char *list, const char *sep);
113-d_char *xs_split_n(const char *str, const char *sep, int times);
114+int xs_list_in(xs_list *list, const xs_val *val);
115+xs_str *xs_join(xs_list *list, const char *sep);
116+xs_list *xs_split_n(const char *str, const char *sep, int times);
117 #define xs_split(str, sep) xs_split_n(str, sep, XS_ALL)
118-d_char *xs_dict_new(void);
119-d_char *xs_dict_append_m(d_char *dict, const char *key, const char *mem, int dsz);
120+
121+xs_dict *xs_dict_new(void);
122+xs_dict *xs_dict_append_m(xs_dict *dict, const xs_str *key, const xs_val *mem, int dsz);
123 #define xs_dict_append(dict, key, data) xs_dict_append_m(dict, key, data, xs_size(data))
124-int xs_dict_iter(char **dict, char **key, char **value);
125-char *xs_dict_get(char *dict, const char *key);
126-d_char *xs_dict_del(d_char *dict, const char *key);
127-d_char *xs_dict_set(d_char *dict, const char *key, const char *data);
128-d_char *xs_val_new(xstype t);
129-d_char *xs_number_new(double f);
130-double xs_number_get(const char *v);
131-const char *xs_number_str(const char *v);
132+int xs_dict_iter(xs_dict **dict, xs_str **key, xs_val **value);
133+xs_dict *xs_dict_get(xs_dict *dict, const xs_str *key);
134+xs_dict *xs_dict_del(xs_dict *dict, const xs_str *key);
135+xs_dict *xs_dict_set(xs_dict *dict, const xs_str *key, const xs_val *data);
136+
137+xs_val *xs_val_new(xstype t);
138+xs_number *xs_number_new(double f);
139+double xs_number_get(const xs_number *v);
140+const char *xs_number_str(const xs_number *v);
141
142 void *xs_memmem(const char *haystack, int h_size, const char *needle, int n_size);
143
144+
145+#ifdef XS_ASSERT
146+#include <assert.h>
147+#define XS_ASSERT_TYPE(v, t) assert(xs_type(v) == t)
148+#define XS_ASSERT_TYPE_NULL(v, t) assert(v == NULL || xs_type(v) == t)
149+#else
150+#define XS_ASSERT_TYPE(v, t) (void)(0)
151+#define XS_ASSERT_TYPE_NULL(v, t) (void)(0)
152+#endif
153+
154+
155 #ifdef XS_IMPLEMENTATION
156
157 void *_xs_realloc(void *ptr, size_t size, const char *file, int line, const char *func)
158@@ -183,22 +204,24 @@ int _xs_blk_size(int sz)
159 }
160
161
162-xstype xs_type(const char *data)
163+xstype xs_type(const xs_val *data)
164 /* return the type of data */
165 {
166 xstype t;
167
168+ if (data == NULL)
169+ t = XSTYPE_NULL;
170+ else
171 switch (data[0]) {
172 case XSTYPE_NULL:
173 case XSTYPE_TRUE:
174 case XSTYPE_FALSE:
175 case XSTYPE_LIST:
176- case XSTYPE_EOL:
177- case XSTYPE_DICT:
178- case XSTYPE_EOD:
179 case XSTYPE_LITEM:
180+ case XSTYPE_DICT:
181 case XSTYPE_DITEM:
182 case XSTYPE_NUMBER:
183+ case XSTYPE_EOM:
184 t = data[0];
185 break;
186 default:
187@@ -210,7 +233,7 @@ xstype xs_type(const char *data)
188 }
189
190
191-void _xs_put_24b(char *ptr, int i)
192+void _xs_put_24b(xs_val *ptr, int i)
193 /* writes i as a 24 bit value */
194 {
195 unsigned char *p = (unsigned char *)ptr;
196@@ -221,7 +244,7 @@ void _xs_put_24b(char *ptr, int i)
197 }
198
199
200-int _xs_get_24b(const char *ptr)
201+int _xs_get_24b(const xs_val *ptr)
202 /* reads a 24 bit value */
203 {
204 unsigned char *p = (unsigned char *)ptr;
205@@ -230,7 +253,7 @@ int _xs_get_24b(const char *ptr)
206 }
207
208
209-int xs_size(const char *data)
210+int xs_size(const xs_val *data)
211 /* returns the size of data in bytes */
212 {
213 int len = 0;
214@@ -286,18 +309,18 @@ int xs_size(const char *data)
215 }
216
217
218-int xs_is_null(const char *data)
219+int xs_is_null(const xs_val *data)
220 /* checks for null */
221 {
222- return !!(data == NULL || xs_type(data) == XSTYPE_NULL);
223+ return (xs_type(data) == XSTYPE_NULL);
224 }
225
226
227-d_char *xs_dup(const char *data)
228+xs_val *xs_dup(const xs_val *data)
229 /* creates a duplicate of data */
230 {
231 int sz = xs_size(data);
232- d_char *s = xs_realloc(NULL, _xs_blk_size(sz));
233+ xs_val *s = xs_realloc(NULL, _xs_blk_size(sz));
234
235 memcpy(s, data, sz);
236
237@@ -305,7 +328,7 @@ d_char *xs_dup(const char *data)
238 }
239
240
241-d_char *xs_expand(d_char *data, int offset, int size)
242+xs_val *xs_expand(xs_val *data, int offset, int size)
243 /* opens a hole in data */
244 {
245 int sz = xs_size(data);
246@@ -325,7 +348,7 @@ d_char *xs_expand(d_char *data, int offset, int size)
247 }
248
249
250-d_char *xs_collapse(d_char *data, int offset, int size)
251+xs_val *xs_collapse(xs_val *data, int offset, int size)
252 /* shrinks data */
253 {
254 int sz = xs_size(data);
255@@ -348,7 +371,7 @@ d_char *xs_collapse(d_char *data, int offset, int size)
256 }
257
258
259-d_char *xs_insert_m(d_char *data, int offset, const char *mem, int size)
260+xs_val *xs_insert_m(xs_val *data, int offset, const char *mem, int size)
261 /* inserts a memory block */
262 {
263 data = xs_expand(data, offset, size);
264@@ -360,16 +383,18 @@ d_char *xs_insert_m(d_char *data, int offset, const char *mem, int size)
265
266 /** strings **/
267
268-d_char *xs_str_new(const char *str)
269+xs_str *xs_str_new(const char *str)
270 /* creates a new string */
271 {
272 return xs_insert(NULL, 0, str ? str : "");
273 }
274
275
276-d_char *xs_str_wrap_i(const char *prefix, d_char *str, const char *suffix)
277+xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix)
278 /* wraps str with prefix and suffix */
279 {
280+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
281+
282 if (prefix)
283 str = xs_insert_m(str, 0, prefix, strlen(prefix));
284
285@@ -380,9 +405,11 @@ d_char *xs_str_wrap_i(const char *prefix, d_char *str, const char *suffix)
286 }
287
288
289-d_char *xs_replace_i(d_char *str, const char *sfrom, const char *sto)
290+xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
291 /* replaces inline all sfrom with sto */
292 {
293+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
294+
295 int sfsz = strlen(sfrom);
296 int stsz = strlen(sto);
297 char *ss;
298@@ -402,11 +429,11 @@ d_char *xs_replace_i(d_char *str, const char *sfrom, const char *sto)
299 }
300
301
302-d_char *xs_fmt(const char *fmt, ...)
303+xs_str *xs_fmt(const char *fmt, ...)
304 /* formats a string with printf()-like marks */
305 {
306 int n;
307- d_char *s = NULL;
308+ xs_str *s = NULL;
309 va_list ap;
310
311 va_start(ap, fmt);
312@@ -455,9 +482,11 @@ int xs_endswith(const char *str, const char *postfix)
313 }
314
315
316-d_char *xs_crop_i(d_char *str, int start, int end)
317+xs_str *xs_crop_i(xs_str *str, int start, int end)
318 /* crops the d_char to be only from start to end */
319 {
320+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
321+
322 int sz = strlen(str);
323
324 if (end <= 0)
325@@ -473,9 +502,11 @@ d_char *xs_crop_i(d_char *str, int start, int end)
326 }
327
328
329-d_char *xs_strip_chars_i(d_char *str, const char *chars)
330+xs_str *xs_strip_chars_i(xs_str *str, const char *chars)
331 /* strips the string of chars from the start and the end */
332 {
333+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
334+
335 int n;
336
337 /* strip first from the end */
338@@ -494,9 +525,11 @@ d_char *xs_strip_chars_i(d_char *str, const char *chars)
339 }
340
341
342-d_char *xs_tolower_i(d_char *str)
343+xs_str *xs_tolower_i(xs_str *str)
344 /* convert to lowercase */
345 {
346+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
347+
348 int n;
349
350 for (n = 0; str[n]; n++)
351@@ -508,14 +541,14 @@ d_char *xs_tolower_i(d_char *str)
352
353 /** lists **/
354
355-d_char *xs_list_new(void)
356+xs_list *xs_list_new(void)
357 /* creates a new list */
358 {
359- d_char *list;
360+ xs_list *list;
361
362 list = xs_realloc(NULL, _xs_blk_size(5));
363 list[0] = XSTYPE_LIST;
364- list[4] = XSTYPE_EOL;
365+ list[4] = XSTYPE_EOM;
366
367 _xs_put_24b(list + 1, 5);
368
369@@ -523,9 +556,11 @@ d_char *xs_list_new(void)
370 }
371
372
373-d_char *_xs_list_write_litem(d_char *list, int offset, const char *mem, int dsz)
374+xs_list *_xs_list_write_litem(xs_list *list, int offset, const char *mem, int dsz)
375 /* writes a list item */
376 {
377+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
378+
379 char c = XSTYPE_LITEM;
380
381 list = xs_insert_m(list, offset, &c, 1);
382@@ -535,30 +570,28 @@ d_char *_xs_list_write_litem(d_char *list, int offset, const char *mem, int dsz)
383 }
384
385
386-d_char *xs_list_append_m(d_char *list, const char *mem, int dsz)
387+xs_list *xs_list_append_m(xs_list *list, const char *mem, int dsz)
388 /* adds a memory block to the list */
389 {
390+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
391+
392 return _xs_list_write_litem(list, xs_size(list) - 1, mem, dsz);
393 }
394
395
396-int xs_list_iter(char **list, char **value)
397+int xs_list_iter(xs_list **list, xs_val **value)
398 /* iterates a list value */
399 {
400 int goon = 1;
401- char *p;
402-
403- if (list == NULL || *list == NULL)
404- return 0;
405
406- p = *list;
407+ xs_val *p = *list;
408
409 /* skip the start of the list */
410- if (*p == XSTYPE_LIST)
411+ if (xs_type(p) == XSTYPE_LIST)
412 p += 4;
413
414 /* an element? */
415- if (*p == XSTYPE_LITEM) {
416+ if (xs_type(p) == XSTYPE_LITEM) {
417 p++;
418
419 *value = p;
420@@ -567,7 +600,6 @@ int xs_list_iter(char **list, char **value)
421 }
422 else {
423 /* end of list */
424- p++;
425 goon = 0;
426 }
427
428@@ -578,11 +610,13 @@ int xs_list_iter(char **list, char **value)
429 }
430
431
432-int xs_list_len(char *list)
433+int xs_list_len(xs_list *list)
434 /* returns the number of elements in the list */
435 {
436+ XS_ASSERT_TYPE_NULL(list, XSTYPE_LIST);
437+
438 int c = 0;
439- char *v;
440+ xs_val *v;
441
442 while (xs_list_iter(&list, &v))
443 c++;
444@@ -591,11 +625,13 @@ int xs_list_len(char *list)
445 }
446
447
448-char *xs_list_get(char *list, int num)
449+xs_val *xs_list_get(xs_list *list, int num)
450 /* returns the element #num */
451 {
452- char *v;
453+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
454+
455 int c = 0;
456+ xs_val *v;
457
458 if (num < 0)
459 num = xs_list_len(list) + num;
460@@ -611,10 +647,12 @@ char *xs_list_get(char *list, int num)
461 }
462
463
464-d_char *xs_list_del(d_char *list, int num)
465+xs_list *xs_list_del(xs_list *list, int num)
466 /* deletes element #num */
467 {
468- char *v;
469+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
470+
471+ xs_val *v;
472
473 if ((v = xs_list_get(list, num)) != NULL)
474 list = xs_collapse(list, v - 1 - list, xs_size(v - 1));
475@@ -623,10 +661,12 @@ d_char *xs_list_del(d_char *list, int num)
476 }
477
478
479-d_char *xs_list_insert(d_char *list, int num, const char *data)
480+xs_list *xs_list_insert(xs_list *list, int num, const xs_val *data)
481 /* inserts an element at #num position */
482 {
483- char *v;
484+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
485+
486+ xs_val *v;
487 int offset;
488
489 if ((v = xs_list_get(list, num)) != NULL)
490@@ -638,9 +678,12 @@ d_char *xs_list_insert(d_char *list, int num, const char *data)
491 }
492
493
494-d_char *xs_list_insert_sorted(d_char *list, const char *str)
495+xs_list *xs_list_insert_sorted(xs_list *list, const xs_str *str)
496 /* inserts a string in the list in its ordered position */
497 {
498+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
499+ XS_ASSERT_TYPE(str, XSTYPE_STRING);
500+
501 char *p, *v;
502 int offset = xs_size(list);
503
504@@ -657,9 +700,11 @@ d_char *xs_list_insert_sorted(d_char *list, const char *str)
505 }
506
507
508-d_char *xs_list_set(d_char *list, int num, const char *data)
509+xs_list *xs_list_set(xs_list *list, int num, const xs_val *data)
510 /* sets the element at #num position */
511 {
512+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
513+
514 list = xs_list_del(list, num);
515 list = xs_list_insert(list, num, data);
516
517@@ -667,10 +712,13 @@ d_char *xs_list_set(d_char *list, int num, const char *data)
518 }
519
520
521-d_char *xs_list_dequeue(d_char *list, char **data, int last)
522+xs_list *xs_list_dequeue(xs_list *list, xs_val **data, int last)
523 /* gets a copy of the first or last element of a list, shrinking it */
524 {
525- char *p = list, *v = NULL;
526+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
527+
528+ xs_list *p = list;
529+ xs_val *v = NULL;
530
531 if (!last) {
532 /* get the first */
533@@ -692,11 +740,13 @@ d_char *xs_list_dequeue(d_char *list, char **data, int last)
534 }
535
536
537-int xs_list_in(char *list, const char *val)
538+int xs_list_in(xs_list *list, const xs_val *val)
539 /* returns the position of val in list or -1 */
540 {
541+ XS_ASSERT_TYPE_NULL(list, XSTYPE_LIST);
542+
543 int n = 0;
544- char *v;
545+ xs_val *v;
546 int sz = xs_size(val);
547
548 while (xs_list_iter(&list, &v)) {
549@@ -710,11 +760,13 @@ int xs_list_in(char *list, const char *val)
550 }
551
552
553-d_char *xs_join(char *list, const char *sep)
554+xs_str *xs_join(xs_list *list, const char *sep)
555 /* joins a list into a string */
556 {
557- d_char *s = NULL;
558- char *v;
559+ XS_ASSERT_TYPE(list, XSTYPE_LIST);
560+
561+ xs_str *s = NULL;
562+ xs_val *v;
563 int c = 0;
564 int offset = 0;
565 int ssz = strlen(sep);
566@@ -749,12 +801,12 @@ d_char *xs_join(char *list, const char *sep)
567 }
568
569
570-d_char *xs_split_n(const char *str, const char *sep, int times)
571+xs_list *xs_split_n(const char *str, const char *sep, int times)
572 /* splits a string into a list upto n times */
573 {
574 int sz = strlen(sep);
575 char *ss;
576- d_char *list;
577+ xs_list *list;
578
579 list = xs_list_new();
580
581@@ -763,7 +815,7 @@ d_char *xs_split_n(const char *str, const char *sep, int times)
582 list = xs_list_append_m(list, str, ss - str);
583
584 /* add the asciiz */
585- list = xs_str_cat(list, "");
586+ list = xs_insert_m(list, xs_size(list) - 1, "", 1);
587
588 /* skip past the separator */
589 str = ss + sz;
590@@ -780,14 +832,14 @@ d_char *xs_split_n(const char *str, const char *sep, int times)
591
592 /** dicts **/
593
594-d_char *xs_dict_new(void)
595+xs_dict *xs_dict_new(void)
596 /* creates a new dict */
597 {
598- d_char *dict;
599+ xs_dict *dict;
600
601 dict = xs_realloc(NULL, _xs_blk_size(5));
602 dict[0] = XSTYPE_DICT;
603- dict[4] = XSTYPE_EOD;
604+ dict[4] = XSTYPE_EOM;
605
606 _xs_put_24b(dict + 1, 5);
607
608@@ -795,9 +847,12 @@ d_char *xs_dict_new(void)
609 }
610
611
612-d_char *xs_dict_append_m(d_char *dict, const char *key, const char *mem, int dsz)
613+xs_dict *xs_dict_append_m(xs_dict *dict, const xs_str *key, const xs_val *mem, int dsz)
614 /* adds a memory block to the dict */
615 {
616+ XS_ASSERT_TYPE(dict, XSTYPE_DICT);
617+ XS_ASSERT_TYPE(key, XSTYPE_STRING);
618+
619 char c = XSTYPE_DITEM;
620 int sz = xs_size(dict);
621 int ksz = xs_size(key);
622@@ -810,23 +865,19 @@ d_char *xs_dict_append_m(d_char *dict, const char *key, const char *mem, int dsz
623 }
624
625
626-int xs_dict_iter(char **dict, char **key, char **value)
627+int xs_dict_iter(xs_dict **dict, xs_str **key, xs_val **value)
628 /* iterates a dict value */
629 {
630 int goon = 1;
631- char *p;
632-
633- if (dict == NULL || *dict == NULL)
634- return 0;
635
636- p = *dict;
637+ xs_val *p = *dict;
638
639 /* skip the start of the list */
640- if (*p == XSTYPE_DICT)
641+ if (xs_type(p) == XSTYPE_DICT)
642 p += 4;
643
644 /* an element? */
645- if (*p == XSTYPE_DITEM) {
646+ if (xs_type(p) == XSTYPE_DITEM) {
647 p++;
648
649 *key = p;
650@@ -837,7 +888,6 @@ int xs_dict_iter(char **dict, char **key, char **value)
651 }
652 else {
653 /* end of list */
654- p++;
655 goon = 0;
656 }
657
658@@ -848,10 +898,14 @@ int xs_dict_iter(char **dict, char **key, char **value)
659 }
660
661
662-char *xs_dict_get(char *dict, const char *key)
663+xs_val *xs_dict_get(xs_dict *dict, const xs_str *key)
664 /* returns the value directed by key */
665 {
666- char *k, *v;
667+ XS_ASSERT_TYPE(dict, XSTYPE_DICT);
668+ XS_ASSERT_TYPE(key, XSTYPE_STRING);
669+
670+ xs_str *k;
671+ xs_val *v;
672
673 while (xs_dict_iter(&dict, &k, &v)) {
674 if (strcmp(k, key) == 0)
675@@ -862,11 +916,15 @@ char *xs_dict_get(char *dict, const char *key)
676 }
677
678
679-d_char *xs_dict_del(d_char *dict, const char *key)
680+xs_dict *xs_dict_del(xs_dict *dict, const xs_str *key)
681 /* deletes a key */
682 {
683- char *k, *v;
684- char *p = dict;
685+ XS_ASSERT_TYPE(dict, XSTYPE_DICT);
686+ XS_ASSERT_TYPE(key, XSTYPE_STRING);
687+
688+ xs_str *k;
689+ xs_val *v;
690+ xs_dict *p = dict;
691
692 while (xs_dict_iter(&p, &k, &v)) {
693 if (strcmp(k, key) == 0) {
694@@ -882,9 +940,12 @@ d_char *xs_dict_del(d_char *dict, const char *key)
695 }
696
697
698-d_char *xs_dict_set(d_char *dict, const char *key, const char *data)
699+xs_dict *xs_dict_set(xs_dict *dict, const xs_str *key, const xs_val *data)
700 /* sets (replaces) a key */
701 {
702+ XS_ASSERT_TYPE(dict, XSTYPE_DICT);
703+ XS_ASSERT_TYPE(key, XSTYPE_STRING);
704+
705 /* delete the possibly existing key */
706 dict = xs_dict_del(dict, key);
707
708@@ -897,10 +958,10 @@ d_char *xs_dict_set(d_char *dict, const char *key, const char *data)
709
710 /** other values **/
711
712-d_char *xs_val_new(xstype t)
713+xs_val *xs_val_new(xstype t)
714 /* adds a new special value */
715 {
716- d_char *v = xs_realloc(NULL, _xs_blk_size(1));
717+ xs_val *v = xs_realloc(NULL, _xs_blk_size(1));
718
719 v[0] = t;
720
721@@ -910,10 +971,10 @@ d_char *xs_val_new(xstype t)
722
723 /** numbers */
724
725-d_char *xs_number_new(double f)
726+xs_number *xs_number_new(double f)
727 /* adds a new number value */
728 {
729- d_char *v;
730+ xs_number *v;
731 char tmp[64];
732
733 snprintf(tmp, sizeof(tmp), "%.15lf", f);
734@@ -940,7 +1001,7 @@ d_char *xs_number_new(double f)
735 }
736
737
738-double xs_number_get(const char *v)
739+double xs_number_get(const xs_number *v)
740 /* gets the number as a double */
741 {
742 double f = 0.0;
743@@ -952,7 +1013,7 @@ double xs_number_get(const char *v)
744 }
745
746
747-const char *xs_number_str(const char *v)
748+const char *xs_number_str(const xs_number *v)
749 /* gets the number as a string */
750 {
751 const char *p = NULL;
+12,
-10
1@@ -4,18 +4,18 @@
2
3 #define _XS_CURL_H
4
5-d_char *xs_http_request(char *method, char *url, d_char *headers,
6- d_char *body, int b_size, int *status,
7- d_char **payload, int *p_size, int timeout);
8+xs_dict *xs_http_request(char *method, char *url, xs_dict *headers,
9+ xs_str *body, int b_size, int *status,
10+ xs_str **payload, int *p_size, int timeout);
11
12 #ifdef XS_IMPLEMENTATION
13
14 #include <curl/curl.h>
15
16 static size_t _header_callback(char *buffer, size_t size,
17- size_t nitems, d_char **userdata)
18+ size_t nitems, xs_dict **userdata)
19 {
20- d_char *headers = *userdata;
21+ xs_dict *headers = *userdata;
22 xs *l;
23
24 /* get the line */
25@@ -83,15 +83,17 @@ static int _post_callback(char *buffer, size_t size,
26 }
27
28
29-d_char *xs_http_request(char *method, char *url, d_char *headers,
30- d_char *body, int b_size, int *status,
31- d_char **payload, int *p_size, int timeout)
32+xs_dict *xs_http_request(char *method, char *url, xs_dict *headers,
33+ xs_str *body, int b_size, int *status,
34+ xs_str **payload, int *p_size, int timeout)
35 /* does an HTTP request */
36 {
37- d_char *response;
38+ xs_dict *response;
39 CURL *curl;
40 struct curl_slist *list = NULL;
41- char *k, *v, *p;
42+ xs_dict *p;
43+ xs_str *k;
44+ xs_val *v;
45 long lstatus;
46 struct _payload_data pd;
47
+14,
-14
1@@ -4,19 +4,19 @@
2
3 #define _XS_ENCDEC_H
4
5- d_char *xs_hex_enc(const char *data, int size);
6- d_char *xs_hex_dec(const char *hex, int *size);
7- d_char *xs_base64_enc(const char *data, int sz);
8- d_char *xs_base64_dec(const char *data, int *size);
9- d_char *xs_utf8_enc(d_char *str, unsigned int cpoint);
10+ xs_str *xs_hex_enc(const xs_val *data, int size);
11+ xs_val *xs_hex_dec(const xs_str *hex, int *size);
12+ xs_str *xs_base64_enc(const xs_val *data, int sz);
13+ xs_val *xs_base64_dec(const xs_str *data, int *size);
14+ xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint);
15
16
17 #ifdef XS_IMPLEMENTATION
18
19-d_char *xs_hex_enc(const char *data, int size)
20+xs_str *xs_hex_enc(const xs_val *data, int size)
21 /* returns an hexdump of data */
22 {
23- d_char *s;
24+ xs_str *s;
25 char *p;
26 int n;
27
28@@ -33,11 +33,11 @@ d_char *xs_hex_enc(const char *data, int size)
29 }
30
31
32-d_char *xs_hex_dec(const char *hex, int *size)
33+xs_val *xs_hex_dec(const xs_str *hex, int *size)
34 /* decodes an hexdump into data */
35 {
36 int sz = strlen(hex);
37- d_char *s = NULL;
38+ xs_val *s = NULL;
39 char *p;
40 int n;
41
42@@ -65,10 +65,10 @@ d_char *xs_hex_dec(const char *hex, int *size)
43 }
44
45
46-d_char *xs_base64_enc(const char *data, int sz)
47+xs_str *xs_base64_enc(const xs_val *data, int sz)
48 /* encodes data to base64 */
49 {
50- d_char *s;
51+ xs_str *s;
52 unsigned char *p;
53 char *i;
54 int bsz, n;
55@@ -110,10 +110,10 @@ d_char *xs_base64_enc(const char *data, int sz)
56 }
57
58
59-d_char *xs_base64_dec(const char *data, int *size)
60+xs_val *xs_base64_dec(const xs_str *data, int *size)
61 /* decodes data from base64 */
62 {
63- d_char *s = NULL;
64+ xs_val *s = NULL;
65 int sz = 0;
66 char *p;
67 static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
68@@ -171,7 +171,7 @@ d_char *xs_base64_dec(const char *data, int *size)
69 }
70
71
72-d_char *xs_utf8_enc(d_char *str, unsigned int cpoint)
73+xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint)
74 /* encodes an Unicode codepoint to utf8 */
75 {
76 unsigned char tmp[4];
+3,
-3
1@@ -4,7 +4,7 @@
2
3 #define _XS_GLOB_H
4
5-d_char *xs_glob_n(const char *spec, int basename, int reverse, int max);
6+xs_list *xs_glob_n(const char *spec, int basename, int reverse, int max);
7 #define xs_glob(spec, basename, reverse) xs_glob_n(spec, basename, reverse, XS_ALL)
8
9
10@@ -12,11 +12,11 @@ d_char *xs_glob_n(const char *spec, int basename, int reverse, int max);
11
12 #include <glob.h>
13
14-d_char *xs_glob_n(const char *spec, int basename, int reverse, int max)
15+xs_list *xs_glob_n(const char *spec, int basename, int reverse, int max)
16 /* does a globbing and returns the found files */
17 {
18 glob_t globbuf;
19- d_char *list = xs_list_new();
20+ xs_list *list = xs_list_new();
21
22 if (glob(spec, 0, NULL, &globbuf) == 0) {
23 int n;
+22,
-21
1@@ -4,18 +4,18 @@
2
3 #define _XS_HTTPD_H
4
5-d_char *xs_url_dec(char *str);
6-d_char *xs_url_vars(char *str);
7-d_char *xs_httpd_request(FILE *f, d_char **payload, int *p_size);
8-void xs_httpd_response(FILE *f, int status, d_char *headers, char *body, int b_size);
9+xs_str *xs_url_dec(char *str);
10+xs_dict *xs_url_vars(char *str);
11+xs_dict *xs_httpd_request(FILE *f, xs_str **payload, int *p_size);
12+void xs_httpd_response(FILE *f, int status, xs_dict *headers, xs_str *body, int b_size);
13
14
15 #ifdef XS_IMPLEMENTATION
16
17-d_char *xs_url_dec(char *str)
18+xs_str *xs_url_dec(char *str)
19 /* decodes an URL */
20 {
21- d_char *s = xs_str_new(NULL);
22+ xs_str *s = xs_str_new(NULL);
23
24 while (*str) {
25 if (*str == '%') {
26@@ -41,19 +41,19 @@ d_char *xs_url_dec(char *str)
27 }
28
29
30-d_char *xs_url_vars(char *str)
31+xs_dict *xs_url_vars(char *str)
32 /* parse url variables */
33 {
34- d_char *vars;
35+ xs_dict *vars;
36
37 vars = xs_dict_new();
38
39 if (str != NULL) {
40- char *v, *l;
41- xs *args;
42-
43 /* split by arguments */
44- args = xs_split(str, "&");
45+ xs *args = xs_split(str, "&");
46+
47+ xs_list *l;
48+ xs_val *v;
49
50 l = args;
51 while (xs_list_iter(&l, &v)) {
52@@ -69,7 +69,7 @@ d_char *xs_url_vars(char *str)
53 }
54
55
56-d_char *_xs_multipart_form_data(char *payload, int p_size, char *header)
57+xs_dict *_xs_multipart_form_data(xs_str *payload, int p_size, char *header)
58 /* parses a multipart/form-data payload */
59 {
60 xs *boundary = NULL;
61@@ -89,7 +89,7 @@ d_char *_xs_multipart_form_data(char *payload, int p_size, char *header)
62
63 bsz = strlen(boundary);
64
65- d_char *p_vars = xs_dict_new();
66+ xs_dict *p_vars = xs_dict_new();
67
68 /* iterate searching the boundaries */
69 while ((p = xs_memmem(payload + offset, p_size - offset, boundary, bsz)) != NULL) {
70@@ -173,12 +173,11 @@ d_char *_xs_multipart_form_data(char *payload, int p_size, char *header)
71 }
72
73
74-d_char *xs_httpd_request(FILE *f, d_char **payload, int *p_size)
75+xs_dict *xs_httpd_request(FILE *f, xs_str **payload, int *p_size)
76 /* processes an httpd connection */
77 {
78- d_char *req = NULL;
79- xs *q_vars = NULL;
80- xs *p_vars = NULL;
81+ xs *q_vars = NULL;
82+ xs *p_vars = NULL;
83 xs *l1, *l2;
84 char *v;
85
86@@ -193,7 +192,7 @@ d_char *xs_httpd_request(FILE *f, d_char **payload, int *p_size)
87 return NULL;
88 }
89
90- req = xs_dict_new();
91+ xs_dict *req = xs_dict_new();
92
93 req = xs_dict_append(req, "method", xs_list_get(l2, 0));
94 req = xs_dict_append(req, "proto", xs_list_get(l2, 2));
95@@ -258,11 +257,13 @@ d_char *xs_httpd_request(FILE *f, d_char **payload, int *p_size)
96 }
97
98
99-void xs_httpd_response(FILE *f, int status, d_char *headers, char *body, int b_size)
100+void xs_httpd_response(FILE *f, int status, xs_dict *headers, xs_str *body, int b_size)
101 /* sends an httpd response */
102 {
103 xs *proto;
104- char *p, *k, *v;
105+ xs_dict *p;
106+ xs_str *k;
107+ xs_val *v;
108
109 proto = xs_fmt("HTTP/1.1 %d ", status);
110 fprintf(f, "%s\r\n", proto);
M
xs_io.h
+8,
-8
1@@ -4,17 +4,17 @@
2
3 #define _XS_IO_H
4
5-d_char *xs_readline(FILE *f);
6-d_char *xs_read(FILE *f, int *size);
7-d_char *xs_readall(FILE *f);
8+xs_str *xs_readline(FILE *f);
9+xs_val *xs_read(FILE *f, int *size);
10+xs_val *xs_readall(FILE *f);
11
12
13 #ifdef XS_IMPLEMENTATION
14
15-d_char *xs_readline(FILE *f)
16+xs_str *xs_readline(FILE *f)
17 /* reads a line from a file */
18 {
19- d_char *s = NULL;
20+ xs_str *s = NULL;
21
22 errno = 0;
23
24@@ -38,10 +38,10 @@ d_char *xs_readline(FILE *f)
25 }
26
27
28-d_char *xs_read(FILE *f, int *sz)
29+xs_val *xs_read(FILE *f, int *sz)
30 /* reads up to size bytes from f */
31 {
32- d_char *s = NULL;
33+ xs_val *s = NULL;
34 int size = *sz;
35 int rdsz = 0;
36
37@@ -76,7 +76,7 @@ d_char *xs_read(FILE *f, int *sz)
38 }
39
40
41-d_char *xs_readall(FILE *f)
42+xs_val *xs_readall(FILE *f)
43 /* reads the rest of the file into a string */
44 {
45 int size = XS_ALL;
+6,
-6
1@@ -4,9 +4,9 @@
2
3 #define _XS_JSON_H
4
5-d_char *xs_json_dumps_pp(char *data, int indent);
6+xs_str *xs_json_dumps_pp(xs_val *data, int indent);
7 #define xs_json_dumps(data) xs_json_dumps_pp(data, 0)
8-d_char *xs_json_loads(const char *json);
9+xs_val *xs_json_loads(const xs_str *json);
10
11
12 #ifdef XS_IMPLEMENTATION
13@@ -148,11 +148,11 @@ d_char *_xs_json_dumps(d_char *s, char *data, int level, int indent)
14 }
15
16
17-d_char *xs_json_dumps_pp(char *data, int indent)
18+xs_str *xs_json_dumps_pp(xs_val *data, int indent)
19 /* dumps a piece of data as JSON */
20 {
21 xstype t = xs_type(data);
22- d_char *s = NULL;
23+ xs_str *s = NULL;
24
25 if (t == XSTYPE_LIST || t == XSTYPE_DICT) {
26 s = xs_str_new(NULL);
27@@ -481,10 +481,10 @@ d_char *_xs_json_loads_object(const char **json, js_type *t)
28 }
29
30
31-d_char *xs_json_loads(const char *json)
32+xs_val *xs_json_loads(const xs_str *json)
33 /* loads a string in JSON format and converts to a multiple data */
34 {
35- d_char *v = NULL;
36+ xs_val *v = NULL;
37 js_type t;
38
39 xs_free(_xs_json_loads_lexer(&json, &t));
+17,
-17
1@@ -4,14 +4,14 @@
2
3 #define _XS_OPENSSL_H
4
5-d_char *xs_md5_hex(const void *input, int size);
6-d_char *xs_sha1_hex(const void *input, int size);
7-d_char *xs_sha256_hex(const void *input, int size);
8-d_char *xs_sha256_base64(const void *input, int size);
9-d_char *xs_rsa_genkey(int bits);
10-d_char *xs_rsa_sign(const char *secret, const char *mem, int size);
11+xs_str *xs_md5_hex(const xs_val *input, int size);
12+xs_str *xs_sha1_hex(const xs_val *input, int size);
13+xs_str *xs_sha256_hex(const xs_val *input, int size);
14+xs_str *xs_sha256_base64(const xs_val *input, int size);
15+xs_dict *xs_rsa_genkey(int bits);
16+xs_str *xs_rsa_sign(const char *secret, const char *mem, int size);
17 int xs_rsa_verify(const char *pubkey, const char *mem, int size, const char *b64sig);
18-d_char *xs_evp_sign(const char *secret, const char *mem, int size);
19+xs_str *xs_evp_sign(const char *secret, const char *mem, int size);
20 int xs_evp_verify(const char *pubkey, const char *mem, int size, const char *b64sig);
21
22
23@@ -23,7 +23,7 @@ int xs_evp_verify(const char *pubkey, const char *mem, int size, const char *b64
24 #include "openssl/pem.h"
25 #include "openssl/evp.h"
26
27-d_char *xs_md5_hex(const void *input, int size)
28+xs_str *xs_md5_hex(const xs_val *input, int size)
29 {
30 unsigned char md5[16];
31 MD5_CTX ctx;
32@@ -36,7 +36,7 @@ d_char *xs_md5_hex(const void *input, int size)
33 }
34
35
36-d_char *xs_sha1_hex(const void *input, int size)
37+xs_str *xs_sha1_hex(const xs_val *input, int size)
38 {
39 unsigned char sha1[20];
40 SHA_CTX ctx;
41@@ -61,7 +61,7 @@ unsigned char *_xs_sha256(const void *input, int size, unsigned char *sha256)
42 }
43
44
45-d_char *xs_sha256_hex(const void *input, int size)
46+xs_str *xs_sha256_hex(const xs_val *input, int size)
47 {
48 unsigned char sha256[32];
49
50@@ -71,7 +71,7 @@ d_char *xs_sha256_hex(const void *input, int size)
51 }
52
53
54-d_char *xs_sha256_base64(const void *input, int size)
55+xs_str *xs_sha256_base64(const xs_val *input, int size)
56 {
57 unsigned char sha256[32];
58
59@@ -81,12 +81,12 @@ d_char *xs_sha256_base64(const void *input, int size)
60 }
61
62
63-d_char *xs_rsa_genkey(int bits)
64+xs_dict *xs_rsa_genkey(int bits)
65 /* generates an RSA keypair */
66 {
67 BIGNUM *bne;
68 RSA *rsa;
69- d_char *keypair = NULL;
70+ xs_dict *keypair = NULL;
71
72 if ((bne = BN_new()) != NULL) {
73 if (BN_set_word(bne, RSA_F4) == 1) {
74@@ -119,10 +119,10 @@ d_char *xs_rsa_genkey(int bits)
75 }
76
77
78-d_char *xs_rsa_sign(const char *secret, const char *mem, int size)
79+xs_str *xs_rsa_sign(const char *secret, const char *mem, int size)
80 /* signs a memory block (secret is in PEM format) */
81 {
82- d_char *signature = NULL;
83+ xs_str *signature = NULL;
84 BIO *b;
85 RSA *rsa;
86 unsigned char *sig;
87@@ -176,10 +176,10 @@ int xs_rsa_verify(const char *pubkey, const char *mem, int size, const char *b64
88 }
89
90
91-d_char *xs_evp_sign(const char *secret, const char *mem, int size)
92+xs_str *xs_evp_sign(const char *secret, const char *mem, int size)
93 /* signs a memory block (secret is in PEM format) */
94 {
95- d_char *signature = NULL;
96+ xs_str *signature = NULL;
97 BIO *b;
98 unsigned char *sig;
99 unsigned int sig_len;
+10,
-9
1@@ -4,22 +4,22 @@
2
3 #define _XS_REGEX_H
4
5-d_char *xs_regex_split_n(const char *str, const char *rx, int count);
6+xs_list *xs_regex_split_n(const char *str, const char *rx, int count);
7 #define xs_regex_split(str, rx) xs_regex_split_n(str, rx, XS_ALL)
8-d_char *xs_regex_match_n(const char *str, const char *rx, int count);
9+xs_list *xs_regex_match_n(const char *str, const char *rx, int count);
10 #define xs_regex_match(str, rx) xs_regex_match_n(str, rx, XS_ALL)
11
12 #ifdef XS_IMPLEMENTATION
13
14 #include <regex.h>
15
16-d_char *xs_regex_split_n(const char *str, const char *rx, int count)
17+xs_list *xs_regex_split_n(const char *str, const char *rx, int count)
18 /* splits str by regex */
19 {
20 regex_t re;
21 regmatch_t rm;
22 int offset = 0;
23- d_char *list = NULL;
24+ xs_list *list = NULL;
25 const char *p;
26
27 if (regcomp(&re, rx, REG_EXTENDED))
28@@ -30,11 +30,11 @@ d_char *xs_regex_split_n(const char *str, const char *rx, int count)
29 while (count > 0 && !regexec(&re, (p = str + offset), 1, &rm, offset > 0 ? REG_NOTBOL : 0)) {
30 /* add first the leading part of the string */
31 list = xs_list_append_m(list, p, rm.rm_so);
32- list = xs_str_cat(list, "");
33+ list = xs_insert_m(list, xs_size(list) - 1, "", 1);
34
35 /* add now the matched text as the separator */
36 list = xs_list_append_m(list, p + rm.rm_so, rm.rm_eo - rm.rm_so);
37- list = xs_str_cat(list, "");
38+ list = xs_insert_m(list, xs_size(list) - 1, "", 1);
39
40 /* move forward */
41 offset += rm.rm_eo;
42@@ -51,12 +51,13 @@ d_char *xs_regex_split_n(const char *str, const char *rx, int count)
43 }
44
45
46-d_char *xs_regex_match_n(const char *str, const char *rx, int count)
47+xs_list *xs_regex_match_n(const char *str, const char *rx, int count)
48 /* returns a list with upto count matches */
49 {
50- d_char *list = xs_list_new();
51+ xs_list *list = xs_list_new();
52 xs *split = NULL;
53- char *p, *v;
54+ xs_list *p;
55+ xs_val *v;
56 int n = 0;
57
58 /* split */
M
xs_set.h
+6,
-6
1@@ -8,13 +8,13 @@ typedef struct _xs_set {
2 int elems; /* number of hash entries */
3 int used; /* number of used hash entries */
4 int *hash; /* hashed offsets */
5- d_char *list; /* list of stored data */
6+ xs_list *list; /* list of stored data */
7 } xs_set;
8
9 void xs_set_init(xs_set *s);
10-d_char *xs_set_result(xs_set *s);
11+xs_list *xs_set_result(xs_set *s);
12 void xs_set_free(xs_set *s);
13-int xs_set_add(xs_set *s, const char *data);
14+int xs_set_add(xs_set *s, const xs_val *data);
15
16
17 #ifdef XS_IMPLEMENTATION
18@@ -33,10 +33,10 @@ void xs_set_init(xs_set *s)
19 }
20
21
22-d_char *xs_set_result(xs_set *s)
23+xs_list *xs_set_result(xs_set *s)
24 /* returns the set as a list and frees it */
25 {
26- d_char *list = s->list;
27+ xs_list *list = s->list;
28 s->list = NULL;
29 s->hash = xs_free(s->hash);
30
31@@ -93,7 +93,7 @@ static int _store_hash(xs_set *s, const char *data, int value)
32 }
33
34
35-int xs_set_add(xs_set *s, const char *data)
36+int xs_set_add(xs_set *s, const xs_val *data)
37 /* adds the data to the set */
38 /* returns: 1 if added, 0 if already there */
39 {
+3,
-3
1@@ -6,7 +6,7 @@
2
3 #include <time.h>
4
5-d_char *xs_str_time(time_t t, const char *fmt, int local);
6+xs_str *xs_str_time(time_t t, const char *fmt, int local);
7 #define xs_str_localtime(t, fmt) xs_str_time(t, fmt, 1)
8 #define xs_str_utctime(t, fmt) xs_str_time(t, fmt, 0)
9 time_t xs_parse_time(const char *str, const char *fmt, int local);
10@@ -15,8 +15,8 @@ time_t xs_parse_time(const char *str, const char *fmt, int local);
11
12 #ifdef XS_IMPLEMENTATION
13
14-d_char *xs_str_time(time_t t, const char *fmt, int local)
15-/* returns a d_char with a formated time */
16+xs_str *xs_str_time(time_t t, const char *fmt, int local)
17+/* returns a string with a formated time */
18 {
19 struct tm tm;
20 char tmp[64];
+1,
-1
1@@ -1 +1 @@
2-/* f64030f1449390169bd09bdcbb052b1a70f8002a */
3+/* 86f70ffc75a8c9601adde42146af65c14d41518a */