mittens 0.3.1 → 0.3.2

data/vendor/snowball/NEWS

@@ -1,3 +1,1390 @@
+Snowball 3.1.1 (2026-06-03)
+===========================
+
+Compiler changes
+----------------
+
+* Bug fixes:
+
+  + Fix a segmentation fault after reporting an error for a string command
+    not followed by a string variable name or string literal.  Bug introduced
+    in 3.1.0.  Patch from Jerry James (#287).
+
+* Compiler command-line options:
+
+  + Emit an error for `-o -`/`-output -`.  Output to stdout is not supported
+    because we need to generate multiple files for some target languages.
+    We were interpreting `-` as a base filename to append extensions to, so
+    we'd create `-.c` and `-.h` for C, but creating filenames that start with
+    `-` seems unhelpful.
+
+Generic code generation changes
+-------------------------------
+
+* Bug fixes:
+
+  + Variable localisation was failing to check the expression on the RHS of an
+    integer test for uses of a variable, so could incorrectly localise an
+    integer variable whose value should have persisted between calls to a
+    function.  This bug won't realistically manifest in real world Snowball
+    code.
+
+* Optimisations:
+
+  + Inline some routines which are only used once.  This is done for routines
+    consisting of a single non-compound command (or cases such as `not
+    <boolean>` and `goto <grouping>` which we internally synthesise a
+    non-compound command for).  Localisation of variables happens after
+    inlining, so variables can now be localised in more cases.
+
+  + `test next` and `not next` are both now simplified to a comparison between
+    `cursor` and `limit` (like `not atlimit` and `atlimit`).  We already
+    normalise `hop 1` to `next`, so `test hop 1` and `not hop 1` are also
+    simplified in this way.
+
+  + Simplify `not` applied to an integer test by removing the `not` and
+    flipping the sense of the test (e.g. `not $(x > y)` becomes `$(x <= y)`)
+    which results in simpler generated code.  More usefully in real world code,
+    this also results in simpler generated code for `not atlimit` (since
+    `atlimit` is converted `$(cursor >= limit)` or `$(cursor <= limit)`
+    (depending on the current direction).
+
+  + Canonicalise `delete` to `<-''`.  3.1.0 added a canonicalisation of `<-''`
+    to `delete`, but if we instead make `<-''` the canonical representation
+    then the generators can easily handle an empty string here specially (and
+    if they don't then the results are still correct), we don't have to handle
+    the delete token after tokenisation, and the optimisation of among when
+    all actions are `<-` plus a literal string can also fire when some actions
+    are `delete`.  (This case occurs in the stemmers for arabic, czech,
+    estonian, hungarian, irish, italian, polish, porter and tamil.)
+
+C++
+---
+
+* Code quality:
+
+  + C++ runtime support is now fully hooked up and can be tested using
+    `make check_cxx`.
+
+  + Don't use `extern "C"` for functions which can throw because MSVC seems to
+    treat such functions as if they were marked `noexcept`.
+
+Javascript
+----------
+
+* Code quality:
+
+  + Fix formatting of code generated by `among` of `<-` optimisation where we
+    were emitting a literal `+` rather than increasing the margin size.  The
+    `+` was actually harmless in practice, but the rest of the file would be
+    misindented.
+
+Python
+------
+
+* Other changes:
+
+  + Skip classifier for Sesotho which isn't yet in the official list of
+    trove classifiers.  Patch from Dmitry Shachnev (#289).
+
+  + Add classifier to indicate support for Python 3.14.
+
+Build system
+------------
+
+* The `generate` target added in 3.1.0 now overrides `FPC` and `MCS` to do
+  nothing, to avoid compiling Pascal and C# code.
+
+* Provide way to run tests under valgrind:
+
+    make RUN_STEMWORDS='valgrind ./stemwords' check
+
+Testsuite
+---------
+
+* compilertest: Require syntax tests have stderr output - we are testing errors
+  here, so we should really be checking the errors we get are the ones we
+  expect.  We expect the compiler to fail, so testing stderr means we will
+  catch unrelated failures.  This provides a regression test for #287.
+
+Documentation
+-------------
+
+* NEWS: Fix formatting/wording of a few existing entries.
+
+* README: List C++ as target language.
+
+Snowball 3.1.0 (2026-05-22)
+===========================
+
+Compiler changes
+----------------
+
+* Bug fixes:
+
+  + Fix segmentation fault if -syntax is used on a program with no code.
+
+  + Fix segmentation fault on some assignment syntax errors.
+
+  + Fix bug introduced in v3.0.0 with conversion of `among` starter.  If there
+    were any commands after the among in the same command list then the among
+    itself would get lost.  Not triggered by any current algorithms.
+
+  + Clear name field when removing dead assignments.  This is visible in the
+    syntax tree shown when command line option -syntax is used, but probably
+    doesn't affect anything otherwise.
+
+* Compiler command-line options:
+
+  + Using `-` for the Snowball source file is now interpreted as stdin.
+
+  + Improve comments generated by `-comments` to show more details of the
+    corresponding Snowball code (e.g. variable names, arithmetic expressions,
+    and literal strings).
+
+  + Add `-coverage` option which enables a code coverage feature.  So far this
+    tracks which among strings and functions are exercised, and which grouping
+    characters are exercised. !
+
+  + Support `-eprefix` for all target languages.  This is easy to do and
+    provides a way to deal with externals which collide with keywords in the
+    target language.  Our build system now uses `-eprefix _` for Python to make
+    the `stem` external non-public (it is called by BaseStemmer method
+    `stemWord()`) and we no longer hard-code prefixing Python externals with
+    `_`.
+
+  + Describe more options in `--help` output.
+
+  + Sort target language options in `--help` output.
+
+  + The `-o` option is now optional.  If not specified we now write output(s)
+    to the same filename as the first source, but with a different extension
+    (e.g. path/to/english.sbl -> path/to/english.c and path/to/english.h).
+
+  + The `-o` option can now optionally include an extension so you can now
+    write `-c++ -o path/to/foo.cxx` instead of `-c++ -o path/to/foo`, which can
+    be more convenient (e.g. in `make` rules) and also provides an easy way to
+    specify an alternative extension (for example, `.cxx`, `.cc` and `.cpp` are
+    all extensions commonly used for C++ source code).
+
+  + Reject `-vprefix` option for target languages which don't support it (it is
+    currently only implemented for C/C++).
+
+* Diagnostics:
+
+  + Clean up and improve error reporting.
+
+  + Improve line numbers reported for some errors and warnings by using the
+    line number of an appropriate token rather than the current line number
+    of the tokeniser (which is often the line after the command being warned
+    about).
+
+  + Improve recovery after various errors, trying to resynchronise based on
+    what's more likely, and eliminating some additional irrelevant errors
+    (including reporting the exact same error twice in some situations).
+
+  + Emit warnings for uses of legacy Snowball language features.
+
+  + The Snowball manual describes `integers (x)` as a declaration of `x` so we
+    now warn:
+
+      integer 'x' declared but not used
+
+    rather than:
+
+      integer 'x' defined but not used
+
+  + 3.0.0 added a warning if the body of a `repeat` or `atleast` loop always
+    signals `t` (meaning it will loop forever which is very undesirable for a
+    stemming algorithm) or always signals `f` (meaning it will never loop,
+    which seems unlikely to be what was intended).  This warning was added to
+    the C generator, but has been moved to generic code so it is now issued
+    regardless of the current target language.
+
+  + Improve the wording of the warning if the body of a `repeat` or `atleast`
+    loop always signals 't' to explicitly say this means the loop is infinite.
+
+  + Improve warning message for unreachable code after `not`.
+
+  + `$x = x + 1` cleared the initialised status of x (rather than just not
+    setting it) which could lead to bogus warnings that `x` is never
+    initialised.
+
+  + The compiler no longer exits immediately after reporting a division by zero
+    error in the Snowball code.
+
+  + We now report a division by zero error for `$x /= 0` (this was meant to be
+    already implemented but wasn't working due to a code typo).
+
+  + More consistent wording of "is a no-op" warnings.
+
+  + Warn that `insert ''` and `attach ''` are no-ops (and don't generate code
+    for them).
+
+  + Warn if a string used to define a grouping repeats characters.  There's no
+    reason to do this, so it seems likely to be a typo.
+
+  + Avoid sometimes reporting "-1 blocks unfreed".
+
+* Optimisations:
+
+  + Speed up processing larger Snowball programs by growing large string
+    buffers exponentially to avoid a huge number of reallocations.  For
+    example, this reduced the time to compile serbian.sbl to C by about 80%!
+
+  + Optimise reading of input file when it is seekable (which it is in typical
+    usage).  Non-seekable input files are still supported.
+
+  + Optimise writing integers when generating code.  72% of integers we write
+    are 0 to 9 and these are now written as a character.  Other values are now
+    handled without a temporary buffer, avoiding a copy.  This reduced the time
+    to compile serbian.sbl to C by about 8%, for example.
+
+  + Optimise comparing among actions to find and merge equivalent actions.
+    The comparison function used for this was carefully returning a full order,
+    but actually we only need to know if the actions are equivalent or not
+    which can be tested more efficiently.  For example, this reduced the time
+    to compile serbian.sbl to C by about 2%.
+
+  + We now precompute the possible signals from each command which means this
+    is now done exactly once per command, whereas previously we could end up
+    doing it many times for some commands in some cases.  The only functional
+    change should we no longer make a pessimistic assumption if the function
+    call depth reaches 100.  This is cleaner but is unlikely to make a
+    difference for any real-world Snowball programs.
+
+  + Handle possible_signals for string-$ which just passes on signals from its
+    subcommand.  This doesn't affect code generation for any algorithms we
+    currently ship.
+
+  + We now only generate function bodies to a temporary buffer for target
+    languages where we need to.  This makes the code a bit clearer and reduces
+    the amount of copying of data so will make the Snowball compiler a little
+    faster.  This change produces identical output for all current algorithms.
+
+  + Tokenisation now decodes symbol tokens using switch statements.  We don't
+    know the length of these tokens in advance, so the old approach of binary
+    chop on a sorted list required searching the list multiple times with
+    different possible lengths.  Alphabetical tokens are still decoded by
+    binary chop.
+
+* Code quality:
+
+  + Remove unused routines and groupings from the program during the analysis
+    phase, which avoids each generator having to have duplicate code to skip
+    them.
+
+  + Fix small memory leak if all uses of a name are eliminated.
+
+  + Always use `snprintf()` instead of `sprintf()`.  If the buffer passed was
+    too small we now emit an error rather than quietly using truncated output.
+
+  + Fix GCC -Wcast-qual warnings in compiler and enable this warning by
+    default.
+
+  + Switch to using the standard C `bool` type in the code of the compiler.
+    (The generated code still aims to require only C90.)
+
+* Other changes:
+
+  + Provide a simpler way to build a cut-down Snowball compiler.  The
+    motivation here was to have a way to more quickly build a smaller Snowball
+    compiler which only targets C.  Rather than have a DISABLE_xxx macro for
+    each language, just check if TARGET_C_ONLY is defined, and only turn off
+    the code to actually call the other generators which greatly reduces the
+    amount of conditionalisation required.
+
+Generic code generation changes
+-------------------------------
+
+* Bug fixes:
+
+  + Fix code generated for `setlimit tomark` for all target languages to
+    restore the limit correctly afterwards.  The bug was not triggered by any
+    of the existing stemmers.
+
+  + We no longer optimise repeat/atleast applied to goto/gopast on a (non)
+    grouping.  This optimisation was flawed - it requires that the code in the
+    loop preserves the cursor's value on failure, but the target language
+    helper functions used here don't currently do that (they probably easily
+    could so there's scope to reinstate this optimisation).
+
+    Looking at the stemmers we ship, this affects the code generated for one
+    loop in indonesian.sbl, but it happens the cursor value is overwritten
+    immediately after this loop anyway.  The bug could affect non-shipped
+    Snowball code though so isn't purely latent.  This bug was introduced in
+    Snowball 3.0.0.
+
+  + When generating target language literal strings we now always escape
+    characters which can be problematic when viewing the generated source code.
+    We always escape control characters U+007F to U+009F, non-breaking space
+    U+00A0 (visually identical to a space), and U+0590 and above (as a crude
+    way to avoid literal LTR characters in sources which can result in
+    confusing rendering).
+
+  + Fix line numbers given to various tokens (the line numbers previously given
+    were at least of lines in the same command or the line after it).  These
+    lone numbers can be seem in the target language comments generated when
+    `-comments` is used.
+
+  + Fix warning and simplification of code when `not` is applied to a command
+    which always signals `t`.  Bug introduced in v3.0.0.  Fixes #271.
+
+  + Warn and simplify `not` applied to a command which always signals `f`.
+
+* Optimisations:
+
+  + Add machinery to generate a Snowball variable as a local variable in the
+    target language instead of it being "global" (typically a private class
+    member in the target language).  This reduces the amount of state in
+    stemmer objects, and typically reduces the overhead of accessing these
+    variables a little.
+
+    We now do this for integers and booleans in all target languages, and
+    for strings in target languages where benchmarking seems to show it
+    is faster (Dart, Go, JS, Pascal, PHP, Python).
+
+    It's done for a Snowball variable which is only used in one routine, that
+    routine doesn't (directly or indirectly) call itself, and the variable is
+    set by any code path which leads to a use of the variable.  The mechanism
+    which traces the code paths errs on being too conservative in some cases,
+    but it's good enough for all instances in the code we ship, and is likely
+    to handle the vast majority of real-world cases.  We issue an "info"
+    diagnostic to report when a variable which is only used in one routine
+    can't be localised - please report if you see this in real world code and
+    we can try to enhance the code path tracing.
+
+  + Tail-calling and similar optimisations can now work for non-trivial
+    routines (previously they only worked for routines consisting of a
+    single command and not enclosed in parentheses).
+
+  + A grouping test at the end of a routine now generates simpler code.
+
+  + A string test at the end of a routine now generates simpler code.
+
+  + Optimise testing a boolean (optionally preceded by `not`) when used at the
+    end of a routine.
+
+  + Optimise an `among` with no commands at the end of a routine.
+
+  + Generate simpler code for `not` applied to testing a boolean variable.
+
+  + A `not` only needs to restore the cursor when its subcommand fails, so we
+    now consider whether its subcommand can modify the cursor on failure
+    (rather than whether it can modify the cursor at all).  Related to #226.
+
+  + An `or` only needs to restore the cursor when a subcommand fails, so we
+    now consider whether its subcommand can modify the cursor on failure
+    (rather than whether it can modify the cursor at all).  We also now
+    consider each subcommand individually, and only emit the cursor restore for
+    those subcommands which need it.  (#226)
+
+  + Both `and` and `or` only need to restore the cursor between sub-commands
+    so no longer consider if the final subcommand might change the cursor.
+    This makes some small improvements to the generated code for a few
+    of the currently shipped algorithms.  (#226)
+
+  + Handle more commands when checking if the cursor needs restoring - this
+    improves the generated code for tamil.sbl a bit.
+
+  + Single case amongs are now refactored to eliminate the `among` and so no
+    longer call the among machinery.  Sometimes a single case among is the
+    natural way to express a single rule in Snowball code as it can show
+    commonality with rulesets with multiple rules, but it's inefficient to
+    actually generate as an among.  Of the stemmers we currently ship, this
+    improves code generation for arabic, estonian, greek and lithuanian.
+
+  + Avoid unnecessary cursor update in among helpers.  We only need to update
+    the cursor on success, but were unconditionally doing so after calling an
+    among function.
+
+  + Handle more commands in repeat_score().  None of these help code generation
+    for any currently shipped algorithms, but they are valid to optimise here.
+
+  + Canonicalise `<-''` to `delete`.
+
+  + Simplify some cases of compound assignment operators when the argument is
+    (or can be simplified to) a constant integer, like we already do for
+    arithmetic expressions.  For example, `$x += len '{a"}' - len 'a'` is a
+    no-op when using a fixed-width encoding.
+
+  + Canonicalise `fail C` to `false` in some cases where `C` has no
+    side-effects.
+
+  + Removing unreachable code could leave single-entry `and`/`or` nodes
+    which could result in generating target language code with unused
+    variables.  These nodes are now replaced with their subnode.
+
+  + Eliminate `true` below `and`/`false` below `or`.  These are unlikely to
+    appear verbatim in real programs, but can be created by optimisations, and
+    also can appear in runtime tests, leading to the generated target language
+    code having unused variables and/or unreachable code.
+
+  + Canonicalise setmark, atmark and atlimit by converting `setmark x` to
+    `$x = cursor`, `atmark x` to `$(cursor == x)` and `atlimit` to either
+    `$(cursor >= limit)` or `$(cursor <= limit)` (depending on whether we're
+    in backwardmode or not).  This means the target language generators have
+    three fewer commands to handle, and also gives us tail-calling of `atlimit`
+    and `atmark x` (there's a tail-callable use of `atlimit` in the Turkish
+    stemmer).
+
+  + Remerge among actions after optimisation.  It seems hard to fully move the
+    code to merge them later, but we can check for actions which have become
+    equivalent to `true` or to other actions after optimisation but before we
+    generate code.
+
+* Code quality:
+
+  + Find Snowball routines which are not reachable by calling an external.  We
+    no longer generate code for such routines, nor for variables and groupings
+    which are only used in them, which helps to avoid "unused" warnings in the
+    generated target language code.
+
+  + If the sub-command of `repeat`/`atleast` always signals `t` or always
+    signals `f` we now prune the rest of the current command list, and simplify
+    the command for always `f` (c_repeat -> c_do; c_atleast -> c_bra).  These
+    changes help to avoid generating redundant target language code which can
+    trigger errors or warnings.
+
+* Other changes:
+
+  + `delete` and `<-` now update the slice end (see the "Snowball Language
+    Changes" section).
+
+Ada
+---
+
+* Bug fixes:
+
+  + Ada variable names are case-insensitive, so if two Snowball names of the
+    same type differed only by case we would generate Ada code with a name
+    collision.  We now avoid such collisions by adding a counter after the type
+    code for the second and subsequent names that differ only by case.
+
+  + Ada stemmer names are now prefixed with `S_` so `or.sbl` now generates
+    stemmer `S_or`, avoiding a name clash with an Ada keyword.
+
+  + Fix Ada code generated `for setlimit tomark p`.  This affected the
+    generated code for the Lithuanian stemmer, but it appears by luck in this
+    case the bug didn't actually affect the stemmer's output for any input.
+
+  + Fix `setlimit` ... `repeat` bug.  The generated Ada code was running the
+    code to recover from a failure inside a `repeat` loop twice due to a
+    missing line of code compared to other generators.  In `backwardmode`, the
+    failure code happens to be idempotent so running it twice doesn't cause a
+    problem, but in forwards mode this results in the cursor getting double
+    adjusted if the length of the stem has changed due to insertions, deletions
+    or substitutions.  None of the existing algorithms use `setlimit` in
+    forwards mode, so they're unaffected by this bug.  Fixes #275.
+
+  + Fix overcopying in string replacement code.  The code to move the tail
+    up/down was copying one byte too many.  We're working in a 1024 byte
+    fixed-length string buffer, and the maximum allowed input word is one byte
+    shorter, so it seems this was harmless in practice.
+
+  + Allow characters <32 and 127 in string literals.
+
+  + `=S` can no longer result in the slice ends becoming negative and
+    triggering a CONSTRAINT_ERROR (the slice is now specified to be unset
+    after `=S` - see the "Snowball Language Changes" section).
+
+  + Fix Ada code generated for string-$ which was actually partly Pascal
+    code (the Ada generator was originally based on the Pascal one) and
+    didn't even compile.  To fix this, Snowball string variables in Ada the
+    same way as the current string.  This means they now take up more space (a
+    fixed 1KB), but a typical Snowball program has either no string variables
+    or just one so the overhead seems acceptable.
+
+  + Fix matching of an empty string variable.  This valid Snowball code would
+    trigger "failed precondition" in Ada:
+
+      externals (stem)
+      strings (s)
+      define stem as ([] ->s s)
+
+  + Fix assumption that there's a single external called "stem".
+
+  + Fix incorrect assumption that an among containing the empty string
+    always matched, even if the empty string had a gating function.
+    This construct is not used by any existing stemmers.
+
+* Optimisations:
+
+  + Avoid calling among helper when the among contains only strings which are
+    one byte long, no among functions are used, and there are no actions.
+
+* Code quality:
+
+  + Fix indentation of generated grouping tables.
+
+  + Rename Context to Z in runtime code.  This now matches variable naming in
+    the generated Ada code (and also the C runtime and generated C code).
+
+  + Eliminate redundant limit check (the Skip_Utf8 helper also checks the
+    limit).  Looking at the history this check is a left-over from when the
+    generated code directly incremented the cursor.
+
+  + Emit Ada literal strings without redundant empty strings between adjacent
+    escaped bytes.
+
+  + Generate dummy loop around `or`, which allows us to handle a sub-command
+    succeeding with Ada `exit` rather than `goto`, which seems clearer.
+
+  + Avoid creating unused labels.  This is just a cosmetic improvements - there
+    are no longer mysterious gaps in the numbering of labels in the generated
+    code.
+
+  + Avoid generating unreachable `exit`.
+
+* Other changes:
+
+  + Implement support for `?` (debug command).  The code we generate for this
+    case is gnat-specific, but previously the code generated didn't compile so
+    working with one implementation seems a step forwards.  The `?` command can
+    now be used to debug Ada, and someone with actual Ada knowledge can now
+    more easily step in and provide a portable replacement.
+
+C/C++
+-----
+
+* Bug fixes:
+
+  + Maintain invariant that the C variable corresponding to a Snowball string
+    variable is non-NULL.  Previously we would release and NULL out the entry
+    in some error cases, but elsewhere the code was assuming the value was
+    non-NULL.
+
+  + Fix invalid code generated for `setlimit`.  This doesn't happen for
+    `setlimit tomark` (which is the only way `setlimit` is used in the stemmers
+    we currently ship.  Bug introduced in v3.0.0.
+
+  + Fix codegen for `hop` with constant argument.  We were relying on the
+    cursor being restored on failure by the code which handled that failure,
+    but if that code is a repeat or atleast command that it has an optimisation
+    which assumes `hop` won't do this.  This means we generated incorrect C
+    code for some cases where `hop` was used inside `repeat` or `atleast`.
+    This doesn't functionally affect any of the stemmers we currently ship.
+    Bug introduced in v2.1.0.
+
+  + Fix bug in code generated when `-vprefix` is specified, introduced in
+    Snowball 2.1.0.
+
+  + Fix incorrect assumption that an among containing the empty string
+    always matched, even if the empty string had a gating function.
+    This construct is not used by any existing stemmers.
+
+* Optimisations:
+
+  + Rework how non-localised variables are stored, which eliminates an
+    indirection on every access to such a variable, and also avoids some extra
+    allocations (one if a stemmer has any non-localised integer or boolean
+    variables, and another if the stemmer has any string variables).  So it
+    uses a bit less memory, it makes creating and destroying a stemmer faster,
+    and it also makes stemming a bit faster (though only by ~0.1% for the
+    English stemmer on our sample vocabulary).  The `-vprefix` option now
+    generates getter functions rather than using macro magic, which means the
+    syntax for accessing Snowball variables from C has changed.
+
+  + We now maintain the invariant that SN_env's p member is non-NULL, which
+    simplifies the runtime code.
+
+  + We now have a specialised implementation of the slice_del() runtime helper.
+    Deleting the slice is a fairly common operation, and can be done more
+    simply than via a generic replace_s() with an empty replacement string.
+    This speeds up the English stemmer by about 1% on our test vocabulary.
+
+  + Avoid calling among helper when the among contains only strings which are
+    one byte long, no among functions are used, and there are no actions.
+
+  + Only fetch SIZE() in replace_s() if we need it.
+
+  + Don't return adjustment from replace_s() runtime helper since calculating
+    the adjustment in the one caller where we actually want it is just one
+    integer addition and one integer subtraction, and that turns out to be
+    slightly more efficient as well as simpler.
+
+  + Move check for negative hop from runtime to generated code.  This means we
+    can omit it for hop with a constant argument, which is all uses of hop in
+    the stemmers we currently ship.
+
+* Code quality:
+
+  + The generated header is now included from the generated C/C++ source file
+    (which seems cleaner than the previous approach of generating the same
+    prototypes in the header and source file).
+
+  + The implementation of among functions has changed.  Previously we stored
+    a function pointer in struct among, but that requires relocation when the
+    code is in a dynamic library, which adds load-time overhead and means
+    the among structures can't be put in a read-only section.
+
+    We now store an integer index instead, and pass in a pointer to
+    a dispatcher function when calling the find_among()/find_among_b() helper
+    which gets called when this index is non-zero.  The value of the index is
+    stored in z->af so the dispatcher function can use it.
+
+    If only one unique function is used in an among, we can just pass this to
+    find_among() as the dispatcher which reduces the overhead for this common
+    case.
+
+    Profiling with cachegrind suggests this change adds a small overhead
+    to algorithms which use among functions - currently finnish and hindi
+    (and also lovins, but that's really only of academic interest and is not
+    enabled by default).
+
+  + Avoid long string in C source.  C90 only guarantees support for literal
+    strings up to 509 characters.  Fixes GCC -Woverlength-strings warning.
+
+  + Avoid C23 feature in C runtime code, introduced in Snowball 3.0.0.
+    Initialising with empty braces was only standardised in C23 (though
+    seems to be widely supported as an extension).
+
+  + Fix code generated for `setlimit` to be C90.  Bug introduced in v3.0.0, but
+    isn't triggered by any of the stemmers we currently ship.
+
+  + Fix -Wshadow warning for nested string-$ use.  We were generating code
+    using a C variable with the fixed name `failure` - now an integer suffix is
+    appended, and we only emit the variable in cases where the subcommand
+    signal isn't known at compile time.
+
+  + Generate `do {`...`} while (0)` around `or` code, which allows us to handle
+    a sub-command succeeding with `break;` rather than having to use `goto`,
+    which reduces the number of labels used and makes the generated code a bit
+    easier to follow.
+
+  + C comments are now generated for `(` and `do` when `-comments` is used.
+
+  + We now generate `+=` or `-=` for `hop <constant>` (instead of something
+    like `z->c = z->c + 2`).  The C compiler should treat both the same, but it
+    arguably makes the generated code a little clearer.
+
+* Other changes:
+
+  + C++: The `-c++` option used to generate exactly the same code as for C,
+    except with extension `.cc` instead of `.c` but now:
+
+    - C++ classes are generated.
+    - C++ `bool` is used for Snowball booleans.
+    - Loop variables are declared inside `for (`...`)`.
+    - Allocation failures and internal errors (e.g. slice_check() failing)
+      throw a C++ exception - this is a bit simpler and more efficient that the
+      C code approach of returning -1 which then has to be checked for and
+      propagated through the generated code.
+
+  + Snowball's debug command (`?`) now works out of the box (previously you
+    have to adjust a `#if 0` preprocessor conditional in the runtime code).
+
+  + Rename `runtime/header.h` (which really seems too generic, and is also easy
+    to confuse with `compiler/header.h`) to `runtime/snowball_runtime.h`.  We
+    expect most users will be using the C stemmers through libstemmer and so
+    won't be affected by this.
+
+C#
+--
+
+* Bug fixes:
+
+  + Fix code generated for `<-s`.  This is not used by any of the stemmers we
+    currently ship.  Test case based on one from ajroetker in #270.
+
+  + Fix code generated for string-$.  This feature is not used by any of the
+    stemmers we currently ship.
+
+  + Fix assumption that there's a single external called "stem".
+
+* Optimisations:
+
+  + Use Debug.Assert() in slice_check() runtime helper.  Previously the runtime
+    code wrote a diagnostic message and continued if one of these checks
+    failed, but failures should only happen with a Snowball program containing
+    logic errors, or for bugs in the Snowball compiler or its runtime (or
+    possibly in the C# compiler, runtime, OS, hardware, etc).  Therefore an
+    assertion seems an appropriate choice, and means the check is not enabled
+    for a production build, which seems more helpful overall.  See #242.
+
+* Code quality:
+
+  + Eliminate duplicates from groupings.  We currently implement these for C#
+    with a linear string search, and a side-effect of this change is that the
+    grouping string is now sorted, which will affect the time taken to look
+    up different characters in an arbitrary way (none of the Snowball sources
+    seem to try to list characters in frequency order).  Really C# should be
+    fixed to use an O(1) lookup like other target languages.
+
+  + The implementation of among functions has changed.  We now store an integer
+    index in the Among class, and pass a dispatcher function to the among
+    helper method.
+
+    If only one unique function is used in an among, we can just pass this to
+    the helper method as the dispatcher which reduces the overhead for this
+    common case.
+
+    Crude profiling with `time make check_csharp` suggests this doesn't harm
+    performance (perhaps a little faster, but maybe just within the noise).
+
+    The main benefit is all Among arrays can now be static, which previously
+    we wasn't possible for those which used among functions (#146).
+
+  + Remove unused return value from Stemmer.Replace() runtime helper.
+
+  + Fix inaccurate doc comments on runtime functions.
+
+* Other changes:
+
+  + csharp_stemwords: Speed up output to stdout.
+
+  + csharp_stemwords: Don't write the chosen stemmer to stdout.  This is not
+    really useful information, and breaks sending the stemmed words to stdout
+    because they're preceded by extra output.
+
+  + csharp_stemwords: Try to open input before output so we don't leave an
+    empty output file behind if we can't open the input file.
+
+Go
+--
+
+* Bug fixes:
+
+  + Fix code generated for non-constant hop.  A non-constant integer expression
+    has type `int` in the generated Go code, but the hop helpers expected
+    `int32`.  For a constant hop this worked because Go integer literals are
+    untyped, so will convert to `int32`.  To fix this, the helpers now take
+    `int` instead of `int32`.
+
+  + Fix code generated if `minint` or `maxint` is used.  In this case we were
+    generating `use std::usize;` near the start of the Go code, but that's
+    actually Rust code and a hangover from the Go backend being originally
+    based on the Rust one.
+
+  + The Go code generated for `->` was incorrectly signalling `f` if the
+    slice was empty.  Luckily this case is not exercised by any current
+    algorithms.  See #242.
+
+  + Fix code generated for string-$ (which isn't used by any of the algorithms
+    we currently ship).
+
+  + A snowball `external` could not previously be called from within the
+    Snowball program.  This is allowed by the Snowball language, but none of
+    the shipped stemmers do this, and it's unlikely any stemmer would.  Perhaps
+    it's useful if you use Snowball for other string-processing tasks.
+
+  + Fix handling of `minint` and `maxint` - we were generating some code copied
+    verbatim from the Rust generator for this case which was not valid Go.
+    (These are not used by any of the algorithms we currently ship.)
+
+* Optimisations:
+
+  + Reuse `env` in stemwords which is measurably faster than creating a new one
+    for every word.
+
+* Code quality:
+
+  + Eliminate unnecessary semicolons from generated code.
+
+  + Fix formatting of generated code.  The code gets run through gofmt which
+    was fixing up these issues, but better to generate the code cleanly to
+    start with.  The only things which gofmt now changes are that it indents
+    variable names to align in adjacent variable declarations, and a couple of
+    things which are apparently for compatibility with older versions of Go.
+
+  + Runtime helpers SliceDel() and SliceFrom() always returned true, but the
+    generated code included failure checks in case false was returned.
+    These helpers no longer return anything, and the checks are gone.
+
+* Documentation:
+
+  + Recommend that users reuse an `env` since this is measurably faster than
+    creating a new one for every word.
+
+* Other changes:
+
+  + Remove `-gopackage` option from compiler.  Use `-package`/`-P` instead
+    (`-gopackage` has just been an alias for these since Snowball 2.0.0).
+
+Java
+----
+
+* Bug fixes:
+
+  + Generate correct Java code for ASCII control chars in string literals.
+
+  + Fix code generated for string-$.  As part of this fix, we now use char[]
+    for string variables as well as the current string, which makes it much
+    simpler to switch to working on a string variable and back.  Fixes #252.
+
+  + Fix assumption that there's a single external called "stem".
+
+* Other changes:
+
+  + The generated Java classes no longer implement Serializable.  This support
+    was added in 2016, but in 2026 this approach to serialization in Java is
+    apparently no longer used due to security problems.  Fixes #255.
+
+Javascript
+----------
+
+* Bug fixes:
+
+  + Fix `->` to work when the slice is empty - previously it incorrectly
+    signalled `f` for this case.  Luckily this case is not exercised by any
+    current algorithms (#242)
+
+  + Generate public functions for all externals.  Patch from simlrh (#258).
+
+  + Fix code generated for string-$
+
+* Optimisations:
+
+  + Use startsWith()/endsWith() in eq_s()/eq_s_b().  This is quite a bit faster
+    as it avoids slice() creating a temporary string (e.g. measured a reduction
+    of ~17% wallclock time for tamil on the test vocabulary, taking the fastest
+    of 5 runs before and after).
+
+  + Optimise among when all actions are `<-` with a literal string.  We now
+    generate a single call to slice_from() with the argument obtained by
+    indexing into an array of literal strings.  This is perhaps faster, albeit
+    not by much, but it definitely results in smaller code, which is helpful
+    for in browser use.  See #227.
+
+  + The substring_i member in the Among class is now an offset from the current
+    index, and now zero in the common case where there's not another string
+    which is a sub-prefix/sub-suffix.  We've also swapped the order of elements
+    so we can omit this in the common case when it is zero and there's no among
+    function).  This reduces the size of the generated Javascript code (even
+    after minification).  Fixes #236.
+
+  + Change slice_check() to assert its conditions.  In C we must not perform
+    string slicing if slice_check() fails because that could result in writing
+    outside of the allocated buffer, but it's not problematic in this way for
+    Javascript, and the situations which slice_check() checks for should only
+    happen with a Snowball program containing logic errors, or for bugs in the
+    Snowball compiler or its runtime (or possibly in the Javascript
+    interpreter, OS, hardware, etc).  Therefore assert() seems an appropriate
+    choice.
+
+* Code quality:
+
+  + Convert to using Javascript modules and classes.  The way among functions
+    are called has been reworked to allow this, copying the approach now used
+    for C and C# (#234, #240).  Patches from Adam Turner and Titus Ng.
+
+  + Adjust generated code to work with deno, and suppress a few deno warnings
+    which are hard to avoid in generated code.
+
+  + Avoid generating blocks around failure handling.  The failure handle code
+    is always a single statement (and if we ever needed more than a statement
+    for some situation then we could arrange to add a block for just those
+    situations).  This significantly reduces the size of the generated JS code.
+
+  + Always inline code for `=>`.  The code is not much longer than the
+    call to a helper function in BaseStemmer.  Also in 3.0.0 we deprecated `=>`
+    and nothing we ship contains this command, so removing it from BaseStemmer
+    reduces the total code size a little.
+
+  + Rename BaseStemmer's internal `cursor` property to `c`.  Unfortunately,
+    `cursor` is a DOM property, so Javascript minifiers are cautious about
+    renaming it to avoid breaking code.  The name `c` matches the naming we use
+    for C, Ada and Pascal.
+
+  + Generate smaller code for hop by constant.  All current uses of hop in the
+    stemmers we ship have a constant argument, so avoid using a temporary
+    variable in these cases.
+
+  + Optimise `+=1` to `++`, `-=1` to `--`.  These are a byte shorter, and it
+    seems Javascript minifiers don't do this for us because it's not a safe
+    transformation unless the minifier can deduce that the variable can't hold
+    a string.
+
+  + Improve temporary var naming and use.  These variables don't need unique
+    generated names now we're declaring them as `const` which has more sensible
+    scoping rules than `var`.
+
+  + Generate smaller code for `insert` and string-`=`.  In some cases we know
+    we have the value of member variable `this.cursor` in local `const c` so
+    use the latter instead.
+
+  + Use triple equality for Javascript.  Patch from Adam Turner.
+
+  + Fix position of grouping type comment which is now placed consistently with
+    other type comments.
+
+  + Use `a` instead of `among_var` in generated code.  This reduces the size of
+    the generated code, which is helpful if a minification step isn't being
+    used.
+
+  + Consistently cuddle braces in runtime code.  The style wasn't entirely
+    consistent before, and cuddling braces matches the generated Javascript
+    code and the Snowball C code.
+
+  + Generate block around case to bound the scope of `const` and `let` within
+    the case.
+
+  + Use `let` in README example.
+
+  + Use `let` consistently in stemwords.js.
+
+  + Initialise integer Snowball variables - we annotate them as being type
+    "number" so we shouldn't let them have value undefined.  Patch from Adam
+    Turner.
+
+  + Improve/fix typescript annotations in runtime and generated code.
+
+  + Annotate runtime with @ts-expect-error.  It doesn't seem to be possible to
+    express the types fully in some places, but the invariants we require are
+    ensured by the Snowball compiler.  Annotating the expected errors allows
+    unexpected type checking errors to be be more easily seen, and they are
+    now fatal is CI.
+
+  + Use `===` and `!==` in stemwords.js.  Patch from Adam Turner.
+
+* Other changes:
+
+  + Make stemmer subclasses anonymous and export them by default.  This makes
+    creating a stemmer object easier as you only need to build the filename of
+    the stemmer subclass, and not also its class name.
+
+  + Adjust interpretation of `-parentclassname` option.  We supply the JS
+    snowball runtime so being able to specify a different base class name
+    doesn't seem very useful, so instead interpret this as the name to import
+    the base class as in generated stemmers.  It now defaults to just `B` which
+    reduces the size of the generated stemmer code a little (even after running
+    it through most Javascript minification tools).
+
+  + Improve stemwords.js option parsing.  Make `-i` and `-o` optional to match
+    other target language versions of stemwords.  Eliminate the check that
+    there are at least 3 command line arguments as we don't require any now.
+    If we encounter an argument we don't understand, we now report it and show
+    the usage message (previously we silently ignored it).  We now exit with
+    status 1 if there's a problem parsing the command line.
+
+  + stemwords.js: Emit help message in one console.log.  Patch from Titus Ng
+    (#221).
+
+Pascal
+------
+
+* Bug fixes:
+
+  + We were generating invalid Pascal code when tail-calling or calling a
+    routine which always fails.  Neither case is currently exercised by any
+    stemmers we ship and generate Pascal code for (the Pascal generator
+    currently only supports iso-8859-1).
+
+  + Fix code generated for string-$ (which isn't used by any of the algorithms
+    we currently ship).
+
+  + Fix assumption that there's a single external called "stem".
+
+* Code quality:
+
+  + Merge EqS and EqV runtime functions.  We can get the length of a Pascal
+    AnsiString `s` cheaply with `Length(s)` so there isn't a need to pass in
+    the length in the string literal case.
+
+  + Eliminate `While` in code generated for `repeat`/`atleast`.  Pascal lacks
+    `Continue` (at least as a standard feature) and this loop only exists so we
+    can jump back to its start with `continue` in other languages - we have a
+    `Break;` at its end so it doesn't loop in the normal way.  In Pascal we
+    generate a label before the loop and use `goto` to continue iterating, so
+    we can get rid of the Pascal loop entirely.
+
+  + Use `Break` instead of `Goto` in code generated for `go`/`gopast`.
+
+  + Generate dummy loop around `or` so we can handle a sub-command succeeding
+    with Pascal `Break` rather than `Goto`, which seems clearer.
+
+  + Avoid generating `Repeat` ... `Until True` dummy loops which are not
+    actually needed.
+
+  + Fix problem introduced in v3.0.0 with formatting of code generated for
+    `go`/`gopast` applied to a grouping.
+
+  + Switch to a simpler name mangling system.  Pascal variable names are
+    case-insensitive but Snowball names are case-sensitive.  We used to address
+    this by encoding the case of letters into a prefix on the name but that can
+    generate long and ugly names in some cases (e.g. integer Foo_Bar ->
+    IUllU_Foo_Bar).  We now avoid collisions by adding a counter after the
+    type code for the second and subsequent names that differ only by case
+    (so Foo_Bar is only mangled if there's another integer which differs
+    only by case which is declared before it, and even then just becomes
+    something like I2_Foo_Bar).
+
+  + Emit Pascal literal strings without redundant empty strings between
+    adjacent escaped bytes.
+
+  + The -comments option now includes the values of string literals, so has
+    been changed to generate "rest of line" comments (starting `//`) rather
+    than block comments (delimited by `{` ... `}`) so that string literals
+    containing `}` don't need escaping.  We were already using `//` comments in
+    the Pascal runtime so this shouldn't harm portability.
+
+Python
+------
+
+* Bug fixes:
+
+  + Fix `algorithms()` when forwarding to PyStemmer.  It looks like this has
+    never worked as the code has been like this since it was merged, and we
+    were forwarding to a method which PyStemmer doesn't provide and never seems
+    to have provided.
+
+  + stemwords.py: Make -i and -o optional.  The command syntax already
+    suggested they were, but actually we gave an error if they were omitted.
+
+  + Fix code generated for string-$ (which isn't used by any of the algorithms
+    we currently ship).
+
+  + Fix `->` to work when the slice is empty - previously it incorrectly
+    signalled `f` for this case.  Luckily this case is not exercised by any
+    current algorithms (#242)
+
+  + Remove deprecated licence classifier which now triggers a deprecation
+    warning from Python's setuptools.  We already specify the licensing in the
+    now preferred way via `license=` with a SPDX licence expression.
+
+* Optimisations:
+
+  + Optimise single-character string literal checks in the same way we already
+    do for C.  This seems to be measurably faster (tested with Turkish which
+    has lots of single character literal tests).
+
+  + Groupings are now implemented via a Python set, or a string for small
+    groupings.
+
+  + Eliminate use of exception in code generated for `or`.  We can instead wrap
+    the code in a loop and use `break`.
+
+  + Eliminate use of exception in `goto` and `gopast`.  We can just use `break`
+    here to exit the `while` loop we're also inside and move the `except` from
+    the previous `try` onto the `while`.
+
+  + Avoid using a temporary for `hop` with a constant argument as benchmarking
+    with timeit shows this is faster.
+
+  + Optimise string test by using startswith()/endswith() with suitable
+    start/end parameters which avoids creating a temporary substring and avoids
+    an explicit limit check.  This speeds up artificial testcases consisting of
+    `goto 'the'` by 10%.
+
+  + Optimise among when all actions are `<-` with a literal string.  We now
+    generate a single call to slice_from() with the argument obtained by
+    indexing into an array of literal strings.  See #227.
+
+  + Reduce overhead of code to forward to PyStemmer, both when forwarding and
+    when using the pure Python stemmers.
+
+  + Reuse exception classes much more.  This reduces the number of labN classes
+    we need by 142 over all the current stemmers.
+
+  + Change slice_check() to assert its conditions.  In C we must not perform
+    string slicing if slice_check() fails because that could result in writing
+    outside of the allocated buffer, but it's not problematic in this way for
+    Python, and the situations which slice_check() checks for should only
+    happen with a Snowball program containing logic errors, or for bugs in the
+    Snowball compiler or its runtime (or possibly in the Python interpreter,
+    OS, hardware, etc).  Therefore assert() seems an appropriate choice.
+
+* Code quality:
+
+  + Use _ as dummy loop variable.  We don't use the loop variable's value, and
+    the loop itself tracks the current iteration so generating nested loops
+    using `_` as the loop variable works correctly.
+
+  + Avoid mysterious gaps in the numbering of variables in the generated code.
+    This was already done for the other languages, but I missed Python it
+    seems.
+
+  + Avoid generating unused lab0 class for a Snowball program which doesn't use
+    any failure labels.
+
+  + Avoid generating a blank line at start of the body of a Snowball `loop`.
+
+  + stemwords.py: Replace deprecated `codecs.open()` with built-in `open()`.
+    Patch from Dmitry Shachnev.
+
+* Documentation:
+
+  + Remove unnecessary semicolons from Python code in docs.
+
+* Other changes:
+
+  + Remove Python 2 support.  We stopped officially supporting it in Snowball
+    2.1.0, but now we've actually stripped out support.  Versions of Python ≥
+    3.3 continue to be supported.  Patch from Dmitry Shachnev (#212).
+
+Rust
+----
+
+* Bug fixes:
+
+  + Fix code generated for string-$ (which isn't used by any of the algorithms
+    we currently ship).
+
+  + A snowball `external` could not previously be called from within the
+    Snowball program.  This is allowed by the Snowball language, but none of
+    the shipped stemmers do this, and it's unlikely any stemmer would, but
+    perhaps it's useful if you use Snowball for other string-processing tasks.
+
+  + The generated code previously treated an empty string returned by
+    slice_to() as an error, but this was buggy since if the slice is empty
+    the return value will be an empty string.  The helper doesn't try
+    to signal an error with an empty string so we can just drop this
+    check.  Luckily this case is not exercised by any current algorithms.
+    See #242.
+
+  + Fix incorrect assumption that an among containing the empty string
+    always matched, even if the empty string had a gating function.
+    This construct is not used by any existing stemmers.
+
+* Optimisations:
+
+  + Avoid calling among helper when the among contains only strings which are
+    one byte long, no among functions are used, and there are no actions.
+
+* Code quality:
+
+  + Fix formatting of code generated for `goto`/`gopast` applied to a grouping
+    or inverted grouping.  This is just a cosmetic problem - functionally it
+    was correct.  The poor formatting was introduced in v3.0.0.
+
+  + Runtime helpers slice_del() and slice_from() always returned true, but
+    the generated code included failure checks in case false was returned.
+    These helpers no longer return anything, and the checks are gone.
+
+  + Generate space after condition in integer test (purely cosmetic).
+
+New Code Generators
+-------------------
+
+* Add Dart generator from Ryan Heise (#156, #250).
+
+* Add PHP generator from Tim Whitlock and Olly Betts (#243).  Requires PHP 8.3
+  or later, which allows us to use typed class constants.
+
+* Add Zig backend from AJ Roetker.  Requires Zig 0.16.0 or later.
+
+Snowball Language Changes
+-------------------------
+
+* `delete` and `<-` now update the slice end.  The manual said that after
+  `[` and `]` "the slice ends will retain the same values until altered",
+  which doesn't make it clear what happens for operations which modify the
+  text the slice ends are in.
+
+  The existing handling here was inconsistent between commands: `delete`
+  and `<-` left the slice ends on the same numeric positions, while
+  `attach` and `insert` adjusted the slice ends to leave the slice marking
+  the equivalent substring of the updated string.  When working in UTF-8
+  the slice end could end up in the middle of a multi-byte character after
+  `delete` or `<-`, which seems especially undesirable.
+
+  I talked this over with Martin Porter and we've agreed that it makes
+  sense for `delete` and `<-` to also update the slice ends (in fact only
+  the right end needs adjusting) and I've clarified the wording in the
+  manual.
+
+  Existing algorithms we ship don't rely on what the slice is set to after
+  these commands.
+
+* The slice is now specified to be unset after `=S` (so the same state as at
+  the start of the program).  Previously Snowball attempted to adjust the slice
+  after `=S`, but there isn't an obvious adjustment in general because it can
+  replace part of the content of the slice.  Martin said he'd not thought of
+  this case, and we've concluded it's best to adjust the Snowball language
+  definition.
+
+New stemming algorithms
+-----------------------
+
+* Add Czech stemmer from Olly Betts and Jim O’Regan (#151).
+
+* Add Persian (Farsi) stemmer from Saeid Darvish (#181).
+
+* Add Polish stemmer from Dmitry Shachnev (#245).
+
+* Add Sesotho stemmer from Kamohelo Lebjane (#260).
+
+Behavioural changes to existing algorithms
+------------------------------------------
+
+* Danish:
+
+  + Adjust to handle apostrophe (#187).
+
+  + Restrict undoubling to valid cases.  Coverage showed that a number of the
+    consonants we would undouble never occur in our Danish vocabulary.  Testing
+    a larger list didn't find any matches for Danish words either, so restrict
+    the undoubling which reduces the potential for damage to foreign words and
+    should be a little more efficient.
+
+* English:
+
+  + Restore exception for `skis` so it stems to `ski`.  This reverts a
+    change made erroneously in Snowball 3.0.0.
+
+  + Improve the stemming of some words starting `inter`:
+    - We now avoid conflating intern, internal, international and
+      internment.
+    - We now conflate interfere/interferes/interference with
+      interfered/interfering.
+    - The stem of `interval` is now `interval` rather than `interv`, which
+      is mostly a cosmetic change as no unrelated words stem to `interv`.
+
+* Estonian:
+
+  + Handle apostrophe (#187).
+
+* Finnish:
+
+  + Handle apostrophe (#187).
+
+  + Improve fallback from illative rules.  If a word ends -han, -hen, -hin,
+    -hon, -hän or -hön but the vowel before does not match we were not removing
+    a suffix in case_ending, we now fallback to handling as a genitive and
+    remove -n.  This changes how we handle about 90 words - almost all for the
+    better, most of the rest seem neutral changes.
+
+  + Allow "ø" to match with -hön as this is seen with Norwegian place names,
+    e.g. Bodøhön.
+
+  + Remove illative form -hun.  This improves the stemming of 14 words in
+    our test vocabulary.
+
+* German:
+
+  + Handle apostrophe (#187).
+
+* Italian:
+
+  + Handle elisions (#187).
+
+* Lithuanian:
+
+  + Don't remove -er- before normal suffixes.  These aren't real grammatic
+    suffixes and seem to have been included mainly to try to conflate ancient
+    forms of the Lithuanian word for "sister" (e.g. "sesers") with modern forms
+    (e.g. "sesė").  We weren't even doing a complete job there however as
+    "seserimis" and "seseris" were not handled.  Removing these suffixes
+    entirely means we no longer try to conflate the ancient and modern forms
+    here, but at least all the forms of the old word get grouped, as do all
+    forms of the new word.  The stemming for ~150 other words is also improved,
+    without obvious downsides.  Patch from Justas Sakalauskas (#263).
+
+  + Remove trailing apostrophe as final step - an apostrophe is sometimes used
+    to separate a Lithuanian ending on an international word (#187).
+
+* Norwegian:
+
+  + Adjust to handle apostrophe (#187).
+
+* Polish:
+
+  + Remove optional apostrophe after removing suffix.  Polish uses an
+    apostrophe to separate loanwords from native suffixes.  (The correct use is
+    to mark the elision of the final sound of a loanword before a Polish
+    inflectional endings, but it's also often used with any loanword) (#187).
+
+Optimisations to existing algorithms
+------------------------------------
+
+* English:
+
+  + Optimise -eed, -eedly handling by performing the much cheaper R1 check
+    before the among of exceptional cases.
+
+* Esperanto:
+
+  + Eliminate use of among functions.  It's easy to avoid them, and they come
+    with a performance overhead in some target languages.  For C, the new
+    version is 0.09% faster (from cachegrind estimated cycle count).
+
+* Indonesian:
+
+  + Avoid use of among functions, which gives a 1.9% speed up for C (from
+    cachegrind estimated cycle count).
+
+* Lithuanian:
+
+  + Minor simplification/optimisation by relying on Snowball restoring the
+    cursor on failure.
+
+* Turkish:
+
+  + Simplify `not test C` to just `not C`.  If C succeeds, then the `not` fails
+    and the cursor will get restored by whatever handles that signal.
+
+Code clarity improvements to existing algorithms
+------------------------------------------------
+
+* Finnish: Rename `V1` and `LONG` to match the names used in the algorithm
+  description on the website.
+
+* Italian: Eliminate use of legacy among starter.
+
+Build system
+------------
+
+* The default flags used with `ar` are now `-cr` instead of `-cru`.  Many
+  Linux distros configure `ar` to use option `D` (deterministic mode) by
+  default, which was triggering a warning that option `u` is ignored.
+  Option `u` is just a minor optimisation for the case where the archive
+  already exist and only some object files have change, so it seems best
+  to just not try to use it and avoid the warning.
+
+  Make variable `ARFLAGS` can now be used to specify flags to use with `ar`,
+  so if you want to continue using `-cru`, you can use:
+
+    make ARFLAGS=-cru
+
+  If `D` is on by default in your `ar`, you'll actually want:
+
+    make ARFLAGS=-cruU
+
+* Add comment documenting how to use iconv.py (simple pure-Python alternative
+  which allows running the testsuite without iconv installed).
+
+* `make clean` now removes all built files for all target languages, and is
+  now tested by CI to ensure this doesn't regress.
+
+* Make "make check_utf8" parallel-safe by avoiding writing the stemmed output
+  to disk by default (except for Arabic).  To get the output saved as tmp.txt
+  on error for debugging you can now use: `make SAVETMP=1 check_utf8`.  Patch
+  from Adam Turner (#237, #238).
+
+* Ada: Fix parallel build by adding missing dependency from .adb to the
+  corresponding .sbl file (#237, #238).
+
+* Go: Use `$(go)` for `go generate` as well.
+
+* Python: Omit output "(THIN_FACTOR=)" if set empty.
+
+* Add SNOWBALL_FLAGS, intended to allow passing options such as `-comments`
+  and `-coverage` during development and debugging.
+
+* Add make targets to assist comparing generated code before and after a
+  compiler change: `baseline-create`, `generate` and `baseline-diff`.
+
+* We now have CI testing that the Snowball compiler builds as C99 (we were
+  already testing that the generated C code builds as C90).  Fixes #283,
+  reported by Domingo Alvarez Duarte.
+
+Testsuite
+---------
+
+* New testsuite for the Snowball compiler which tests parsing, errors and
+  warnings.
+
+* New runtime testsuite which tests the implementation of Snowball language
+  features in each supported target language.  These provide something much
+  more like a proper set of unit tests rather than relying on checking all the
+  algorithms produce the expected output to validate all the target language
+  generators.  These tests are run with -comments on to provide some test
+  coverage for this option.  Fixes #157.
+
+* stemtest: Add more number testcases, relocated to here from finnish/voc.txt.
+  They're better by stemtest as we want to avoid any stemmer damaging numbers,
+  and testcases here can easily be run for all stemmers.
+
 Snowball 3.0.1 (2025-05-09)
 ===========================
 
@@ -323,15 +1710,15 @@ Behavioural changes to existing algorithms
   contain other accented characters and it seems better for the stemmer to
   handle such words the same way regardless of the encoding in use.
 
-* English: Replace '-ogist' with '-og' to conflate "geologist" and "geology", etc.
-  Suggested by Marc Schipperheijn on snowball-discuss.
+* English: Replace '-ogist' with '-og' to conflate "geologist" and "geology",
+  etc.  Suggested by Marc Schipperheijn on snowball-discuss.
 
 * English: Add extra condition to undoubling.  We no longer undouble if the
   double consonant is preceded by exactly "a", "e" or "o" to avoid conflating
   "add"/"ad", "egg"/"eg", "off"/"of", etc.  Fixes #182, reported by Ed Page.
 
-* English: Avoid conflating 'emerge' and 'emergency'.  Reported by Frederick Ross
-  on snowball-discuss.
+* English: Avoid conflating 'emerge' and 'emergency'.  Reported by Frederick
+  Ross on snowball-discuss.
 
 * English: Avoid conflating 'evening' and 'even'.  Reported by Ann B on
   snowball-discuss.
@@ -429,7 +1816,7 @@ Behavioural changes to existing algorithms
 
 * Spanish: Handle -acion like -ación and -ucion like -ución.  It's apparently
   common to miss off accents in Spanish, and there are examples in our test
-  vocabulary that these change helps.  Proposed by Damian Janowski.
+  vocabulary that these changes help.  Proposed by Damian Janowski.
 
 * Swedish: Replace suffix "öst" with "ös" when preceded by any of 'iklnprtuv'
   rather than just 'l'.  The new rule only requires the "öst" to be in R1
@@ -653,7 +2040,7 @@ Compiler
   in the case where we were in a stringdef (but correct if we weren't).
 
 * Eliminate special handling for among starter.  We now convert the starter
-  to be a command before the among, adding an explict substring if there
+  to be a command before the among, adding an explicit substring if there
   isn't one.
 
 * We now warn if the body of a `repeat` or `atleast` loop always signals
@@ -831,7 +2218,7 @@ Code generation improvements
   + Constant numeric subexpressions and constant numeric tests are now
     evaluated at Snowball compile time.
 
-  + Simplify the following degnerate `loop` and `atleast` constructs where
+  + Simplify the following degenerate `loop` and `atleast` constructs where
     N is a compile-time constant:
 
     - loop N C where N <= 0 is a no-op.