1 files changed, 64 insertions, 6 deletions

diff --git a/xs.h b/xs.h
index 11f0722..0727dd2 100644
--- a/xs.h
+++ b/xs.h
@@ -98,6 +98,8 @@ xs_list *_xs_list_append(xs_list *list, const xs_val *vals[]);
 #define xs_list_append(list, ...) _xs_list_append(list, (const xs_val *[]){ __VA_ARGS__, NULL })
 int xs_list_iter(xs_list **list, const xs_val **value);
 int xs_list_next(const xs_list *list, const xs_val **value, int *ctxt);
+int xs_list_cap(xs_list *list, int max);
+xs_list *xs_list_reverse(const xs_list *l);
 int xs_list_len(const xs_list *list);
 const xs_val *xs_list_get(const xs_list *list, int num);
 xs_list *xs_list_del(xs_list *list, int num);
@@ -133,6 +135,7 @@ xs_dict *xs_dict_set_path_sep(xs_dict *dict, const char *path, const xs_val *val
 #define xs_dict_set_path(dict, path, value) xs_dict_set_path_sep(dict, path, value, ".")
 
 xs_val *xs_val_new(xstype t);
+xs_number *_xs_number_new(const char *str);
 xs_number *xs_number_new(double f);
 xs_number *xs_number_new_l(long l);
 double xs_number_get(const xs_number *v);
@@ -141,6 +144,7 @@ const char *xs_number_str(const xs_number *v);
 
 xs_data *xs_data_new(const void *data, int size);
 int xs_data_size(const xs_data *value);
+const void *xs_data_ptr(const xs_data *value);
 void xs_data_get(void *data, const xs_data *value);
 
 void *xs_memmem(const char *haystack, int h_size, const char *needle, int n_size);
@@ -161,6 +165,7 @@ uint64_t xs_hash64_func(const char *data, int size);
 
 #define xs_is_true(v) (xs_type((v)) == XSTYPE_TRUE)
 #define xs_is_false(v) (xs_type((v)) == XSTYPE_FALSE)
+#define xs_bool(v) xs_stock((v) ? XSTYPE_TRUE : XSTYPE_FALSE)
 #define xs_not(v) xs_stock(xs_is_true((v)) ? XSTYPE_FALSE : XSTYPE_TRUE)
 #define xs_is_string(v) (xs_type((v)) == XSTYPE_STRING)
 #define xs_is_list(v) (xs_type((v)) == XSTYPE_LIST)
@@ -703,7 +708,7 @@ xs_str *xs_tolower_i(xs_str *str)
     int n;
 
     for (n = 0; str[n]; n++)
-        str[n] = tolower(str[n]);
+        str[n] = tolower((int)str[n]);
 
     return str;
 }
@@ -717,7 +722,7 @@ xs_str *xs_toupper_i(xs_str *str)
     int n;
 
     for (n = 0; str[n]; n++)
-        str[n] = toupper(str[n]);
+        str[n] = toupper((int)str[n]);
 
     return str;
 }
@@ -850,6 +855,52 @@ int xs_list_next(const xs_list *list, const xs_val **value, int *ctxt)
 }
 
 
+int xs_list_cap(xs_list *list, int max)
+/* caps the list to have a maximum of max items */
+{
+    int n, ctxt = 0;
+    const char *v;
+
+    /* advance upto max elements */
+    for (n = 0; n < max + 1 && xs_list_next(list, &v, &ctxt); n++);
+
+    /* more than max items? */
+    if (n == max + 1) {
+        /* insert an end of list over the XSTYPE_LITEM of the old item */
+        char *p = (char *)v;
+        p[-1] = '\0';
+
+        /* rewrite the list len */
+        _xs_put_size(list, p - list);
+    }
+
+    return n == max + 1;
+}
+
+
+xs_list *xs_list_reverse(const xs_list *l)
+/* creates a new list as a reverse version of l */
+{
+    xs_list *n = xs_dup(l);
+    const xs_val *v;
+
+    /* move to one byte before the EOM */
+    char *p = n + xs_size(n) - 1;
+
+    xs_list_foreach(l, v) {
+        /* size of v, plus the LITEM */
+        int z = xs_size(v) + 1;
+
+        p -= z;
+
+        /* copy v, including its LITEM */
+        memcpy(p, v - 1, z);
+    }
+
+    return n;
+}
+
+
 int xs_list_len(const xs_list *list)
 /* returns the number of elements in the list */
 {
@@ -965,10 +1016,9 @@ int xs_list_in(const xs_list *list, const xs_val *val)
 
     int n = 0;
     const xs_val *v;
-    int sz = xs_size(val);
 
     xs_list_foreach(list, v) {
-        if (sz == xs_size(v) && memcmp(val, v, sz) == 0)
+        if (xs_cmp(val, v) == 0)
             return n;
 
         n++;
@@ -1511,7 +1561,8 @@ xs_data *xs_data_new(const void *data, int size)
 
     _xs_put_size(v, total_size);
 
-    memcpy(&v[1 + _XS_TYPE_SIZE], data, size);
+    if (data)
+        memcpy(&v[1 + _XS_TYPE_SIZE], data, size);
 
     return v;
 }
@@ -1524,10 +1575,17 @@ int xs_data_size(const xs_data *value)
 }
 
 
+const void *xs_data_ptr(const xs_data *value)
+/* return an internal pointer to the stored data */
+{
+    return &value[1 + _XS_TYPE_SIZE];
+}
+
+
 void xs_data_get(void *data, const xs_data *value)
 /* copies the raw data stored inside value into data */
 {
-    memcpy(data, &value[1 + _XS_TYPE_SIZE], xs_data_size(value));
+    memcpy(data, xs_data_ptr(value), xs_data_size(value));
 }