mittens 0.3.1 → 0.3.2

data/vendor/snowball/compiler/space.c

@@ -1,15 +1,17 @@
 
+#include <limits.h>
+#include <stdarg.h>
 #include <stdio.h>    /* for printf */
 #include <stdlib.h>   /* malloc, free */
 #include <string.h>   /* memmove */
 
 #include "header.h"
 
-#define HEAD 2*sizeof(int)
+#define HEAD (2 * sizeof(int))
 #define EXTENDER 40
 
 
-/*  This modules provides a simple mechanism for arbitrary length writable
+/*  This module provides a simple mechanism for arbitrary length writable
     strings, called 'blocks'. They are 'symbol *' items rather than 'char *'
     items however.
 
@@ -31,10 +33,8 @@
     For example:
 
         symbol * b = create_b(0);
-        {   symbol i;
-            for (i = 'A'; i <= 'Z'; i++) {
-                add_symbol_to_b(b, i);
-            }
+        for (symbol i = 'A'; i <= 'Z'; i++) {
+            add_symbol_to_b(b, i);
         }
 
     After running the above code b contains:
@@ -52,13 +52,12 @@
 extern symbol * create_b(int n) {
     symbol * p = (symbol *) (HEAD + (char *) MALLOC(HEAD + (n + 1) * sizeof(symbol)));
     CAPACITY(p) = n;
-    SIZE(p) = 0;
+    SET_SIZE(p, 0);
     return p;
 }
 
 extern void report_b(FILE * out, const symbol * p) {
-    int i;
-    for (i = 0; i < SIZE(p); i++) {
+    for (int i = 0; i < SIZE(p); i++) {
         if (p[i] > 255) {
             printf("In report_b, can't convert p[%d] to char because it's 0x%02x\n", i, (int)p[i]);
             exit(1);
@@ -79,14 +78,16 @@ extern void lose_b(symbol * p) {
 extern symbol * increase_capacity_b(symbol * p, int n) {
     symbol * q = create_b(CAPACITY(p) + n + EXTENDER);
     memmove(q, p, CAPACITY(p) * sizeof(symbol));
-    SIZE(q) = SIZE(p);
+    SET_SIZE(q, SIZE(p));
     lose_b(p); return q;
 }
 
 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)); SIZE(p) += n; return p;
+    memmove(p + SIZE(p), q, n * sizeof(symbol));
+    ADD_TO_SIZE(p, n);
+    return p;
 }
 
 extern symbol * copy_b(const symbol * p) {
@@ -113,49 +114,74 @@ extern void * check_malloc(size_t n) {
 }
 
 extern void check_free(void * p) {
-    space_count--;
+    if (p) space_count--;
     free(p);
 }
 
-/* To convert a block to a zero terminated string:  */
+extern int checked_snprintf(char *str, size_t size,
+                            const char *restrict format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    int r = vsnprintf(str, size, format, ap);
+    va_end(ap);
+    // Some pre-C99 snprintf implementations return -1 if the buffer is too
+    // small so cast to unsigned for a simpler test (we require C99, but better
+    // to be robust if we encounter a C99 compiler with pre-C99 quirks in its
+    // runtime library).
+    if ((unsigned)r >= size) {
+        fprintf(stderr, "snprintf(buf, %zu, \"%s\", ...) would overflow\n",
+                size, format);
+        exit(1);
+    }
+    return r;
+}
 
+/* Convert a block to a zero terminated string. */
 extern char * b_to_sz(const symbol * p) {
     int n = SIZE(p);
     char * s = (char *)xmalloc(n + 1);
-    {
-        int i;
-        for (i = 0; i < n; i++) {
-            if (p[i] > 255) {
-                printf("In b_to_s, can't convert p[%d] to char because it's 0x%02x\n", i, (int)p[i]);
-                exit(1);
-            }
-            s[i] = (char)p[i];
+    for (int i = 0; i < n; i++) {
+        if (p[i] > 255) {
+            printf("In b_to_s, can't convert p[%d] to char because it's 0x%02x\n", i, (int)p[i]);
+            exit(1);
         }
+        s[i] = (char)p[i];
     }
     s[n] = 0;
     return s;
 }
 
-/* Add a single symbol to a block. If p = 0 the
-   block is created. */
-
+/* Add a single symbol to a block. If p = 0 the block is created. */
 extern symbol * add_symbol_to_b(symbol * p, symbol ch) {
-    int k;
     if (p == NULL) p = create_b(1);
-    k = SIZE(p);
-    {
-        int x = k + 1 - CAPACITY(p);
-        if (x > 0) p = increase_capacity_b(p, x);
-    }
+    int k = SIZE(p);
+    int x = k + 1 - CAPACITY(p);
+    if (x > 0) p = increase_capacity_b(p, x);
     p[k] = ch;
-    SIZE(p)++;
+    ADD_TO_SIZE(p, 1);
     return p;
 }
 
 extern byte * create_s(int n) {
     byte * p = (byte *) (HEAD + (byte *) MALLOC(HEAD + (n + 1)));
     CAPACITY(p) = n;
-    SIZE(p) = 0;
+    SET_SIZE(p, 0);
+    return p;
+}
+
+extern byte * create_s_from_sz(const char * s) {
+    int n = strlen(s);
+    byte * p = create_s(n);
+    memcpy(p, s, n + 1);
+    SET_SIZE(p, n);
+    return p;
+}
+
+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;
 }
 
@@ -169,53 +195,66 @@ extern void lose_s(byte * p) {
 }
 
 extern byte * increase_capacity_s(byte * p, int n) {
-    byte * q = create_s(CAPACITY(p) + n + EXTENDER);
+    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));
-    SIZE(q) = 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);
+    return p;
+}
+
 extern byte * copy_s(const byte * p) {
-    return add_s_to_s(NULL, (const char*)p, SIZE(p));
+    return add_s_to_s(NULL, p);
 }
 
 /* Add a string with given length to a byte block. If p = 0 the
    block is created. */
 
