mittens 0.3.1 → 0.3.2

data/vendor/snowball/compiler/driver.c

@@ -9,6 +9,8 @@
 #define DEFAULT_JAVA_AMONG_CLASS "org.tartarus.snowball.Among"
 #define DEFAULT_JAVA_STRING_CLASS "java.lang.StringBuilder"
 
+#define DEFAULT_DART_BASE_CLASS "SnowballProgram"
+
 #define DEFAULT_GO_PACKAGE "snowball"
 #define DEFAULT_GO_SNOWBALL_RUNTIME "github.com/snowballstem/snowball/go"
 
@@ -20,7 +22,10 @@
 #define DEFAULT_CS_AMONG_CLASS "Among"
 #define DEFAULT_CS_STRING_CLASS "StringBuilder"
 
-#define DEFAULT_JS_BASE_CLASS "BaseStemmer"
+#define DEFAULT_CPLUSPLUS_NAMESPACE "Snowball"
+#define DEFAULT_CPLUSPLUS_BASE_CLASS "Stemmer"
+
+#define DEFAULT_JS_BASE_CLASS "B"
 
 #define DEFAULT_PYTHON_BASE_CLASS "BaseStemmer"
 
@@ -33,33 +38,21 @@ static void print_arglist(int exit_code) {
     fprintf(f, "Usage: snowball SOURCE_FILE... [OPTIONS]\n\n"
                "Supported options:\n"
                "  -o, -output OUTPUT_BASE\n"
-               "  -s, -syntax\n"
-               "  -comments\n"
-#ifndef DISABLE_JAVA
-               "  -j, -java\n"
-#endif
-#ifndef DISABLE_CSHARP
-               "  -cs, -csharp\n"
-#endif
-               "  -c++\n"
-#ifndef DISABLE_PASCAL
-               "  -pascal\n"
-#endif
-#ifndef DISABLE_PYTHON
-               "  -py, -python\n"
-#endif
-#ifndef DISABLE_JS
+               "  -s, -syntax                      show syntax tree and stop\n"
+               "  -comments                        generate comments\n"
+               "  -coverage                        generate coverage report\n"
+               "  -ada                             generate Ada\n"
+               "  -c++                             generate C++\n"
+               "  -cs, -csharp                     generate C#\n"
+               "  -dart                            generate Dart\n"
+               "  -go                              generate Go\n"
+               "  -j, -java                        generate Java\n"
                "  -js                              generate Javascript\n"
-#endif
-#ifndef DISABLE_RUST
-               "  -rust\n"
-#endif
-#ifndef DISABLE_GO
-               "  -go\n"
-#endif
-#ifndef DISABLE_ADA
-               "  -ada\n"
-#endif
+               "  -pascal                          generate Pascal\n"
+               "  -php                             generate PHP\n"
+               "  -py, -python                     generate Python\n"
+               "  -rust                            generate Rust\n"
+               "  -zig                             generate Zig\n"
                "  -w, -widechars\n"
                "  -u, -utf8\n"
                "  -n, -name CLASS_NAME\n"
@@ -67,16 +60,13 @@ static void print_arglist(int exit_code) {
                "  -vp, -vprefix VARIABLE_PREFIX\n"
                "  -i, -include DIRECTORY\n"
                "  -r, -runtime DIRECTORY\n"
+               "  -cheader                         header name to include from C/C++ file\n"
+               "  -hheader                         header name to include from C/C++ header\n"
                "  -p, -parentclassname CLASS_NAME  fully qualified parent class name\n"
-#if !defined(DISABLE_JAVA) || !defined(DISABLE_CSHARP)
                "  -P, -Package PACKAGE_NAME        package name for stemmers\n"
                "  -S, -Stringclass STRING_CLASS    StringBuffer-compatible class\n"
                "  -a, -amongclass AMONG_CLASS      fully qualified name of the Among class\n"
-#endif
-#ifndef DISABLE_GO
-               "  -gop, -gopackage PACKAGE_NAME    Go package name for stemmers\n"
                "  -gor, -goruntime PACKAGE_NAME    Go snowball runtime package\n"
-#endif
                "  --help                           display this help and exit\n"
                "  --version                        output version information and exit\n"
            );
@@ -101,7 +91,8 @@ static FILE * get_output(byte * s) {
     return output;
 }
 
-static int read_options(struct options * o, int argc, char * argv[]) {
+static struct options * read_options(int * argc_ptr, char * argv[]) {
+    int argc = *argc_ptr;
     int i = 1;
     int new_argc = 1;
     /* Note down the last option used to specify an explicit encoding so
@@ -109,31 +100,18 @@ static int read_options(struct options * o, int argc, char * argv[]) {
      */
     const char * encoding_opt = NULL;
 
-    /* set defaults: */
-
-    o->output_file = NULL;
-    o->syntax_tree = false;
-    o->comments = false;
-    o->js_esm = false;
-    o->externals_prefix = NULL;
-    o->variables_prefix = NULL;
-    o->runtime_path = NULL;
-    o->parent_class_name = NULL;
-    o->string_class = NULL;
-    o->among_class = NULL;
-    o->package = NULL;
-    o->go_snowball_runtime = DEFAULT_GO_SNOWBALL_RUNTIME;
-    o->name = NULL;
-    o->make_lang = LANG_C;
-    o->includes = NULL;
-    o->includes_end = NULL;
+    NEW(options, o);
+    *o = (struct options){0};
+
+    // Set defaults which differ from empty initialisation.
+    o->target_lang = LANG_C;
     o->encoding = ENC_SINGLEBYTE;
 
     /* read options: */
 
     while (i < argc) {
         char * s = argv[i++];
-        if (s[0] != '-') {
+        if (s[0] != '-' || s[1] == '\0') {
             /* Non-option argument - shuffle down. */
             argv[new_argc++] = s;
             continue;
@@ -141,77 +119,67 @@ static int read_options(struct options * o, int argc, char * argv[]) {
 
         {
             if (eq(s, "-o") || eq(s, "-output")) {
-               check_lim(i, argc);
-                o->output_file = argv[i++];
+                check_lim(i, argc);
+                if (strcmp(argv[i], "-") == 0) {
+                    fprintf(stderr, "output to stdout not supported\n");
+                    exit(1);
+                }
+                o->output_file = create_s_from_sz(argv[i++]);
                 continue;
             }
             if (eq(s, "-n") || eq(s, "-name")) {
-                char * new_name;
-                size_t len;
-
                 check_lim(i, argc);
-                /* Take a copy of the argument here, because
-                 * later we will free o->name */
-                len = strlen(argv[i]);
-                new_name = MALLOC(len + 1);
-                memcpy(new_name, argv[i++], len);
-                new_name[len] = '\0';
-                o->name = new_name;
+                o->name = create_s_from_sz(argv[i++]);
                 continue;
             }
-#ifndef DISABLE_JS
             if (eq(s, "-js")) {
-                o->make_lang = LANG_JAVASCRIPT;
-                o->js_esm = false;
+                o->target_lang = LANG_JAVASCRIPT;
+                continue;
+            }
+            if (eq(s, "-php")) {
+                o->target_lang = LANG_PHP;
                 continue;
             }
-#endif
-#ifndef DISABLE_RUST
             if (eq(s, "-rust")) {
-                o->make_lang = LANG_RUST;
+                o->target_lang = LANG_RUST;
+                continue;
+            }
+            if (eq(s, "-zig")) {
+                o->target_lang = LANG_ZIG;
                 continue;
             }
-#endif
-#ifndef DISABLE_GO
             if (eq(s, "-go")) {
-                o->make_lang = LANG_GO;
+                o->target_lang = LANG_GO;
                 continue;
             }
-#endif
-#ifndef DISABLE_JAVA
             if (eq(s, "-j") || eq(s, "-java")) {
-                o->make_lang = LANG_JAVA;
+                o->target_lang = LANG_JAVA;
+                continue;
+            }
+            if (eq(s, "-dart")) {
+                o->target_lang = LANG_DART;
                 continue;
             }
-#endif
-#ifndef DISABLE_CSHARP
             if (eq(s, "-cs") || eq(s, "-csharp")) {
-                o->make_lang = LANG_CSHARP;
+                o->target_lang = LANG_CSHARP;
                 continue;
             }
-#endif
             if (eq(s, "-c++")) {
-                o->make_lang = LANG_CPLUSPLUS;
+                o->target_lang = LANG_CPLUSPLUS;
                 continue;
             }
-#ifndef DISABLE_PASCAL
             if (eq(s, "-pascal")) {
-                o->make_lang = LANG_PASCAL;
+                o->target_lang = LANG_PASCAL;
                 continue;
             }
-#endif
-#ifndef DISABLE_PYTHON
             if (eq(s, "-py") || eq(s, "-python")) {
-                o->make_lang = LANG_PYTHON;
+                o->target_lang = LANG_PYTHON;
                 continue;
             }
-#endif
-#ifndef DISABLE_ADA
             if (eq(s, "-ada")) {
-                o->make_lang = LANG_ADA;
+                o->target_lang = LANG_ADA;
                 continue;
             }
-#endif
             if (eq(s, "-w") || eq(s, "-widechars")) {
                 encoding_opt = s;
                 o->encoding = ENC_WIDECHARS;
@@ -225,6 +193,10 @@ static int read_options(struct options * o, int argc, char * argv[]) {
                 o->comments = true;
                 continue;
             }
+            if (eq(s, "-coverage")) {
+                o->coverage = true;
+                continue;
+            }
             if (eq(s, "-ep") || eq(s, "-eprefix")) {
                 check_lim(i, argc);
                 o->externals_prefix = argv[i++];
@@ -235,14 +207,25 @@ static int read_options(struct options * o, int argc, char * argv[]) {
                 o->variables_prefix = argv[i++];
                 continue;
             }
+            if (eq(s, "-cheader")) {
+                check_lim(i, argc);
+                o->cheader = argv[i++];
+                continue;
+            }
+            if (eq(s, "-hheader")) {
+                check_lim(i, argc);
+                o->hheader = argv[i++];
+                continue;
+            }
             if (eq(s, "-i") || eq(s, "-include")) {
                 check_lim(i, argc);
 
                 {
                     NEW(include, p);
+                    *p = (struct include){0};
                     byte * include_dir = add_sz_to_s(NULL, argv[i++]);
                     include_dir = add_char_to_s(include_dir, '/');
-                    p->next = NULL; p->s = include_dir;
+                    p->s = include_dir;
 
                     if (o->includes == NULL) {
                         o->includes = p;
@@ -268,7 +251,6 @@ static int read_options(struct options * o, int argc, char * argv[]) {
                 o->parent_class_name = argv[i++];
                 continue;
             }
-#if !defined(DISABLE_JAVA) || !defined(DISABLE_CSHARP)
             if (eq(s, "-P") || eq(s, "-Package")) {
                 check_lim(i, argc);
                 o->package = argv[i++];
@@ -284,19 +266,11 @@ static int read_options(struct options * o, int argc, char * argv[]) {
                 o->among_class = argv[i++];
                 continue;
             }
-#endif
-#ifndef DISABLE_GO
-            if (eq(s, "-gop") || eq(s, "-gopackage")) {
-                check_lim(i, argc);
-                o->package = argv[i++];
-                continue;
-            }
             if (eq(s, "-gor") || eq(s, "-goruntime")) {
                 check_lim(i, argc);
                 o->go_snowball_runtime = argv[i++];
                 continue;
             }
-#endif
             if (eq(s, "--help")) {
                 print_arglist(0);
             }
@@ -317,10 +291,16 @@ static int read_options(struct options * o, int argc, char * argv[]) {
     argv[new_argc] = NULL;
 
     /* Set language-dependent defaults. */
-    switch (o->make_lang) {
+    switch (o->target_lang) {
         case LANG_C:
+            encoding_opt = NULL;
+            break;
         case LANG_CPLUSPLUS:
             encoding_opt = NULL;
+            if (!o->parent_class_name)
+                o->parent_class_name = DEFAULT_CPLUSPLUS_BASE_CLASS;
+            if (!o->package)
+                o->package = DEFAULT_CPLUSPLUS_NAMESPACE;
             break;
         case LANG_CSHARP:
             o->encoding = ENC_WIDECHARS;
@@ -337,6 +317,8 @@ static int read_options(struct options * o, int argc, char * argv[]) {
             o->encoding = ENC_UTF8;
             if (!o->package)
                 o->package = DEFAULT_GO_PACKAGE;
+            if (!o->go_snowball_runtime)
+                o->go_snowball_runtime = DEFAULT_GO_SNOWBALL_RUNTIME;
             break;
         case LANG_ADA:
             o->encoding = ENC_UTF8;
@@ -354,11 +336,19 @@ static int read_options(struct options * o, int argc, char * argv[]) {
             if (!o->package)
                 o->package = DEFAULT_JAVA_PACKAGE;
             break;
+        case LANG_DART:
+            o->encoding = ENC_WIDECHARS;
+            if (!o->parent_class_name)
+                o->parent_class_name = DEFAULT_DART_BASE_CLASS;
+            break;
         case LANG_JAVASCRIPT:
             o->encoding = ENC_WIDECHARS;
             if (!o->parent_class_name)
                 o->parent_class_name = DEFAULT_JS_BASE_CLASS;
             break;
+        case LANG_PHP:
+            o->encoding = ENC_UTF8;
+            break;
         case LANG_PYTHON:
             o->encoding = ENC_WIDECHARS;
             if (!o->parent_class_name)
@@ -367,6 +357,9 @@ static int read_options(struct options * o, int argc, char * argv[]) {
         case LANG_RUST:
             o->encoding = ENC_UTF8;
             break;
+        case LANG_ZIG:
+            o->encoding = ENC_UTF8;
+            break;
         default:
             break;
     }
@@ -376,247 +369,416 @@ static int read_options(struct options * o, int argc, char * argv[]) {
                 encoding_opt);
     }
 
-    if (o->make_lang != LANG_C && o->make_lang != LANG_CPLUSPLUS) {
+    if (o->target_lang != LANG_C && o->target_lang != LANG_CPLUSPLUS) {
         if (o->runtime_path) {
             fprintf(stderr, "warning: -r/-runtime only meaningful for C and C++\n");
         }
-        if (o->externals_prefix) {
-            fprintf(stderr, "warning: -ep/-eprefix only meaningful for C and C++\n");
+        if (o->variables_prefix) {
+            fprintf(stderr, "warning: -vp/-vprefix only meaningful for C and C++\n");
+        }
+        if (o->coverage) {
+            fprintf(stderr, "warning: -coverage only currently supported for C and C++\n");
         }
     }
-    if (!o->externals_prefix) o->externals_prefix = "";
 
-    if (!o->name && o->output_file) {
-        /* Default class name to basename of output_file - this is the standard
-         * convention for at least Java and C#.
-         */
-        const char * slash = strrchr(o->output_file, '/');
-        size_t len;
-        const char * leaf = (slash == NULL) ? o->output_file : slash + 1;
+    // Split any extension off o->output_file and set o->output_leaf to just
+    // its leafname (which e.g. is used to generate `#include "english.h"` in
+    // path/to/english.c).
+    if (!o->output_file) {
+        // Default output uses the basename from the first Snowball source.
+        // E.g. algorithms/english.sbl -> english
+        const char * first_source = argv[1];
+        const char * slash = strrchr(first_source, '/');
+        const char * leaf = (slash == NULL) ? first_source : slash + 1;
 
         slash = strrchr(leaf, '\\');
         if (slash != NULL) leaf = slash + 1;
 
-        {
-            const char * dot = strchr(leaf, '.');
-            len = (dot == NULL) ? strlen(leaf) : (size_t)(dot - leaf);
+        const char * dot = strrchr(leaf, '.');
+        if (dot) {
+            o->output_file = create_s_from_data(leaf, dot - leaf);
+        } else {
+            o->output_file = create_s_from_sz(leaf);
         }
+        o->output_leaf = copy_s(o->output_file);
+    } else {
+        // Remove any extension from o->output_file so `-o path/to/english.c`
+        // works.
+        o->output_file[SIZE(o->output_file)] = '\0';
+        const char * output_file = (const char *)o->output_file;
+        const char * slash = strrchr(output_file, '/');
+        const char * leaf = (slash == NULL) ? output_file : slash + 1;
 
-        {
-            char * new_name = MALLOC(len + 1);
-            switch (o->make_lang) {
-                case LANG_CSHARP:
-                case LANG_PASCAL:
-                    /* Upper case initial letter. */
-                    memcpy(new_name, leaf, len);
-                    new_name[0] = toupper(new_name[0]);
-                    break;
-                case LANG_JAVASCRIPT:
-                case LANG_PYTHON: {
-                    /* Upper case initial letter and change each
-                     * underscore+letter or hyphen+letter to an upper case
-                     * letter.
-                     */
-                    size_t new_len = 0;
-                    int uc_next = true;
-                    for (size_t j = 0; j != len; ++j) {
-                        unsigned char ch = leaf[j];
-                        if (ch == '_' || ch == '-') {
-                            uc_next = true;
+        slash = strrchr(leaf, '\\');
+        if (slash != NULL) leaf = slash + 1;
+
+        const char * dot = strrchr(leaf, '.');
+        if (dot) {
+            o->extension = create_s_from_sz(dot);
+            SET_SIZE(o->output_file, dot - output_file);
+            o->output_leaf = create_s_from_data(leaf, dot - leaf);
+        } else {
+            o->output_leaf = create_s_from_sz(leaf);
+        }
+    }
+
+    if (!o->name) {
+        o->name = copy_s(o->output_leaf);
+        const byte * dot = memchr(o->name, '.', SIZE(o->name));
+        if (dot) {
+            // Trim off any extension (we only remove the last of multiple
+            // extensions above).
+            SET_SIZE(o->name, dot - o->name);
+        }
+        switch (o->target_lang) {
+            case LANG_CSHARP:
+            case LANG_PASCAL:
+                /* Upper case initial letter. */
+                o->name[0] = toupper(o->name[0]);
+                break;
+            case LANG_CPLUSPLUS:
+            case LANG_PHP:
+            case LANG_PYTHON: {
+                /* Upper case initial letter and change each
+                 * underscore+letter or hyphen+letter to an upper case
+                 * letter.
+                 */
+                size_t len = SIZE(o->name);
+                size_t new_len = 0;
+                bool uc_next = true;
+                for (size_t j = 0; j != len; ++j) {
+                    byte ch = o->name[j];
+                    if (ch == '_' || ch == '-') {
+                        uc_next = true;
+                    } else {
+                        if (uc_next) {
+                            o->name[new_len] = toupper(ch);
+                            uc_next = false;
                         } else {
-                            if (uc_next) {
-                                new_name[new_len] = toupper(ch);
-                                uc_next = false;
-                            } else {
-                                new_name[new_len] = ch;
-                            }
-                            ++new_len;
+                            o->name[new_len] = ch;
                         }
+                        ++new_len;
                     }
-                    len = new_len;
-                    break;
                 }
-                default:
-                    /* Just copy. */
-                    memcpy(new_name, leaf, len);
-                    break;
+                SET_SIZE(o->name, new_len);
+                break;
             }
-            new_name[len] = '\0';
-            o->name = new_name;
+            default:
+                /* Just use as-is, e.g. that's the Java convention. */
+                break;
         }
     }
 
-    return new_argc;
+    *argc_ptr = new_argc;
+    return o;
 }
 
 extern int main(int argc, char * argv[]) {
-    int i;
-    NEW(options, o);
-    argc = read_options(o, argc, argv);
-    {
-        char * file = argv[1];
-        byte * u = get_input(file);
+    struct options * o = read_options(&argc, argv);
+    char * file = argv[1];
+    byte * u = get_input(file);
+    if (u == NULL) {
+        fprintf(stderr, "Can't open input %s\n", file);
+        exit(1);
+    }
+
+    struct tokeniser * t = create_tokeniser(u, file);
+    struct analyser * a = create_analyser(t);
+    struct input ** next_input_ptr = &(t->next);
+    unsigned localise_mask = 0;
+    a->encoding = t->encoding = o->encoding;
+    t->includes = o->includes;
+    /* If multiple source files are specified, set up the others to be
+     * read after the first in order, using the same mechanism as
+     * 'get' uses. */
+    for (int i = 2; i != argc; ++i) {
+        NEW(input, q);
+        *q = (struct input){0};
+        file = argv[i];
+        u = get_input(file);
         if (u == NULL) {
             fprintf(stderr, "Can't open input %s\n", file);
             exit(1);
         }
-        {
-            struct tokeniser * t = create_tokeniser(u, file);
-            struct analyser * a = create_analyser(t);
-            struct input ** next_input_ptr = &(t->next);
-            a->encoding = t->encoding = o->encoding;
-            t->includes = o->includes;
-            /* If multiple source files are specified, set up the others to be
-             * read after the first in order, using the same mechanism as
-             * 'get' uses. */
-            for (i = 2; i != argc; ++i) {
-                NEW(input, q);
-                file = argv[i];
-                u = get_input(file);
-                if (u == NULL) {
-                    fprintf(stderr, "Can't open input %s\n", file);
-                    exit(1);
+        q->p = u;
+        q->file = file;
+        q->line_number = 1;
+        *next_input_ptr = q;
+        next_input_ptr = &(q->next);
+    }
+    *next_input_ptr = NULL;
+
+    /* Whether it's helpful to try to localise string variables varies
+     * greatly between target languages.  One reason for this is likely
+     * to be that strings are immutable in some languages (e.g. Dart,
+     * Javascript, Python) so each string operation creates a new
+     * string anyway.
+     *
+     * We've attempted to benchmark most languages to decide.
+     *
+     * One potential gotcha here is for garbage collected languages,
+     * where our benchmark might not trigger GC and in that case our
+     * timing is missing the cost of that, which any long running
+     * indexing process will eventually incur.
+     *
+     * We've mostly used the following artificial benchmark which
+     * exercises a local string variable to test this:
+     *
+     *   strings ( s )
+     *   routines ( r )
+     *   externals ( stem )
+     *   define r as (-> s s)
+     *   define stem as ( next [tolimit] loop 100000000 do r )
+     *
+     * Replace e.g. english.sbl with this and build the stemwords
+     * equivalent for the target language, then:
+     *
+     * $ echo nonalphabetisations|time ./stemwords
+     *
+     * The appropriate number of iterations to use varies, and is
+     * annotated below.
+     */
+    switch (o->target_lang) {
+        case LANG_ADA:
+            // 1000000000: local 13.7s vs global 5.2s
+        case LANG_C:
+            // We lack a way to generate lose_s(v) on every `return`
+            // from the function, but manually adjusting the generated
+            // code to do this gives:
+            //
+            // 1000000000: local 44.9s vs global 6.3s
+        case LANG_CPLUSPLUS:
+            // String variables are handled the same as LANG_C.
+        case LANG_CSHARP:
+            // 100000000: local 18.8s vs global 12.4s
+        case LANG_JAVA:
+            // 1000000000: local 10.1s vs global 7.1s
+        case LANG_RUST:
+            // 1000000000: localising was slightly slower.
+        case LANG_ZIG:
+            // 10000000: localising strings was slightly slower.
+            localise_mask = (1 << t_boolean) | (1 << t_integer);
+            break;
+        case LANG_DART:
+            // Not timed, but strings are immutable so seems likely
+            // to be helpful to localise.
+        case LANG_GO:
+            // 1000000000: localising was about 10% faster.
+        case LANG_JAVASCRIPT:
+            // 10000000: Slightly faster.
+        case LANG_PASCAL:
+            // Slightly faster.
+        case LANG_PHP:
+            // Slightly faster.
+        case LANG_PYTHON:
+            // 10000000: local 7.6s vs global 7.9s.  Microbenchmarking
+            // with timeit aligns with this.
+            localise_mask = (1 << t_boolean) | (1 << t_integer) | (1 << t_string);
+            break;
+    }
+    read_program(a, localise_mask);
+    if (t->error_count > 0) exit(1);
+    if (o->syntax_tree) print_program(a);
+    if (!o->syntax_tree) {
+        struct generator * g = create_generator(a, o);
+        switch (o->target_lang) {
+            case LANG_C:
+            case LANG_CPLUSPLUS: {
+                byte * s = copy_s(o->output_file);
+                s = add_literal_to_s(s, ".h");
+                o->output_h = get_output(s);
+                SET_SIZE(s, SIZE(o->output_file));
+                if (o->extension &&
+                    !(SIZE(o->extension) == 2 && memcmp(o->extension, ".h", 2) == 0)) {
+                    s = add_s_to_s(s, o->extension);
+                } else if (o->target_lang == LANG_CPLUSPLUS) {
+                    s = add_literal_to_s(s, ".cc");
+                } else {
+                    s = add_literal_to_s(s, ".c");
                 }
-                q->p = u;
-                q->c = 0;
-                q->file = file;
-                q->file_owned = 0;
-                q->line_number = 1;
-                *next_input_ptr = q;
-                next_input_ptr = &(q->next);
-            }
-            *next_input_ptr = NULL;
-            read_program(a);
-            if (t->error_count > 0) exit(1);
-            if (o->syntax_tree) print_program(a);
-            if (!o->syntax_tree) {
-                struct generator * g;
-
-                const char * output_base = o->output_file;
-                if (!output_base) {
-                    fprintf(stderr, "Please include the -o option\n");
-                    print_arglist(1);
+                o->output_src = get_output(s);
+                lose_s(s);
+
+                generate_program_c(g);
+                fclose(o->output_src);
+                fclose(o->output_h);
+                break;
+            }
+#ifndef TARGET_C_ONLY
+            case LANG_ADA: {
+                byte * s = copy_s(o->output_file);
+                s = add_literal_to_s(s, ".ads");
+                o->output_h = get_output(s);
+                SET_SIZE(s, SIZE(o->output_file));
+                if (o->extension &&
+                    !(SIZE(o->extension) == 4 && memcmp(o->extension, ".ads", 2) == 0)) {
+                    s = add_s_to_s(s, o->extension);
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".adb");
                 }
-                g = create_generator(a, o);
-                if (o->make_lang == LANG_C || o->make_lang == LANG_CPLUSPLUS) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".h");
-                    o->output_h = get_output(s);
-                    s[SIZE(s) - 1] = 'c';
-                    if (o->make_lang == LANG_CPLUSPLUS) {
-                        s = add_char_to_s(s, 'c');
-                    }
-                    o->output_src = get_output(s);
-                    lose_s(s);
+                o->output_src = get_output(s);
+                lose_s(s);
 
-                    generate_program_c(g);
-                    fclose(o->output_src);
-                    fclose(o->output_h);
+                generate_program_ada(g);
+                fclose(o->output_src);
+                fclose(o->output_h);
+                break;
+            }
+            case LANG_CSHARP: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".cs");
+                }
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_csharp(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_DART: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".dart");
+                }
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_dart(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_GO: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".go");
                 }
-#ifndef DISABLE_JAVA
-                if (o->make_lang == LANG_JAVA) {
-                    byte * s = add_sz_to_s(NULL, output_base);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_go(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_JAVA: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
                     s = add_literal_to_s(s, ".java");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_java(g);
-                    fclose(o->output_src);
                 }
-#endif
-#ifndef DISABLE_PASCAL
-                if (o->make_lang == LANG_PASCAL) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".pas");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_pascal(g);
-                    fclose(o->output_src);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_java(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_JAVASCRIPT: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".js");
                 }
-#endif
-#ifndef DISABLE_PYTHON
-                if (o->make_lang == LANG_PYTHON) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".py");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_python(g);
-                    fclose(o->output_src);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_js(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_PASCAL: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".pas");
                 }
-#endif
-#ifndef DISABLE_JS
-                if (o->make_lang == LANG_JAVASCRIPT) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    if (o->js_esm) {
-                        s = add_literal_to_s(s, ".mjs");
-                    } else {
-                        s = add_literal_to_s(s, ".js");
-                    }
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_js(g);
-                    fclose(o->output_src);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_pascal(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_PHP: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".php");
                 }
-#endif
-#ifndef DISABLE_CSHARP
-                if (o->make_lang == LANG_CSHARP) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".cs");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_csharp(g);
-                    fclose(o->output_src);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_php(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_PYTHON: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".py");
                 }
-#endif
-#ifndef DISABLE_RUST
-                if (o->make_lang == LANG_RUST) {
-                    byte * s = add_sz_to_s(NULL, output_base);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_python(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_RUST: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
                     s = add_literal_to_s(s, ".rs");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_rust(g);
-                    fclose(o->output_src);
                 }
-#endif
-#ifndef DISABLE_GO
-                if (o->make_lang == LANG_GO) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".go");
-                    o->output_src = get_output(s);
-                    lose_s(s);
-                    generate_program_go(g);
-                    fclose(o->output_src);
-                }
-#endif
-#ifndef DISABLE_ADA
-                if (o->make_lang == LANG_ADA) {
-                    byte * s = add_sz_to_s(NULL, output_base);
-                    s = add_literal_to_s(s, ".ads");
-                    o->output_h = get_output(s);
-                    s[SIZE(s) - 1] = 'b';
-                    o->output_src = get_output(s);
-                    lose_s(s);
-
-                    generate_program_ada(g);
-                    fclose(o->output_src);
-                    fclose(o->output_h);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_rust(g);
+                fclose(o->output_src);
+                break;
+            }
+            case LANG_ZIG: {
+                byte * s = copy_s(o->output_file);
+                if (o->extension) {
+                    s = add_s_to_s(s, o->extension);
+                } else {
+                    s = add_literal_to_s(s, ".zig");
                 }
-#endif
-                close_generator(g);
+                o->output_src = get_output(s);
+                lose_s(s);
+                generate_program_zig(g);
+                fclose(o->output_src);
+                break;
             }
-            close_tokeniser(t);
-            close_analyser(a);
+#else
+            default:
+                fprintf(stderr, "Support for requested target language not enabled\n");
+                exit(1);
+#endif
         }
-        lose_s(u);
+        close_generator(g);
     }
-    {   struct include * p = o->includes;
-        while (p) {
-            struct include * q = p->next;
-            lose_s(p->s);
-            FREE(p);
-            p = q;
-        }
+    close_tokeniser(t);
+    close_analyser(a);
+    lose_s(u);
+
+    struct include * p = o->includes;
+    while (p) {
+        struct include * q = p->next;
+        lose_s(p->s);
+        FREE(p);
+        p = q;
     }
-    FREE(o->name);
+
+    lose_s(o->extension);
+    lose_s(o->name);
+    lose_s(o->output_file);
+    lose_s(o->output_leaf);
     FREE(o);
     if (space_count) fprintf(stderr, "%d blocks unfreed\n", space_count);
     return 0;