* This is also the base of $SCITECOPATH.
* Changing it is useful for packaging where it is not possible to factor out the common
  files between Curses and Gtk builds into a "sciteco-common" package.
  As an alternative, you can now create disjunct sciteco-curses and sciteco-gtk packages.
* You will most likely want to use this for Gtk builds as in:
  --with-interface=gtk --program-prefix=g --with-scitecodatadir=/usr/local/share/gsciteco.

* Since Scintilla no longer automatically scrolls the caret (see 941f48da6dde691a7800290cc729aaaacd051392),
  the caret wouldn't always end up in the view on startup.
* Added teco_interface_refresh() which includes SCI_SCROLLCARET and
  is invoked on startup. This helps with the Curses backend.
  It also reduces code redundancies.
* On Gtk, the caret cannot be easily scrolled on startup as long as no size is allocated
  to the window, so we also added a size-allocate callback to the
  window's event box. Sizes are less often allocated to the event box than to the
  window itself for some strange reason.

* This probably did not cause any bugs.

* teco_interrupt() turned out to be unsuitable to kill child processes (eg. when <EB> hangs).
  Instead, we have Win32-specific code now.
* Since SIGINT can be ignored on UNIX, pressing CTRL+C was not guaranteed to kill the
  child process (eg. when <EB> hangs).
  At the same time, it makes sense to send SIGINT first, so programs can terminate gracefully.
  The behaviour has therefore been adapted: Interrupting with CTRL+C the first time will kill
  gracefully. The second time, a more agressive signal is sent to kill the child process.
  Unfortunately, this would be relatively tricky and complicated to do on Windows, so CTRL+C will always
  "hard-kill" the child process.
* Moreover, teco_interrupt() killed the entire process on Windows when called the second time.
  This resulted in any interruption to terminate SciTECO unexpectedly when tried the second time on Gtk/Win32.
* teco_sigint_occurred renamed to teco_interrupted:
  There may be several different sources for setting this flag.
* Checking for CTRL+C on Gtk involves driving the main event loop repeatedly.
  This is a very expensive operation. We now do that only every 100ms. This is still sufficient since
  keyboard input comes from humans.
  This optimization saves 75% runtime on Windows and 90% on Linux.
  * The same optimization turned out to be contraproductive on PDCurses/WinGUI.

* The caret wasn't always kept out of the UZ and at some point would totally leave the view.
  This was apparently cause by executing two SCI_SCROLLCARETs per teco_interface_cmdline_update().
* Instead, we now use a CARET_EVEN scroll policy which also works sufficiently well.

* This is using an Input Method now.
* Entering dead keys has probably always been broken in Gtk which I only did not notice
  because I use a keyboard layout without dead keys.
  This affects the ^ and ` keys on a German layout.
* Once we support Unicode input, it would make sense to abuse Scintilla's already existing input method support.
  Unfortunately, forwarding keyboard events to the Scintilla view breaks event freezing and results in flickering.

* Turns out that using gtk_widget_destroy(), the finalize handler never gets called!?
  This means we were leaking memory.
* Using g_object_unref() fixes that and the initial Scintilla patch is no longer necessary.
* There have previously been use-after-free bugs when *not* using gtk_widget_destroy().
  This has apparently been fixed in the meantime in Scintilla.

* The patch avoids all automatic scrolling consistently, including in SCI_UNDO.
  This speads up Undo (especially after interruptions).
* Also, the patch disables a very costly and pointless (in SciTECO) algorithm that
  effectively made <Ix$> uninterruptible.
* Effectively reverts large parts of 8ef010da59743fcc4927c790f585ba414ec7b129.
  I have never liked using unintuitive Scintilla messages to avoid scrolling.

* An empty but valid teco_string_t can contain NULL pointers.
  More precisely, a state's done_cb() can be invoked with such empty strings
  in case of empty string arguments.
  Also a registers get_string() can return the NULL pointer
  for existing registers with uninitialized string parts.
* In all of these cases, the language should treat "uninitialized" strings
  exactly like empty strings.
* Not doing so, resulted in a number of vulnerabilities.
  * EN$$ crashed if "_" was uninitialized
  * The ^E@q and ^ENq string building constructs would crash for existing but
    uninitialized registers q.
  * ?$ would crash
  * ESSETILEXER$$ would crash
* This is now fixed.
  Test cases have been added.
* I cannot guarantee that I have found all such cases.
  Generally, it might be wise to change our definitions and make sure that
  every teco_string_t must have an associated heap object to be valid.
  All functions returning pointer+length pairs should consequently also never
  return NULL pointers.