* ALL keypresses (the UTF-8 sequences resulting from key presses) can now be remapped.
* This is especially useful with Unicode support, as you might want to alias
  international characters to their corresponding latin form in the start state,
  so you don't have to change keyboard layouts so often.
  This is done automatically in Gtk, where we have hardware key press information,
  but has to be done with key macros in Curses.
  There is a new key mask 4 (bit 3) for that purpose now.
* Also, you might want to define non-ANSI letters to perform special functions in
  the start state where it won't be accepted by the parser anyway.
  Suppose you have a macro M→, you could define
  @^U[^K→]{m→} 1^_U[^K→]
  This effectively "extends" the parser and allow you to call macro "→" by a single
  key press. See also #5.
* The register prefix has been changed from ^F (for function) to ^K (for key).
  This is the only thing you have to change in order to migrate existing
  function key macros.
* Key macros are enabled by default. There is no longer any way to disable
  function key handling in curses, as I never found any reason or need to disable it.
  Theoretically, the default ESCDELAY could turn out to be too small and function
  keys don't get through. I doubt that's possible unless on extremely slow serial lines.
  Even then, you'd have to increase ESCDELAY and instead of disabling function keys
  simply define an escape surrogate.
* The ED flag has been removed and its place is reserved for a future mouse support flag
  (which does make sense to disable in curses sometimes).
  fnkeys.tes is consequently also enabled by default in sample.teco_ini.
* Key macros are handled as an unit. If one character results in an error,
  the entire string is rubbed out.
  This fixes the "CLOSE" key on Gtk.
  It also makes sure that the original error message is preserved and not overwritten
  by some subsequent syntax error.
  It was never useful that we kept inserting characters after the first error.

It's not a real Lexilla lexer, but simply styles the document
once in lexer.set.git in order to highlight comment lines.

* ^Uq however always sets an UTF8 register as the source
  is supposed to be a SciTECO macro which is always UTF-8.
* :^Uq preserves the register's encoding
* teco_doc_set_string() now also sets the encoding
* instead of trying to restore the encoding in teco_doc_undo_set_string(),
  we now swap out the document in a teco_doc_t and pass it to an undo token.
* The get_codepage() Q-Reg method has been removed as the same
  can now be done with teco_doc_get_string() and the get_string() method.

* ^E is heavily overloaded and can also be used to check whether a given index is valid
  (as it is the same that most movement commands to internally).
  Besides that, it is mainly useful for interfacing with Scintilla messages.
* EE takes a code page or 0 for ANSI/ASCII.
  Currently all documents and new registers are UTF-8.
  There will have to be some kind of codepage inheritance and a single-byte-only mode.

* This is optimized for Groff, but works for Heirloom Troff and Neatroff as well.
  Currently, the Heirloom and Neatroff requests are just added ontop of the Groff
  ones. Theoretically, we could also try to separate the keyword lists into
  a base K&R set with Groff, Heirloom and Neatroff ontop.
* The lexer necessarily has many restrictions, as Troff is fundamentally unparseable
  (like classic TECO) and needs a lot of per-request knowledge.
* The "*.mm" extension has been removed from the lexers/cpp.tes.
  I don't know what language this was for, and I prefer `*.mm` files
  to be considered Troff.
* Temporarily changed the lexilla submodule URL.
  The corresponding Lexila lexer is in the process of being upstreamed.
  Once it is, I will probably revert the submodule to the official repository,
  as the "troff" branch is not stable (can be rebased).

* Horizontal movements (left/right cursor keys) establish the current column
  and vertical movements (up/down) will try to keep on that column.
* This has long been problematic in SciTECO as it requires state that gets
  reversed when the command line replacement takes place.
* I experimented with encoding the current horizontal position into the braced
  movement operations as in (123C5U$), but I decided that this was clumsy and
  I generally did not want these expressions to become even larger.
* Instead I decided to add some minimal support to the C core in the form of 4EJ
  which is like a number register only that it does NOT get reversed on rubout.
  This is exploited by the fnkeys.tes macros by storing the current position
  beyond replacements.
* In theory, this should be a property of the document, but we cannot easily
  store custom parameters per document.
  So instead, there is just one global variable.
  When editing another buffer, it gets reset to .ESGETCOLUMN$$.
  sample.teco_ini has been updated.
* The current X position only makes sense in the context of fnkeys.tes, as
  TECO commands like <C> are not necessarily "horizonal" movements.
  For the same reason, the core does not try to initialize 4EJ automatically
  when editing new buffers.
  It's entirely left to the TECO macros.
* The commandline replacement is more robust now as it checks braced
  expressions at the end of the command line more thorougly.
  It will no longer swallow all preceding braced expressions.
  Only if they are at least 4 characters in length and end in `C)` or `R)`.

* Works only in Gtk of course and only in the parser start state.
* Since its side effects can neither be reversed, nor does it have any side effects on the editor state,
  we can completely rub it out.
* Currently, it will only affect the current buffer and only the text area.
  It would be trivial to apply the zoom to the commandline widget as well (FIXME?).
  There is currently no way that the zoom value or any font size could be passed to the CSS, though.
  So the auto-completion overlay could only be zoomed if Gtk supports a zoom factor as well.

* This does not make sense for most SciTECO builds, but only when you
  want to optimize for size as the lexers take up 50% of the compressed binary
  size.
  Without Lexilla, it should be possible get it compiled in about 500kb.
* It can be useful for instance when building for embedded distributions.
* When Lexilla is disabled, symbols-scilexer.c is also not generated
  (we assume that the Lexilla sources are not available and it also doesn't serve any purpose).
* Consequently, most of the lexer configuration scripts are also not installed
  under --without-lexilla.