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