-extern byte * add_s_to_s(byte * p, const char * s, int n) {
-    int k;
-    if (p == NULL) p = create_s(n);
-    k = SIZE(p);
-    {
-        int x = k + n - CAPACITY(p);
-        if (x > 0) p = increase_capacity_s(p, x);
+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);
     }
+    int k = SIZE(p);
     memcpy(p + k, s, n);
-    SIZE(p) += n;
+    SET_SIZE(p, k + n);
     return p;
 }
 
+/* Add a byte block to a byte block. If p = 0 the
+   block is created. */
+
+extern byte * add_s_to_s(byte * p, const byte * s) {
+    return add_slen_to_s(p, (const char *)s, SIZE(s));
+}
+
 /* Add a zero terminated string to a byte block. If p = 0 the
    block is created. */
 
 extern byte * add_sz_to_s(byte * p, const char * s) {
-    return add_s_to_s(p, s, strlen(s));
+    return add_slen_to_s(p, s, strlen(s));
 }
 
 /* Add a single character to a byte block. If p = 0 the
    block is created. */
 
 extern byte * add_char_to_s(byte * p, char ch) {
-    int k;
-    if (p == NULL) p = create_s(1);
-    k = SIZE(p);
-    {
-        int x = k + 1 - CAPACITY(p);
-        if (x > 0) p = increase_capacity_s(p, x);
+    if (p == NULL) {
+        p = create_s(1);
+    } else {
+        p = ensure_capacity_s(p, 1);
     }
-    p[k] = ch;
-    SIZE(p)++;
+    p[SIZE(p)] = ch;
+    ADD_TO_SIZE(p, 1);
     return p;
 }
 
@@ -242,8 +281,7 @@ extern void str_delete(struct str * str) {
 
 /* Append a str to this str. */
 extern void str_append(struct str * str, const struct str * add) {
-    byte * q = add->data;
-    str->data = add_s_to_s(str->data, (char *)q, SIZE(q));
+    str->data = add_s_to_s(str->data, add->data);
 }
 
 /* Append a character to this str. */
@@ -253,7 +291,7 @@ extern void str_append_ch(struct str * str, char add) {
 
 /* Append a low level byte block to a str. */
 extern void str_append_s(struct str * str, const byte * q) {
-    str->data = add_s_to_s(str->data, (const char *)q, SIZE(q));
+    str->data = add_s_to_s(str->data, q);
 }
 
 /* Append a (char *, null terminated) string to a str. */
@@ -263,9 +301,18 @@ extern void str_append_string(struct str * str, const char * s) {
 
 /* Append an integer to a str. */
 extern void str_append_int(struct str * str, int i) {
-    char s[30];
-    sprintf(s, "%d", i);
-    str_append_string(str, s);
+    // Most calls are for integers 0 to 9 (~72%).
+    if (i >= 0 && i <= 9) {
+        str_append_ch(str, '0' + i);
+        return;
+    }
+
+    // Ensure there's enough space then snprintf() directly onto the end.
+    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);
+    ADD_TO_SIZE(str->data, r);
 }
 
 /* Append wide character to a string as UTF-8. */
@@ -286,7 +333,7 @@ extern void str_append_wchar_as_utf8(struct str * str, symbol ch) {
 
 /* Clear a string */
 extern void str_clear(struct str * str) {
-    SIZE(str->data) = 0;
+    SET_SIZE(str->data, 0);
 }
 
 /* Set a string */
@@ -325,16 +372,27 @@ extern int str_back(const struct str *str) {
  * Or do nothing if the string is empty.
  */
 extern void str_pop(const struct str *str) {
-    if (SIZE(str->data)) --SIZE(str->data);
+    if (SIZE(str->data)) ADD_TO_SIZE(str->data, -1);
+}
+
+/* Remove the last n characters of the str.
+ *
+ * Or make the string empty if its length is less than n.
+ */
+extern void str_pop_n(const struct str *str, int n) {
+    if (SIZE(str->data) > n) {
+        ADD_TO_SIZE(str->data, -n);
+    } else {
+        SET_SIZE(str->data, 0);
+    }
 }
 
 extern int get_utf8(const symbol * p, int * slot) {
-    int b0, b1;
-    b0 = *p++;
+    int b0 = *p++;
     if (b0 < 0xC0) {   /* 1100 0000 */
         * slot = b0; return 1;
     }
-    b1 = *p++;
+    int b1 = *p++;
     if (b0 < 0xE0) {   /* 1110 0000 */
         * slot = (b0 & 0x1F) << 6 | (b1 & 0x3F); return 2;
     }