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