mittens 0.3.3 → 0.3.5

data/vendor/snowball/compiler/generator_python.c

@@ -54,7 +54,7 @@ static void write_varref(struct generator * g, struct name * p) {
     write_varname(g, p);
 }
 
-static void write_literal_string(struct generator * g, symbol * p) {
+static void write_literal_string(struct generator * g, const symbol * p) {
     write_char(g, '"');
     for (int i = 0; i < SIZE(p); i++) {
         int ch = p[i];
@@ -1201,7 +1201,7 @@ static void generate_debug(struct generator * g, struct node * p) {
     write_comment(g, p);
     g->I[0] = g->debug_count++;
     g->I[1] = p->line_number;
-    writef(g, "~Mself.debug(~I0, ~I1)~N", p);
+    writef(g, "~Mself.__debug(~I0, ~I1)~N", p);
 }
 
 static void generate(struct generator * g, struct node * p) {
@@ -1314,7 +1314,7 @@ static void generate_among_table(struct generator * g, struct among * x) {
     write_newline(g);
     write_comment(g, x->node);
 
-    struct amongvec * v = x->b;
+    struct amongvec * v = x->v;
 
     g->I[0] = x->number;
 
@@ -1348,7 +1348,7 @@ static void generate_among_table(struct generator * g, struct among * x) {
 
 static void generate_amongs(struct generator * g) {
     for (struct among * x = g->analyser->amongs; x; x = x->next) {
-        generate_among_table(g, x);
+        if (!x->duplicate) generate_among_table(g, x);
     }
 }
 
@@ -1442,6 +1442,25 @@ extern void generate_program_python(struct generator * g) {
     generate_groupings(g);
 
     generate_members(g);
+
+    if (g->analyser->debug_used) {
+       w(g, "~N"
+            "~Mdef __debug(self, n, line):~N~+"
+            "~Mlength = len(self.current)~N"
+            "~Mprint(\"%3d (line %4d): [%d]'\" % (n, line, length), end='')~N"
+            "~Mfor i in range(0, length + 1):~N~+"
+            "~Mif self.limit_backward == i: print('{', end='')~N"
+            "~Mif self.bra == i: print('[', end='')~N"
+            "~Mif self.cursor == i: print('|', end='')~N"
+            "~Mif self.ket == i: print(']', end='')~N"
+            "~Mif self.limit == i: print('}', end='')~N"
+            "~Mif i < length:~N~+"
+            "~Mch = self.current[i]~N"
+            "~Mprint(ch if ch != '\\0' else '#', end='')~N~-~-"
+            "~Mprint(\"'\")~N~-"
+            "~N");
+    }
+
     generate_methods(g);
 
     generate_amongs(g);

data/vendor/snowball/compiler/generator_rust.c

@@ -32,7 +32,7 @@ static void write_varref(struct generator * g, struct name * p) {
     write_varname(g, p);
 }
 
-static void write_literal_string(struct generator * g, symbol * p) {
+static void write_literal_string(struct generator * g, const symbol * p) {
     int i = 0;
     write_char(g, '"');
     while (i < SIZE(p)) {
@@ -47,7 +47,7 @@ static void write_literal_string(struct generator * g, symbol * p) {
             write_wchar_as_utf8(g, ch);
         } else {
             write_string(g, "\\u{");
-            write_hex4(g, ch);
+            write_hex(g, ch);
             write_string(g, "}");
         }
     }
@@ -702,10 +702,10 @@ static void generate_hop(struct generator * g, struct node * p) {
     // Generate the AE to a temporary block so we can substitute it in
     // write_failure_if().
     struct str * ae = str_new();
-    struct str * s = g->outbuf;
+    struct str * saved_outbuf = g->outbuf;
     g->outbuf = ae;
     generate_AE(g, p->AE);
-    g->outbuf = s;
+    g->outbuf = saved_outbuf;
     g->B[0] = str_data(ae);
     g->S[0] = p->mode == m_forward ? "" : "_back";
     g->S[1] = p->AE->type == c_number ? "" : "_checked";
@@ -1086,7 +1086,7 @@ static void generate_define(struct generator * g, struct node * p) {
         }
     }
 
-    if (q->amongvar_needed) {
+    if (amongvar_needed(p->left)) {
         w(g, "~Mlet mut among_var;~N");
     }
 
@@ -1143,7 +1143,7 @@ static void generate_substring(struct generator * g, struct node * p) {
     struct among * x = p->among;
     int block = -1;
     unsigned int bitmap = 0;
-    struct amongvec * among_cases = x->b;
+    struct amongvec * among_cases = x->v;
     int empty_case = -1;
     int n_cases = 0;
     symbol cases[2];
@@ -1340,7 +1340,7 @@ static void generate_debug(struct generator * g, struct node * p) {
     write_comment(g, p);
     g->I[0] = g->debug_count++;
     g->I[1] = p->line_number;
-    writef(g, "~Menv.debug(~I0, ~I1);~N", p);
+    writef(g, "~Mdebug(env, ~I0, ~I1);~N", p);
 }
 
 static void generate(struct generator * g, struct node * p) {
@@ -1444,7 +1444,7 @@ static void generate_class_begin(struct generator * g) {
 static void generate_among_table(struct generator * g, struct among * x) {
     write_comment(g, x->node);
 
-    struct amongvec * v = x->b;
+    struct amongvec * v = x->v;
 
     g->I[0] = x->number;
     g->I[1] = x->literalstring_count;
@@ -1470,12 +1470,12 @@ static void generate_among_table(struct generator * g, struct among * x) {
 }
 
 static void generate_amongs(struct generator * g) {
-    struct str * s = g->outbuf;
+    struct str * saved_outbuf = g->outbuf;
     g->outbuf = g->declarations;
     for (struct among * x = g->analyser->amongs; x; x = x->next) {
-        if (x->used) generate_among_table(g, x);
+        if (x->used && !x->duplicate) generate_among_table(g, x);
     }
-    g->outbuf = s;
+    g->outbuf = saved_outbuf;
 }
 
 static void set_bit(symbol * b, int i) { b[i >> 3] |= 1 << (i & 7); }
@@ -1504,12 +1504,12 @@ static void generate_grouping_table(struct generator * g, struct grouping * q) {
 }
 
 static void generate_groupings(struct generator * g) {
-    struct str * s = g->outbuf;
+    struct str * saved_outbuf = g->outbuf;
     g->outbuf = g->declarations;
     for (struct grouping * q = g->analyser->groupings; q; q = q->next) {
         generate_grouping_table(g, q);
     }
-    g->outbuf = s;
+    g->outbuf = saved_outbuf;
 }
 
 static void generate_members(struct generator * g) {
@@ -1555,6 +1555,10 @@ extern void generate_program_rust(struct generator * g) {
         /* std::i32 is used in the code generated for i32::MAX and i32::MIN */
         w(g, "use std::i32;~N~N");
     }
+    if (g->analyser->debug_used) {
+        w(g, "use std::io;~N");
+        w(g, "use std::io::Write;~N~N");
+    }
     generate_class_begin(g);
 
     generate_members(g);
@@ -1562,6 +1566,26 @@ extern void generate_program_rust(struct generator * g) {
     g->declarations = g->outbuf;
     g->outbuf = str_new();
 
+    if (g->analyser->debug_used) {
+        w(g, "~Mfn debug(env: &mut SnowballEnv, n: i32, line: i32) {~+~N"
+             "~Mlet length = env.current.len();~N"
+             "~Mprint!(\"{:3} (line {:4}): [{}]'\", n, line, length);~N"
+             "~Mlet mut b = env.current.bytes();~N"
+             "~Mfor i in 0..length + 1 {~N~+"
+             "~Mif env.limit_backward == i as i32 { print!(\"{{\") }~N"
+             "~Mif env.bra == i as i32 { print!(\"[\") }~N"
+             "~Mif env.cursor == i as i32 { print!(\"|\") }~N"
+             "~Mif env.ket == i as i32 { print!(\"]\") }~N"
+             "~Mif env.limit == i as i32 { print!(\"}}\") }~N"
+             "~Mif (i < length) {~N~+"
+             "~Mlet ch = b.next();~N"
+             "~Mif ch == Some(0) { print!(\"#\"); } else { let _ = io::stdout().write(ch.as_slice()); }~N~-"
+             "~M}~N~-"
+             "~M}~N"
+             "~Mprintln!(\"'\");~N~-"
+             "}~N~N");
+    }
+
     generate_methods(g);
 
     generate_amongs(g);

data/vendor/snowball/compiler/generator_zig.c

@@ -38,7 +38,7 @@ static void write_stringref(struct generator * g, struct name * p) {
     write_string(g, ".slice()");
 }
 
-static void write_literal_string(struct generator * g, symbol * p) {
+static void write_literal_string(struct generator * g, const symbol * p) {
     int i = 0;
     write_char(g, '"');
     while (i < SIZE(p)) {
@@ -718,10 +718,10 @@ static void generate_hop(struct generator * g, struct node * p) {
     // Generate the AE to a temporary block so we can substitute it in
     // write_failure_if().
     struct str * ae = str_new();
-    struct str * s = g->outbuf;
+    struct str * saved_outbuf = g->outbuf;
     g->outbuf = ae;
     generate_AE(g, p->AE);
-    g->outbuf = s;
+    g->outbuf = saved_outbuf;
     g->B[0] = str_data(ae);
     g->S[0] = p->mode == m_forward ? "" : "Back";
     g->S[1] = p->AE->type == c_number ? "" : "Checked";
@@ -1134,7 +1134,7 @@ static void generate_define(struct generator * g, struct node * p) {
         }
     }
 
-    if (q->amongvar_needed) {
+    if (amongvar_needed(p->left)) {
         w(g, "~Mvar among_var: i32 = 0;~N");
     }
 
@@ -1364,7 +1364,7 @@ static void generate_class_begin(struct generator * g) {
 static void generate_among_table(struct generator * g, struct among * x) {
     write_comment(g, x->node);
 
-    struct amongvec * v = x->b;
+    struct amongvec * v = x->v;
 
     g->I[0] = x->number;
     w(g, "~Mconst a_~I0 = [_]snowball.Among{~N~+");
@@ -1389,7 +1389,7 @@ static void generate_among_table(struct generator * g, struct among * x) {
 
 static void generate_amongs(struct generator * g) {
     for (struct among * x = g->analyser->amongs; x; x = x->next) {
-        generate_among_table(g, x);
+        if (!x->duplicate) generate_among_table(g, x);
     }
 }
 

data/vendor/snowball/compiler/header.h

@@ -1,9 +1,13 @@
 #include <stdio.h>
 #if __STDC_VERSION__ < 202311l
 # include <stdbool.h>
+#elif defined _MSC_VER && __STDC_VERSION__-0 <= 202312l
+// MSVC 2026 with -std:clatest defines __STDC_VERSION__ to 202312 (one more
+// than the correct value for C23!) but doesn't provide bool, true and false.
+# include <stdbool.h>
 #endif
 
-#define SNOWBALL_VERSION "3.1.1"
+#define SNOWBALL_VERSION "3.2.0"
 
 typedef unsigned char byte;
 typedef unsigned short symbol;
@@ -26,7 +30,17 @@ typedef unsigned short symbol;
 extern symbol * create_b(int n);
 extern void report_b(FILE * out, const symbol * p);
 extern void lose_b(symbol * p);
-extern symbol * increase_capacity_b(symbol * p, int n);
+extern symbol * reserve_b_(symbol * p, int n);
+static inline symbol * reserve_b(symbol * p, int n) {
+    if (n > CAPACITY(p)) p = reserve_b_(p, n);
+    return p;
+}
+extern symbol * resize_b(symbol * p, int n);
+static inline symbol * ensure_nul_b(symbol * p) {
+    p = reserve_b(p, SIZE(p) + 1);
+    p[SIZE(p)] = 0;
+    return p;
+}
 extern symbol * add_to_b(symbol * p, const symbol * q, int n);
 extern symbol * copy_b(const symbol * p);
 extern char * b_to_sz(const symbol * p);
@@ -40,8 +54,17 @@ extern byte * create_s_from_data(const char * s, int n);
 
 extern void report_s(FILE * out, const byte * p);
 extern void lose_s(byte * p);
-extern byte * increase_capacity_s(byte * p, int n);
-extern byte * ensure_capacity_s(byte * p, int n);
+extern byte * reserve_s_(byte * p, int n);
+static inline byte * reserve_s(byte * p, int n) {
+    if (n > CAPACITY(p)) p = reserve_s_(p, n);
+    return p;
+}
+extern byte * resize_s(byte * p, int n);
+static inline byte * ensure_nul_s(byte * p) {
+    p = reserve_s(p, SIZE(p) + 1);
+    p[SIZE(p)] = 0;
+    return p;
+}
 extern byte * copy_s(const byte * p);
 extern byte * add_s_to_s(byte * p, const byte * s);
 extern byte * add_slen_to_s(byte * p, const char * s, int n);
@@ -201,6 +224,7 @@ extern byte * get_input(const char * filename);
 extern struct tokeniser * create_tokeniser(byte * b, char * file);
 extern int read_token(struct tokeniser * t);
 extern int peek_token(struct tokeniser * t);
+extern void push_token(struct tokeniser * t, int token);
 #define hold_token(T) ((T)->token_held = true)
 extern const char * name_of_token(int code);
 extern void disable_token(struct tokeniser * t, int code);
@@ -210,8 +234,8 @@ extern int space_count;
 extern void * check_malloc(size_t n);
 extern void check_free(void * p);
 
-extern int checked_snprintf(char *str, size_t size,
-                            const char *restrict format, ...)
+extern int checked_snprintf(char * str, size_t size,
+                            const char * format, ...)
 #ifdef __GNUC__
     __attribute__ ((__format__ (__printf__, 3, 4)))
 #endif
@@ -227,9 +251,15 @@ struct name {
     bool value_used;            /* (For variables) is its value ever used? */
     bool initialised;           /* (For variables) is it ever initialised? */
     bool used_in_definition;    /* (grouping) used in grouping definition? */
-    bool amongvar_needed;       /* for routines, externals */
-    bool among_with_function;   /* (routines/externals) contains among with func */
+    // (routines/externals) contains among
+    bool has_among;
+    // (routines/externals) contains among with function(s)
+    bool has_among_function;
     bool case_collision;        /* A name of the same type differs only by case */
+    // (routines/externals) Could this directly or indirectly call itself?
+    bool recursive;
+    // (routines/externals) Temporary flag used while determining `recursive`.
+    bool visited;
     struct node * definition;   /* (routines/externals) c_define node */
     int uses_in_among;          /* (routines/externals) Count of uses in amongs */
     // Initialised to -1; set to -2 if reachable from an external.
@@ -250,12 +280,19 @@ struct literalstring {
     symbol * b;
 };
 
+struct c_literalstring {
+    struct c_literalstring * next;
+    const symbol * b;
+};
+
 struct amongvec {
     symbol * b;      /* the string giving the case */
     int size;        /* - and its size */
     struct node * action; /* the corresponding action */
-    int i;           /* the amongvec index of the longest substring of b */
-    int result;      /* the numeric result for the case */
+    // The amongvec index of the longest substring of b, or -1 for none.
+    int i;
+    // among_var value for this case (starts from 1, or -1 for empty action).
+    int result;
     int line_number; /* for diagnostics */
     int function_index; /* 1-based */
     // 0-based index giving order of strings in source.  Used for stable
@@ -264,24 +301,54 @@ struct amongvec {
     struct name * function;
 };
 
+struct among_function_scenario {
+    struct name * function;
+    int t_result; // result (1...).
+    int f_result; // 0 or result (1...) or AFS_FLAG | af_index to chain.
+    // If `function` signals f, apply this delta to the value the cursor had on
+    // entry (add for forwards; subtract for backwards).
+    int cursor_adjustment;
+};
+
+// Used to find common-subtrees to reuse.  We currently linear search this for
+// each subtree we encode, but it seems in practice that's very fast, even for
+// the large amongs in the stemmers we ship (the largest seems to be in greek.sbl
+// which results in 1161 entries in this linked list).
+//
+// Note that if we had a separate list per value of len we would only need to
+// store start in each item (and could store as a symbol*).
+struct among_subtree {
+    struct among_subtree * next;
+    int start;
+    int len;
+};
+
 struct among {
     struct among * next;
-    struct amongvec * b;      /* pointer to the amongvec */
+    struct amongvec * v;      /* pointer to the amongvec */
+    // Details for among function handling in the state machine implementation.
+    struct among_function_scenario * af;
+    struct among_subtree * subtree;
+    int af_count;             /* number of entries in af. */
+    symbol * table;           /* table used in C implementation. */
+    byte * table_endianness;  /* flag values needing byteswap on big-endian. */
     int number;               /* amongs are numbered 0, 1, 2 ... */
     int literalstring_count;  /* in this among */
     int command_count;        /* in this among (excludes "no command" entries) */
     int nocommand_count;      /* number of "no command" entries in this among */
-    int function_count;       /* number of different functions in this among */
+    int function_count;       /* number of cases with a function in this among */
+    int unique_function_count;/* number of different functions in this among */
     bool amongvar_needed;     /* do we need to set among_var? */
     bool always_matches;      /* will this among always match? */
     bool used;                /* is this among in reachable code? */
+    bool c0_used;             /* Need c0 variable in C implementation? */
+    bool duplicate;           /* Is this among a duplicate of another? */
     int same_action;          /* type code if same for all actions; <0 otherwise */
     int shortest_size;        /* smallest non-zero string length in this among */
     int longest_size;         /* longest string length in this among */
     struct node * substring;  /* i.e. substring ... among ( ... ) */
     struct node ** commands;  /* array with command_count entries */
     struct node * node;       /* pointer to the node for this among */
-    struct name * in_routine; /* pointer to name for routine this among is in */
 };
 
 struct grouping {
@@ -297,7 +364,7 @@ struct node {
     struct node * next;
     struct node * left;
     struct node * aux;     /* used in setlimit */
-    struct among * among;  /* used in among */
+    struct among * among;  /* used in substring and among */
     struct node * right;
     byte type;
     byte mode;
@@ -409,6 +476,8 @@ struct generator {
     const char * varname_prefix;
     // String to indent by for each margin level (four spaces by default).
     const char * margin_indent;
+    // (C/C++) Linked list used to merge string literals.
+    struct c_literalstring * c_literalstrings;
 };
 
 /* Special values for failure_label in struct generator. */
@@ -480,6 +549,7 @@ extern void write_int(struct generator * g, int i);
 extern void wi3(struct generator * g, int i);
 extern void write_hex4(struct generator * g, unsigned ch);
 extern void write_hex(struct generator * g, unsigned i);
+extern void write_octal3(struct generator * g, unsigned n);
 extern void write_symbol(struct generator * g, symbol s);
 extern void write_s(struct generator * g, const byte * b);
 extern void write_str(struct generator * g, struct str * str);
@@ -497,6 +567,7 @@ extern int K_needed_node_on_f(struct node * p);
 extern int K_needed_for_and(struct node * p);
 extern int K_needed_for_or(struct node * p);
 extern int repeat_restore(struct node * p);
+extern bool amongvar_needed(struct node * p);
 
 extern int just_return_on_fail(struct generator * g);
 extern int tailcallable(struct generator * g, struct node * p);

data/vendor/snowball/compiler/space.c

@@ -3,13 +3,15 @@
 #include <stdarg.h>
 #include <stdio.h>    /* for printf */
 #include <stdlib.h>   /* malloc, free */
-#include <string.h>   /* memmove */
+#include <string.h>   /* memcpy */
 
 #include "header.h"
 
 #define HEAD (2 * sizeof(int))
 #define EXTENDER 40
 
+// Threshold in bytes above which reallocations double the size.
+#define EXPONENTIAL_GROWTH_THRESHOLD 512
 
 /*  This module provides a simple mechanism for arbitrary length writable
     strings, called 'blocks'. They are 'symbol *' items rather than 'char *'
@@ -19,8 +21,8 @@
 
         symbol * b = create_b(n);
             - create an empty block b with room for n symbols
-        b = increase_capacity_b(b, n);
-            - increase the capacity of block b by n symbols (b may change)
+        b = reserve_b(b, n);
+            - ensure that the capacity of b is at least n (b may change)
         b2 = copy_b(b)
             - copy block b into b2
         lose_b(b);
@@ -44,9 +46,9 @@
 
 /*  For a block b, SIZE(b) is the number of symbols so far written into it,
     CAPACITY(b) the total number it can contain, so SIZE(b) <= CAPACITY(b).
-    In fact blocks have 1 extra character over the promised capacity so
-    they can be zero terminated by 'b[SIZE(b)] = 0;' without fear of
-    overwriting.
+
+    NB In the compiler, blocks do NOT have 1 extra character over the promised
+    capacity - use ensure_nul_b() and ensure_nul_s() to zero terminate.
 */
 
 extern symbol * create_b(int n) {
@@ -75,17 +77,35 @@ extern void lose_b(symbol * p) {
     FREE((char *) p - HEAD);
 }
 
-extern symbol * increase_capacity_b(symbol * p, int n) {
-    symbol * q = create_b(CAPACITY(p) + n + EXTENDER);
-    memmove(q, p, CAPACITY(p) * sizeof(symbol));
+extern symbol * reserve_b_(symbol * p, int n) {
+    const int EXP_THRESHOLD = EXPONENTIAL_GROWTH_THRESHOLD / sizeof(symbol);
+    int new_size = n + EXTENDER;
+    if (new_size > EXP_THRESHOLD) {
+        // Switch to exponential growth for large strings.
+        int c = (CAPACITY(p) | (EXP_THRESHOLD * 2 - 1)) + 1;
+        while (c < new_size) c *= 2;
+        new_size = c;
+    }
+    symbol * q = create_b(new_size);
+    memcpy(q, p, SIZE(p) * sizeof(symbol));
     SET_SIZE(q, SIZE(p));
-    lose_b(p); return q;
+    lose_b(p);
+    return q;
+}
+
+extern symbol * resize_b(symbol * p, int n) {
+    int size = SIZE(p);
+    if (n > size) {
+        p = reserve_b(p, n);
+        memset(p + size, 0, (n - size) * sizeof(symbol));
+    }
+    SET_SIZE(p, n);
+    return p;
 }
 
 extern symbol * add_to_b(symbol * p, const symbol * q, int n) {
-    int x = SIZE(p) + n - CAPACITY(p);
-    if (x > 0) p = increase_capacity_b(p, x);
-    memmove(p + SIZE(p), q, n * sizeof(symbol));
+    p = reserve_b(p, SIZE(p) + n);
+    memcpy(p + SIZE(p), q, n * sizeof(symbol));
     ADD_TO_SIZE(p, n);
     return p;
 }
@@ -118,8 +138,8 @@ extern void check_free(void * p) {
     free(p);
 }
 
-extern int checked_snprintf(char *str, size_t size,
-                            const char *restrict format, ...) {
+extern int checked_snprintf(char * str, size_t size,
+                            const char * format, ...) {
     va_list ap;
     va_start(ap, format);
     int r = vsnprintf(str, size, format, ap);
@@ -153,11 +173,12 @@ extern char * b_to_sz(const symbol * p) {
 
 /* Add a single symbol to a block. If p = 0 the block is created. */
 extern symbol * add_symbol_to_b(symbol * p, symbol ch) {
-    if (p == NULL) p = create_b(1);
-    int k = SIZE(p);
-    int x = k + 1 - CAPACITY(p);
-    if (x > 0) p = increase_capacity_b(p, x);
-    p[k] = ch;
+    if (p == NULL) {
+        p = create_b(1);
+    } else {
+        p = reserve_b(p, SIZE(p) + 1);
+    }
+    p[SIZE(p)] = ch;
     ADD_TO_SIZE(p, 1);
     return p;
 }
@@ -170,7 +191,7 @@ extern byte * create_s(int n) {
 }
 
 extern byte * create_s_from_sz(const char * s) {
-    int n = strlen(s);
+    int n = (int)strlen(s);
     byte * p = create_s(n);
     memcpy(p, s, n + 1);
     SET_SIZE(p, n);
@@ -180,7 +201,6 @@ extern byte * create_s_from_sz(const char * s) {
 extern byte * create_s_from_data(const char * s, int n) {
     byte * p = create_s(n);
     memcpy(p, s, n);
-    p[n] = '\0';
     SET_SIZE(p, n);
     return p;
 }
@@ -194,20 +214,29 @@ extern void lose_s(byte * p) {
     FREE((byte *) p - HEAD);
 }
 
-extern byte * increase_capacity_s(byte * p, int n) {
-    int new_size = CAPACITY(p) + n + EXTENDER;
-    // Switch to exponential growth for large strings.
-    if (new_size > 512) new_size *= 2;
-    byte * q = create_s(new_size);
-    memmove(q, p, CAPACITY(p));
+extern byte * reserve_s_(byte * p, int n) {
+    const int EXP_THRESHOLD = EXPONENTIAL_GROWTH_THRESHOLD / sizeof(byte);
+    n += EXTENDER;
+    if (n > EXP_THRESHOLD) {
+        // Switch to exponential growth for large strings.
+        int c = (CAPACITY(p) | (EXP_THRESHOLD * 2 - 1)) + 1;
+        while (c < n) c *= 2;
+        n = c;
+    }
+    byte * q = create_s(n);
+    memcpy(q, p, SIZE(p));
     SET_SIZE(q, SIZE(p));
     lose_s(p);
     return q;
 }
 
-extern byte * ensure_capacity_s(byte * p, int n) {
-    int x = SIZE(p) + n - CAPACITY(p);
-    if (x > 0) p = increase_capacity_s(p, x);
+extern byte * resize_s(byte * p, int n) {
+    int size = SIZE(p);
+    if (n > size) {
+        p = reserve_s(p, n);
+        memset(p + size, 0, n - size);
+    }
+    SET_SIZE(p, n);
     return p;
 }
 
@@ -222,7 +251,7 @@ extern byte * add_slen_to_s(byte * p, const char * s, int n) {
     if (p == NULL) {
         p = create_s(n);
     } else {
-        p = ensure_capacity_s(p, n);
+        p = reserve_s(p, SIZE(p) + n);
     }
     int k = SIZE(p);
     memcpy(p + k, s, n);
@@ -241,7 +270,7 @@ extern byte * add_s_to_s(byte * p, const byte * s) {
    block is created. */
 
 extern byte * add_sz_to_s(byte * p, const char * s) {
-    return add_slen_to_s(p, s, strlen(s));
+    return add_slen_to_s(p, s, (int)strlen(s));
 }
 
 /* Add a single character to a byte block. If p = 0 the
@@ -251,7 +280,7 @@ extern byte * add_char_to_s(byte * p, char ch) {
     if (p == NULL) {
         p = create_s(1);
     } else {
-        p = ensure_capacity_s(p, 1);
+        p = reserve_s(p, SIZE(p) + 1);
     }
     p[SIZE(p)] = ch;
     ADD_TO_SIZE(p, 1);
@@ -308,17 +337,17 @@ extern void str_append_int(struct str * str, int i) {
     }
 
     // Ensure there's enough space then snprintf() directly onto the end.
+    int size = SIZE(str->data);
     int max_size = (CHAR_BIT * sizeof(int) + 5) / 3;
-    str->data = ensure_capacity_s(str->data, max_size);
-    int r = checked_snprintf((char*)str->data + SIZE(str->data), max_size,
-                             "%d", i);
+    str->data = reserve_s(str->data, size + max_size);
+    int r = checked_snprintf((char*)str->data + size, max_size, "%d", i);
     ADD_TO_SIZE(str->data, r);
 }
 
 /* Append wide character to a string as UTF-8. */
 extern void str_append_wchar_as_utf8(struct str * str, symbol ch) {
     if (ch < 0x80) {
-        str_append_ch(str, ch);
+        str_append_ch(str, (char)ch);
         return;
     }
     if (ch < 0x800) {