mittens 0.3.0 → 0.3.2

data/vendor/snowball/compiler/header.h

@@ -1,21 +1,27 @@
 #include <stdio.h>
+#if __STDC_VERSION__ < 202311l
+# include <stdbool.h>
+#endif
 
-#define SNOWBALL_VERSION "3.0.1"
+#define SNOWBALL_VERSION "3.1.1"
 
 typedef unsigned char byte;
 typedef unsigned short symbol;
 
-#define true 1
-#define false 0
-
 #define MALLOC check_malloc
 #define FREE check_free
 
-#define NEW(type, p) struct type * p = (struct type *) MALLOC(sizeof(struct type))
-#define NEWVEC(type, p, n) struct type * p = (struct type *) MALLOC(sizeof(struct type) * (n))
+// Declare variable `V` of type `struct TYPE *` and dynamically allocate it.
+// We exit on allocation failure so `V` is always non-NULL.
+#define NEW(TYPE, V) struct TYPE * V = (struct TYPE *) MALLOC(sizeof(struct TYPE))
 
-#define SIZE(p)     ((int *)(p))[-1]
-#define CAPACITY(p) ((int *)(p))[-2]
+// Similar to NEW() but allocates an array of N objects of type `struct TYPE *`.
+#define NEWVEC(TYPE, V, N) struct TYPE * V = (struct TYPE *) MALLOC(sizeof(struct TYPE) * (N))
+
+#define SIZE(p)            ((const int *)(p))[-1]
+#define SET_SIZE(p, n)     ((int *)(p))[-1] = (n)
+#define ADD_TO_SIZE(p, n)  ((int *)(p))[-1] += (n)
+#define CAPACITY(p)        ((int *)(p))[-2]
 
 extern symbol * create_b(int n);
 extern void report_b(FILE * out, const symbol * p);
@@ -29,15 +35,20 @@ extern symbol * add_symbol_to_b(symbol * p, symbol ch);
 // These routines are like those above but work in byte instead of symbol.
 
 extern byte * create_s(int n);
+extern byte * create_s_from_sz(const char * s);
+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 * copy_s(const byte * p);
-extern byte * add_s_to_s(byte * p, const char * s, int n);
+extern byte * add_s_to_s(byte * p, const byte * s);
+extern byte * add_slen_to_s(byte * p, const char * s, int n);
 extern byte * add_sz_to_s(byte * p, const char * s);
 extern byte * add_char_to_s(byte * p, char ch);
 // "" LIT is a trick to make compilation fail if LIT is not a string literal.
-#define add_literal_to_s(P, LIT) add_s_to_s(P, "" LIT, sizeof(LIT) - 1)
+#define add_literal_to_s(P, LIT) add_slen_to_s(P, "" LIT, sizeof(LIT) - 1)
 
 struct str; /* defined in space.c */
 
@@ -56,12 +67,13 @@ extern byte * str_data(const struct str * str);
 extern int str_len(const struct str * str);
 extern int str_back(const struct str *str);
 extern void str_pop(const struct str *str);
+extern void str_pop_n(const struct str *str, int n);
 extern void output_str(FILE * outfile, struct str * str);
 
 extern int get_utf8(const symbol * p, int * slot);
 extern int put_utf8(int ch, symbol * p);
 
