2.84
xs.h
1/* copyright (c) 2022 - 2025 grunfink et al. / MIT license */
2
3#ifndef _XS_H
4
5#define _XS_H
6
7#include <stdio.h>
8#include <string.h>
9#include <stdlib.h>
10#include <ctype.h>
11#include <unistd.h>
12#include <stdarg.h>
13#include <signal.h>
14#include <errno.h>
15#include <stdint.h>
16
17typedef enum {
18 XSTYPE_STRING = 0x02, /* C string (\0 delimited) (NOT STORED) */
19 XSTYPE_NUMBER = 0x17, /* double in spirit, stored as a C string (\0 delimited) */
20 XSTYPE_NULL = 0x18, /* Special NULL value */
21 XSTYPE_TRUE = 0x06, /* Boolean */
22 XSTYPE_FALSE = 0x15, /* Boolean */
23 XSTYPE_LIST = 0x1d, /* Sequence of LITEMs up to EOM (with size) */
24 XSTYPE_LITEM = 0x1f, /* Element of a list (any type) */
25 XSTYPE_DICT = 0x1c, /* Sequence of KEYVALs up to EOM (with size) */
26 XSTYPE_KEYVAL = 0x1e, /* key + value (STRING key + any type) */
27 XSTYPE_DATA = 0x10 /* A block of anonymous data */
28} xstype;
29
30
31/* types */
32typedef char xs_val;
33typedef char xs_str;
34typedef char xs_list;
35typedef char xs_keyval;
36typedef char xs_dict;
37typedef char xs_number;
38typedef char xs_data;
39
40/* size in bytes of the type size */
41#define _XS_TYPE_SIZE 4
42
43/* auto-destroyable strings */
44#define xs __attribute__ ((__cleanup__ (_xs_destroy))) xs_val
45
46/* not really all, just very much */
47#define XS_ALL 0xfffffff
48
49#ifndef xs_countof
50#define xs_countof(a) (sizeof((a)) / sizeof((*a)))
51#endif
52
53void *xs_free(void *ptr);
54void *_xs_realloc(void *ptr, size_t size, const char *file, int line, const char *func);
55#define xs_realloc(ptr, size) _xs_realloc(ptr, size, __FILE__, __LINE__, __func__)
56int _xs_blk_size(int sz);
57void _xs_destroy(char **var);
58#define xs_debug() raise(SIGTRAP)
59xstype xs_type(const xs_val *data);
60int xs_size(const xs_val *data);
61int xs_is_null(const xs_val *data);
62int xs_cmp(const xs_val *v1, const xs_val *v2);
63const xs_val *xs_or(const xs_val *v1, const xs_val *v2);
64xs_val *xs_dup(const xs_val *data);
65xs_val *xs_expand(xs_val *data, int offset, int size);
66xs_val *xs_collapse(xs_val *data, int offset, int size);
67xs_val *xs_insert_m(xs_val *data, int offset, const char *mem, int size);
68#define xs_insert(data, offset, data2) xs_insert_m(data, offset, data2, xs_size(data2))
69#define xs_append_m(data, mem, size) xs_insert_m(data, xs_size(data) - 1, mem, size)
70xs_val *xs_stock(int type);
71
72xs_str *xs_str_new(const char *str);
73xs_str *xs_str_new_sz(const char *mem, int sz);
74xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix);
75#define xs_str_prepend_i(str, prefix) xs_str_wrap_i(prefix, str, NULL)
76xs_str *_xs_str_cat(xs_str *str, const char *strs[]);
77#define xs_str_cat(str, ...) _xs_str_cat(str, (const char *[]){ __VA_ARGS__, NULL })
78xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times);
79#define xs_replace_i(str, sfrom, sto) xs_replace_in(str, sfrom, sto, XS_ALL)
80#define xs_replace(str, sfrom, sto) xs_replace_in(xs_dup(str), sfrom, sto, XS_ALL)
81#define xs_replace_n(str, sfrom, sto, times) xs_replace_in(xs_dup(str), sfrom, sto, times)
82xs_str *xs_fmt(const char *fmt, ...);
83int xs_str_in(const char *haystack, const char *needle);
84int xs_between(const char *prefix, const char *str, const char *suffix);
85#define xs_startswith(str, prefix) xs_between(prefix, str, NULL)
86#define xs_endswith(str, suffix) xs_between(NULL, str, suffix)
87xs_str *xs_crop_i(xs_str *str, int start, int end);
88xs_str *xs_lstrip_chars_i(xs_str *str, const char *chars);
89xs_str *xs_rstrip_chars_i(xs_str *str, const char *chars);
90xs_str *xs_strip_chars_i(xs_str *str, const char *chars);
91#define xs_strip_i(str) xs_strip_chars_i(str, " \r\n\t\v\f")
92xs_str *xs_tolower_i(xs_str *str);
93xs_str *xs_toupper_i(xs_str *str);
94
95xs_list *xs_list_new(void);
96xs_list *xs_list_append_m(xs_list *list, const char *mem, int dsz);
97xs_list *_xs_list_append(xs_list *list, const xs_val *vals[]);
98#define xs_list_append(list, ...) _xs_list_append(list, (const xs_val *[]){ __VA_ARGS__, NULL })
99int xs_list_iter(xs_list **list, const xs_val **value);
100int xs_list_next(const xs_list *list, const xs_val **value, int *ctxt);
101int xs_list_len(const xs_list *list);
102const xs_val *xs_list_get(const xs_list *list, int num);
103xs_list *xs_list_del(xs_list *list, int num);
104xs_list *xs_list_insert(xs_list *list, int num, const xs_val *data);
105xs_list *xs_list_set(xs_list *list, int num, const xs_val *data);
106xs_list *xs_list_dequeue(xs_list *list, xs_val **data, int last);
107#define xs_list_pop(list, data) xs_list_dequeue(list, data, 1)
108#define xs_list_shift(list, data) xs_list_dequeue(list, data, 0)
109int xs_list_in(const xs_list *list, const xs_val *val);
110xs_str *xs_join(const xs_list *list, const char *sep);
111xs_list *xs_split_n(const char *str, const char *sep, int times);
112#define xs_split(str, sep) xs_split_n(str, sep, XS_ALL)
113xs_list *xs_list_cat(xs_list *l1, const xs_list *l2);
114
115int xs_keyval_size(const xs_str *key, const xs_val *value);
116xs_str *xs_keyval_key(const xs_keyval *keyval);
117xs_val *xs_keyval_value(const xs_keyval *keyval);
118xs_keyval *xs_keyval_make(xs_keyval *keyval, const xs_str *key, const xs_val *value);
119
120xs_dict *xs_dict_new(void);
121xs_dict *xs_dict_append(xs_dict *dict, const xs_str *key, const xs_val *value);
122xs_dict *xs_dict_prepend(xs_dict *dict, const xs_str *key, const xs_val *value);
123int xs_dict_next(const xs_dict *dict, const xs_str **key, const xs_val **value, int *ctxt);
124const xs_val *xs_dict_get(const xs_dict *dict, const xs_str *key);
125#define xs_dict_get_def(dict, key, def) xs_or(xs_dict_get(dict, key), def)
126xs_dict *xs_dict_del(xs_dict *dict, const xs_str *key);
127xs_dict *xs_dict_set(xs_dict *dict, const xs_str *key, const xs_val *data);
128xs_dict *xs_dict_gc(const xs_dict *dict);
129
130const xs_val *xs_dict_get_path_sep(const xs_dict *dict, const char *path, const char *sep);
131#define xs_dict_get_path(dict, path) xs_dict_get_path_sep(dict, path, ".")
132xs_dict *xs_dict_set_path_sep(xs_dict *dict, const char *path, const xs_val *value, const char *sep);
133#define xs_dict_set_path(dict, path, value) xs_dict_set_path_sep(dict, path, value, ".")
134
135xs_val *xs_val_new(xstype t);
136xs_number *xs_number_new(double f);
137xs_number *xs_number_new_l(long l);
138double xs_number_get(const xs_number *v);
139long xs_number_get_l(const xs_number *v);
140const char *xs_number_str(const xs_number *v);
141
142xs_data *xs_data_new(const void *data, int size);
143int xs_data_size(const xs_data *value);
144void xs_data_get(void *data, const xs_data *value);
145
146void *xs_memmem(const char *haystack, int h_size, const char *needle, int n_size);
147
148unsigned int xs_hash_func(const char *data, int size);
149uint64_t xs_hash64_func(const char *data, int size);
150
151#ifdef XS_ASSERT
152#include <assert.h>
153#define XS_ASSERT_TYPE(v, t) assert(xs_type(v) == t)
154#define XS_ASSERT_TYPE_NULL(v, t) assert(v == NULL || xs_type(v) == t)
155#else
156#define XS_ASSERT_TYPE(v, t) (void)(0)
157#define XS_ASSERT_TYPE_NULL(v, t) (void)(0)
158#endif
159
160#define xs_return(v) xs_val *__r = v; v = NULL; return __r
161
162#define xs_is_true(v) (xs_type((v)) == XSTYPE_TRUE)
163#define xs_is_false(v) (xs_type((v)) == XSTYPE_FALSE)
164#define xs_not(v) xs_stock(xs_is_true((v)) ? XSTYPE_FALSE : XSTYPE_TRUE)
165#define xs_is_string(v) (xs_type((v)) == XSTYPE_STRING)
166#define xs_is_list(v) (xs_type((v)) == XSTYPE_LIST)
167#define xs_is_dict(v) (xs_type((v)) == XSTYPE_DICT)
168#define xs_is_number(v) (xs_type((v)) == XSTYPE_NUMBER)
169
170#define xs_list_foreach(l, v) for (int ct_##__LINE__ = 0; xs_list_next(l, &v, &ct_##__LINE__); )
171#define xs_dict_foreach(l, k, v) for (int ct_##__LINE__ = 0; xs_dict_next(l, &k, &v, &ct_##__LINE__); )
172
173
174#ifdef XS_IMPLEMENTATION
175
176void *_xs_realloc(void *ptr, size_t size, const char *file, int line, const char *func)
177{
178 xs_val *ndata = realloc(ptr, size);
179
180 if (ndata == NULL) {
181 fprintf(stderr, "ERROR: out of memory at %s:%d: %s()\n", file, line, func);
182 abort();
183 }
184
185#ifdef XS_DEBUG
186 if (ndata != ptr) {
187 int n;
188 FILE *f = fopen("xs_memory.out", "a");
189
190 if (ptr != NULL)
191 fprintf(f, "%p r\n", ptr);
192
193 fprintf(f, "%p a %ld %s:%d: %s", ndata, size, file, line, func);
194
195 if (ptr != NULL) {
196 fprintf(f, " [");
197 for (n = 0; n < 32 && ndata[n]; n++) {
198 if (ndata[n] >= 32 && ndata[n] <= 127)
199 fprintf(f, "%c", ndata[n]);
200 else
201 fprintf(f, "\\%02x", (unsigned char)ndata[n]);
202 }
203 fprintf(f, "]");
204 }
205
206 fprintf(f, "\n");
207
208 fclose(f);
209 }
210#else
211 (void)file;
212 (void)line;
213 (void)func;
214#endif
215
216 return ndata;
217}
218
219
220void *xs_free(void *ptr)
221{
222#ifdef XS_DEBUG
223 if (ptr != NULL) {
224 FILE *f = fopen("xs_memory.out", "a");
225 fprintf(f, "%p b\n", ptr);
226 fclose(f);
227 }
228#endif
229
230 free(ptr);
231 return NULL;
232}
233
234
235void _xs_destroy(char **var)
236{
237/*
238 if (_xs_debug)
239 printf("_xs_destroy %p\n", var);
240*/
241 xs_free(*var);
242}
243
244
245int _xs_blk_size(int sz)
246/* calculates the block size */
247{
248 int blk_size = 4096;
249
250 if (sz < 256)
251 blk_size = 32;
252 else
253 if (sz < 4096)
254 blk_size = 256;
255
256 return ((((sz) + blk_size) / blk_size) * blk_size);
257}
258
259
260xstype xs_type(const xs_val *data)
261/* return the type of data */
262{
263 xstype t;
264
265 if (data == NULL)
266 t = XSTYPE_NULL;
267 else
268 switch (data[0]) {
269 case XSTYPE_NULL:
270 case XSTYPE_TRUE:
271 case XSTYPE_FALSE:
272 case XSTYPE_LIST:
273 case XSTYPE_LITEM:
274 case XSTYPE_DICT:
275 case XSTYPE_KEYVAL:
276 case XSTYPE_NUMBER:
277 case XSTYPE_DATA:
278 t = data[0];
279 break;
280 default:
281 t = XSTYPE_STRING;
282 break;
283 }
284
285 return t;
286}
287
288
289void _xs_put_size(xs_val *ptr, int i)
290/* must match _XS_TYPE_SIZE */
291{
292 memcpy(ptr + 1, &i, sizeof(i));
293}
294
295
296int _xs_get_size(const xs_val *ptr)
297/* must match _XS_TYPE_SIZE */
298{
299 int i;
300 memcpy(&i, ptr + 1, sizeof(i));
301 return i;
302}
303
304
305int xs_size(const xs_val *data)
306/* returns the size of data in bytes */
307{
308 int len = 0;
309 const char *p;
310
311 if (data == NULL)
312 return 0;
313
314 switch (xs_type(data)) {
315 case XSTYPE_STRING:
316 len = strlen(data) + 1;
317 break;
318
319 case XSTYPE_LIST:
320 case XSTYPE_DICT:
321 case XSTYPE_DATA:
322 len = _xs_get_size(data);
323
324 break;
325
326 case XSTYPE_KEYVAL:
327 /* calculate the size of the key and the value */
328 p = data + 1;
329 p += xs_size(p);
330 p += xs_size(p);
331
332 len = p - data;
333
334 break;
335
336 case XSTYPE_LITEM:
337 /* it's the size of the item + 1 */
338 p = data + 1;
339 p += xs_size(p);
340
341 len = p - data;
342
343 break;
344
345 case XSTYPE_NUMBER:
346 len = 1 + xs_size(data + 1);
347
348 break;
349
350 default:
351 len = 1;
352 }
353
354 return len;
355}
356
357
358int xs_is_null(const xs_val *data)
359/* checks for null */
360{
361 return (xs_type(data) == XSTYPE_NULL);
362}
363
364
365int xs_cmp(const xs_val *v1, const xs_val *v2)
366/* compares two values */
367{
368 xstype t1 = xs_type(v1);
369 xstype t2 = xs_type(v2);
370
371 if (t1 == XSTYPE_NULL || t2 == XSTYPE_NULL)
372 return 0;
373
374 if (t1 == XSTYPE_STRING && t2 == XSTYPE_STRING)
375 return strcmp(v1, v2);
376
377 if (t1 == XSTYPE_NUMBER && t2 == XSTYPE_NUMBER) {
378 double d1 = xs_number_get(v1);
379 double d2 = xs_number_get(v2);
380
381 return d1 == d2 ? 0 : d1 < d2 ? -1 : 1;
382 }
383
384 int s1 = xs_size(v1);
385 int s2 = xs_size(v2);
386 int d = s1 - s2;
387
388 return d == 0 ? memcmp(v1, v2, s1) : d;
389}
390
391
392const xs_val *xs_or(const xs_val *v1, const xs_val *v2)
393/* returns v1 if it's not NULL, else v2 */
394{
395 return v1 == NULL ? v2 : v1;
396}
397
398
399xs_val *xs_dup(const xs_val *data)
400/* creates a duplicate of data */
401{
402 xs_val *s = NULL;
403
404 if (data) {
405 int sz = xs_size(data);
406 s = xs_realloc(NULL, _xs_blk_size(sz));
407
408 memcpy(s, data, sz);
409 }
410
411 return s;
412}
413
414
415xs_val *xs_expand(xs_val *data, int offset, int size)
416/* opens a hole in data */
417{
418 xstype type = xs_type(data);
419 int sz = xs_size(data);
420 int n;
421
422 sz += size;
423
424 /* open room */
425 data = xs_realloc(data, _xs_blk_size(sz));
426
427 /* move up the rest of the data */
428 for (n = sz - 1; n >= offset + size; n--)
429 data[n] = data[n - size];
430
431 if (type == XSTYPE_LIST ||
432 type == XSTYPE_DICT ||
433 type == XSTYPE_DATA)
434 _xs_put_size(data, sz);
435
436 return data;
437}
438
439
440xs_val *xs_collapse(xs_val *data, int offset, int size)
441/* shrinks data */
442{
443 int sz = xs_size(data);
444 int n;
445
446 /* don't try to delete beyond the limit */
447 if (offset + size > sz)
448 size = sz - offset;
449
450 /* shrink total size */
451 sz -= size;
452
453 for (n = offset; n < sz; n++)
454 data[n] = data[n + size];
455
456 if (xs_type(data) == XSTYPE_LIST ||
457 xs_type(data) == XSTYPE_DICT ||
458 xs_type(data) == XSTYPE_DATA)
459 _xs_put_size(data, sz);
460
461 return xs_realloc(data, _xs_blk_size(sz));
462}
463
464
465xs_val *xs_insert_m(xs_val *data, int offset, const char *mem, int size)
466/* inserts a memory block */
467{
468 data = xs_expand(data, offset, size);
469 memcpy(data + offset, mem, size);
470
471 return data;
472}
473
474
475xs_val *xs_stock(int type)
476/* returns stock values */
477{
478 static xs_val stock_null[] = { XSTYPE_NULL };
479 static xs_val stock_true[] = { XSTYPE_TRUE };
480 static xs_val stock_false[] = { XSTYPE_FALSE };
481 static xs_val stock_0[] = { XSTYPE_NUMBER, '0', '\0' };
482 static xs_val stock_1[] = { XSTYPE_NUMBER, '1', '\0' };
483 static xs_list *stock_list = NULL;
484 static xs_dict *stock_dict = NULL;
485
486 switch (type) {
487 case 0: return stock_0;
488 case 1: return stock_1;
489 case XSTYPE_NULL: return stock_null;
490 case XSTYPE_TRUE: return stock_true;
491 case XSTYPE_FALSE: return stock_false;
492
493 case XSTYPE_LIST:
494 if (stock_list == NULL)
495 stock_list = xs_list_new();
496 return stock_list;
497
498 case XSTYPE_DICT:
499 if (stock_dict == NULL)
500 stock_dict = xs_dict_new();
501 return stock_dict;
502 }
503
504 return NULL;
505}
506
507
508/** strings **/
509
510xs_str *xs_str_new(const char *str)
511/* creates a new string */
512{
513 return xs_insert(NULL, 0, str ? str : "");
514}
515
516
517xs_str *xs_str_new_sz(const char *mem, int sz)
518/* creates a new string from a memory block, adding an asciiz */
519{
520 xs_str *s = xs_realloc(NULL, _xs_blk_size(sz + 1));
521 memcpy(s, mem, sz);
522 s[sz] = '\0';
523
524 return s;
525}
526
527
528xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix)
529/* wraps str with prefix and suffix */
530{
531 XS_ASSERT_TYPE(str, XSTYPE_STRING);
532
533 if (prefix)
534 str = xs_insert_m(str, 0, prefix, strlen(prefix));
535
536 if (suffix)
537 str = xs_insert_m(str, strlen(str), suffix, strlen(suffix));
538
539 return str;
540}
541
542
543xs_str *_xs_str_cat(xs_str *str, const char *strs[])
544/* concatenates all strings after str */
545{
546 int o = strlen(str);
547
548 while (*strs) {
549 int sz = strlen(*strs);
550 str = xs_insert_m(str, o, *strs, sz);
551 o += sz;
552 strs++;
553 }
554
555 return str;
556}
557
558
559xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times)
560/* replaces inline all sfrom with sto */
561{
562 XS_ASSERT_TYPE(str, XSTYPE_STRING);
563
564 int sfsz = strlen(sfrom);
565 int stsz = strlen(sto);
566 int diff = stsz - sfsz;
567 char *ss;
568 int offset = 0;
569
570 while (times > 0 && (ss = strstr(str + offset, sfrom)) != NULL) {
571 int n_offset = ss - str;
572
573 if (diff < 0)
574 str = xs_collapse(str, n_offset, -diff);
575 else
576 if (diff > 0)
577 str = xs_expand(str, n_offset, diff);
578
579 memcpy(str + n_offset, sto, stsz);
580
581 offset = n_offset + stsz;
582
583 times--;
584 }
585
586 return str;
587}
588
589
590xs_str *xs_fmt(const char *fmt, ...)
591/* formats a string with printf()-like marks */
592{
593 int n;
594 xs_str *s = NULL;
595 va_list ap;
596
597 va_start(ap, fmt);
598 n = vsnprintf(s, 0, fmt, ap);
599 va_end(ap);
600
601 if (n > 0) {
602 s = xs_realloc(NULL, _xs_blk_size(n + 1));
603
604 va_start(ap, fmt);
605 vsnprintf(s, n + 1, fmt, ap);
606 va_end(ap);
607 }
608
609 return s;
610}
611
612
613int xs_str_in(const char *haystack, const char *needle)
614/* finds needle in haystack and returns the offset or -1 */
615{
616 char *s;
617 int r = -1;
618
619 if ((s = strstr(haystack, needle)) != NULL)
620 r = s - haystack;
621
622 return r;
623}
624
625
626int xs_between(const char *prefix, const char *str, const char *suffix)
627/* returns true if str starts with prefix and ends with suffix */
628{
629 int sz = strlen(str);
630 int psz = prefix ? strlen(prefix) : 0;
631 int ssz = suffix ? strlen(suffix) : 0;
632
633 if (sz < psz || sz < ssz)
634 return 0;
635
636 if (prefix && memcmp(str, prefix, psz) != 0)
637 return 0;
638
639 if (suffix && memcmp(str + sz - ssz, suffix, ssz) != 0)
640 return 0;
641
642 return 1;
643}
644
645
646xs_str *xs_crop_i(xs_str *str, int start, int end)
647/* crops the string to be only from start to end */
648{
649 int sz = strlen(str);
650
651 if (end <= 0)
652 end = sz + end;
653
654 /* crop from the top */
655 if (end >= 0 && end < sz)
656 str[end] = '\0';
657
658 /* crop from the bottom */
659 str = xs_collapse(str, 0, start);
660
661 return str;
662}
663
664
665xs_str *xs_lstrip_chars_i(xs_str *str, const char *chars)
666/* strips all chars from the start of str */
667{
668 int n;
669
670 for (n = 0; str[n] && strchr(chars, str[n]); n++);
671
672 if (n)
673 str = xs_collapse(str, 0, n);
674
675 return str;
676}
677
678
679xs_str *xs_rstrip_chars_i(xs_str *str, const char *chars)
680/* strips all chars from the end of str */
681{
682 int n;
683
684 for (n = strlen(str); n > 0 && strchr(chars, str[n - 1]); n--);
685 str[n] = '\0';
686
687 return str;
688}
689
690
691xs_str *xs_strip_chars_i(xs_str *str, const char *chars)
692/* strips the string of chars from the start and the end */
693{
694 return xs_lstrip_chars_i(xs_rstrip_chars_i(str, chars), chars);
695}
696
697
698xs_str *xs_tolower_i(xs_str *str)
699/* convert to lowercase */
700{
701 XS_ASSERT_TYPE(str, XSTYPE_STRING);
702
703 int n;
704
705 for (n = 0; str[n]; n++)
706 str[n] = tolower(str[n]);
707
708 return str;
709}
710
711
712xs_str *xs_toupper_i(xs_str *str)
713/* convert to lowercase */
714{
715 XS_ASSERT_TYPE(str, XSTYPE_STRING);
716
717 int n;
718
719 for (n = 0; str[n]; n++)
720 str[n] = toupper(str[n]);
721
722 return str;
723}
724
725
726/** lists **/
727
728xs_list *xs_list_new(void)
729/* creates a new list */
730{
731 int sz = 1 + _XS_TYPE_SIZE + 1;
732 xs_list *l = xs_realloc(NULL, sz);
733 memset(l, '\0', sz);
734
735 l[0] = XSTYPE_LIST;
736 _xs_put_size(l, sz);
737
738 return l;
739}
740
741
742xs_list *_xs_list_write_litem(xs_list *list, int offset, const char *mem, int dsz)
743/* writes a list item */
744{
745 XS_ASSERT_TYPE(list, XSTYPE_LIST);
746
747 if (mem == NULL) {
748 mem = xs_stock(XSTYPE_NULL);
749 dsz = xs_size(mem);
750 }
751
752 list = xs_expand(list, offset, dsz + 1);
753
754 list[offset] = XSTYPE_LITEM;
755 memcpy(list + offset + 1, mem, dsz);
756
757 return list;
758}
759
760
761xs_list *xs_list_append_m(xs_list *list, const char *mem, int dsz)
762/* adds a memory block to the list */
763{
764 XS_ASSERT_TYPE(list, XSTYPE_LIST);
765
766 return _xs_list_write_litem(list, xs_size(list) - 1, mem, dsz);
767}
768
769
770xs_list *_xs_list_append(xs_list *list, const xs_val *vals[])
771/* adds several values to the list */
772{
773 /* special case: if the first argument is NULL, just insert it */
774 if (*vals == NULL)
775 return xs_list_append_m(list, NULL, 0);
776
777 while (*vals) {
778 list = xs_list_append_m(list, *vals, xs_size(*vals));
779 vals++;
780 }
781
782 return list;
783}
784
785
786int xs_list_iter(xs_list **list, const xs_val **value)
787/* iterates a list value */
788{
789 int goon = 1;
790
791 xs_val *p = *list;
792
793 /* skip the start of the list */
794 if (xs_type(p) == XSTYPE_LIST)
795 p += 1 + _XS_TYPE_SIZE;
796
797 /* an element? */
798 if (xs_type(p) == XSTYPE_LITEM) {
799 p++;
800
801 *value = p;
802
803 p += xs_size(*value);
804 }
805 else {
806 /* end of list */
807 goon = 0;
808 }
809
810 /* store back the pointer */
811 *list = p;
812
813 return goon;
814}
815
816
817int xs_list_next(const xs_list *list, const xs_val **value, int *ctxt)
818/* iterates a list, with context */
819{
820 if (xs_type(list) != XSTYPE_LIST)
821 return 0;
822
823 int goon = 1;
824
825 const char *p = list;
826
827 /* skip the start of the list */
828 if (*ctxt == 0)
829 *ctxt = 1 + _XS_TYPE_SIZE;
830
831 p += *ctxt;
832
833 /* an element? */
834 if (xs_type(p) == XSTYPE_LITEM) {
835 p++;
836
837 *value = p;
838
839 p += xs_size(*value);
840 }
841 else {
842 /* end of list */
843 goon = 0;
844 }
845
846 /* update the context */
847 *ctxt = p - list;
848
849 return goon;
850}
851
852
853int xs_list_len(const xs_list *list)
854/* returns the number of elements in the list */
855{
856 XS_ASSERT_TYPE_NULL(list, XSTYPE_LIST);
857
858 int c = 0;
859 const xs_val *v;
860
861 xs_list_foreach(list, v)
862 c++;
863
864 return c;
865}
866
867
868const xs_val *xs_list_get(const xs_list *list, int num)
869/* returns the element #num */
870{
871 XS_ASSERT_TYPE(list, XSTYPE_LIST);
872
873 if (num < 0)
874 num = xs_list_len(list) + num;
875
876 int c = 0;
877 const xs_val *v;
878
879 xs_list_foreach(list, v) {
880 if (c == num)
881 return v;
882
883 c++;
884 }
885
886 return NULL;
887}
888
889
890xs_list *xs_list_del(xs_list *list, int num)
891/* deletes element #num */
892{
893 XS_ASSERT_TYPE(list, XSTYPE_LIST);
894
895 const xs_val *v;
896
897 if ((v = xs_list_get(list, num)) != NULL)
898 list = xs_collapse(list, v - 1 - list, xs_size(v - 1));
899
900 return list;
901}
902
903
904xs_list *xs_list_insert(xs_list *list, int num, const xs_val *data)
905/* inserts an element at #num position */
906{
907 XS_ASSERT_TYPE(list, XSTYPE_LIST);
908
909 const xs_val *v;
910 int offset;
911
912 if ((v = xs_list_get(list, num)) != NULL)
913 offset = v - list;
914 else
915 offset = xs_size(list);
916
917 return _xs_list_write_litem(list, offset - 1, data, xs_size(data));
918}
919
920
921xs_list *xs_list_set(xs_list *list, int num, const xs_val *data)
922/* sets the element at #num position */
923{
924 XS_ASSERT_TYPE(list, XSTYPE_LIST);
925
926 list = xs_list_del(list, num);
927 list = xs_list_insert(list, num, data);
928
929 return list;
930}
931
932
933xs_list *xs_list_dequeue(xs_list *list, xs_val **data, int last)
934/* gets a copy of the first or last element of a list, shrinking it */
935{
936 XS_ASSERT_TYPE(list, XSTYPE_LIST);
937
938 int ct = 0;
939 const xs_val *v = NULL;
940
941 if (!last) {
942 /* get the first */
943 xs_list_next(list, &v, &ct);
944 }
945 else {
946 /* iterate to the end */
947 while (xs_list_next(list, &v, &ct));
948 }
949
950 if (v != NULL) {
951 *data = xs_dup(v);
952
953 /* collapse from the address of the element */
954 list = xs_collapse(list, v - 1 - list, xs_size(v - 1));
955 }
956
957 return list;
958}
959
960
961int xs_list_in(const xs_list *list, const xs_val *val)
962/* returns the position of val in list or -1 */
963{
964 XS_ASSERT_TYPE_NULL(list, XSTYPE_LIST);
965
966 int n = 0;
967 const xs_val *v;
968 int sz = xs_size(val);
969
970 xs_list_foreach(list, v) {
971 if (sz == xs_size(v) && memcmp(val, v, sz) == 0)
972 return n;
973
974 n++;
975 }
976
977 return -1;
978}
979
980
981xs_str *xs_join(const xs_list *list, const char *sep)
982/* joins a list into a string */
983{
984 XS_ASSERT_TYPE(list, XSTYPE_LIST);
985
986 xs_str *s = NULL;
987 const xs_val *v;
988 int c = 0;
989 int offset = 0;
990 int ssz = strlen(sep);
991
992 xs_list_foreach(list, v) {
993 /* refuse to join non-string values */
994 if (xs_type(v) == XSTYPE_NUMBER)
995 v = xs_number_str(v);
996
997 if (xs_type(v) == XSTYPE_STRING) {
998 int sz;
999
1000 /* add the separator */
1001 if (c != 0 && ssz) {
1002 s = xs_realloc(s, offset + ssz);
1003 memcpy(s + offset, sep, ssz);
1004 offset += ssz;
1005 }
1006
1007 /* add the element */
1008 if ((sz = strlen(v)) > 0) {
1009 s = xs_realloc(s, offset + sz);
1010 memcpy(s + offset, v, sz);
1011 offset += sz;
1012 }
1013
1014 c++;
1015 }
1016 }
1017
1018 /* null-terminate */
1019 s = xs_realloc(s, _xs_blk_size(offset + 1));
1020 s[offset] = '\0';
1021
1022 return s;
1023}
1024
1025
1026xs_list *xs_split_n(const char *str, const char *sep, int times)
1027/* splits a string into a list upto n times */
1028{
1029 xs_list *list = xs_list_new();
1030
1031 if (!xs_is_string(str) || !xs_is_string(sep))
1032 return list;
1033
1034 int sz = strlen(sep);
1035 char *ss;
1036
1037 while (times > 0 && (ss = strstr(str, sep)) != NULL) {
1038 /* create a new string with this slice and add it to the list */
1039 xs *s = xs_str_new_sz(str, ss - str);
1040
1041 if (xs_is_string(s))
1042 list = xs_list_append(list, s);
1043
1044 /* skip past the separator */
1045 str = ss + sz;
1046
1047 times--;
1048 }
1049
1050 /* add the rest of the string */
1051 if (xs_is_string(str))
1052 list = xs_list_append(list, str);
1053
1054 return list;
1055}
1056
1057
1058xs_list *xs_list_cat(xs_list *l1, const xs_list *l2)
1059/* concatenates list l2 to l1 */
1060{
1061 XS_ASSERT_TYPE(l1, XSTYPE_LIST);
1062 XS_ASSERT_TYPE(l2, XSTYPE_LIST);
1063
1064 /* inserts at the end of l1 the content of l2 (skipping header and footer) */
1065 return xs_insert_m(l1, xs_size(l1) - 1,
1066 l2 + 1 + _XS_TYPE_SIZE, xs_size(l2) - (1 + _XS_TYPE_SIZE + 1));
1067}
1068
1069
1070/** keyvals **/
1071
1072int xs_keyval_size(const xs_str *key, const xs_val *value)
1073/* returns the needed size for a keyval */
1074{
1075 return 1 + xs_size(key) + xs_size(value);
1076}
1077
1078
1079xs_str *xs_keyval_key(const xs_keyval *keyval)
1080/* returns a pointer to the key of the keyval */
1081{
1082 return (xs_str *)&keyval[1];
1083}
1084
1085
1086xs_val *xs_keyval_value(const xs_keyval *keyval)
1087/* returns a pointer to the value of the keyval */
1088{
1089 return (xs_val *)&keyval[1 + xs_size(xs_keyval_key(keyval))];
1090}
1091
1092
1093xs_keyval *xs_keyval_make(xs_keyval *keyval, const xs_str *key, const xs_val *value)
1094/* builds a keyval into mem (should have enough size) */
1095{
1096 keyval[0] = XSTYPE_KEYVAL;
1097 memcpy(xs_keyval_key(keyval), key, xs_size(key));
1098 memcpy(xs_keyval_value(keyval), value, xs_size(value));
1099
1100 return keyval;
1101}
1102
1103
1104/** dicts **/
1105
1106typedef struct {
1107 int value_offset; /* offset to value (from dict start) */
1108 int next; /* next node in sequential scanning */
1109 int child[4]; /* child nodes in hashed search */
1110 char key[]; /* C string key */
1111} ditem_hdr;
1112
1113typedef struct {
1114 int size; /* size of full dict (_XS_TYPE_SIZE) */
1115 int first; /* first node for sequential scanning */
1116 int last; /* last node for sequential scanning */
1117 int root; /* root node for hashed search */
1118 /* a bunch of ditem_hdr and value follows */
1119} dict_hdr;
1120
1121
1122xs_dict *xs_dict_new(void)
1123/* creates a new dict */
1124{
1125 /* size of dict */
1126 int sz = 1 + sizeof(dict_hdr);
1127
1128 xs_dict *d = xs_realloc(NULL, sz);
1129 memset(d, '\0', sz);
1130
1131 d[0] = XSTYPE_DICT;
1132 _xs_put_size(d, sz);
1133
1134 return d;
1135}
1136
1137static int *_xs_dict_locate(const xs_dict *dict, const char *key)
1138/* locates a ditem */
1139{
1140 unsigned int h = xs_hash_func(key, strlen(key));
1141
1142 /* start from the root */
1143 dict_hdr *dh = (dict_hdr *)(dict + 1);
1144 int *off = &dh->root;
1145
1146 while (*off) {
1147 /* pointer to ditem */
1148 ditem_hdr *di = (ditem_hdr *)(dict + *off);
1149
1150 /* pointer to the key */
1151 const char *d_key = di->key;
1152
1153 if (strcmp(key, d_key) == 0)
1154 break;
1155
1156 off = &di->child[h >> 30];
1157 h <<= 2;
1158 }
1159
1160 return off;
1161}
1162
1163
1164xs_dict *xs_dict_set(xs_dict *dict, const xs_str *key, const xs_val *value)
1165/* sets a key/value pair */
1166{
1167 if (value == NULL)
1168 value = xs_stock(XSTYPE_NULL);
1169
1170 if (xs_type(dict) == XSTYPE_DICT) {
1171 int *o = _xs_dict_locate(dict, key);
1172 int end = xs_size(dict);
1173
1174 if (!*o) {
1175 /* ditem does not exist yet: append to the end */
1176 *o = end;
1177
1178 int ksz = xs_size(key);
1179 int vsz = xs_size(value);
1180 int dsz = sizeof(ditem_hdr) + ksz + vsz;
1181
1182 /* open room in the dict for the full ditem */
1183 dict = xs_expand(dict, end, dsz);
1184
1185 dict_hdr *dh = (dict_hdr *)(dict + 1);
1186
1187 /* build the ditem */
1188 ditem_hdr *di = (ditem_hdr *)(dict + end);
1189 memset(di, '\0', dsz);
1190
1191 /* set the offset to the value */
1192 di->value_offset = end + sizeof(ditem_hdr) + ksz;
1193
1194 /* copy the key */
1195 memcpy(di->key, key, ksz);
1196
1197 /* copy the value */
1198 memcpy(dict + di->value_offset, value, vsz);
1199
1200 /* chain to the sequential list */
1201 if (dh->first == 0)
1202 dh->first = end;
1203 else {
1204 /* chain this new element to the last one */
1205 ditem_hdr *dil = (ditem_hdr *)(dict + dh->last);
1206 dil->next = end;
1207 }
1208
1209 dh->last = end;
1210 }
1211 else {
1212 /* ditem already exists */
1213 ditem_hdr *di = (ditem_hdr *)(dict + *o);
1214
1215 /* get pointer to the value offset */
1216 int *i = &di->value_offset;
1217
1218 /* deleted? recover offset */
1219 if (*i < 0)
1220 *i *= -1;
1221
1222 /* get old value */
1223 xs_val *o_value = dict + *i;
1224
1225 /* will new value fit over the old one? */
1226 if (xs_size(value) <= xs_size(o_value)) {
1227 /* just overwrite */
1228 /* (difference is leaked inside the dict) */
1229 memcpy(o_value, value, xs_size(value));
1230 }
1231 else {
1232 /* not enough room: new value will live at the end of the dict */
1233 /* (old value is leaked inside the dict) */
1234 *i = end;
1235
1236 dict = xs_insert(dict, end, value);
1237 }
1238 }
1239 }
1240
1241 return dict;
1242}
1243
1244
1245xs_dict *xs_dict_append(xs_dict *dict, const xs_str *key, const xs_val *value)
1246/* just an alias (for this implementation it's the same) */
1247{
1248 return xs_dict_set(dict, key, value);
1249}
1250
1251
1252xs_dict *xs_dict_prepend(xs_dict *dict, const xs_str *key, const xs_val *value)
1253/* just an alias (for this implementation it's the same) */
1254{
1255 return xs_dict_set(dict, key, value);
1256}
1257
1258
1259xs_dict *xs_dict_del(xs_dict *dict, const xs_str *key)
1260/* deletes a key/value pair */
1261{
1262 if (xs_type(dict) == XSTYPE_DICT) {
1263 int *o = _xs_dict_locate(dict, key);
1264
1265 if (*o) {
1266 /* found ditem */
1267 ditem_hdr *di = (ditem_hdr *)(dict + *o);
1268
1269 /* deleted ditems have a negative value offset */
1270 di->value_offset *= -1;
1271 }
1272 }
1273
1274 return dict;
1275}
1276
1277
1278const xs_val *xs_dict_get(const xs_dict *dict, const xs_str *key)
1279/* gets a value by key, or NULL */
1280{
1281 if (xs_type(dict) == XSTYPE_DICT) {
1282 int *o = _xs_dict_locate(dict, key);
1283
1284 if (*o) {
1285 /* found ditem */
1286 ditem_hdr *di = (ditem_hdr *)(dict + *o);
1287
1288 if (di->value_offset > 0)
1289 return dict + di->value_offset;
1290 }
1291 }
1292
1293 return NULL;
1294}
1295
1296
1297int xs_dict_next(const xs_dict *dict, const xs_str **key, const xs_val **value, int *ctxt)
1298/* dict iterator, with context */
1299{
1300 if (xs_type(dict) != XSTYPE_DICT)
1301 return 0;
1302
1303 if (*ctxt == 0) {
1304 /* at the beginning: get the first sequential item */
1305 const dict_hdr *dh = (dict_hdr *)(dict + 1);
1306 *ctxt = dh->first;
1307 }
1308
1309 *value = NULL;
1310
1311 while (*value == NULL && *ctxt > 0) {
1312 const ditem_hdr *di = (ditem_hdr *)(dict + *ctxt);
1313
1314 /* get value */
1315 if (di->value_offset > 0) {
1316 *value = (xs_val *)(dict + di->value_offset);
1317
1318 /* get key */
1319 *key = (xs_str *)&di->key;
1320 }
1321
1322 /* get offset to next ditem */
1323 *ctxt = di->next ? di->next : -1;
1324 }
1325
1326 return *value != NULL;
1327}
1328
1329
1330xs_dict *xs_dict_gc(const xs_dict *dict)
1331/* creates a copy of dict, but garbage-collected */
1332{
1333 xs_dict *nd = xs_dict_new();
1334 const xs_str *k;
1335 const xs_val *v;
1336
1337 xs_dict_foreach(dict, k, v) {
1338 if (xs_type(v) == XSTYPE_DICT) {
1339 xs *sd = xs_dict_gc(v);
1340 nd = xs_dict_set(nd, k, sd);
1341 }
1342 else
1343 nd = xs_dict_set(nd, k, v);
1344 }
1345
1346 return nd;
1347}
1348
1349
1350const xs_val *xs_dict_get_path_sep(const xs_dict *dict, const char *path, const char *sep)
1351/* gets a value from dict given a path separated by sep */
1352{
1353 /* split by the separator */
1354 xs *l = xs_split_n(path, sep, 1);
1355
1356 /* only one part? just get */
1357 if (xs_list_len(l) == 1)
1358 return xs_dict_get(dict, path);
1359
1360 const char *prefix = xs_list_get(l, 0);
1361 const char *rest = xs_list_get(l, 1);
1362 const xs_dict *sd = xs_dict_get(dict, prefix);
1363
1364 if (xs_type(sd) == XSTYPE_DICT)
1365 return xs_dict_get_path_sep(sd, rest, sep);
1366
1367 return NULL;
1368}
1369
1370
1371xs_dict *xs_dict_set_path_sep(xs_dict *dict, const char *path, const xs_val *value, const char *sep)
1372/* sets a value into dict given a path separated by sep;
1373 intermediate dicts are created if needed */
1374{
1375 /* split by the separator */
1376 xs *l = xs_split_n(path, sep, 1);
1377
1378 /* only one part? just set */
1379 if (xs_list_len(l) == 1)
1380 return xs_dict_set(dict, path, value);
1381
1382 const char *prefix = xs_list_get(l, 0);
1383 const char *rest = xs_list_get(l, 1);
1384
1385 xs *nd = NULL;
1386
1387 /* does the first part of path exist? */
1388 const xs_dict *cd = xs_dict_get(dict, prefix);
1389
1390 if (xs_type(cd) == XSTYPE_DICT)
1391 nd = xs_dup(cd);
1392 else
1393 nd = xs_dict_new();
1394
1395 /* move down the path */
1396 nd = xs_dict_set_path_sep(nd, rest, value, sep);
1397
1398 /* set */
1399 return xs_dict_set(dict, prefix, nd);
1400}
1401
1402
1403/** other values **/
1404
1405xs_val *xs_val_new(xstype t)
1406/* adds a new special value */
1407{
1408 xs_val *v = xs_realloc(NULL, _xs_blk_size(1));
1409
1410 v[0] = t;
1411
1412 return v;
1413}
1414
1415
1416/** numbers */
1417
1418xs_number *_xs_number_new(const char *str)
1419{
1420 xs_number *v = xs_realloc(NULL, 1 + xs_size(str));
1421
1422 v[0] = XSTYPE_NUMBER;
1423 memcpy(&v[1], str, xs_size(str));
1424
1425 return v;
1426}
1427
1428
1429xs_number *xs_number_new(double f)
1430/* creates a new number value from a double */
1431{
1432 char tmp[64];
1433
1434 snprintf(tmp, sizeof(tmp), "%.15lf", f);
1435
1436 /* strip useless zeros */
1437 if (strchr(tmp, '.') != NULL) {
1438 char *ptr;
1439
1440 for (ptr = tmp + strlen(tmp) - 1; *ptr == '0'; ptr--);
1441
1442 if (*ptr != '.')
1443 ptr++;
1444
1445 *ptr = '\0';
1446 }
1447
1448 return _xs_number_new(tmp);
1449}
1450
1451
1452xs_number *xs_number_new_l(long l)
1453/* creates a new number value from a long */
1454{
1455 char tmp[64];
1456
1457 snprintf(tmp, sizeof(tmp), "%ld", l);
1458
1459 return _xs_number_new(tmp);
1460}
1461
1462
1463double xs_number_get(const xs_number *v)
1464/* gets the number as a double */
1465{
1466 if (xs_type(v) == XSTYPE_NUMBER)
1467 v++;
1468
1469 if (xs_type(v) == XSTYPE_STRING)
1470 return atof(v);
1471
1472 return 0.0;
1473}
1474
1475
1476long xs_number_get_l(const xs_number *v)
1477/* gets the number as a long */
1478{
1479 if (xs_type(v) == XSTYPE_NUMBER)
1480 v++;
1481
1482 if (xs_type(v) == XSTYPE_STRING)
1483 return atol(v);
1484
1485 return 0;
1486}
1487
1488
1489const char *xs_number_str(const xs_number *v)
1490/* gets the number as a string */
1491{
1492 if (xs_type(v) == XSTYPE_NUMBER)
1493 return v + 1;
1494
1495 return NULL;
1496}
1497
1498
1499/** raw data blocks **/
1500
1501xs_data *xs_data_new(const void *data, int size)
1502/* returns a new raw data value */
1503{
1504 xs_data *v;
1505
1506 /* add the overhead (data type + size) */
1507 int total_size = size + 1 + _XS_TYPE_SIZE;
1508
1509 v = xs_realloc(NULL, _xs_blk_size(total_size));
1510 v[0] = XSTYPE_DATA;
1511
1512 _xs_put_size(v, total_size);
1513
1514 memcpy(&v[1 + _XS_TYPE_SIZE], data, size);
1515
1516 return v;
1517}
1518
1519
1520int xs_data_size(const xs_data *value)
1521/* returns the size of the data stored inside value */
1522{
1523 return _xs_get_size(value) - (1 + _XS_TYPE_SIZE);
1524}
1525
1526
1527void xs_data_get(void *data, const xs_data *value)
1528/* copies the raw data stored inside value into data */
1529{
1530 memcpy(data, &value[1 + _XS_TYPE_SIZE], xs_data_size(value));
1531}
1532
1533
1534void *xs_memmem(const char *haystack, int h_size, const char *needle, int n_size)
1535/* clone of memmem */
1536{
1537 char *p, *r = NULL;
1538 int offset = 0;
1539
1540 while (!r && h_size - offset > n_size &&
1541 (p = memchr(haystack + offset, *needle, h_size - offset))) {
1542 if (memcmp(p, needle, n_size) == 0)
1543 r = p;
1544 else
1545 offset = p - haystack + 1;
1546 }
1547
1548 return r;
1549}
1550
1551
1552unsigned int xs_hash_func(const char *data, int size)
1553/* a general purpose hashing function */
1554{
1555 unsigned int hash = 0x666;
1556
1557 for (int n = 0; n < size; n++) {
1558 hash ^= (unsigned char)data[n];
1559 hash *= 111111111;
1560 }
1561
1562 return hash ^ hash >> 16;
1563}
1564
1565
1566uint64_t xs_hash64_func(const char *data, int size)
1567/* a general purpose hashing function (64 bit) */
1568{
1569 uint64_t hash = 0x100;
1570
1571 for (int n = 0; n < size; n++) {
1572 hash ^= (unsigned char)data[n];
1573 hash *= 1111111111111111111;
1574 }
1575
1576 return hash;
1577}
1578
1579
1580#endif /* XS_IMPLEMENTATION */
1581
1582#endif /* _XS_H */
