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