-typedef enum { ENC_SINGLEBYTE, ENC_UTF8, ENC_WIDECHARS } enc;
+typedef enum { ENC_SINGLEBYTE = 0, ENC_UTF8, ENC_WIDECHARS } enc;
 
 /* stringdef name and value */
 struct m_pair {
@@ -120,7 +132,7 @@ enum token_codes {
     c_literalstring,
 
     /* These token values are synthesised by the analyser. */
-    c_mathassign,
+    c_stringassign,
     c_neg,
     c_call,
     c_grouping,
@@ -130,12 +142,13 @@ enum token_codes {
     c_gopast_grouping,
     c_goto_non,
     c_gopast_non,
+    c_not_booltest,
 
     NUM_TOKEN_CODES
 };
 
 enum uplus_modes {
-    UPLUS_NONE,
+    UPLUS_NONE = 0,
     UPLUS_DEFINED,
     UPLUS_UNICODE
 };
@@ -157,18 +170,21 @@ struct tokeniser {
     // Used for c_name names.
     byte * s;
     int number;
+    // String escape start character or -1.
     int m_start;
+    // String escape end character.
     int m_end;
+    // Link list of stringdefs.
     struct m_pair * m_pairs;
+    // Nesting depth of get directives.
     int get_depth;
     int error_count;
     int token;
     int previous_token;
-    byte token_held;
-    byte token_reported_as_unexpected;
+    bool token_held;
+    bool token_reported_as_unexpected;
     enc encoding;
 
-    int omission;
     struct include * includes;
 
     /* Mode in which U+ has been used:
@@ -194,6 +210,13 @@ 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, ...)
+#ifdef __GNUC__
+    __attribute__ ((__format__ (__printf__, 3, 4)))
+#endif
+    ;
+
 struct node;
 
 struct name {
@@ -201,16 +224,24 @@ struct name {
     byte * s;
     byte type;                  /* t_string etc */
     byte mode;                  /* for routines, externals (m_forward, etc) */
-    byte referenced;
-    byte used_in_among;         /* Function used in among? */
-    byte value_used;            /* (For variables) is its value ever used? */
-    byte initialised;           /* (For variables) is it ever initialised? */
-    byte used_in_definition;    /* (grouping) used in grouping definition? */
-    struct node * definition;   /* for routines, externals */
-    int count;                  /* 0, 1, 2 for each type */
+    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 */
+    bool case_collision;        /* A name of the same type differs only by case */
+    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.
+    // Reachable names are then numbered 0, 1, 2, ... with separate numbering
+    // per type.
+    int count;
+    // Number of references to this name.
+    int references;
     struct grouping * grouping; /* for grouping names */
     struct node * used;         /* First use, or NULL if not used */
     struct name * local_to;     /* Local to one routine/external */
+    int among_index;            /* for functions used in among */
     int declaration_line_number;/* Line number of declaration */
 };
 
@@ -225,7 +256,11 @@ struct amongvec {
     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 */
-    int line_number; /* for diagnostics and stable sorting */
+    int line_number; /* for diagnostics */
+    int function_index; /* 1-based */
+    // 0-based index giving order of strings in source.  Used for stable
+    // sorting of amongvec entries and -coverage.
+    int string_index;
     struct name * function;
 };
 
@@ -234,15 +269,19 @@ struct among {
     struct amongvec * b;      /* pointer to the amongvec */
     int number;               /* amongs are numbered 0, 1, 2 ... */
     int literalstring_count;  /* in this among */
-    int command_count;        /* in this among (includes "no command" entries) */
+    int command_count;        /* in this among (excludes "no command" entries) */
     int nocommand_count;      /* number of "no command" entries in this among */
-    int function_count;       /* in this among */
-    int amongvar_needed;      /* do we need to set among_var? */
-    int always_matches;       /* will this among always match? */
+    int 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? */
+    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 {
@@ -266,14 +305,17 @@ struct node {
     // (e.g. 42, 2+2, lenof '{U+0246}') from constant AEs which can have a
     // different value depending on platform and/or target language and/or
     // Unicode mode (e.g. maxint, sizeof '{U+0246}') - some warnings which
-    // depend on a constant AEs value should only fire for the first set.
-    byte fixed_constant;
+    // depend on a constant AE's value should only fire for the first set.
+    bool fixed_constant;
+    // Return 0 for always f.
+    // Return 1 for always t.
+    // Return -1 for don't know (or can raise t or f).
+    signed char possible_signals;
     struct node * AE;
     struct name * name;
     symbol * literalstring;
     int number;
     int line_number;
-    int amongvar_needed;   /* used in routine definitions */
 };
 
 enum name_types {
@@ -285,37 +327,32 @@ enum name_types {
 /*  If this list is extended, adjust write_varname in generator.c  */
 };
 
-/*  In name_count[i] below, remember that
-    type   is
-    ----+----
-      0 |  string
-      1 |  boolean
-      2 |  integer
-      3 |  routine
-      4 |  external
-      5 |  grouping
-*/
-
 struct analyser {
     struct tokeniser * tokeniser;
     struct node * nodes;
     struct name * names;
     struct literalstring * literalstrings;
     byte mode;
-    byte modifyable;          /* false inside reverse(...) */
+    bool modifyable;          /* false inside reverse(...) */
     struct node * program;
     struct node * program_end;
-    int name_count[t_size];   /* name_count[i] counts the number of names of type i */
+    /* name_count[i] counts the number of names of type i, where i is an enum
+     * name_types value.  These counts *EXCLUDE* localised variables and
+     * variables which optimised away (e.g. declared but never used).
+     */
+    int name_count[t_size];
+    /* name_count[t_string] + name_count[t_boolean] + name_count[t_integer] */
+    int variable_count;
     struct among * amongs;
     struct among * amongs_end;
-    int among_count;
-    int amongvar_needed;      /* used in reading routine definitions */
     int among_with_function_count; /* number of amongs with functions */
     struct grouping * groupings;
     struct grouping * groupings_end;
     struct node * substring;  /* pending 'substring' in current routine definition */
+    struct name * current_routine; /* routine/external we're currently on. */
     enc encoding;
-    byte int_limits_used;     /* are maxint or minint used? */
+    bool int_limits_used;     /* are maxint or minint used? */
+    bool debug_used;          /* is the '?' command used? */
 };
 
 enum analyser_modes {
@@ -330,20 +367,22 @@ extern void print_program(struct analyser * a);
 extern struct analyser * create_analyser(struct tokeniser * t);
 extern void close_analyser(struct analyser * a);
 
-extern void read_program(struct analyser * a);
+/** Read and analyse the program.
+ *
+ *  @param localise_mask  bitmask of variable types the generator can localise
+ */
+extern void read_program(struct analyser * a, unsigned localise_mask);
 
 struct generator {
     struct analyser * analyser;
     struct options * options;
-    int unreachable;           /* 0 if code can be reached, 1 if current code
-                                * is unreachable. */
+    bool unreachable;          /* false if code can be reached, true if current
+                                * code is unreachable. */
     int var_number;            /* Number of next variable to use. */
     struct str * outbuf;       /* temporary str to store output */
     struct str * declarations; /* str storing variable declarations */
     int next_label;
-#ifndef DISABLE_PYTHON
-    int max_label;
-#endif
+    int max_label;             /* Only used by Python */
     int margin;
 
     /* Target language code to execute in case of failure. */
@@ -357,15 +396,19 @@ struct generator {
     const char * S[10];  /* strings */
     byte * B[10];        /* byte blocks */
     int I[10];           /* integers */
-    struct name * V[5];  /* variables */
-    symbol * L[5];       /* literals, used in formatted write */
 
     int line_count;      /* counts number of lines output */
     int line_labelled;   /* in ISO C, will need extra ';' if it is a block end */
     int literalstring_count;
     int keep_count;      /* used to number keep/restore pairs to avoid compiler warnings
                             about shadowed variables */
-    int temporary_used;  /* track if temporary variable used (Ada and Pascal) */
+    bool temporary_used; /* track if temporary variable used (Ada and Pascal) */
+    char java_import_arrays; /* need `import java.util.Arrays;` */
+    char java_import_chararraysequence; /* need `import org.tartarus.snowball.CharArraySequence;` */
+    // Prefix for generated variable names (`v_` by default).
+    const char * varname_prefix;
+    // String to indent by for each margin level (four spaces by default).
+    const char * margin_indent;
 };
 
 /* Special values for failure_label in struct generator. */
@@ -375,17 +418,37 @@ enum special_labels {
 
 struct options {
     /* for the command line: */
-    const char * output_file;
-    char * name;
+    byte * output_file;
+    // output_file but without any path.
+    byte * output_leaf;
+    // Extension specified in -o option (or NULL if none).
+    byte * extension;
+    byte * name;
     FILE * output_src;
     FILE * output_h;
-    byte syntax_tree;
-    byte comments;
-    byte js_esm;
+    bool syntax_tree;
+    bool comments;
+    bool coverage;
     enc encoding;
-    enum { LANG_JAVA, LANG_C, LANG_CPLUSPLUS, LANG_CSHARP, LANG_PASCAL, LANG_PYTHON, LANG_JAVASCRIPT, LANG_RUST, LANG_GO, LANG_ADA } make_lang;
+    enum {
+        LANG_C = 0, // We generate C by default.
+        LANG_ADA,
+        LANG_CPLUSPLUS,
+        LANG_CSHARP,
+        LANG_DART,
+        LANG_GO,
+        LANG_JAVA,
+        LANG_JAVASCRIPT,
+        LANG_PASCAL,
+        LANG_PHP,
+        LANG_PYTHON,
+        LANG_RUST,
+        LANG_ZIG
+    } target_lang;
     const char * externals_prefix;
     const char * variables_prefix;
+    const char * cheader;
+    const char * hheader;
     const char * runtime_path;
     const char * parent_class_name;
     const char * package;
@@ -401,64 +464,68 @@ struct options {
 extern struct generator * create_generator(struct analyser * a, struct options * o);
 extern void close_generator(struct generator * g);
 
+static inline int new_label(struct generator * g) {
+    return g->next_label++;
+}
+
+extern struct str * vars_newname(struct generator * g);
+
+extern void write_margin(struct generator * g);
+
 extern void write_char(struct generator * g, int ch);
 extern void write_newline(struct generator * g);
 extern void write_string(struct generator * g, const char * s);
 extern void write_wchar_as_utf8(struct generator * g, symbol ch);
 extern void write_int(struct generator * g, int i);
-extern void write_hex4(struct generator * g, int ch);
+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_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);
 extern void write_c_relop(struct generator * g, int relop);
 
-extern void write_comment_content(struct generator * g, struct node * p);
+extern void write_comment_content(struct generator * g, struct node * p,
+                                  const char * end);
 extern void write_generated_comment_content(struct generator * g);
 extern void write_start_comment(struct generator * g,
                                 const char * comment_start,
                                 const char * comment_end);
 
-extern int K_needed(struct generator * g, struct node * p);
-extern int repeat_restore(struct generator * g, struct node * p);
-extern int check_possible_signals_list(struct generator * g,
-                                       struct node * p,
-                                       int type,
-                                       int call_depth);
+extern int K_needed(struct node * p);
+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 int just_return_on_fail(struct generator * g);
+extern int tailcallable(struct generator * g, struct node * p);
 
 /* Generator for C code. */
 extern void generate_program_c(struct generator * g);
 
-#ifndef DISABLE_JAVA
 /* Generator for Java code. */
 extern void generate_program_java(struct generator * g);
-#endif
 
-#ifndef DISABLE_CSHARP
+/* Generator for Dart code. */
+extern void generate_program_dart(struct generator * g);
+
 /* Generator for C# code. */
 extern void generate_program_csharp(struct generator * g);
-#endif
 
-#ifndef DISABLE_PASCAL
 extern void generate_program_pascal(struct generator * g);
-#endif
 
-#ifndef DISABLE_PYTHON
+extern void generate_program_php(struct generator * g);
+
 /* Generator for Python code. */
 extern void generate_program_python(struct generator * g);
-#endif
 
-#ifndef DISABLE_JS
 extern void generate_program_js(struct generator * g);
-#endif
 
-#ifndef DISABLE_RUST
 extern void generate_program_rust(struct generator * g);
-#endif
 
-#ifndef DISABLE_GO
 extern void generate_program_go(struct generator * g);
-#endif
 
-#ifndef DISABLE_ADA
 extern void generate_program_ada(struct generator * g);
-#endif
+
+extern void generate_program_zig(struct generator * g);