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