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