Backport from xs.

xs.h

@@ -65,8 +65,10 @@ xs_str *xs_str_new(const char *str);
 xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix);
 #define xs_str_prepend_i(str, prefix) xs_str_wrap_i(prefix, str, NULL)
 #define xs_str_cat(str, suffix) xs_str_wrap_i(NULL, str, suffix)
-xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto);
+xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times);
-#define xs_replace(str, sfrom, sto) xs_replace_i(xs_dup(str), sfrom, sto)
+#define xs_replace_i(str, sfrom, sto) xs_replace_in(str, sfrom, sto, XS_ALL)
+#define xs_replace(str, sfrom, sto) xs_replace_in(xs_dup(str), sfrom, sto, XS_ALL)
+#define xs_replace_n(str, sfrom, sto, times) xs_replace_in(xs_dup(str), sfrom, sto, times)
 xs_str *xs_fmt(const char *fmt, ...);
 int xs_str_in(const char *haystack, const char *needle);
 int _xs_startsorends(const char *str, const char *xfix, int ends);
@@ -416,7 +418,7 @@ xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix)
 }
 
 
-xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
+xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times)
 /* replaces inline all sfrom with sto */
 {
     XS_ASSERT_TYPE(str, XSTYPE_STRING);
@@ -426,7 +428,7 @@ xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
     char *ss;
     int offset = 0;
 
-    while ((ss = strstr(str + offset, sfrom)) != NULL) {
+    while (times > 0 && (ss = strstr(str + offset, sfrom)) != NULL) {
         int n_offset = ss - str;
 
         str = xs_collapse(str, n_offset, sfsz);
@@ -434,6 +436,8 @@ xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
         memcpy(str + n_offset, sto, stsz);
 
         offset = n_offset + stsz;
+
+        times--;
     }
 
     return str;

xs_encdec.h

@@ -7,13 +7,20 @@
  xs_str *xs_hex_enc(const xs_val *data, int size);
  xs_val *xs_hex_dec(const xs_str *hex, int *size);
  int xs_is_hex(const char *str);
+ xs_str *xs_base32_enc(const xs_val *data, int sz);
+ xs_str *xs_base32hex_enc(const xs_val *data, int sz);
+ xs_val *xs_base32_dec(const xs_str *data, int *size);
+ xs_val *xs_base32hex_dec(const xs_str *data, int *size);
  xs_str *xs_base64_enc(const xs_val *data, int sz);
  xs_val *xs_base64_dec(const xs_str *data, int *size);
+ int xs_is_base64(const char *str);
  xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint);
 
 
 #ifdef XS_IMPLEMENTATION
 
+/** hex **/
+
 xs_str *xs_hex_enc(const xs_val *data, int size)
 /* returns an hexdump of data */
 {
@@ -78,16 +85,178 @@ int xs_is_hex(const char *str)
 }
 
 
-xs_str *xs_base64_enc(const xs_val *data, int sz)
+/** base32 */
-/* encodes data to base64 */
+
+static char *xs_b32_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                          "234567=";
+
+static char *xs_b32hex_tbl = "0123456789"
+                             "ABCDEFGHIJKLMNOPQRSTUV=";
+
+/*
+    00000|00011|11111|12222|22223|33333|33444|44444
+*/
+
+xs_str *xs_base32_enc_tbl(const xs_val *data, int sz, const char *b32_tbl)
+/* encodes data to base32 using a table */
+{
+    xs_str *s = xs_str_new(NULL);
+    unsigned char *p;
+    int n;
+
+    p = (unsigned char *)data;
+
+    for (n = 0; n < sz; n += 5) {
+        int l = sz - n;
+        char enc[9] = "========";
+
+        enc[0] = b32_tbl[(p[n] >> 3) & 0x1f];
+
+        if (l > 1) {
+            enc[1] = b32_tbl[(p[n] << 2 | p[n + 1] >> 6) & 0x1f];
+            enc[2] = b32_tbl[(p[n + 1] >> 1) & 0x1f];
+
+            if (l > 2) {
+                enc[3] = b32_tbl[(p[n + 1] << 4 | p[n + 2] >> 4) & 0x1f];
+
+                if (l > 3) {
+                    enc[4] = b32_tbl[(p[n + 2] << 1 | p[n + 3] >> 7) & 0x1f];
+                    enc[5] = b32_tbl[(p[n + 3] >> 2) & 0x1f];
+
+                    if (l > 4) {
+                        enc[6] = b32_tbl[(p[n + 3] << 3 | p[n + 4] >> 5) & 0x1f];
+                        enc[7] = b32_tbl[(p[n + 4]) & 0x1f];
+                    }
+                    else
+                        enc[6] = b32_tbl[(p[n + 3] << 3) & 0x1f];
+                }
+                else
+                    enc[4] = b32_tbl[(p[n + 2] << 1) & 0x1f];
+            }
+            else
+                enc[3] = b32_tbl[(p[n + 1] << 4) & 0x1f];
+        }
+        else
+            enc[1] = b32_tbl[(p[n] << 2) & 0x1f];
+
+        s = xs_str_cat(s, enc);
+    }
+
+    return s;
+}
+
+
+xs_str *xs_base32_enc(const xs_val *data, int sz)
+/* encodes data to base32 */
+{
+    return xs_base32_enc_tbl(data, sz, xs_b32_tbl);
+}
+
+
+xs_str *xs_base32hex_enc(const xs_val *data, int sz)
+/* encodes data to base32 with HEX alphabet (RFC4648) */
+{
+    return xs_base32_enc_tbl(data, sz, xs_b32hex_tbl);
+}
+
+
+xs_val *xs_base32_dec_tbl(const xs_str *data, int *size, const char *b32_tbl)
+/* decodes data from base32 using a table */
+{
+    xs_val *s = NULL;
+    int sz = 0;
+    char *p;
+
+    p = (char *)data;
+
+    /* size of data must be a multiple of 8 */
+    if (strlen(p) % 8)
+        return NULL;
+
+    for (p = (char *)data; *p; p += 8) {
+        int cs[8];
+        int n;
+        unsigned char tmp[5];
+
+        for (n = 0; n < 8; n++) {
+            char *ss = strchr(b32_tbl, p[n]);
+
+            if (ss == NULL) {
+                /* not a base32 char */
+                return xs_free(s);
+            }
+
+            cs[n] = ss - b32_tbl;
+        }
+
+        n = 0;
+
+        /* #0 byte */
+        tmp[n++] = cs[0] << 3 | cs[1] >> 2;
+
+        if (cs[2] != 32) {
+            /* #1 byte */
+            tmp[n++] = (cs[1] & 0x3) << 6 | cs[2] << 1 | (cs[3] & 0x10) >> 4;
+
+            if (cs[4] != 32) {
+                /* #2 byte */
+                tmp[n++] = (cs[3] & 0xf) << 4 | cs[4] >> 1;
+
+                if (cs[5] != 32) {
+                    /* #3 byte */
+                    tmp[n++] = (cs[4] & 0x1) << 7 | cs[5] << 2 | cs[6] >> 3;
+
+                    if (cs[7] != 32) {
+                        /* #4 byte */
+                        tmp[n++] = (cs[6] & 0x7) << 5 | cs[7];
+                    }
+                }
+            }
+        }
+
+        /* must be done manually because data can be pure binary */
+        s = xs_realloc(s, _xs_blk_size(sz + n));
+        memcpy(s + sz, tmp, n);
+        sz += n;
+    }
+
+    /* asciiz it to use it as a string */
+    s = xs_realloc(s, _xs_blk_size(sz + 1));
+    s[sz] = '\0';
+
+    *size = sz;
+
+    return s;
+}
+
+
+xs_val *xs_base32_dec(const xs_str *data, int *size)
+/* decodes data from base32 */
+{
+    return xs_base32_dec_tbl(data, size, xs_b32_tbl);
+}
+
+
+xs_val *xs_base32hex_dec(const xs_str *data, int *size)
+/* decodes data from base32 with HEX alphabet (RFC4648) */
+{
+    return xs_base32_dec_tbl(data, size, xs_b32hex_tbl);
+}
+
+
+/** base64 */
+
+static char *xs_b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                          "abcdefghijklmnopqrstuvwxyz"
+                          "0123456789+/=";
+
+xs_str *xs_base64_enc_tbl(const xs_val *data, int sz, const char *b64_tbl)
+/* encodes data to base64 using a table */
 {
     xs_str *s;
     unsigned char *p;
     char *i;
     int bsz, n;
-    static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                           "abcdefghijklmnopqrstuvwxyz"
-                           "0123456789+/";
 
     bsz = ((sz + 3 - 1) / 3) * 4;
     i = s = xs_realloc(NULL, _xs_blk_size(bsz + 1));
@@ -123,15 +292,19 @@ xs_str *xs_base64_enc(const xs_val *data, int sz)
 }
 
 
-xs_val *xs_base64_dec(const xs_str *data, int *size)
+xs_str *xs_base64_enc(const xs_val *data, int sz)
-/* decodes data from base64 */
+/* encodes data to base64 */
+{
+    return xs_base64_enc_tbl(data, sz, xs_b64_tbl);
+}
+
+
+xs_val *xs_base64_dec_tbl(const xs_str *data, int *size, const char *b64_tbl)
+/* decodes data from base64 using a table */
 {
     xs_val *s = NULL;
     int sz = 0;
     char *p;
-    static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                           "abcdefghijklmnopqrstuvwxyz"
-                           "0123456789+/=";
 
     p = (char *)data;
 
@@ -184,6 +357,34 @@ xs_val *xs_base64_dec(const xs_str *data, int *size)
 }
 
 
+xs_val *xs_base64_dec(const xs_str *data, int *size)
+/* decodes data from base64 */
+{
+    return xs_base64_dec_tbl(data, size, xs_b64_tbl);
+}
+
+
+int xs_is_base64_tbl(const char *str, const char *b64_tbl)
+/* returns 1 if str is a base64 string, with table */
+{
+    while (*str) {
+        if (strchr(b64_tbl, *str++) == NULL)
+            return 0;
+    }
+
+    return 1;
+}
+
+
+int xs_is_base64(const char *str)
+/* returns 1 if str is a base64 string */
+{
+    return xs_is_base64_tbl(str, xs_b64_tbl);
+}
+
+
+/** utf-8 **/
+
 xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint)
 /* encodes an Unicode codepoint to utf8 */
 {

xs_version.h

@@ -1 +1 @@
-/* a885c7cc4c8e6384ae23125ed05f434471ccc6fb */
+/* dfdd729248d7169b80cb6a7462fe6c0ba6efeb16 */