Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/mRemoteNG/PuTTYNG.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/terminal
diff options
context:
space:
mode:
authorDimitrij <kvarkas@gmail.com>2022-10-31 00:45:23 +0300
committerDimitrij <kvarkas@gmail.com>2022-10-31 00:45:23 +0300
commit302fb2e8ddea1c993552c9a30c02f41d01ca54a9 (patch)
treed6cf1b32664296ef2cecda33caeafbe39e6695c1 /terminal
parent59105d9b26363e47f00676bd365b2ac8d4cb536a (diff)
parent4ff82ab29a22936b78510c68f544a99e677efed3 (diff)
Merge tag 'tags/0.78'HEADmaster
Diffstat (limited to 'terminal')
-rw-r--r--terminal/bidi.c3609
-rw-r--r--terminal/bidi.h147
-rw-r--r--terminal/bidi_gettype.c33
-rw-r--r--terminal/bidi_test.c372
-rw-r--r--terminal/terminal.c7910
-rw-r--r--terminal/terminal.h563
6 files changed, 12634 insertions, 0 deletions
diff --git a/terminal/bidi.c b/terminal/bidi.c
new file mode 100644
index 00000000..c17671b6
--- /dev/null
+++ b/terminal/bidi.c
@@ -0,0 +1,3609 @@
+/*
+ * Implementation of the Unicode bidirectional and Arabic shaping
+ * algorithms for PuTTY.
+ *
+ * Original version written and kindly contributed to this code base
+ * by Ahmad Khalifa of Arabeyes. The bidi part was almost completely
+ * rewritten in 2021 by Simon Tatham to bring it up to date, but the
+ * shaping part is still the one by the original authors.
+ *
+ * Implementation notes:
+ *
+ * Algorithm version
+ * -----------------
+ *
+ * This algorithm is up to date with Unicode Standard Annex #9
+ * revision 44:
+ *
+ * https://www.unicode.org/reports/tr9/tr9-44.html
+ *
+ * and passes the full conformance test suite in Unicode 14.0.0.
+ *
+ * Paragraph and line handling
+ * ---------------------------
+ *
+ * The full Unicode bidi algorithm expects to receive text containing
+ * multiple paragraphs, together with a decision about how those
+ * paragraphs are broken up into lines. It calculates embedding levels
+ * a whole paragraph at a time without considering the line breaks,
+ * but then the final reordering of the text for display is done to
+ * each _line_ independently based on the levels computed for the text
+ * in that line.
+ *
+ * This algorithm omits all of that, because it's intended for use as
+ * a display-time transformation of a text terminal, which doesn't
+ * preserve enough semantic information to decide what's a paragraph
+ * break and what is not. So a piece of input text provided to this
+ * algorithm is always expected to consist of exactly one paragraph
+ * *and* exactly one line.
+ *
+ * Embeddings, overrides and isolates
+ * ----------------------------------
+ *
+ * This implementation has full support for all the Unicode special
+ * control characters that modify bidi behaviour, such as
+ *
+ * U+202A LEFT-TO-RIGHT EMBEDDING
+ * U+202B RIGHT-TO-LEFT EMBEDDING
+ * U+202D LEFT-TO-RIGHT OVERRIDE
+ * U+202E RIGHT-TO-LEFT OVERRIDE
+ * U+202C POP DIRECTIONAL FORMATTING
+ * U+2068 FIRST STRONG ISOLATE
+ * U+2066 LEFT-TO-RIGHT ISOLATE
+ * U+2067 RIGHT-TO-LEFT ISOLATE
+ * U+2069 POP DIRECTIONAL ISOLATE
+ *
+ * However, at present, the terminal emulator that is a client of this
+ * code has no way to pass those in (because they're dropped during
+ * escape sequence processing and don't get stored in the terminal
+ * state). Nonetheless, the code is all here, so if the terminal
+ * emulator becomes able to record those characters at some later
+ * point, we'll be all set to take account of them during bidi.
+ *
+ * But the _main_ purpose of supporting the full bidi algorithm is
+ * simply that that's the easiest way to be sure it's correct, because
+ * if you support the whole thing, you can run the full conformance
+ * test suite. (And I don't 100% believe that restricting to the
+ * subset of _tests_ valid with a reduced character set will test the
+ * full set of _functionality_ relevant to the reduced set.)
+ *
+ * Retained formatting characters
+ * ------------------------------
+ *
+ * The standard bidi algorithm, in step X9, deletes assorted
+ * formatting characters from the text: all the embedding and override
+ * section initiator characters, the Pop Directional Formatting
+ * character that closes one of those sections again, and any
+ * character labelled as Boundary Neutral. So the characters it
+ * returns are not a _full_ reordering of the input; some input
+ * characters vanish completely.
+ *
+ * This would be fine, if it were not for the fact that - as far as I
+ * can see - _exactly one_ Unicode code point in the discarded
+ * category has a wcwidth() of more than 0, namely U+00AD SOFT HYPHEN
+ * which is a printing character for terminal purposes but has a bidi
+ * class of BN.
+ *
+ * Therefore, we must implement a modified version of the algorithm,
+ * as described in section 5.2 of TR9, which retains those formatting
+ * characters so that a client can find out where they ended up in the
+ * reordering.
+ *
+ * Section 5.2 describes a set of modifications to the algorithm that
+ * are _intended_ to achieve this without changing the rest of the
+ * behaviour: that is, if you take the output of the modified
+ * algorithm and delete all the characters that the standard algorithm
+ * would have removed, you should end up with the remaining characters
+ * in the same order that the standard algorithm would have delivered.
+ * However, section 5.2 admits the possibility of error, and says "in
+ * case of any deviation the explicit algorithm is the normative
+ * statement for conformance". And indeed, in one or two places I
+ * found I had to make my own tweaks to the section 5.2 description in
+ * order to get the whole test suite to pass, because I think the 5.2
+ * modifications if taken literally don't quite achieve that. My
+ * justification is that sentence of 5.2: in case of doubt, the right
+ * thing is to make the code behave the same as the official
+ * algorithm.
+ *
+ * It's possible that there might still be some undiscovered
+ * discrepancies between the behaviour of the standard and modified
+ * algorithms. So, just in case, I've kept in this code the ability to
+ * implement the _standard_ algorithm too! If you compile with
+ * -DREMOVE_FORMATTING_CHARS, this code should go back to implementing
+ * the literal UAX#9 bidi algorithm - so you can run your suspect
+ * input through both versions, making it much easier to figure out
+ * why they differ, and in which of the many stages of the algorithm
+ * the difference was introduced.
+ *
+ * However, beware that when compiling in this mode, the do_bidi
+ * interface to the terminal will stop working, and just abort() when
+ * called! The only useful thing you can do with this mode is to run
+ * the companion program bidi_test.c.
+ */
+
+#include <stdlib.h> /* definition of wchar_t */
+
+#include "putty.h"
+#include "misc.h"
+#include "bidi.h"
+
+typedef struct {
+ char type;
+ wchar_t form_b;
+} shape_node;
+
+/* Kept near the actual table, for verification. */
+#define SHAPE_FIRST 0x621
+#define SHAPE_LAST (SHAPE_FIRST + lenof(shapetypes) - 1)
+
+static const shape_node shapetypes[] = {
+ /* index, Typ, Iso, Ligature Index*/
+ /* 621 */ {SU, 0xFE80},
+ /* 622 */ {SR, 0xFE81},
+ /* 623 */ {SR, 0xFE83},
+ /* 624 */ {SR, 0xFE85},
+ /* 625 */ {SR, 0xFE87},
+ /* 626 */ {SD, 0xFE89},
+ /* 627 */ {SR, 0xFE8D},
+ /* 628 */ {SD, 0xFE8F},
+ /* 629 */ {SR, 0xFE93},
+ /* 62A */ {SD, 0xFE95},
+ /* 62B */ {SD, 0xFE99},
+ /* 62C */ {SD, 0xFE9D},
+ /* 62D */ {SD, 0xFEA1},
+ /* 62E */ {SD, 0xFEA5},
+ /* 62F */ {SR, 0xFEA9},
+ /* 630 */ {SR, 0xFEAB},
+ /* 631 */ {SR, 0xFEAD},
+ /* 632 */ {SR, 0xFEAF},
+ /* 633 */ {SD, 0xFEB1},
+ /* 634 */ {SD, 0xFEB5},
+ /* 635 */ {SD, 0xFEB9},
+ /* 636 */ {SD, 0xFEBD},
+ /* 637 */ {SD, 0xFEC1},
+ /* 638 */ {SD, 0xFEC5},
+ /* 639 */ {SD, 0xFEC9},
+ /* 63A */ {SD, 0xFECD},
+ /* 63B */ {SU, 0x0},
+ /* 63C */ {SU, 0x0},
+ /* 63D */ {SU, 0x0},
+ /* 63E */ {SU, 0x0},
+ /* 63F */ {SU, 0x0},
+ /* 640 */ {SC, 0x0},
+ /* 641 */ {SD, 0xFED1},
+ /* 642 */ {SD, 0xFED5},
+ /* 643 */ {SD, 0xFED9},
+ /* 644 */ {SD, 0xFEDD},
+ /* 645 */ {SD, 0xFEE1},
+ /* 646 */ {SD, 0xFEE5},
+ /* 647 */ {SD, 0xFEE9},
+ /* 648 */ {SR, 0xFEED},
+ /* 649 */ {SR, 0xFEEF}, /* SD */
+ /* 64A */ {SD, 0xFEF1},
+ /* 64B */ {SU, 0x0},
+ /* 64C */ {SU, 0x0},
+ /* 64D */ {SU, 0x0},
+ /* 64E */ {SU, 0x0},
+ /* 64F */ {SU, 0x0},
+ /* 650 */ {SU, 0x0},
+ /* 651 */ {SU, 0x0},
+ /* 652 */ {SU, 0x0},
+ /* 653 */ {SU, 0x0},
+ /* 654 */ {SU, 0x0},
+ /* 655 */ {SU, 0x0},
+ /* 656 */ {SU, 0x0},
+ /* 657 */ {SU, 0x0},
+ /* 658 */ {SU, 0x0},
+ /* 659 */ {SU, 0x0},
+ /* 65A */ {SU, 0x0},
+ /* 65B */ {SU, 0x0},
+ /* 65C */ {SU, 0x0},
+ /* 65D */ {SU, 0x0},
+ /* 65E */ {SU, 0x0},
+ /* 65F */ {SU, 0x0},
+ /* 660 */ {SU, 0x0},
+ /* 661 */ {SU, 0x0},
+ /* 662 */ {SU, 0x0},
+ /* 663 */ {SU, 0x0},
+ /* 664 */ {SU, 0x0},
+ /* 665 */ {SU, 0x0},
+ /* 666 */ {SU, 0x0},
+ /* 667 */ {SU, 0x0},
+ /* 668 */ {SU, 0x0},
+ /* 669 */ {SU, 0x0},
+ /* 66A */ {SU, 0x0},
+ /* 66B */ {SU, 0x0},
+ /* 66C */ {SU, 0x0},
+ /* 66D */ {SU, 0x0},
+ /* 66E */ {SU, 0x0},
+ /* 66F */ {SU, 0x0},
+ /* 670 */ {SU, 0x0},
+ /* 671 */ {SR, 0xFB50},
+ /* 672 */ {SU, 0x0},
+ /* 673 */ {SU, 0x0},
+ /* 674 */ {SU, 0x0},
+ /* 675 */ {SU, 0x0},
+ /* 676 */ {SU, 0x0},
+ /* 677 */ {SU, 0x0},
+ /* 678 */ {SU, 0x0},
+ /* 679 */ {SD, 0xFB66},
+ /* 67A */ {SD, 0xFB5E},
+ /* 67B */ {SD, 0xFB52},
+ /* 67C */ {SU, 0x0},
+ /* 67D */ {SU, 0x0},
+ /* 67E */ {SD, 0xFB56},
+ /* 67F */ {SD, 0xFB62},
+ /* 680 */ {SD, 0xFB5A},
+ /* 681 */ {SU, 0x0},
+ /* 682 */ {SU, 0x0},
+ /* 683 */ {SD, 0xFB76},
+ /* 684 */ {SD, 0xFB72},
+ /* 685 */ {SU, 0x0},
+ /* 686 */ {SD, 0xFB7A},
+ /* 687 */ {SD, 0xFB7E},
+ /* 688 */ {SR, 0xFB88},
+ /* 689 */ {SU, 0x0},
+ /* 68A */ {SU, 0x0},
+ /* 68B */ {SU, 0x0},
+ /* 68C */ {SR, 0xFB84},
+ /* 68D */ {SR, 0xFB82},
+ /* 68E */ {SR, 0xFB86},
+ /* 68F */ {SU, 0x0},
+ /* 690 */ {SU, 0x0},
+ /* 691 */ {SR, 0xFB8C},
+ /* 692 */ {SU, 0x0},
+ /* 693 */ {SU, 0x0},
+ /* 694 */ {SU, 0x0},
+ /* 695 */ {SU, 0x0},
+ /* 696 */ {SU, 0x0},
+ /* 697 */ {SU, 0x0},
+ /* 698 */ {SR, 0xFB8A},
+ /* 699 */ {SU, 0x0},
+ /* 69A */ {SU, 0x0},
+ /* 69B */ {SU, 0x0},
+ /* 69C */ {SU, 0x0},
+ /* 69D */ {SU, 0x0},
+ /* 69E */ {SU, 0x0},
+ /* 69F */ {SU, 0x0},
+ /* 6A0 */ {SU, 0x0},
+ /* 6A1 */ {SU, 0x0},
+ /* 6A2 */ {SU, 0x0},
+ /* 6A3 */ {SU, 0x0},
+ /* 6A4 */ {SD, 0xFB6A},
+ /* 6A5 */ {SU, 0x0},
+ /* 6A6 */ {SD, 0xFB6E},
+ /* 6A7 */ {SU, 0x0},
+ /* 6A8 */ {SU, 0x0},
+ /* 6A9 */ {SD, 0xFB8E},
+ /* 6AA */ {SU, 0x0},
+ /* 6AB */ {SU, 0x0},
+ /* 6AC */ {SU, 0x0},
+ /* 6AD */ {SD, 0xFBD3},
+ /* 6AE */ {SU, 0x0},
+ /* 6AF */ {SD, 0xFB92},
+ /* 6B0 */ {SU, 0x0},
+ /* 6B1 */ {SD, 0xFB9A},
+ /* 6B2 */ {SU, 0x0},
+ /* 6B3 */ {SD, 0xFB96},
+ /* 6B4 */ {SU, 0x0},
+ /* 6B5 */ {SU, 0x0},
+ /* 6B6 */ {SU, 0x0},
+ /* 6B7 */ {SU, 0x0},
+ /* 6B8 */ {SU, 0x0},
+ /* 6B9 */ {SU, 0x0},
+ /* 6BA */ {SR, 0xFB9E},
+ /* 6BB */ {SD, 0xFBA0},
+ /* 6BC */ {SU, 0x0},
+ /* 6BD */ {SU, 0x0},
+ /* 6BE */ {SD, 0xFBAA},
+ /* 6BF */ {SU, 0x0},
+ /* 6C0 */ {SR, 0xFBA4},
+ /* 6C1 */ {SD, 0xFBA6},
+ /* 6C2 */ {SU, 0x0},
+ /* 6C3 */ {SU, 0x0},
+ /* 6C4 */ {SU, 0x0},
+ /* 6C5 */ {SR, 0xFBE0},
+ /* 6C6 */ {SR, 0xFBD9},
+ /* 6C7 */ {SR, 0xFBD7},
+ /* 6C8 */ {SR, 0xFBDB},
+ /* 6C9 */ {SR, 0xFBE2},
+ /* 6CA */ {SU, 0x0},
+ /* 6CB */ {SR, 0xFBDE},
+ /* 6CC */ {SD, 0xFBFC},
+ /* 6CD */ {SU, 0x0},
+ /* 6CE */ {SU, 0x0},
+ /* 6CF */ {SU, 0x0},
+ /* 6D0 */ {SU, 0x0},
+ /* 6D1 */ {SU, 0x0},
+ /* 6D2 */ {SR, 0xFBAE},
+};
+
+/*
+ * Returns the bidi character type of ch.
+ *
+ * The data table in this function is constructed from the Unicode
+ * Character Database version 14.0.0, downloadable from unicode.org at
+ * the URL
+ *
+ * https://www.unicode.org/Public/14.0.0/ucd/
+ *
+ * by the following fragment of Perl:
+
+perl -ne '@_=split ";"; $num = hex $_[0]; $type = $_[4];' \
+ -e '$fl = ($_[1] =~ /First/ ? 1 : $_[1] =~ /Last/ ? 2 : 0);' \
+ -e 'if ($type eq $runtype and ($runend == $num-1 or ' \
+ -e ' ($fl==2 and $pfl==1))) {$runend = $num;} else { &reset; }' \
+ -e '$pfl=$fl; END { &reset }; sub reset {' \
+ -e 'printf" {0x%04x, 0x%04x, %s},\n",$runstart,$runend,$runtype' \
+ -e ' if defined $runstart and $runtype ne "ON";' \
+ -e '$runstart=$runend=$num; $runtype=$type;}' \
+ UnicodeData.txt
+
+ */
+unsigned char bidi_getType(int ch)
+{
+ static const struct {
+ int first, last, type;
+ } lookup[] = {
+ {0x0000, 0x0008, BN},
+ {0x0009, 0x0009, S},
+ {0x000a, 0x000a, B},
+ {0x000b, 0x000b, S},
+ {0x000c, 0x000c, WS},
+ {0x000d, 0x000d, B},
+ {0x000e, 0x001b, BN},
+ {0x001c, 0x001e, B},
+ {0x001f, 0x001f, S},
+ {0x0020, 0x0020, WS},
+ {0x0023, 0x0025, ET},
+ {0x002b, 0x002b, ES},
+ {0x002c, 0x002c, CS},
+ {0x002d, 0x002d, ES},
+ {0x002e, 0x002f, CS},
+ {0x0030, 0x0039, EN},
+ {0x003a, 0x003a, CS},
+ {0x0041, 0x005a, L},
+ {0x0061, 0x007a, L},
+ {0x007f, 0x0084, BN},
+ {0x0085, 0x0085, B},
+ {0x0086, 0x009f, BN},
+ {0x00a0, 0x00a0, CS},
+ {0x00a2, 0x00a5, ET},
+ {0x00aa, 0x00aa, L},
+ {0x00ad, 0x00ad, BN},
+ {0x00b0, 0x00b1, ET},
+ {0x00b2, 0x00b3, EN},
+ {0x00b5, 0x00b5, L},
+ {0x00b9, 0x00b9, EN},
+ {0x00ba, 0x00ba, L},
+ {0x00c0, 0x00d6, L},
+ {0x00d8, 0x00f6, L},
+ {0x00f8, 0x02b8, L},
+ {0x02bb, 0x02c1, L},
+ {0x02d0, 0x02d1, L},
+ {0x02e0, 0x02e4, L},
+ {0x02ee, 0x02ee, L},
+ {0x0300, 0x036f, NSM},
+ {0x0370, 0x0373, L},
+ {0x0376, 0x0377, L},
+ {0x037a, 0x037d, L},
+ {0x037f, 0x037f, L},
+ {0x0386, 0x0386, L},
+ {0x0388, 0x038a, L},
+ {0x038c, 0x038c, L},
+ {0x038e, 0x03a1, L},
+ {0x03a3, 0x03f5, L},
+ {0x03f7, 0x0482, L},
+ {0x0483, 0x0489, NSM},
+ {0x048a, 0x052f, L},
+ {0x0531, 0x0556, L},
+ {0x0559, 0x0589, L},
+ {0x058f, 0x058f, ET},
+ {0x0591, 0x05bd, NSM},
+ {0x05be, 0x05be, R},
+ {0x05bf, 0x05bf, NSM},
+ {0x05c0, 0x05c0, R},
+ {0x05c1, 0x05c2, NSM},
+ {0x05c3, 0x05c3, R},
+ {0x05c4, 0x05c5, NSM},
+ {0x05c6, 0x05c6, R},
+ {0x05c7, 0x05c7, NSM},
+ {0x05d0, 0x05ea, R},
+ {0x05ef, 0x05f4, R},
+ {0x0600, 0x0605, AN},
+ {0x0608, 0x0608, AL},
+ {0x0609, 0x060a, ET},
+ {0x060b, 0x060b, AL},
+ {0x060c, 0x060c, CS},
+ {0x060d, 0x060d, AL},
+ {0x0610, 0x061a, NSM},
+ {0x061b, 0x064a, AL},
+ {0x064b, 0x065f, NSM},
+ {0x0660, 0x0669, AN},
+ {0x066a, 0x066a, ET},
+ {0x066b, 0x066c, AN},
+ {0x066d, 0x066f, AL},
+ {0x0670, 0x0670, NSM},
+ {0x0671, 0x06d5, AL},
+ {0x06d6, 0x06dc, NSM},
+ {0x06dd, 0x06dd, AN},
+ {0x06df, 0x06e4, NSM},
+ {0x06e5, 0x06e6, AL},
+ {0x06e7, 0x06e8, NSM},
+ {0x06ea, 0x06ed, NSM},
+ {0x06ee, 0x06ef, AL},
+ {0x06f0, 0x06f9, EN},
+ {0x06fa, 0x070d, AL},
+ {0x070f, 0x0710, AL},
+ {0x0711, 0x0711, NSM},
+ {0x0712, 0x072f, AL},
+ {0x0730, 0x074a, NSM},
+ {0x074d, 0x07a5, AL},
+ {0x07a6, 0x07b0, NSM},
+ {0x07b1, 0x07b1, AL},
+ {0x07c0, 0x07ea, R},
+ {0x07eb, 0x07f3, NSM},
+ {0x07f4, 0x07f5, R},
+ {0x07fa, 0x07fa, R},
+ {0x07fd, 0x07fd, NSM},
+ {0x07fe, 0x0815, R},
+ {0x0816, 0x0819, NSM},
+ {0x081a, 0x081a, R},
+ {0x081b, 0x0823, NSM},
+ {0x0824, 0x0824, R},
+ {0x0825, 0x0827, NSM},
+ {0x0828, 0x0828, R},
+ {0x0829, 0x082d, NSM},
+ {0x0830, 0x083e, R},
+ {0x0840, 0x0858, R},
+ {0x0859, 0x085b, NSM},
+ {0x085e, 0x085e, R},
+ {0x0860, 0x086a, AL},
+ {0x0870, 0x088e, AL},
+ {0x0890, 0x0891, AN},
+ {0x0898, 0x089f, NSM},
+ {0x08a0, 0x08c9, AL},
+ {0x08ca, 0x08e1, NSM},
+ {0x08e2, 0x08e2, AN},
+ {0x08e3, 0x0902, NSM},
+ {0x0903, 0x0939, L},
+ {0x093a, 0x093a, NSM},
+ {0x093b, 0x093b, L},
+ {0x093c, 0x093c, NSM},
+ {0x093d, 0x0940, L},
+ {0x0941, 0x0948, NSM},
+ {0x0949, 0x094c, L},
+ {0x094d, 0x094d, NSM},
+ {0x094e, 0x0950, L},
+ {0x0951, 0x0957, NSM},
+ {0x0958, 0x0961, L},
+ {0x0962, 0x0963, NSM},
+ {0x0964, 0x0980, L},
+ {0x0981, 0x0981, NSM},
+ {0x0982, 0x0983, L},
+ {0x0985, 0x098c, L},
+ {0x098f, 0x0990, L},
+ {0x0993, 0x09a8, L},
+ {0x09aa, 0x09b0, L},
+ {0x09b2, 0x09b2, L},
+ {0x09b6, 0x09b9, L},
+ {0x09bc, 0x09bc, NSM},
+ {0x09bd, 0x09c0, L},
+ {0x09c1, 0x09c4, NSM},
+ {0x09c7, 0x09c8, L},
+ {0x09cb, 0x09cc, L},
+ {0x09cd, 0x09cd, NSM},
+ {0x09ce, 0x09ce, L},
+ {0x09d7, 0x09d7, L},
+ {0x09dc, 0x09dd, L},
+ {0x09df, 0x09e1, L},
+ {0x09e2, 0x09e3, NSM},
+ {0x09e6, 0x09f1, L},
+ {0x09f2, 0x09f3, ET},
+ {0x09f4, 0x09fa, L},
+ {0x09fb, 0x09fb, ET},
+ {0x09fc, 0x09fd, L},
+ {0x09fe, 0x09fe, NSM},
+ {0x0a01, 0x0a02, NSM},
+ {0x0a03, 0x0a03, L},
+ {0x0a05, 0x0a0a, L},
+ {0x0a0f, 0x0a10, L},
+ {0x0a13, 0x0a28, L},
+ {0x0a2a, 0x0a30, L},
+ {0x0a32, 0x0a33, L},
+ {0x0a35, 0x0a36, L},
+ {0x0a38, 0x0a39, L},
+ {0x0a3c, 0x0a3c, NSM},
+ {0x0a3e, 0x0a40, L},
+ {0x0a41, 0x0a42, NSM},
+ {0x0a47, 0x0a48, NSM},
+ {0x0a4b, 0x0a4d, NSM},
+ {0x0a51, 0x0a51, NSM},
+ {0x0a59, 0x0a5c, L},
+ {0x0a5e, 0x0a5e, L},
+ {0x0a66, 0x0a6f, L},
+ {0x0a70, 0x0a71, NSM},
+ {0x0a72, 0x0a74, L},
+ {0x0a75, 0x0a75, NSM},
+ {0x0a76, 0x0a76, L},
+ {0x0a81, 0x0a82, NSM},
+ {0x0a83, 0x0a83, L},
+ {0x0a85, 0x0a8d, L},
+ {0x0a8f, 0x0a91, L},
+ {0x0a93, 0x0aa8, L},
+ {0x0aaa, 0x0ab0, L},
+ {0x0ab2, 0x0ab3, L},
+ {0x0ab5, 0x0ab9, L},
+ {0x0abc, 0x0abc, NSM},
+ {0x0abd, 0x0ac0, L},
+ {0x0ac1, 0x0ac5, NSM},
+ {0x0ac7, 0x0ac8, NSM},
+ {0x0ac9, 0x0ac9, L},
+ {0x0acb, 0x0acc, L},
+ {0x0acd, 0x0acd, NSM},
+ {0x0ad0, 0x0ad0, L},
+ {0x0ae0, 0x0ae1, L},
+ {0x0ae2, 0x0ae3, NSM},
+ {0x0ae6, 0x0af0, L},
+ {0x0af1, 0x0af1, ET},
+ {0x0af9, 0x0af9, L},
+ {0x0afa, 0x0aff, NSM},
+ {0x0b01, 0x0b01, NSM},
+ {0x0b02, 0x0b03, L},
+ {0x0b05, 0x0b0c, L},
+ {0x0b0f, 0x0b10, L},
+ {0x0b13, 0x0b28, L},
+ {0x0b2a, 0x0b30, L},
+ {0x0b32, 0x0b33, L},
+ {0x0b35, 0x0b39, L},
+ {0x0b3c, 0x0b3c, NSM},
+ {0x0b3d, 0x0b3e, L},
+ {0x0b3f, 0x0b3f, NSM},
+ {0x0b40, 0x0b40, L},
+ {0x0b41, 0x0b44, NSM},
+ {0x0b47, 0x0b48, L},
+ {0x0b4b, 0x0b4c, L},
+ {0x0b4d, 0x0b4d, NSM},
+ {0x0b55, 0x0b56, NSM},
+ {0x0b57, 0x0b57, L},
+ {0x0b5c, 0x0b5d, L},
+ {0x0b5f, 0x0b61, L},
+ {0x0b62, 0x0b63, NSM},
+ {0x0b66, 0x0b77, L},
+ {0x0b82, 0x0b82, NSM},
+ {0x0b83, 0x0b83, L},
+ {0x0b85, 0x0b8a, L},
+ {0x0b8e, 0x0b90, L},
+ {0x0b92, 0x0b95, L},
+ {0x0b99, 0x0b9a, L},
+ {0x0b9c, 0x0b9c, L},
+ {0x0b9e, 0x0b9f, L},
+ {0x0ba3, 0x0ba4, L},
+ {0x0ba8, 0x0baa, L},
+ {0x0bae, 0x0bb9, L},
+ {0x0bbe, 0x0bbf, L},
+ {0x0bc0, 0x0bc0, NSM},
+ {0x0bc1, 0x0bc2, L},
+ {0x0bc6, 0x0bc8, L},
+ {0x0bca, 0x0bcc, L},
+ {0x0bcd, 0x0bcd, NSM},
+ {0x0bd0, 0x0bd0, L},
+ {0x0bd7, 0x0bd7, L},
+ {0x0be6, 0x0bf2, L},
+ {0x0bf9, 0x0bf9, ET},
+ {0x0c00, 0x0c00, NSM},
+ {0x0c01, 0x0c03, L},
+ {0x0c04, 0x0c04, NSM},
+ {0x0c05, 0x0c0c, L},
+ {0x0c0e, 0x0c10, L},
+ {0x0c12, 0x0c28, L},
+ {0x0c2a, 0x0c39, L},
+ {0x0c3c, 0x0c3c, NSM},
+ {0x0c3d, 0x0c3d, L},
+ {0x0c3e, 0x0c40, NSM},
+ {0x0c41, 0x0c44, L},
+ {0x0c46, 0x0c48, NSM},
+ {0x0c4a, 0x0c4d, NSM},
+ {0x0c55, 0x0c56, NSM},
+ {0x0c58, 0x0c5a, L},
+ {0x0c5d, 0x0c5d, L},
+ {0x0c60, 0x0c61, L},
+ {0x0c62, 0x0c63, NSM},
+ {0x0c66, 0x0c6f, L},
+ {0x0c77, 0x0c77, L},
+ {0x0c7f, 0x0c80, L},
+ {0x0c81, 0x0c81, NSM},
+ {0x0c82, 0x0c8c, L},
+ {0x0c8e, 0x0c90, L},
+ {0x0c92, 0x0ca8, L},
+ {0x0caa, 0x0cb3, L},
+ {0x0cb5, 0x0cb9, L},
+ {0x0cbc, 0x0cbc, NSM},
+ {0x0cbd, 0x0cc4, L},
+ {0x0cc6, 0x0cc8, L},
+ {0x0cca, 0x0ccb, L},
+ {0x0ccc, 0x0ccd, NSM},
+ {0x0cd5, 0x0cd6, L},
+ {0x0cdd, 0x0cde, L},
+ {0x0ce0, 0x0ce1, L},
+ {0x0ce2, 0x0ce3, NSM},
+ {0x0ce6, 0x0cef, L},
+ {0x0cf1, 0x0cf2, L},
+ {0x0d00, 0x0d01, NSM},
+ {0x0d02, 0x0d0c, L},
+ {0x0d0e, 0x0d10, L},
+ {0x0d12, 0x0d3a, L},
+ {0x0d3b, 0x0d3c, NSM},
+ {0x0d3d, 0x0d40, L},
+ {0x0d41, 0x0d44, NSM},
+ {0x0d46, 0x0d48, L},
+ {0x0d4a, 0x0d4c, L},
+ {0x0d4d, 0x0d4d, NSM},
+ {0x0d4e, 0x0d4f, L},
+ {0x0d54, 0x0d61, L},
+ {0x0d62, 0x0d63, NSM},
+ {0x0d66, 0x0d7f, L},
+ {0x0d81, 0x0d81, NSM},
+ {0x0d82, 0x0d83, L},
+ {0x0d85, 0x0d96, L},
+ {0x0d9a, 0x0db1, L},
+ {0x0db3, 0x0dbb, L},
+ {0x0dbd, 0x0dbd, L},
+ {0x0dc0, 0x0dc6, L},
+ {0x0dca, 0x0dca, NSM},
+ {0x0dcf, 0x0dd1, L},
+ {0x0dd2, 0x0dd4, NSM},
+ {0x0dd6, 0x0dd6, NSM},
+ {0x0dd8, 0x0ddf, L},
+ {0x0de6, 0x0def, L},
+ {0x0df2, 0x0df4, L},
+ {0x0e01, 0x0e30, L},
+ {0x0e31, 0x0e31, NSM},
+ {0x0e32, 0x0e33, L},
+ {0x0e34, 0x0e3a, NSM},
+ {0x0e3f, 0x0e3f, ET},
+ {0x0e40, 0x0e46, L},
+ {0x0e47, 0x0e4e, NSM},
+ {0x0e4f, 0x0e5b, L},
+ {0x0e81, 0x0e82, L},
+ {0x0e84, 0x0e84, L},
+ {0x0e86, 0x0e8a, L},
+ {0x0e8c, 0x0ea3, L},
+ {0x0ea5, 0x0ea5, L},
+ {0x0ea7, 0x0eb0, L},
+ {0x0eb1, 0x0eb1, NSM},
+ {0x0eb2, 0x0eb3, L},
+ {0x0eb4, 0x0ebc, NSM},
+ {0x0ebd, 0x0ebd, L},
+ {0x0ec0, 0x0ec4, L},
+ {0x0ec6, 0x0ec6, L},
+ {0x0ec8, 0x0ecd, NSM},
+ {0x0ed0, 0x0ed9, L},
+ {0x0edc, 0x0edf, L},
+ {0x0f00, 0x0f17, L},
+ {0x0f18, 0x0f19, NSM},
+ {0x0f1a, 0x0f34, L},
+ {0x0f35, 0x0f35, NSM},
+ {0x0f36, 0x0f36, L},
+ {0x0f37, 0x0f37, NSM},
+ {0x0f38, 0x0f38, L},
+ {0x0f39, 0x0f39, NSM},
+ {0x0f3e, 0x0f47, L},
+ {0x0f49, 0x0f6c, L},
+ {0x0f71, 0x0f7e, NSM},
+ {0x0f7f, 0x0f7f, L},
+ {0x0f80, 0x0f84, NSM},
+ {0x0f85, 0x0f85, L},
+ {0x0f86, 0x0f87, NSM},
+ {0x0f88, 0x0f8c, L},
+ {0x0f8d, 0x0f97, NSM},
+ {0x0f99, 0x0fbc, NSM},
+ {0x0fbe, 0x0fc5, L},
+ {0x0fc6, 0x0fc6, NSM},
+ {0x0fc7, 0x0fcc, L},
+ {0x0fce, 0x0fda, L},
+ {0x1000, 0x102c, L},
+ {0x102d, 0x1030, NSM},
+ {0x1031, 0x1031, L},
+ {0x1032, 0x1037, NSM},
+ {0x1038, 0x1038, L},
+ {0x1039, 0x103a, NSM},
+ {0x103b, 0x103c, L},
+ {0x103d, 0x103e, NSM},
+ {0x103f, 0x1057, L},
+ {0x1058, 0x1059, NSM},
+ {0x105a, 0x105d, L},
+ {0x105e, 0x1060, NSM},
+ {0x1061, 0x1070, L},
+ {0x1071, 0x1074, NSM},
+ {0x1075, 0x1081, L},
+ {0x1082, 0x1082, NSM},
+ {0x1083, 0x1084, L},
+ {0x1085, 0x1086, NSM},
+ {0x1087, 0x108c, L},
+ {0x108d, 0x108d, NSM},
+ {0x108e, 0x109c, L},
+ {0x109d, 0x109d, NSM},
+ {0x109e, 0x10c5, L},
+ {0x10c7, 0x10c7, L},
+ {0x10cd, 0x10cd, L},
+ {0x10d0, 0x1248, L},
+ {0x124a, 0x124d, L},
+ {0x1250, 0x1256, L},
+ {0x1258, 0x1258, L},
+ {0x125a, 0x125d, L},
+ {0x1260, 0x1288, L},
+ {0x128a, 0x128d, L},
+ {0x1290, 0x12b0, L},
+ {0x12b2, 0x12b5, L},
+ {0x12b8, 0x12be, L},
+ {0x12c0, 0x12c0, L},
+ {0x12c2, 0x12c5, L},
+ {0x12c8, 0x12d6, L},
+ {0x12d8, 0x1310, L},
+ {0x1312, 0x1315, L},
+ {0x1318, 0x135a, L},
+ {0x135d, 0x135f, NSM},
+ {0x1360, 0x137c, L},
+ {0x1380, 0x138f, L},
+ {0x13a0, 0x13f5, L},
+ {0x13f8, 0x13fd, L},
+ {0x1401, 0x167f, L},
+ {0x1680, 0x1680, WS},
+ {0x1681, 0x169a, L},
+ {0x16a0, 0x16f8, L},
+ {0x1700, 0x1711, L},
+ {0x1712, 0x1714, NSM},
+ {0x1715, 0x1715, L},
+ {0x171f, 0x1731, L},
+ {0x1732, 0x1733, NSM},
+ {0x1734, 0x1736, L},
+ {0x1740, 0x1751, L},
+ {0x1752, 0x1753, NSM},
+ {0x1760, 0x176c, L},
+ {0x176e, 0x1770, L},
+ {0x1772, 0x1773, NSM},
+ {0x1780, 0x17b3, L},
+ {0x17b4, 0x17b5, NSM},
+ {0x17b6, 0x17b6, L},
+ {0x17b7, 0x17bd, NSM},
+ {0x17be, 0x17c5, L},
+ {0x17c6, 0x17c6, NSM},
+ {0x17c7, 0x17c8, L},
+ {0x17c9, 0x17d3, NSM},
+ {0x17d4, 0x17da, L},
+ {0x17db, 0x17db, ET},
+ {0x17dc, 0x17dc, L},
+ {0x17dd, 0x17dd, NSM},
+ {0x17e0, 0x17e9, L},
+ {0x180b, 0x180d, NSM},
+ {0x180e, 0x180e, BN},
+ {0x180f, 0x180f, NSM},
+ {0x1810, 0x1819, L},
+ {0x1820, 0x1878, L},
+ {0x1880, 0x1884, L},
+ {0x1885, 0x1886, NSM},
+ {0x1887, 0x18a8, L},
+ {0x18a9, 0x18a9, NSM},
+ {0x18aa, 0x18aa, L},
+ {0x18b0, 0x18f5, L},
+ {0x1900, 0x191e, L},
+ {0x1920, 0x1922, NSM},
+ {0x1923, 0x1926, L},
+ {0x1927, 0x1928, NSM},
+ {0x1929, 0x192b, L},
+ {0x1930, 0x1931, L},
+ {0x1932, 0x1932, NSM},
+ {0x1933, 0x1938, L},
+ {0x1939, 0x193b, NSM},
+ {0x1946, 0x196d, L},
+ {0x1970, 0x1974, L},
+ {0x1980, 0x19ab, L},
+ {0x19b0, 0x19c9, L},
+ {0x19d0, 0x19da, L},
+ {0x1a00, 0x1a16, L},
+ {0x1a17, 0x1a18, NSM},
+ {0x1a19, 0x1a1a, L},
+ {0x1a1b, 0x1a1b, NSM},
+ {0x1a1e, 0x1a55, L},
+ {0x1a56, 0x1a56, NSM},
+ {0x1a57, 0x1a57, L},
+ {0x1a58, 0x1a5e, NSM},
+ {0x1a60, 0x1a60, NSM},
+ {0x1a61, 0x1a61, L},
+ {0x1a62, 0x1a62, NSM},
+ {0x1a63, 0x1a64, L},
+ {0x1a65, 0x1a6c, NSM},
+ {0x1a6d, 0x1a72, L},
+ {0x1a73, 0x1a7c, NSM},
+ {0x1a7f, 0x1a7f, NSM},
+ {0x1a80, 0x1a89, L},
+ {0x1a90, 0x1a99, L},
+ {0x1aa0, 0x1aad, L},
+ {0x1ab0, 0x1ace, NSM},
+ {0x1b00, 0x1b03, NSM},
+ {0x1b04, 0x1b33, L},
+ {0x1b34, 0x1b34, NSM},
+ {0x1b35, 0x1b35, L},
+ {0x1b36, 0x1b3a, NSM},
+ {0x1b3b, 0x1b3b, L},
+ {0x1b3c, 0x1b3c, NSM},
+ {0x1b3d, 0x1b41, L},
+ {0x1b42, 0x1b42, NSM},
+ {0x1b43, 0x1b4c, L},
+ {0x1b50, 0x1b6a, L},
+ {0x1b6b, 0x1b73, NSM},
+ {0x1b74, 0x1b7e, L},
+ {0x1b80, 0x1b81, NSM},
+ {0x1b82, 0x1ba1, L},
+ {0x1ba2, 0x1ba5, NSM},
+ {0x1ba6, 0x1ba7, L},
+ {0x1ba8, 0x1ba9, NSM},
+ {0x1baa, 0x1baa, L},
+ {0x1bab, 0x1bad, NSM},
+ {0x1bae, 0x1be5, L},
+ {0x1be6, 0x1be6, NSM},
+ {0x1be7, 0x1be7, L},
+ {0x1be8, 0x1be9, NSM},
+ {0x1bea, 0x1bec, L},
+ {0x1bed, 0x1bed, NSM},
+ {0x1bee, 0x1bee, L},
+ {0x1bef, 0x1bf1, NSM},
+ {0x1bf2, 0x1bf3, L},
+ {0x1bfc, 0x1c2b, L},
+ {0x1c2c, 0x1c33, NSM},
+ {0x1c34, 0x1c35, L},
+ {0x1c36, 0x1c37, NSM},
+ {0x1c3b, 0x1c49, L},
+ {0x1c4d, 0x1c88, L},
+ {0x1c90, 0x1cba, L},
+ {0x1cbd, 0x1cc7, L},
+ {0x1cd0, 0x1cd2, NSM},
+ {0x1cd3, 0x1cd3, L},
+ {0x1cd4, 0x1ce0, NSM},
+ {0x1ce1, 0x1ce1, L},
+ {0x1ce2, 0x1ce8, NSM},
+ {0x1ce9, 0x1cec, L},
+ {0x1ced, 0x1ced, NSM},
+ {0x1cee, 0x1cf3, L},
+ {0x1cf4, 0x1cf4, NSM},
+ {0x1cf5, 0x1cf7, L},
+ {0x1cf8, 0x1cf9, NSM},
+ {0x1cfa, 0x1cfa, L},
+ {0x1d00, 0x1dbf, L},
+ {0x1dc0, 0x1dff, NSM},
+ {0x1e00, 0x1f15, L},
+ {0x1f18, 0x1f1d, L},
+ {0x1f20, 0x1f45, L},
+ {0x1f48, 0x1f4d, L},
+ {0x1f50, 0x1f57, L},
+ {0x1f59, 0x1f59, L},
+ {0x1f5b, 0x1f5b, L},
+ {0x1f5d, 0x1f5d, L},
+ {0x1f5f, 0x1f7d, L},
+ {0x1f80, 0x1fb4, L},
+ {0x1fb6, 0x1fbc, L},
+ {0x1fbe, 0x1fbe, L},
+ {0x1fc2, 0x1fc4, L},
+ {0x1fc6, 0x1fcc, L},
+ {0x1fd0, 0x1fd3, L},
+ {0x1fd6, 0x1fdb, L},
+ {0x1fe0, 0x1fec, L},
+ {0x1ff2, 0x1ff4, L},
+ {0x1ff6, 0x1ffc, L},
+ {0x2000, 0x200a, WS},
+ {0x200b, 0x200d, BN},
+ {0x200e, 0x200e, L},
+ {0x200f, 0x200f, R},
+ {0x2028, 0x2028, WS},
+ {0x2029, 0x2029, B},
+ {0x202a, 0x202a, LRE},
+ {0x202b, 0x202b, RLE},
+ {0x202c, 0x202c, PDF},
+ {0x202d, 0x202d, LRO},
+ {0x202e, 0x202e, RLO},
+ {0x202f, 0x202f, CS},
+ {0x2030, 0x2034, ET},
+ {0x2044, 0x2044, CS},
+ {0x205f, 0x205f, WS},
+ {0x2060, 0x2064, BN},
+ {0x2066, 0x2066, LRI},
+ {0x2067, 0x2067, RLI},
+ {0x2068, 0x2068, FSI},
+ {0x2069, 0x2069, PDI},
+ {0x206a, 0x206f, BN},
+ {0x2070, 0x2070, EN},
+ {0x2071, 0x2071, L},
+ {0x2074, 0x2079, EN},
+ {0x207a, 0x207b, ES},
+ {0x207f, 0x207f, L},
+ {0x2080, 0x2089, EN},
+ {0x208a, 0x208b, ES},
+ {0x2090, 0x209c, L},
+ {0x20a0, 0x20c0, ET},
+ {0x20d0, 0x20f0, NSM},
+ {0x2102, 0x2102, L},
+ {0x2107, 0x2107, L},
+ {0x210a, 0x2113, L},
+ {0x2115, 0x2115, L},
+ {0x2119, 0x211d, L},
+ {0x2124, 0x2124, L},
+ {0x2126, 0x2126, L},
+ {0x2128, 0x2128, L},
+ {0x212a, 0x212d, L},
+ {0x212e, 0x212e, ET},
+ {0x212f, 0x2139, L},
+ {0x213c, 0x213f, L},
+ {0x2145, 0x2149, L},
+ {0x214e, 0x214f, L},
+ {0x2160, 0x2188, L},
+ {0x2212, 0x2212, ES},
+ {0x2213, 0x2213, ET},
+ {0x2336, 0x237a, L},
+ {0x2395, 0x2395, L},
+ {0x2488, 0x249b, EN},
+ {0x249c, 0x24e9, L},
+ {0x26ac, 0x26ac, L},
+ {0x2800, 0x28ff, L},
+ {0x2c00, 0x2ce4, L},
+ {0x2ceb, 0x2cee, L},
+ {0x2cef, 0x2cf1, NSM},
+ {0x2cf2, 0x2cf3, L},
+ {0x2d00, 0x2d25, L},
+ {0x2d27, 0x2d27, L},
+ {0x2d2d, 0x2d2d, L},
+ {0x2d30, 0x2d67, L},
+ {0x2d6f, 0x2d70, L},
+ {0x2d7f, 0x2d7f, NSM},
+ {0x2d80, 0x2d96, L},
+ {0x2da0, 0x2da6, L},
+ {0x2da8, 0x2dae, L},
+ {0x2db0, 0x2db6, L},
+ {0x2db8, 0x2dbe, L},
+ {0x2dc0, 0x2dc6, L},
+ {0x2dc8, 0x2dce, L},
+ {0x2dd0, 0x2dd6, L},
+ {0x2dd8, 0x2dde, L},
+ {0x2de0, 0x2dff, NSM},
+ {0x3000, 0x3000, WS},
+ {0x3005, 0x3007, L},
+ {0x3021, 0x3029, L},
+ {0x302a, 0x302d, NSM},
+ {0x302e, 0x302f, L},
+ {0x3031, 0x3035, L},
+ {0x3038, 0x303c, L},
+ {0x3041, 0x3096, L},
+ {0x3099, 0x309a, NSM},
+ {0x309d, 0x309f, L},
+ {0x30a1, 0x30fa, L},
+ {0x30fc, 0x30ff, L},
+ {0x3105, 0x312f, L},
+ {0x3131, 0x318e, L},
+ {0x3190, 0x31bf, L},
+ {0x31f0, 0x321c, L},
+ {0x3220, 0x324f, L},
+ {0x3260, 0x327b, L},
+ {0x327f, 0x32b0, L},
+ {0x32c0, 0x32cb, L},
+ {0x32d0, 0x3376, L},
+ {0x337b, 0x33dd, L},
+ {0x33e0, 0x33fe, L},
+ {0x3400, 0x4dbf, L},
+ {0x4e00, 0xa48c, L},
+ {0xa4d0, 0xa60c, L},
+ {0xa610, 0xa62b, L},
+ {0xa640, 0xa66e, L},
+ {0xa66f, 0xa672, NSM},
+ {0xa674, 0xa67d, NSM},
+ {0xa680, 0xa69d, L},
+ {0xa69e, 0xa69f, NSM},
+ {0xa6a0, 0xa6ef, L},
+ {0xa6f0, 0xa6f1, NSM},
+ {0xa6f2, 0xa6f7, L},
+ {0xa722, 0xa787, L},
+ {0xa789, 0xa7ca, L},
+ {0xa7d0, 0xa7d1, L},
+ {0xa7d3, 0xa7d3, L},
+ {0xa7d5, 0xa7d9, L},
+ {0xa7f2, 0xa801, L},
+ {0xa802, 0xa802, NSM},
+ {0xa803, 0xa805, L},
+ {0xa806, 0xa806, NSM},
+ {0xa807, 0xa80a, L},
+ {0xa80b, 0xa80b, NSM},
+ {0xa80c, 0xa824, L},
+ {0xa825, 0xa826, NSM},
+ {0xa827, 0xa827, L},
+ {0xa82c, 0xa82c, NSM},
+ {0xa830, 0xa837, L},
+ {0xa838, 0xa839, ET},
+ {0xa840, 0xa873, L},
+ {0xa880, 0xa8c3, L},
+ {0xa8c4, 0xa8c5, NSM},
+ {0xa8ce, 0xa8d9, L},
+ {0xa8e0, 0xa8f1, NSM},
+ {0xa8f2, 0xa8fe, L},
+ {0xa8ff, 0xa8ff, NSM},
+ {0xa900, 0xa925, L},
+ {0xa926, 0xa92d, NSM},
+ {0xa92e, 0xa946, L},
+ {0xa947, 0xa951, NSM},
+ {0xa952, 0xa953, L},
+ {0xa95f, 0xa97c, L},
+ {0xa980, 0xa982, NSM},
+ {0xa983, 0xa9b2, L},
+ {0xa9b3, 0xa9b3, NSM},
+ {0xa9b4, 0xa9b5, L},
+ {0xa9b6, 0xa9b9, NSM},
+ {0xa9ba, 0xa9bb, L},
+ {0xa9bc, 0xa9bd, NSM},
+ {0xa9be, 0xa9cd, L},
+ {0xa9cf, 0xa9d9, L},
+ {0xa9de, 0xa9e4, L},
+ {0xa9e5, 0xa9e5, NSM},
+ {0xa9e6, 0xa9fe, L},
+ {0xaa00, 0xaa28, L},
+ {0xaa29, 0xaa2e, NSM},
+ {0xaa2f, 0xaa30, L},
+ {0xaa31, 0xaa32, NSM},
+ {0xaa33, 0xaa34, L},
+ {0xaa35, 0xaa36, NSM},
+ {0xaa40, 0xaa42, L},
+ {0xaa43, 0xaa43, NSM},
+ {0xaa44, 0xaa4b, L},
+ {0xaa4c, 0xaa4c, NSM},
+ {0xaa4d, 0xaa4d, L},
+ {0xaa50, 0xaa59, L},
+ {0xaa5c, 0xaa7b, L},
+ {0xaa7c, 0xaa7c, NSM},
+ {0xaa7d, 0xaaaf, L},
+ {0xaab0, 0xaab0, NSM},
+ {0xaab1, 0xaab1, L},
+ {0xaab2, 0xaab4, NSM},
+ {0xaab5, 0xaab6, L},
+ {0xaab7, 0xaab8, NSM},
+ {0xaab9, 0xaabd, L},
+ {0xaabe, 0xaabf, NSM},
+ {0xaac0, 0xaac0, L},
+ {0xaac1, 0xaac1, NSM},
+ {0xaac2, 0xaac2, L},
+ {0xaadb, 0xaaeb, L},
+ {0xaaec, 0xaaed, NSM},
+ {0xaaee, 0xaaf5, L},
+ {0xaaf6, 0xaaf6, NSM},
+ {0xab01, 0xab06, L},
+ {0xab09, 0xab0e, L},
+ {0xab11, 0xab16, L},
+ {0xab20, 0xab26, L},
+ {0xab28, 0xab2e, L},
+ {0xab30, 0xab69, L},
+ {0xab70, 0xabe4, L},
+ {0xabe5, 0xabe5, NSM},
+ {0xabe6, 0xabe7, L},
+ {0xabe8, 0xabe8, NSM},
+ {0xabe9, 0xabec, L},
+ {0xabed, 0xabed, NSM},
+ {0xabf0, 0xabf9, L},
+ {0xac00, 0xd7a3, L},
+ {0xd7b0, 0xd7c6, L},
+ {0xd7cb, 0xd7fb, L},
+ {0xd800, 0xfa6d, L},
+ {0xfa70, 0xfad9, L},
+ {0xfb00, 0xfb06, L},
+ {0xfb13, 0xfb17, L},
+ {0xfb1d, 0xfb1d, R},
+ {0xfb1e, 0xfb1e, NSM},
+ {0xfb1f, 0xfb28, R},
+ {0xfb29, 0xfb29, ES},
+ {0xfb2a, 0xfb36, R},
+ {0xfb38, 0xfb3c, R},
+ {0xfb3e, 0xfb3e, R},
+ {0xfb40, 0xfb41, R},
+ {0xfb43, 0xfb44, R},
+ {0xfb46, 0xfb4f, R},
+ {0xfb50, 0xfbc2, AL},
+ {0xfbd3, 0xfd3d, AL},
+ {0xfd50, 0xfd8f, AL},
+ {0xfd92, 0xfdc7, AL},
+ {0xfdf0, 0xfdfc, AL},
+ {0xfe00, 0xfe0f, NSM},
+ {0xfe20, 0xfe2f, NSM},
+ {0xfe50, 0xfe50, CS},
+ {0xfe52, 0xfe52, CS},
+ {0xfe55, 0xfe55, CS},
+ {0xfe5f, 0xfe5f, ET},
+ {0xfe62, 0xfe63, ES},
+ {0xfe69, 0xfe6a, ET},
+ {0xfe70, 0xfe74, AL},
+ {0xfe76, 0xfefc, AL},
+ {0xfeff, 0xfeff, BN},
+ {0xff03, 0xff05, ET},
+ {0xff0b, 0xff0b, ES},
+ {0xff0c, 0xff0c, CS},
+ {0xff0d, 0xff0d, ES},
+ {0xff0e, 0xff0f, CS},
+ {0xff10, 0xff19, EN},
+ {0xff1a, 0xff1a, CS},
+ {0xff21, 0xff3a, L},
+ {0xff41, 0xff5a, L},
+ {0xff66, 0xffbe, L},
+ {0xffc2, 0xffc7, L},
+ {0xffca, 0xffcf, L},
+ {0xffd2, 0xffd7, L},
+ {0xffda, 0xffdc, L},
+ {0xffe0, 0xffe1, ET},
+ {0xffe5, 0xffe6, ET},
+ {0x10000, 0x1000b, L},
+ {0x1000d, 0x10026, L},
+ {0x10028, 0x1003a, L},
+ {0x1003c, 0x1003d, L},
+ {0x1003f, 0x1004d, L},
+ {0x10050, 0x1005d, L},
+ {0x10080, 0x100fa, L},
+ {0x10100, 0x10100, L},
+ {0x10102, 0x10102, L},
+ {0x10107, 0x10133, L},
+ {0x10137, 0x1013f, L},
+ {0x1018d, 0x1018e, L},
+ {0x101d0, 0x101fc, L},
+ {0x101fd, 0x101fd, NSM},
+ {0x10280, 0x1029c, L},
+ {0x102a0, 0x102d0, L},
+ {0x102e0, 0x102e0, NSM},
+ {0x102e1, 0x102fb, EN},
+ {0x10300, 0x10323, L},
+ {0x1032d, 0x1034a, L},
+ {0x10350, 0x10375, L},
+ {0x10376, 0x1037a, NSM},
+ {0x10380, 0x1039d, L},
+ {0x1039f, 0x103c3, L},
+ {0x103c8, 0x103d5, L},
+ {0x10400, 0x1049d, L},
+ {0x104a0, 0x104a9, L},
+ {0x104b0, 0x104d3, L},
+ {0x104d8, 0x104fb, L},
+ {0x10500, 0x10527, L},
+ {0x10530, 0x10563, L},
+ {0x1056f, 0x1057a, L},
+ {0x1057c, 0x1058a, L},
+ {0x1058c, 0x10592, L},
+ {0x10594, 0x10595, L},
+ {0x10597, 0x105a1, L},
+ {0x105a3, 0x105b1, L},
+ {0x105b3, 0x105b9, L},
+ {0x105bb, 0x105bc, L},
+ {0x10600, 0x10736, L},
+ {0x10740, 0x10755, L},
+ {0x10760, 0x10767, L},
+ {0x10780, 0x10785, L},
+ {0x10787, 0x107b0, L},
+ {0x107b2, 0x107ba, L},
+ {0x10800, 0x10805, R},
+ {0x10808, 0x10808, R},
+ {0x1080a, 0x10835, R},
+ {0x10837, 0x10838, R},
+ {0x1083c, 0x1083c, R},
+ {0x1083f, 0x10855, R},
+ {0x10857, 0x1089e, R},
+ {0x108a7, 0x108af, R},
+ {0x108e0, 0x108f2, R},
+ {0x108f4, 0x108f5, R},
+ {0x108fb, 0x1091b, R},
+ {0x10920, 0x10939, R},
+ {0x1093f, 0x1093f, R},
+ {0x10980, 0x109b7, R},
+ {0x109bc, 0x109cf, R},
+ {0x109d2, 0x10a00, R},
+ {0x10a01, 0x10a03, NSM},
+ {0x10a05, 0x10a06, NSM},
+ {0x10a0c, 0x10a0f, NSM},
+ {0x10a10, 0x10a13, R},
+ {0x10a15, 0x10a17, R},
+ {0x10a19, 0x10a35, R},
+ {0x10a38, 0x10a3a, NSM},
+ {0x10a3f, 0x10a3f, NSM},
+ {0x10a40, 0x10a48, R},
+ {0x10a50, 0x10a58, R},
+ {0x10a60, 0x10a9f, R},
+ {0x10ac0, 0x10ae4, R},
+ {0x10ae5, 0x10ae6, NSM},
+ {0x10aeb, 0x10af6, R},
+ {0x10b00, 0x10b35, R},
+ {0x10b40, 0x10b55, R},
+ {0x10b58, 0x10b72, R},
+ {0x10b78, 0x10b91, R},
+ {0x10b99, 0x10b9c, R},
+ {0x10ba9, 0x10baf, R},
+ {0x10c00, 0x10c48, R},
+ {0x10c80, 0x10cb2, R},
+ {0x10cc0, 0x10cf2, R},
+ {0x10cfa, 0x10cff, R},
+ {0x10d00, 0x10d23, AL},
+ {0x10d24, 0x10d27, NSM},
+ {0x10d30, 0x10d39, AN},
+ {0x10e60, 0x10e7e, AN},
+ {0x10e80, 0x10ea9, R},
+ {0x10eab, 0x10eac, NSM},
+ {0x10ead, 0x10ead, R},
+ {0x10eb0, 0x10eb1, R},
+ {0x10f00, 0x10f27, R},
+ {0x10f30, 0x10f45, AL},
+ {0x10f46, 0x10f50, NSM},
+ {0x10f51, 0x10f59, AL},
+ {0x10f70, 0x10f81, R},
+ {0x10f82, 0x10f85, NSM},
+ {0x10f86, 0x10f89, R},
+ {0x10fb0, 0x10fcb, R},
+ {0x10fe0, 0x10ff6, R},
+ {0x11000, 0x11000, L},
+ {0x11001, 0x11001, NSM},
+ {0x11002, 0x11037, L},
+ {0x11038, 0x11046, NSM},
+ {0x11047, 0x1104d, L},
+ {0x11066, 0x1106f, L},
+ {0x11070, 0x11070, NSM},
+ {0x11071, 0x11072, L},
+ {0x11073, 0x11074, NSM},
+ {0x11075, 0x11075, L},
+ {0x1107f, 0x11081, NSM},
+ {0x11082, 0x110b2, L},
+ {0x110b3, 0x110b6, NSM},
+ {0x110b7, 0x110b8, L},
+ {0x110b9, 0x110ba, NSM},
+ {0x110bb, 0x110c1, L},
+ {0x110c2, 0x110c2, NSM},
+ {0x110cd, 0x110cd, L},
+ {0x110d0, 0x110e8, L},
+ {0x110f0, 0x110f9, L},
+ {0x11100, 0x11102, NSM},
+ {0x11103, 0x11126, L},
+ {0x11127, 0x1112b, NSM},
+ {0x1112c, 0x1112c, L},
+ {0x1112d, 0x11134, NSM},
+ {0x11136, 0x11147, L},
+ {0x11150, 0x11172, L},
+ {0x11173, 0x11173, NSM},
+ {0x11174, 0x11176, L},
+ {0x11180, 0x11181, NSM},
+ {0x11182, 0x111b5, L},
+ {0x111b6, 0x111be, NSM},
+ {0x111bf, 0x111c8, L},
+ {0x111c9, 0x111cc, NSM},
+ {0x111cd, 0x111ce, L},
+ {0x111cf, 0x111cf, NSM},
+ {0x111d0, 0x111df, L},
+ {0x111e1, 0x111f4, L},
+ {0x11200, 0x11211, L},
+ {0x11213, 0x1122e, L},
+ {0x1122f, 0x11231, NSM},
+ {0x11232, 0x11233, L},
+ {0x11234, 0x11234, NSM},
+ {0x11235, 0x11235, L},
+ {0x11236, 0x11237, NSM},
+ {0x11238, 0x1123d, L},
+ {0x1123e, 0x1123e, NSM},
+ {0x11280, 0x11286, L},
+ {0x11288, 0x11288, L},
+ {0x1128a, 0x1128d, L},
+ {0x1128f, 0x1129d, L},
+ {0x1129f, 0x112a9, L},
+ {0x112b0, 0x112de, L},
+ {0x112df, 0x112df, NSM},
+ {0x112e0, 0x112e2, L},
+ {0x112e3, 0x112ea, NSM},
+ {0x112f0, 0x112f9, L},
+ {0x11300, 0x11301, NSM},
+ {0x11302, 0x11303, L},
+ {0x11305, 0x1130c, L},
+ {0x1130f, 0x11310, L},
+ {0x11313, 0x11328, L},
+ {0x1132a, 0x11330, L},
+ {0x11332, 0x11333, L},
+ {0x11335, 0x11339, L},
+ {0x1133b, 0x1133c, NSM},
+ {0x1133d, 0x1133f, L},
+ {0x11340, 0x11340, NSM},
+ {0x11341, 0x11344, L},
+ {0x11347, 0x11348, L},
+ {0x1134b, 0x1134d, L},
+ {0x11350, 0x11350, L},
+ {0x11357, 0x11357, L},
+ {0x1135d, 0x11363, L},
+ {0x11366, 0x1136c, NSM},
+ {0x11370, 0x11374, NSM},
+ {0x11400, 0x11437, L},
+ {0x11438, 0x1143f, NSM},
+ {0x11440, 0x11441, L},
+ {0x11442, 0x11444, NSM},
+ {0x11445, 0x11445, L},
+ {0x11446, 0x11446, NSM},
+ {0x11447, 0x1145b, L},
+ {0x1145d, 0x1145d, L},
+ {0x1145e, 0x1145e, NSM},
+ {0x1145f, 0x11461, L},
+ {0x11480, 0x114b2, L},
+ {0x114b3, 0x114b8, NSM},
+ {0x114b9, 0x114b9, L},
+ {0x114ba, 0x114ba, NSM},
+ {0x114bb, 0x114be, L},
+ {0x114bf, 0x114c0, NSM},
+ {0x114c1, 0x114c1, L},
+ {0x114c2, 0x114c3, NSM},
+ {0x114c4, 0x114c7, L},
+ {0x114d0, 0x114d9, L},
+ {0x11580, 0x115b1, L},
+ {0x115b2, 0x115b5, NSM},
+ {0x115b8, 0x115bb, L},
+ {0x115bc, 0x115bd, NSM},
+ {0x115be, 0x115be, L},
+ {0x115bf, 0x115c0, NSM},
+ {0x115c1, 0x115db, L},
+ {0x115dc, 0x115dd, NSM},
+ {0x11600, 0x11632, L},
+ {0x11633, 0x1163a, NSM},
+ {0x1163b, 0x1163c, L},
+ {0x1163d, 0x1163d, NSM},
+ {0x1163e, 0x1163e, L},
+ {0x1163f, 0x11640, NSM},
+ {0x11641, 0x11644, L},
+ {0x11650, 0x11659, L},
+ {0x11680, 0x116aa, L},
+ {0x116ab, 0x116ab, NSM},
+ {0x116ac, 0x116ac, L},
+ {0x116ad, 0x116ad, NSM},
+ {0x116ae, 0x116af, L},
+ {0x116b0, 0x116b5, NSM},
+ {0x116b6, 0x116b6, L},
+ {0x116b7, 0x116b7, NSM},
+ {0x116b8, 0x116b9, L},
+ {0x116c0, 0x116c9, L},
+ {0x11700, 0x1171a, L},
+ {0x1171d, 0x1171f, NSM},
+ {0x11720, 0x11721, L},
+ {0x11722, 0x11725, NSM},
+ {0x11726, 0x11726, L},
+ {0x11727, 0x1172b, NSM},
+ {0x11730, 0x11746, L},
+ {0x11800, 0x1182e, L},
+ {0x1182f, 0x11837, NSM},
+ {0x11838, 0x11838, L},
+ {0x11839, 0x1183a, NSM},
+ {0x1183b, 0x1183b, L},
+ {0x118a0, 0x118f2, L},
+ {0x118ff, 0x11906, L},
+ {0x11909, 0x11909, L},
+ {0x1190c, 0x11913, L},
+ {0x11915, 0x11916, L},
+ {0x11918, 0x11935, L},
+ {0x11937, 0x11938, L},
+ {0x1193b, 0x1193c, NSM},
+ {0x1193d, 0x1193d, L},
+ {0x1193e, 0x1193e, NSM},
+ {0x1193f, 0x11942, L},
+ {0x11943, 0x11943, NSM},
+ {0x11944, 0x11946, L},
+ {0x11950, 0x11959, L},
+ {0x119a0, 0x119a7, L},
+ {0x119aa, 0x119d3, L},
+ {0x119d4, 0x119d7, NSM},
+ {0x119da, 0x119db, NSM},
+ {0x119dc, 0x119df, L},
+ {0x119e0, 0x119e0, NSM},
+ {0x119e1, 0x119e4, L},
+ {0x11a00, 0x11a00, L},
+ {0x11a01, 0x11a06, NSM},
+ {0x11a07, 0x11a08, L},
+ {0x11a09, 0x11a0a, NSM},
+ {0x11a0b, 0x11a32, L},
+ {0x11a33, 0x11a38, NSM},
+ {0x11a39, 0x11a3a, L},
+ {0x11a3b, 0x11a3e, NSM},
+ {0x11a3f, 0x11a46, L},
+ {0x11a47, 0x11a47, NSM},
+ {0x11a50, 0x11a50, L},
+ {0x11a51, 0x11a56, NSM},
+ {0x11a57, 0x11a58, L},
+ {0x11a59, 0x11a5b, NSM},
+ {0x11a5c, 0x11a89, L},
+ {0x11a8a, 0x11a96, NSM},
+ {0x11a97, 0x11a97, L},
+ {0x11a98, 0x11a99, NSM},
+ {0x11a9a, 0x11aa2, L},
+ {0x11ab0, 0x11af8, L},
+ {0x11c00, 0x11c08, L},
+ {0x11c0a, 0x11c2f, L},
+ {0x11c30, 0x11c36, NSM},
+ {0x11c38, 0x11c3d, NSM},
+ {0x11c3e, 0x11c45, L},
+ {0x11c50, 0x11c6c, L},
+ {0x11c70, 0x11c8f, L},
+ {0x11c92, 0x11ca7, NSM},
+ {0x11ca9, 0x11ca9, L},
+ {0x11caa, 0x11cb0, NSM},
+ {0x11cb1, 0x11cb1, L},
+ {0x11cb2, 0x11cb3, NSM},
+ {0x11cb4, 0x11cb4, L},
+ {0x11cb5, 0x11cb6, NSM},
+ {0x11d00, 0x11d06, L},
+ {0x11d08, 0x11d09, L},
+ {0x11d0b, 0x11d30, L},
+ {0x11d31, 0x11d36, NSM},
+ {0x11d3a, 0x11d3a, NSM},
+ {0x11d3c, 0x11d3d, NSM},
+ {0x11d3f, 0x11d45, NSM},
+ {0x11d46, 0x11d46, L},
+ {0x11d47, 0x11d47, NSM},
+ {0x11d50, 0x11d59, L},
+ {0x11d60, 0x11d65, L},
+ {0x11d67, 0x11d68, L},
+ {0x11d6a, 0x11d8e, L},
+ {0x11d90, 0x11d91, NSM},
+ {0x11d93, 0x11d94, L},
+ {0x11d95, 0x11d95, NSM},
+ {0x11d96, 0x11d96, L},
+ {0x11d97, 0x11d97, NSM},
+ {0x11d98, 0x11d98, L},
+ {0x11da0, 0x11da9, L},
+ {0x11ee0, 0x11ef2, L},
+ {0x11ef3, 0x11ef4, NSM},
+ {0x11ef5, 0x11ef8, L},
+ {0x11fb0, 0x11fb0, L},
+ {0x11fc0, 0x11fd4, L},
+ {0x11fdd, 0x11fe0, ET},
+ {0x11fff, 0x12399, L},
+ {0x12400, 0x1246e, L},
+ {0x12470, 0x12474, L},
+ {0x12480, 0x12543, L},
+ {0x12f90, 0x12ff2, L},
+ {0x13000, 0x1342e, L},
+ {0x13430, 0x13438, L},
+ {0x14400, 0x14646, L},
+ {0x16800, 0x16a38, L},
+ {0x16a40, 0x16a5e, L},
+ {0x16a60, 0x16a69, L},
+ {0x16a6e, 0x16abe, L},
+ {0x16ac0, 0x16ac9, L},
+ {0x16ad0, 0x16aed, L},
+ {0x16af0, 0x16af4, NSM},
+ {0x16af5, 0x16af5, L},
+ {0x16b00, 0x16b2f, L},
+ {0x16b30, 0x16b36, NSM},
+ {0x16b37, 0x16b45, L},
+ {0x16b50, 0x16b59, L},
+ {0x16b5b, 0x16b61, L},
+ {0x16b63, 0x16b77, L},
+ {0x16b7d, 0x16b8f, L},
+ {0x16e40, 0x16e9a, L},
+ {0x16f00, 0x16f4a, L},
+ {0x16f4f, 0x16f4f, NSM},
+ {0x16f50, 0x16f87, L},
+ {0x16f8f, 0x16f92, NSM},
+ {0x16f93, 0x16f9f, L},
+ {0x16fe0, 0x16fe1, L},
+ {0x16fe3, 0x16fe3, L},
+ {0x16fe4, 0x16fe4, NSM},
+ {0x16ff0, 0x16ff1, L},
+ {0x17000, 0x187f7, L},
+ {0x18800, 0x18cd5, L},
+ {0x18d00, 0x18d08, L},
+ {0x1aff0, 0x1aff3, L},
+ {0x1aff5, 0x1affb, L},
+ {0x1affd, 0x1affe, L},
+ {0x1b000, 0x1b122, L},
+ {0x1b150, 0x1b152, L},
+ {0x1b164, 0x1b167, L},
+ {0x1b170, 0x1b2fb, L},
+ {0x1bc00, 0x1bc6a, L},
+ {0x1bc70, 0x1bc7c, L},
+ {0x1bc80, 0x1bc88, L},
+ {0x1bc90, 0x1bc99, L},
+ {0x1bc9c, 0x1bc9c, L},
+ {0x1bc9d, 0x1bc9e, NSM},
+ {0x1bc9f, 0x1bc9f, L},
+ {0x1bca0, 0x1bca3, BN},
+ {0x1cf00, 0x1cf2d, NSM},
+ {0x1cf30, 0x1cf46, NSM},
+ {0x1cf50, 0x1cfc3, L},
+ {0x1d000, 0x1d0f5, L},
+ {0x1d100, 0x1d126, L},
+ {0x1d129, 0x1d166, L},
+ {0x1d167, 0x1d169, NSM},
+ {0x1d16a, 0x1d172, L},
+ {0x1d173, 0x1d17a, BN},
+ {0x1d17b, 0x1d182, NSM},
+ {0x1d183, 0x1d184, L},
+ {0x1d185, 0x1d18b, NSM},
+ {0x1d18c, 0x1d1a9, L},
+ {0x1d1aa, 0x1d1ad, NSM},
+ {0x1d1ae, 0x1d1e8, L},
+ {0x1d242, 0x1d244, NSM},
+ {0x1d2e0, 0x1d2f3, L},
+ {0x1d360, 0x1d378, L},
+ {0x1d400, 0x1d454, L},
+ {0x1d456, 0x1d49c, L},
+ {0x1d49e, 0x1d49f, L},
+ {0x1d4a2, 0x1d4a2, L},
+ {0x1d4a5, 0x1d4a6, L},
+ {0x1d4a9, 0x1d4ac, L},
+ {0x1d4ae, 0x1d4b9, L},
+ {0x1d4bb, 0x1d4bb, L},
+ {0x1d4bd, 0x1d4c3, L},
+ {0x1d4c5, 0x1d505, L},
+ {0x1d507, 0x1d50a, L},
+ {0x1d50d, 0x1d514, L},
+ {0x1d516, 0x1d51c, L},
+ {0x1d51e, 0x1d539, L},
+ {0x1d53b, 0x1d53e, L},
+ {0x1d540, 0x1d544, L},
+ {0x1d546, 0x1d546, L},
+ {0x1d54a, 0x1d550, L},
+ {0x1d552, 0x1d6a5, L},
+ {0x1d6a8, 0x1d6da, L},
+ {0x1d6dc, 0x1d714, L},
+ {0x1d716, 0x1d74e, L},
+ {0x1d750, 0x1d788, L},
+ {0x1d78a, 0x1d7c2, L},
+ {0x1d7c4, 0x1d7cb, L},
+ {0x1d7ce, 0x1d7ff, EN},
+ {0x1d800, 0x1d9ff, L},
+ {0x1da00, 0x1da36, NSM},
+ {0x1da37, 0x1da3a, L},
+ {0x1da3b, 0x1da6c, NSM},
+ {0x1da6d, 0x1da74, L},
+ {0x1da75, 0x1da75, NSM},
+ {0x1da76, 0x1da83, L},
+ {0x1da84, 0x1da84, NSM},
+ {0x1da85, 0x1da8b, L},
+ {0x1da9b, 0x1da9f, NSM},
+ {0x1daa1, 0x1daaf, NSM},
+ {0x1df00, 0x1df1e, L},
+ {0x1e000, 0x1e006, NSM},
+ {0x1e008, 0x1e018, NSM},
+ {0x1e01b, 0x1e021, NSM},
+ {0x1e023, 0x1e024, NSM},
+ {0x1e026, 0x1e02a, NSM},
+ {0x1e100, 0x1e12c, L},
+ {0x1e130, 0x1e136, NSM},
+ {0x1e137, 0x1e13d, L},
+ {0x1e140, 0x1e149, L},
+ {0x1e14e, 0x1e14f, L},
+ {0x1e290, 0x1e2ad, L},
+ {0x1e2ae, 0x1e2ae, NSM},
+ {0x1e2c0, 0x1e2eb, L},
+ {0x1e2ec, 0x1e2ef, NSM},
+ {0x1e2f0, 0x1e2f9, L},
+ {0x1e2ff, 0x1e2ff, ET},
+ {0x1e7e0, 0x1e7e6, L},
+ {0x1e7e8, 0x1e7eb, L},
+ {0x1e7ed, 0x1e7ee, L},
+ {0x1e7f0, 0x1e7fe, L},
+ {0x1e800, 0x1e8c4, R},
+ {0x1e8c7, 0x1e8cf, R},
+ {0x1e8d0, 0x1e8d6, NSM},
+ {0x1e900, 0x1e943, R},
+ {0x1e944, 0x1e94a, NSM},
+ {0x1e94b, 0x1e94b, R},
+ {0x1e950, 0x1e959, R},
+ {0x1e95e, 0x1e95f, R},
+ {0x1ec71, 0x1ecb4, AL},
+ {0x1ed01, 0x1ed3d, AL},
+ {0x1ee00, 0x1ee03, AL},
+ {0x1ee05, 0x1ee1f, AL},
+ {0x1ee21, 0x1ee22, AL},
+ {0x1ee24, 0x1ee24, AL},
+ {0x1ee27, 0x1ee27, AL},
+ {0x1ee29, 0x1ee32, AL},
+ {0x1ee34, 0x1ee37, AL},
+ {0x1ee39, 0x1ee39, AL},
+ {0x1ee3b, 0x1ee3b, AL},
+ {0x1ee42, 0x1ee42, AL},
+ {0x1ee47, 0x1ee47, AL},
+ {0x1ee49, 0x1ee49, AL},
+ {0x1ee4b, 0x1ee4b, AL},
+ {0x1ee4d, 0x1ee4f, AL},
+ {0x1ee51, 0x1ee52, AL},
+ {0x1ee54, 0x1ee54, AL},
+ {0x1ee57, 0x1ee57, AL},
+ {0x1ee59, 0x1ee59, AL},
+ {0x1ee5b, 0x1ee5b, AL},
+ {0x1ee5d, 0x1ee5d, AL},
+ {0x1ee5f, 0x1ee5f, AL},
+ {0x1ee61, 0x1ee62, AL},
+ {0x1ee64, 0x1ee64, AL},
+ {0x1ee67, 0x1ee6a, AL},
+ {0x1ee6c, 0x1ee72, AL},
+ {0x1ee74, 0x1ee77, AL},
+ {0x1ee79, 0x1ee7c, AL},
+ {0x1ee7e, 0x1ee7e, AL},
+ {0x1ee80, 0x1ee89, AL},
+ {0x1ee8b, 0x1ee9b, AL},
+ {0x1eea1, 0x1eea3, AL},
+ {0x1eea5, 0x1eea9, AL},
+ {0x1eeab, 0x1eebb, AL},
+ {0x1f100, 0x1f10a, EN},
+ {0x1f110, 0x1f12e, L},
+ {0x1f130, 0x1f169, L},
+ {0x1f170, 0x1f1ac, L},
+ {0x1f1e6, 0x1f202, L},
+ {0x1f210, 0x1f23b, L},
+ {0x1f240, 0x1f248, L},
+ {0x1f250, 0x1f251, L},
+ {0x1fbf0, 0x1fbf9, EN},
+ {0x20000, 0x2a6df, L},
+ {0x2a700, 0x2b738, L},
+ {0x2b740, 0x2b81d, L},
+ {0x2b820, 0x2cea1, L},
+ {0x2ceb0, 0x2ebe0, L},
+ {0x2f800, 0x2fa1d, L},
+ {0x30000, 0x3134a, L},
+ {0xe0001, 0xe0001, BN},
+ {0xe0020, 0xe007f, BN},
+ {0xe0100, 0xe01ef, NSM},
+ {0xf0000, 0xffffd, L},
+ {0x100000, 0x10fffd, L},
+ };
+
+ int i, j, k;
+
+ i = -1;
+ j = lenof(lookup);
+
+ while (j - i > 1) {
+ k = (i + j) / 2;
+ if (ch < lookup[k].first)
+ j = k;
+ else if (ch > lookup[k].last)
+ i = k;
+ else
+ return lookup[k].type;
+ }
+
+ /*
+ * If we reach here, the character was not in any of the
+ * intervals listed in the lookup table. This means we return
+ * ON (`Other Neutrals'). This is the appropriate code for any
+ * character genuinely not listed in the Unicode table, and
+ * also the table above has deliberately left out any
+ * characters _explicitly_ listed as ON (to save space!).
+ */
+ return ON;
+}
+
+/*
+ * Return the mirrored version of a glyph.
+
+ * The data table in this function is constructed from the Unicode
+ * Character Database version 14.0.0, downloadable from unicode.org at
+ * the URL
+ *
+ * https://www.unicode.org/Public/14.0.0/ucd/
+ *
+ * by the following fragment of Perl:
+
+perl -e '
+ while (<<>>) {
+ chomp; s{\s}{}g; s{#.*$}{}; next unless /./;
+ @_ = split /;/, $_;
+ $src = hex $_[0]; $dst = hex $_[1];
+ $m{$src}=$dst; $m{$dst}=$src;
+ }
+ for $src (sort {$a <=> $b} keys %m) {
+ printf " {0x%04x, 0x%04x},\n", $src, $m{$src};
+ }
+' BidiMirroring.txt
+
+ *
+ * FIXME: there are also glyphs which the text rendering engine is
+ * supposed to display left-right reflected, since no mirrored glyph
+ * exists in Unicode itself to indicate the reflected form. Those are
+ * listed in comments in BidiMirroring.txt. Many of them are
+ * mathematical, e.g. the square root sign, or set difference
+ * operator, or integral sign. No API currently exists here to
+ * communicate the need for that reflected display back to the client.
+ */
+static unsigned mirror_glyph(unsigned int ch)
+{
+ static const struct {
+ unsigned src, dst;
+ } mirror_pairs[] = {
+ {0x0028, 0x0029},
+ {0x0029, 0x0028},
+ {0x003c, 0x003e},
+ {0x003e, 0x003c},
+ {0x005b, 0x005d},
+ {0x005d, 0x005b},
+ {0x007b, 0x007d},
+ {0x007d, 0x007b},
+ {0x00ab, 0x00bb},
+ {0x00bb, 0x00ab},
+ {0x0f3a, 0x0f3b},
+ {0x0f3b, 0x0f3a},
+ {0x0f3c, 0x0f3d},
+ {0x0f3d, 0x0f3c},
+ {0x169b, 0x169c},
+ {0x169c, 0x169b},
+ {0x2039, 0x203a},
+ {0x203a, 0x2039},
+ {0x2045, 0x2046},
+ {0x2046, 0x2045},
+ {0x207d, 0x207e},
+ {0x207e, 0x207d},
+ {0x208d, 0x208e},
+ {0x208e, 0x208d},
+ {0x2208, 0x220b},
+ {0x2209, 0x220c},
+ {0x220a, 0x220d},
+ {0x220b, 0x2208},
+ {0x220c, 0x2209},
+ {0x220d, 0x220a},
+ {0x2215, 0x29f5},
+ {0x221f, 0x2bfe},
+ {0x2220, 0x29a3},
+ {0x2221, 0x299b},
+ {0x2222, 0x29a0},
+ {0x2224, 0x2aee},
+ {0x223c, 0x223d},
+ {0x223d, 0x223c},
+ {0x2243, 0x22cd},
+ {0x2245, 0x224c},
+ {0x224c, 0x2245},
+ {0x2252, 0x2253},
+ {0x2253, 0x2252},
+ {0x2254, 0x2255},
+ {0x2255, 0x2254},
+ {0x2264, 0x2265},
+ {0x2265, 0x2264},
+ {0x2266, 0x2267},
+ {0x2267, 0x2266},
+ {0x2268, 0x2269},
+ {0x2269, 0x2268},
+ {0x226a, 0x226b},
+ {0x226b, 0x226a},
+ {0x226e, 0x226f},
+ {0x226f, 0x226e},
+ {0x2270, 0x2271},
+ {0x2271, 0x2270},
+ {0x2272, 0x2273},
+ {0x2273, 0x2272},
+ {0x2274, 0x2275},
+ {0x2275, 0x2274},
+ {0x2276, 0x2277},
+ {0x2277, 0x2276},
+ {0x2278, 0x2279},
+ {0x2279, 0x2278},
+ {0x227a, 0x227b},
+ {0x227b, 0x227a},
+ {0x227c, 0x227d},
+ {0x227d, 0x227c},
+ {0x227e, 0x227f},
+ {0x227f, 0x227e},
+ {0x2280, 0x2281},
+ {0x2281, 0x2280},
+ {0x2282, 0x2283},
+ {0x2283, 0x2282},
+ {0x2284, 0x2285},
+ {0x2285, 0x2284},
+ {0x2286, 0x2287},
+ {0x2287, 0x2286},
+ {0x2288, 0x2289},
+ {0x2289, 0x2288},
+ {0x228a, 0x228b},
+ {0x228b, 0x228a},
+ {0x228f, 0x2290},
+ {0x2290, 0x228f},
+ {0x2291, 0x2292},
+ {0x2292, 0x2291},
+ {0x2298, 0x29b8},
+ {0x22a2, 0x22a3},
+ {0x22a3, 0x22a2},
+ {0x22a6, 0x2ade},
+ {0x22a8, 0x2ae4},
+ {0x22a9, 0x2ae3},
+ {0x22ab, 0x2ae5},
+ {0x22b0, 0x22b1},
+ {0x22b1, 0x22b0},
+ {0x22b2, 0x22b3},
+ {0x22b3, 0x22b2},
+ {0x22b4, 0x22b5},
+ {0x22b5, 0x22b4},
+ {0x22b6, 0x22b7},
+ {0x22b7, 0x22b6},
+ {0x22b8, 0x27dc},
+ {0x22c9, 0x22ca},
+ {0x22ca, 0x22c9},
+ {0x22cb, 0x22cc},
+ {0x22cc, 0x22cb},
+ {0x22cd, 0x2243},
+ {0x22d0, 0x22d1},
+ {0x22d1, 0x22d0},
+ {0x22d6, 0x22d7},
+ {0x22d7, 0x22d6},
+ {0x22d8, 0x22d9},
+ {0x22d9, 0x22d8},
+ {0x22da, 0x22db},
+ {0x22db, 0x22da},
+ {0x22dc, 0x22dd},
+ {0x22dd, 0x22dc},
+ {0x22de, 0x22df},
+ {0x22df, 0x22de},
+ {0x22e0, 0x22e1},
+ {0x22e1, 0x22e0},
+ {0x22e2, 0x22e3},
+ {0x22e3, 0x22e2},
+ {0x22e4, 0x22e5},
+ {0x22e5, 0x22e4},
+ {0x22e6, 0x22e7},
+ {0x22e7, 0x22e6},
+ {0x22e8, 0x22e9},
+ {0x22e9, 0x22e8},
+ {0x22ea, 0x22eb},
+ {0x22eb, 0x22ea},
+ {0x22ec, 0x22ed},
+ {0x22ed, 0x22ec},
+ {0x22f0, 0x22f1},
+ {0x22f1, 0x22f0},
+ {0x22f2, 0x22fa},
+ {0x22f3, 0x22fb},
+ {0x22f4, 0x22fc},
+ {0x22f6, 0x22fd},
+ {0x22f7, 0x22fe},
+ {0x22fa, 0x22f2},
+ {0x22fb, 0x22f3},
+ {0x22fc, 0x22f4},
+ {0x22fd, 0x22f6},
+ {0x22fe, 0x22f7},
+ {0x2308, 0x2309},
+ {0x2309, 0x2308},
+ {0x230a, 0x230b},
+ {0x230b, 0x230a},
+ {0x2329, 0x232a},
+ {0x232a, 0x2329},
+ {0x2768, 0x2769},
+ {0x2769, 0x2768},
+ {0x276a, 0x276b},
+ {0x276b, 0x276a},
+ {0x276c, 0x276d},
+ {0x276d, 0x276c},
+ {0x276e, 0x276f},
+ {0x276f, 0x276e},
+ {0x2770, 0x2771},
+ {0x2771, 0x2770},
+ {0x2772, 0x2773},
+ {0x2773, 0x2772},
+ {0x2774, 0x2775},
+ {0x2775, 0x2774},
+ {0x27c3, 0x27c4},
+ {0x27c4, 0x27c3},
+ {0x27c5, 0x27c6},
+ {0x27c6, 0x27c5},
+ {0x27c8, 0x27c9},
+ {0x27c9, 0x27c8},
+ {0x27cb, 0x27cd},
+ {0x27cd, 0x27cb},
+ {0x27d5, 0x27d6},
+ {0x27d6, 0x27d5},
+ {0x27dc, 0x22b8},
+ {0x27dd, 0x27de},
+ {0x27de, 0x27dd},
+ {0x27e2, 0x27e3},
+ {0x27e3, 0x27e2},
+ {0x27e4, 0x27e5},
+ {0x27e5, 0x27e4},
+ {0x27e6, 0x27e7},
+ {0x27e7, 0x27e6},
+ {0x27e8, 0x27e9},
+ {0x27e9, 0x27e8},
+ {0x27ea, 0x27eb},
+ {0x27eb, 0x27ea},
+ {0x27ec, 0x27ed},
+ {0x27ed, 0x27ec},
+ {0x27ee, 0x27ef},
+ {0x27ef, 0x27ee},
+ {0x2983, 0x2984},
+ {0x2984, 0x2983},
+ {0x2985, 0x2986},
+ {0x2986, 0x2985},
+ {0x2987, 0x2988},
+ {0x2988, 0x2987},
+ {0x2989, 0x298a},
+ {0x298a, 0x2989},
+ {0x298b, 0x298c},
+ {0x298c, 0x298b},
+ {0x298d, 0x2990},
+ {0x298e, 0x298f},
+ {0x298f, 0x298e},
+ {0x2990, 0x298d},
+ {0x2991, 0x2992},
+ {0x2992, 0x2991},
+ {0x2993, 0x2994},
+ {0x2994, 0x2993},
+ {0x2995, 0x2996},
+ {0x2996, 0x2995},
+ {0x2997, 0x2998},
+ {0x2998, 0x2997},
+ {0x299b, 0x2221},
+ {0x29a0, 0x2222},
+ {0x29a3, 0x2220},
+ {0x29a4, 0x29a5},
+ {0x29a5, 0x29a4},
+ {0x29a8, 0x29a9},
+ {0x29a9, 0x29a8},
+ {0x29aa, 0x29ab},
+ {0x29ab, 0x29aa},
+ {0x29ac, 0x29ad},
+ {0x29ad, 0x29ac},
+ {0x29ae, 0x29af},
+ {0x29af, 0x29ae},
+ {0x29b8, 0x2298},
+ {0x29c0, 0x29c1},
+ {0x29c1, 0x29c0},
+ {0x29c4, 0x29c5},
+ {0x29c5, 0x29c4},
+ {0x29cf, 0x29d0},
+ {0x29d0, 0x29cf},
+ {0x29d1, 0x29d2},
+ {0x29d2, 0x29d1},
+ {0x29d4, 0x29d5},
+ {0x29d5, 0x29d4},
+ {0x29d8, 0x29d9},
+ {0x29d9, 0x29d8},
+ {0x29da, 0x29db},
+ {0x29db, 0x29da},
+ {0x29e8, 0x29e9},
+ {0x29e9, 0x29e8},
+ {0x29f5, 0x2215},
+ {0x29f8, 0x29f9},
+ {0x29f9, 0x29f8},
+ {0x29fc, 0x29fd},
+ {0x29fd, 0x29fc},
+ {0x2a2b, 0x2a2c},
+ {0x2a2c, 0x2a2b},
+ {0x2a2d, 0x2a2e},
+ {0x2a2e, 0x2a2d},
+ {0x2a34, 0x2a35},
+ {0x2a35, 0x2a34},
+ {0x2a3c, 0x2a3d},
+ {0x2a3d, 0x2a3c},
+ {0x2a64, 0x2a65},
+ {0x2a65, 0x2a64},
+ {0x2a79, 0x2a7a},
+ {0x2a7a, 0x2a79},
+ {0x2a7b, 0x2a7c},
+ {0x2a7c, 0x2a7b},
+ {0x2a7d, 0x2a7e},
+ {0x2a7e, 0x2a7d},
+ {0x2a7f, 0x2a80},
+ {0x2a80, 0x2a7f},
+ {0x2a81, 0x2a82},
+ {0x2a82, 0x2a81},
+ {0x2a83, 0x2a84},
+ {0x2a84, 0x2a83},
+ {0x2a85, 0x2a86},
+ {0x2a86, 0x2a85},
+ {0x2a87, 0x2a88},
+ {0x2a88, 0x2a87},
+ {0x2a89, 0x2a8a},
+ {0x2a8a, 0x2a89},
+ {0x2a8b, 0x2a8c},
+ {0x2a8c, 0x2a8b},
+ {0x2a8d, 0x2a8e},
+ {0x2a8e, 0x2a8d},
+ {0x2a8f, 0x2a90},
+ {0x2a90, 0x2a8f},
+ {0x2a91, 0x2a92},
+ {0x2a92, 0x2a91},
+ {0x2a93, 0x2a94},
+ {0x2a94, 0x2a93},
+ {0x2a95, 0x2a96},
+ {0x2a96, 0x2a95},
+ {0x2a97, 0x2a98},
+ {0x2a98, 0x2a97},
+ {0x2a99, 0x2a9a},
+ {0x2a9a, 0x2a99},
+ {0x2a9b, 0x2a9c},
+ {0x2a9c, 0x2a9b},
+ {0x2a9d, 0x2a9e},
+ {0x2a9e, 0x2a9d},
+ {0x2a9f, 0x2aa0},
+ {0x2aa0, 0x2a9f},
+ {0x2aa1, 0x2aa2},
+ {0x2aa2, 0x2aa1},
+ {0x2aa6, 0x2aa7},
+ {0x2aa7, 0x2aa6},
+ {0x2aa8, 0x2aa9},
+ {0x2aa9, 0x2aa8},
+ {0x2aaa, 0x2aab},
+ {0x2aab, 0x2aaa},
+ {0x2aac, 0x2aad},
+ {0x2aad, 0x2aac},
+ {0x2aaf, 0x2ab0},
+ {0x2ab0, 0x2aaf},
+ {0x2ab1, 0x2ab2},
+ {0x2ab2, 0x2ab1},
+ {0x2ab3, 0x2ab4},
+ {0x2ab4, 0x2ab3},
+ {0x2ab5, 0x2ab6},
+ {0x2ab6, 0x2ab5},
+ {0x2ab7, 0x2ab8},
+ {0x2ab8, 0x2ab7},
+ {0x2ab9, 0x2aba},
+ {0x2aba, 0x2ab9},
+ {0x2abb, 0x2abc},
+ {0x2abc, 0x2abb},
+ {0x2abd, 0x2abe},
+ {0x2abe, 0x2abd},
+ {0x2abf, 0x2ac0},
+ {0x2ac0, 0x2abf},
+ {0x2ac1, 0x2ac2},
+ {0x2ac2, 0x2ac1},
+ {0x2ac3, 0x2ac4},
+ {0x2ac4, 0x2ac3},
+ {0x2ac5, 0x2ac6},
+ {0x2ac6, 0x2ac5},
+ {0x2ac7, 0x2ac8},
+ {0x2ac8, 0x2ac7},
+ {0x2ac9, 0x2aca},
+ {0x2aca, 0x2ac9},
+ {0x2acb, 0x2acc},
+ {0x2acc, 0x2acb},
+ {0x2acd, 0x2ace},
+ {0x2ace, 0x2acd},
+ {0x2acf, 0x2ad0},
+ {0x2ad0, 0x2acf},
+ {0x2ad1, 0x2ad2},
+ {0x2ad2, 0x2ad1},
+ {0x2ad3, 0x2ad4},
+ {0x2ad4, 0x2ad3},
+ {0x2ad5, 0x2ad6},
+ {0x2ad6, 0x2ad5},
+ {0x2ade, 0x22a6},
+ {0x2ae3, 0x22a9},
+ {0x2ae4, 0x22a8},
+ {0x2ae5, 0x22ab},
+ {0x2aec, 0x2aed},
+ {0x2aed, 0x2aec},
+ {0x2aee, 0x2224},
+ {0x2af7, 0x2af8},
+ {0x2af8, 0x2af7},
+ {0x2af9, 0x2afa},
+ {0x2afa, 0x2af9},
+ {0x2bfe, 0x221f},
+ {0x2e02, 0x2e03},
+ {0x2e03, 0x2e02},
+ {0x2e04, 0x2e05},
+ {0x2e05, 0x2e04},
+ {0x2e09, 0x2e0a},
+ {0x2e0a, 0x2e09},
+ {0x2e0c, 0x2e0d},
+ {0x2e0d, 0x2e0c},
+ {0x2e1c, 0x2e1d},
+ {0x2e1d, 0x2e1c},
+ {0x2e20, 0x2e21},
+ {0x2e21, 0x2e20},
+ {0x2e22, 0x2e23},
+ {0x2e23, 0x2e22},
+ {0x2e24, 0x2e25},
+ {0x2e25, 0x2e24},
+ {0x2e26, 0x2e27},
+ {0x2e27, 0x2e26},
+ {0x2e28, 0x2e29},
+ {0x2e29, 0x2e28},
+ {0x2e55, 0x2e56},
+ {0x2e56, 0x2e55},
+ {0x2e57, 0x2e58},
+ {0x2e58, 0x2e57},
+ {0x2e59, 0x2e5a},
+ {0x2e5a, 0x2e59},
+ {0x2e5b, 0x2e5c},
+ {0x2e5c, 0x2e5b},
+ {0x3008, 0x3009},
+ {0x3009, 0x3008},
+ {0x300a, 0x300b},
+ {0x300b, 0x300a},
+ {0x300c, 0x300d},
+ {0x300d, 0x300c},
+ {0x300e, 0x300f},
+ {0x300f, 0x300e},
+ {0x3010, 0x3011},
+ {0x3011, 0x3010},
+ {0x3014, 0x3015},
+ {0x3015, 0x3014},
+ {0x3016, 0x3017},
+ {0x3017, 0x3016},
+ {0x3018, 0x3019},
+ {0x3019, 0x3018},
+ {0x301a, 0x301b},
+ {0x301b, 0x301a},
+ {0xfe59, 0xfe5a},
+ {0xfe5a, 0xfe59},
+ {0xfe5b, 0xfe5c},
+ {0xfe5c, 0xfe5b},
+ {0xfe5d, 0xfe5e},
+ {0xfe5e, 0xfe5d},
+ {0xfe64, 0xfe65},
+ {0xfe65, 0xfe64},
+ {0xff08, 0xff09},
+ {0xff09, 0xff08},
+ {0xff1c, 0xff1e},
+ {0xff1e, 0xff1c},
+ {0xff3b, 0xff3d},
+ {0xff3d, 0xff3b},
+ {0xff5b, 0xff5d},
+ {0xff5d, 0xff5b},
+ {0xff5f, 0xff60},
+ {0xff60, 0xff5f},
+ {0xff62, 0xff63},
+ {0xff63, 0xff62},
+ };
+
+ int i, j, k;
+
+ i = -1;
+ j = lenof(mirror_pairs);
+
+ while (j - i > 1) {
+ k = (i + j) / 2;
+ if (ch < mirror_pairs[k].src)
+ j = k;
+ else if (ch > mirror_pairs[k].src)
+ i = k;
+ else
+ return mirror_pairs[k].dst;
+ }
+
+ return ch;
+}
+
+/*
+ * Identify the bracket characters treated specially by bidi rule
+ * BD19, and return their paired character(s).
+ *
+ * The data table in this function is constructed from the Unicode
+ * Character Database version 14.0.0, downloadable from unicode.org at
+ * the URL
+ *
+ * https://www.unicode.org/Public/14.0.0/ucd/
+ *
+ * by the following fragment of Perl:
+
+perl -e '
+ open BIDIBRACKETS, "<", $ARGV[0] or die;
+ while (<BIDIBRACKETS>) {
+ chomp; s{\s}{}g; s{#.*$}{}; next unless /./;
+ @_ = split /;/, $_;
+ $src = hex $_[0]; $dst = hex $_[1]; $kind = $_[2];
+ $m{$src}=[$kind, $dst];
+ }
+ open UNICODEDATA, "<", $ARGV[1] or die;
+ while (<UNICODEDATA>) {
+ chomp; @_ = split /;/, $_;
+ $src = hex $_[0]; next unless defined $m{$src};
+ if ($_[5] =~ /^[0-9a-f]+$/i) {
+ $equiv = hex $_[5];
+ $e{$src} = $equiv;
+ $e{$equiv} = $src;
+ }
+ }
+ for $src (sort {$a <=> $b} keys %m) {
+ ($kind, $dst) = @{$m{$src}};
+ $equiv = 0 + $e{$dst};
+ printf " {0x%04x, {0x%04x, 0x%04x, %s}},\n", $src, $dst, $equiv,
+ $kind eq "c" ? "BT_CLOSE" : "BT_OPEN";
+ }
+' BidiBrackets.txt UnicodeData.txt
+
+ */
+typedef enum { BT_NONE, BT_OPEN, BT_CLOSE } BracketType;
+typedef struct BracketTypeData {
+ unsigned partner, equiv_partner;
+ BracketType type;
+} BracketTypeData;
+static BracketTypeData bracket_type(unsigned int ch)
+{
+ static const struct {
+ unsigned src;
+ BracketTypeData payload;
+ } bracket_pairs[] = {
+ {0x0028, {0x0029, 0x0000, BT_OPEN}},
+ {0x0029, {0x0028, 0x0000, BT_CLOSE}},
+ {0x005b, {0x005d, 0x0000, BT_OPEN}},
+ {0x005d, {0x005b, 0x0000, BT_CLOSE}},
+ {0x007b, {0x007d, 0x0000, BT_OPEN}},
+ {0x007d, {0x007b, 0x0000, BT_CLOSE}},
+ {0x0f3a, {0x0f3b, 0x0000, BT_OPEN}},
+ {0x0f3b, {0x0f3a, 0x0000, BT_CLOSE}},
+ {0x0f3c, {0x0f3d, 0x0000, BT_OPEN}},
+ {0x0f3d, {0x0f3c, 0x0000, BT_CLOSE}},
+ {0x169b, {0x169c, 0x0000, BT_OPEN}},
+ {0x169c, {0x169b, 0x0000, BT_CLOSE}},
+ {0x2045, {0x2046, 0x0000, BT_OPEN}},
+ {0x2046, {0x2045, 0x0000, BT_CLOSE}},
+ {0x207d, {0x207e, 0x0000, BT_OPEN}},
+ {0x207e, {0x207d, 0x0000, BT_CLOSE}},
+ {0x208d, {0x208e, 0x0000, BT_OPEN}},
+ {0x208e, {0x208d, 0x0000, BT_CLOSE}},
+ {0x2308, {0x2309, 0x0000, BT_OPEN}},
+ {0x2309, {0x2308, 0x0000, BT_CLOSE}},
+ {0x230a, {0x230b, 0x0000, BT_OPEN}},
+ {0x230b, {0x230a, 0x0000, BT_CLOSE}},
+ {0x2329, {0x232a, 0x3009, BT_OPEN}},
+ {0x232a, {0x2329, 0x3008, BT_CLOSE}},
+ {0x2768, {0x2769, 0x0000, BT_OPEN}},
+ {0x2769, {0x2768, 0x0000, BT_CLOSE}},
+ {0x276a, {0x276b, 0x0000, BT_OPEN}},
+ {0x276b, {0x276a, 0x0000, BT_CLOSE}},
+ {0x276c, {0x276d, 0x0000, BT_OPEN}},
+ {0x276d, {0x276c, 0x0000, BT_CLOSE}},
+ {0x276e, {0x276f, 0x0000, BT_OPEN}},
+ {0x276f, {0x276e, 0x0000, BT_CLOSE}},
+ {0x2770, {0x2771, 0x0000, BT_OPEN}},
+ {0x2771, {0x2770, 0x0000, BT_CLOSE}},
+ {0x2772, {0x2773, 0x0000, BT_OPEN}},
+ {0x2773, {0x2772, 0x0000, BT_CLOSE}},
+ {0x2774, {0x2775, 0x0000, BT_OPEN}},
+ {0x2775, {0x2774, 0x0000, BT_CLOSE}},
+ {0x27c5, {0x27c6, 0x0000, BT_OPEN}},
+ {0x27c6, {0x27c5, 0x0000, BT_CLOSE}},
+ {0x27e6, {0x27e7, 0x0000, BT_OPEN}},
+ {0x27e7, {0x27e6, 0x0000, BT_CLOSE}},
+ {0x27e8, {0x27e9, 0x0000, BT_OPEN}},
+ {0x27e9, {0x27e8, 0x0000, BT_CLOSE}},
+ {0x27ea, {0x27eb, 0x0000, BT_OPEN}},
+ {0x27eb, {0x27ea, 0x0000, BT_CLOSE}},
+ {0x27ec, {0x27ed, 0x0000, BT_OPEN}},
+ {0x27ed, {0x27ec, 0x0000, BT_CLOSE}},
+ {0x27ee, {0x27ef, 0x0000, BT_OPEN}},
+ {0x27ef, {0x27ee, 0x0000, BT_CLOSE}},
+ {0x2983, {0x2984, 0x0000, BT_OPEN}},
+ {0x2984, {0x2983, 0x0000, BT_CLOSE}},
+ {0x2985, {0x2986, 0x0000, BT_OPEN}},
+ {0x2986, {0x2985, 0x0000, BT_CLOSE}},
+ {0x2987, {0x2988, 0x0000, BT_OPEN}},
+ {0x2988, {0x2987, 0x0000, BT_CLOSE}},
+ {0x2989, {0x298a, 0x0000, BT_OPEN}},
+ {0x298a, {0x2989, 0x0000, BT_CLOSE}},
+ {0x298b, {0x298c, 0x0000, BT_OPEN}},
+ {0x298c, {0x298b, 0x0000, BT_CLOSE}},
+ {0x298d, {0x2990, 0x0000, BT_OPEN}},
+ {0x298e, {0x298f, 0x0000, BT_CLOSE}},
+ {0x298f, {0x298e, 0x0000, BT_OPEN}},
+ {0x2990, {0x298d, 0x0000, BT_CLOSE}},
+ {0x2991, {0x2992, 0x0000, BT_OPEN}},
+ {0x2992, {0x2991, 0x0000, BT_CLOSE}},
+ {0x2993, {0x2994, 0x0000, BT_OPEN}},
+ {0x2994, {0x2993, 0x0000, BT_CLOSE}},
+ {0x2995, {0x2996, 0x0000, BT_OPEN}},
+ {0x2996, {0x2995, 0x0000, BT_CLOSE}},
+ {0x2997, {0x2998, 0x0000, BT_OPEN}},
+ {0x2998, {0x2997, 0x0000, BT_CLOSE}},
+ {0x29d8, {0x29d9, 0x0000, BT_OPEN}},
+ {0x29d9, {0x29d8, 0x0000, BT_CLOSE}},
+ {0x29da, {0x29db, 0x0000, BT_OPEN}},
+ {0x29db, {0x29da, 0x0000, BT_CLOSE}},
+ {0x29fc, {0x29fd, 0x0000, BT_OPEN}},
+ {0x29fd, {0x29fc, 0x0000, BT_CLOSE}},
+ {0x2e22, {0x2e23, 0x0000, BT_OPEN}},
+ {0x2e23, {0x2e22, 0x0000, BT_CLOSE}},
+ {0x2e24, {0x2e25, 0x0000, BT_OPEN}},
+ {0x2e25, {0x2e24, 0x0000, BT_CLOSE}},
+ {0x2e26, {0x2e27, 0x0000, BT_OPEN}},
+ {0x2e27, {0x2e26, 0x0000, BT_CLOSE}},
+ {0x2e28, {0x2e29, 0x0000, BT_OPEN}},
+ {0x2e29, {0x2e28, 0x0000, BT_CLOSE}},
+ {0x2e55, {0x2e56, 0x0000, BT_OPEN}},
+ {0x2e56, {0x2e55, 0x0000, BT_CLOSE}},
+ {0x2e57, {0x2e58, 0x0000, BT_OPEN}},
+ {0x2e58, {0x2e57, 0x0000, BT_CLOSE}},
+ {0x2e59, {0x2e5a, 0x0000, BT_OPEN}},
+ {0x2e5a, {0x2e59, 0x0000, BT_CLOSE}},
+ {0x2e5b, {0x2e5c, 0x0000, BT_OPEN}},
+ {0x2e5c, {0x2e5b, 0x0000, BT_CLOSE}},
+ {0x3008, {0x3009, 0x232a, BT_OPEN}},
+ {0x3009, {0x3008, 0x2329, BT_CLOSE}},
+ {0x300a, {0x300b, 0x0000, BT_OPEN}},
+ {0x300b, {0x300a, 0x0000, BT_CLOSE}},
+ {0x300c, {0x300d, 0x0000, BT_OPEN}},
+ {0x300d, {0x300c, 0x0000, BT_CLOSE}},
+ {0x300e, {0x300f, 0x0000, BT_OPEN}},
+ {0x300f, {0x300e, 0x0000, BT_CLOSE}},
+ {0x3010, {0x3011, 0x0000, BT_OPEN}},
+ {0x3011, {0x3010, 0x0000, BT_CLOSE}},
+ {0x3014, {0x3015, 0x0000, BT_OPEN}},
+ {0x3015, {0x3014, 0x0000, BT_CLOSE}},
+ {0x3016, {0x3017, 0x0000, BT_OPEN}},
+ {0x3017, {0x3016, 0x0000, BT_CLOSE}},
+ {0x3018, {0x3019, 0x0000, BT_OPEN}},
+ {0x3019, {0x3018, 0x0000, BT_CLOSE}},
+ {0x301a, {0x301b, 0x0000, BT_OPEN}},
+ {0x301b, {0x301a, 0x0000, BT_CLOSE}},
+ {0xfe59, {0xfe5a, 0x0000, BT_OPEN}},
+ {0xfe5a, {0xfe59, 0x0000, BT_CLOSE}},
+ {0xfe5b, {0xfe5c, 0x0000, BT_OPEN}},
+ {0xfe5c, {0xfe5b, 0x0000, BT_CLOSE}},
+ {0xfe5d, {0xfe5e, 0x0000, BT_OPEN}},
+ {0xfe5e, {0xfe5d, 0x0000, BT_CLOSE}},
+ {0xff08, {0xff09, 0x0000, BT_OPEN}},
+ {0xff09, {0xff08, 0x0000, BT_CLOSE}},
+ {0xff3b, {0xff3d, 0x0000, BT_OPEN}},
+ {0xff3d, {0xff3b, 0x0000, BT_CLOSE}},
+ {0xff5b, {0xff5d, 0x0000, BT_OPEN}},
+ {0xff5d, {0xff5b, 0x0000, BT_CLOSE}},
+ {0xff5f, {0xff60, 0x0000, BT_OPEN}},
+ {0xff60, {0xff5f, 0x0000, BT_CLOSE}},
+ {0xff62, {0xff63, 0x0000, BT_OPEN}},
+ {0xff63, {0xff62, 0x0000, BT_CLOSE}},
+ };
+
+ int i, j, k;
+
+ i = -1;
+ j = lenof(bracket_pairs);
+
+ while (j - i > 1) {
+ k = (i + j) / 2;
+ if (ch < bracket_pairs[k].src) {
+ j = k;
+ } else if (ch > bracket_pairs[k].src) {
+ i = k;
+ } else {
+ return bracket_pairs[k].payload;
+ }
+ }
+
+ static const BracketTypeData null = { 0, 0, BT_NONE };
+ return null;
+}
+
+/*
+ * Function exported to front ends to allow them to identify
+ * bidi-active characters (in case, for example, the platform's
+ * text display function can't conveniently be prevented from doing
+ * its own bidi and so special treatment is required for characters
+ * that would cause the bidi algorithm to activate).
+ *
+ * This function is passed a single Unicode code point, and returns
+ * nonzero if the presence of this code point can possibly cause
+ * the bidi algorithm to do any reordering. Thus, any string
+ * composed entirely of characters for which is_rtl() returns zero
+ * should be safe to pass to a bidi-active platform display
+ * function without fear.
+ *
+ * (is_rtl() must therefore also return true for any character
+ * which would be affected by Arabic shaping, but this isn't
+ * important because all such characters are right-to-left so it
+ * would have flagged them anyway.)
+ */
+bool is_rtl(int c)
+{
+ return typeIsBidiActive(bidi_getType(c));
+}
+
+/* The Main shaping function, and the only one to be used
+ * by the outside world.
+ *
+ * line: buffer to apply shaping to. this must be passed by doBidi() first
+ * to: output buffer for the shaped data
+ * count: number of characters in line
+ */
+int do_shape(bidi_char *line, bidi_char *to, int count)
+{
+ int i, tempShape;
+ bool ligFlag = false;
+
+ for (i=0; i<count; i++) {
+ to[i] = line[i];
+ tempShape = STYPE(line[i].wc);
+ switch (tempShape) {
+ case SC:
+ break;
+
+ case SU:
+ break;
+
+ case SR:
+ tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = SFINAL((SISOLATED(line[i].wc)));
+ else
+ to[i].wc = SISOLATED(line[i].wc);
+ break;
+
+
+ case SD:
+ /* Make Ligatures */
+ tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
+ if (line[i].wc == 0x644) {
+ if (i > 0) switch (line[i-1].wc) {
+ case 0x622:
+ ligFlag = true;
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = 0xFEF6;
+ else
+ to[i].wc = 0xFEF5;
+ break;
+ case 0x623:
+ ligFlag = true;
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = 0xFEF8;
+ else
+ to[i].wc = 0xFEF7;
+ break;
+ case 0x625:
+ ligFlag = true;
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = 0xFEFA;
+ else
+ to[i].wc = 0xFEF9;
+ break;
+ case 0x627:
+ ligFlag = true;
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = 0xFEFC;
+ else
+ to[i].wc = 0xFEFB;
+ break;
+ }
+ if (ligFlag) {
+ to[i-1].wc = 0x20;
+ ligFlag = false;
+ break;
+ }
+ }
+
+ if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC)) {
+ tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
+ if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = SMEDIAL((SISOLATED(line[i].wc)));
+ else
+ to[i].wc = SFINAL((SISOLATED(line[i].wc)));
+ break;
+ }
+
+ tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
+ if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
+ to[i].wc = SINITIAL((SISOLATED(line[i].wc)));
+ else
+ to[i].wc = SISOLATED(line[i].wc);
+ break;
+
+
+ }
+ }
+ return 1;
+}
+
+typedef enum { DO_NEUTRAL, DO_LTR, DO_RTL } DirectionalOverride;
+
+typedef struct DSStackEntry {
+ /*
+ * An entry in the directional status stack (rule section X).
+ */
+ unsigned char level;
+ bool isolate;
+ DirectionalOverride override;
+} DSStackEntry;
+
+typedef struct BracketStackEntry {
+ /*
+ * An entry in the bracket-pair-tracking stack (rule BD16).
+ */
+ unsigned ch;
+ size_t c;
+} BracketStackEntry;
+
+typedef struct IsolatingRunSequence {
+ size_t start, end;
+ BidiType sos, eos, embeddingDirection;
+} IsolatingRunSequence;
+
+#define MAX_DEPTH 125 /* specified in the standard */
+
+struct BidiContext {
+ /*
+ * Storage space preserved between runs, all allocated to the same
+ * length (internal_array_sizes).
+ */
+ size_t internal_array_sizes;
+ BidiType *types, *origTypes;
+ unsigned char *levels;
+ size_t *irsindices, *bracketpos;
+ bool *irsdone;
+
+ /*
+ * Separately allocated with its own size field
+ */
+ IsolatingRunSequence *irslist;
+ size_t irslistsize;
+
+ /*
+ * Rewritten to point to the input to the currently active run of
+ * the bidi algorithm
+ */
+ bidi_char *text;
+ size_t textlen;
+
+ /*
+ * State within a run of the algorithm
+ */
+ BidiType paragraphOverride;
+ DSStackEntry dsstack[MAX_DEPTH + 2];
+ size_t ds_sp;
+ size_t overflowIsolateCount, overflowEmbeddingCount, validIsolateCount;
+ unsigned char paragraphLevel;
+ size_t *irs;
+ size_t irslen;
+ BidiType sos, eos, embeddingDirection;
+ BracketStackEntry bstack[63]; /* constant size specified in rule BD16 */
+};
+
+BidiContext *bidi_new_context(void)
+{
+ BidiContext *ctx = snew(BidiContext);
+ memset(ctx, 0, sizeof(BidiContext));
+ return ctx;
+}
+
+void bidi_free_context(BidiContext *ctx)
+{
+ sfree(ctx->types);
+ sfree(ctx->origTypes);
+ sfree(ctx->levels);
+ sfree(ctx->irsindices);
+ sfree(ctx->irsdone);
+ sfree(ctx->bracketpos);
+ sfree(ctx->irslist);
+ sfree(ctx);
+}
+
+static void ensure_arrays(BidiContext *ctx, size_t textlen)
+{
+ if (textlen <= ctx->internal_array_sizes)
+ return;
+ ctx->internal_array_sizes = textlen;
+ ctx->types = sresize(ctx->types, ctx->internal_array_sizes, BidiType);
+ ctx->origTypes = sresize(ctx->origTypes, ctx->internal_array_sizes,
+ BidiType);
+ ctx->levels = sresize(ctx->levels, ctx->internal_array_sizes,
+ unsigned char);
+ ctx->irsindices = sresize(ctx->irsindices, ctx->internal_array_sizes,
+ size_t);
+ ctx->irsdone = sresize(ctx->irsdone, ctx->internal_array_sizes, bool);
+ ctx->bracketpos = sresize(ctx->bracketpos, ctx->internal_array_sizes,
+ size_t);
+}
+
+static void setup_types(BidiContext *ctx)
+{
+ for (size_t i = 0; i < ctx->textlen; i++)
+ ctx->types[i] = ctx->origTypes[i] = bidi_getType(ctx->text[i].wc);
+}
+
+static bool text_needs_bidi(BidiContext *ctx)
+{
+ /*
+ * Initial optimisation: check for any bidi-active character at
+ * all in an input line. If there aren't any, we can skip the
+ * whole algorithm.
+ *
+ * Also include the paragraph override in this check!
+ */
+ for (size_t i = 0; i < ctx->textlen; i++)
+ if (typeIsBidiActive(ctx->types[i]))
+ return true;
+ return typeIsBidiActive(ctx->paragraphOverride);
+}
+
+static size_t find_matching_pdi(const BidiType *types, size_t i, size_t size)
+{
+ /* Assuming that types[i] is an isolate initiator, find its
+ * matching PDI by rule BD9. */
+ unsigned counter = 1;
+ i++;
+ for (; i < size; i++) {
+ BidiType t = types[i];
+ if (typeIsIsolateInitiator(t)) {
+ counter++;
+ } else if (t == PDI) {
+ counter--;
+ if (counter == 0)
+ return i;
+ }
+ }
+
+ /* If no PDI was found, return the length of the array. */
+ return size;
+}
+
+static unsigned char rule_p2_p3(const BidiType *types, size_t size)
+{
+ /*
+ * Rule P2. Find the first strong type (L, R or AL), ignoring
+ * anything inside an isolated segment.
+ *
+ * Rule P3. If that type is R or AL, choose a paragraph embeddding
+ * level of 1, otherwise 0.
+ */
+ for (size_t i = 0; i < size; i++) {
+ BidiType t = types[i];
+ if (typeIsIsolateInitiator(t))
+ i = find_matching_pdi(types, i, size);
+ else if (typeIsStrong(t))
+ return (t == L ? 0 : 1);
+ }
+
+ return 0; /* default if no strong type found */
+}
+
+static void set_paragraph_level(BidiContext *ctx)
+{
+ if (ctx->paragraphOverride == L)
+ ctx->paragraphLevel = 0;
+ else if (ctx->paragraphOverride == R)
+ ctx->paragraphLevel = 1;
+ else
+ ctx->paragraphLevel = rule_p2_p3(ctx->types, ctx->textlen);
+}
+
+static inline unsigned char nextOddLevel(unsigned char x) { return (x+1)|1; }
+static inline unsigned char nextEvenLevel(unsigned char x) { return (x|1)+1; }
+
+static inline void push(BidiContext *ctx, unsigned char level,
+ DirectionalOverride override, bool isolate)
+{
+ ctx->ds_sp++;
+ assert(ctx->ds_sp < lenof(ctx->dsstack));
+ ctx->dsstack[ctx->ds_sp].level = level;
+ ctx->dsstack[ctx->ds_sp].override = override;
+ ctx->dsstack[ctx->ds_sp].isolate = isolate;
+}
+
+static inline void pop(BidiContext *ctx)
+{
+ assert(ctx->ds_sp > 0);
+ ctx->ds_sp--;
+}
+
+static void process_explicit_embeddings(BidiContext *ctx)
+{
+ /*
+ * Rule X1 initialisation.
+ */
+ ctx->ds_sp = (size_t)-1;
+ push(ctx, ctx->paragraphLevel, DO_NEUTRAL, false);
+ ctx->overflowIsolateCount = 0;
+ ctx->overflowEmbeddingCount = 0;
+ ctx->validIsolateCount = 0;
+
+ #define stk (&ctx->dsstack[ctx->ds_sp])
+
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ BidiType t = ctx->types[i];
+ switch (t) {
+ case RLE: case LRE: case RLO: case LRO: {
+ /* Rules X2-X5 */
+ unsigned char newLevel;
+ DirectionalOverride override;
+
+#ifndef REMOVE_FORMATTING_CHARS
+ ctx->levels[i] = stk->level;
+#endif
+
+ switch (t) {
+ case RLE: /* rule X2 */
+ newLevel = nextOddLevel(stk->level);
+ override = DO_NEUTRAL;
+ break;
+ case LRE: /* rule X3 */
+ newLevel = nextEvenLevel(stk->level);
+ override = DO_NEUTRAL;
+ break;
+ case RLO: /* rule X4 */
+ newLevel = nextOddLevel(stk->level);
+ override = DO_RTL;
+ break;
+ case LRO: /* rule X5 */
+ newLevel = nextEvenLevel(stk->level);
+ override = DO_LTR;
+ break;
+ default:
+ unreachable("how did this get past the outer switch?");
+ }
+
+ if (newLevel <= MAX_DEPTH &&
+ ctx->overflowIsolateCount == 0 &&
+ ctx->overflowEmbeddingCount == 0) {
+ /* Embedding code is valid. Push a stack entry. */
+ push(ctx, newLevel, override, false);
+ } else {
+ /* Embedding code is an overflow one. */
+ if (ctx->overflowIsolateCount == 0)
+ ctx->overflowEmbeddingCount++;
+ }
+ break;
+ }
+
+ case RLI: case LRI: case FSI: {
+ /* Rules X5a, X5b, X5c */
+
+ if (t == FSI) {
+ /* Rule X5c: decide whether this should be treated
+ * like RLI or LRI */
+ size_t pdi = find_matching_pdi(ctx->types, i, ctx->textlen);
+ unsigned char level = rule_p2_p3(ctx->types + (i + 1),
+ pdi - (i + 1));
+ t = (level == 1 ? RLI : LRI);
+ }
+
+ ctx->levels[i] = stk->level;
+ if (stk->override != DO_NEUTRAL)
+ ctx->types[i] = (stk->override == DO_LTR ? L :
+ stk->override == DO_RTL ? R : t);
+
+ unsigned char newLevel = (t == RLI ? nextOddLevel(stk->level) :
+ nextEvenLevel(stk->level));
+
+ if (newLevel <= MAX_DEPTH &&
+ ctx->overflowIsolateCount == 0 &&
+ ctx->overflowEmbeddingCount == 0) {
+ /* Isolate code is valid. Push a stack entry. */
+ push(ctx, newLevel, DO_NEUTRAL, true);
+ ctx->validIsolateCount++;
+ } else {
+ /* Isolate code is an overflow one. */
+ ctx->overflowIsolateCount++;
+ }
+ break;
+ }
+
+ case PDI: {
+ /* Rule X6a */
+ if (ctx->overflowIsolateCount > 0) {
+ ctx->overflowIsolateCount--;
+ } else if (ctx->validIsolateCount == 0) {
+ /* Do nothing: spurious isolate-pop */
+ } else {
+ /* Valid isolate-pop. We expect that the stack must
+ * therefore contain at least one isolate==true entry,
+ * so pop everything up to and including it. */
+ ctx->overflowEmbeddingCount = 0;
+ while (!stk->isolate)
+ pop(ctx);
+ pop(ctx);
+ ctx->validIsolateCount--;
+ }
+ ctx->levels[i] = stk->level;
+ if (stk->override != DO_NEUTRAL)
+ ctx->types[i] = (stk->override == DO_LTR ? L : R);
+ break;
+ }
+
+ case PDF: {
+ /* Rule X7 */
+ if (ctx->overflowIsolateCount > 0) {
+ /* Do nothing if we've overflowed on isolates */
+ } else if (ctx->overflowEmbeddingCount > 0) {
+ ctx->overflowEmbeddingCount--;
+ } else if (ctx->ds_sp > 0 && !stk->isolate) {
+ pop(ctx);
+ } else {
+ /* Do nothing: spurious embedding-pop */
+ }
+
+#ifndef REMOVE_FORMATTING_CHARS
+ ctx->levels[i] = stk->level;
+#endif
+ break;
+ }
+
+ case B: {
+ /* Rule X8: if an explicit paragraph separator appears in
+ * this text at all then it does not participate in any of
+ * the above, and just gets assigned the paragraph level.
+ *
+ * PS, it had better be right at the end of the text,
+ * because we have not implemented rule P1 in this code. */
+ assert(i == ctx->textlen - 1);
+ ctx->levels[i] = ctx->paragraphLevel;
+ break;
+ }
+
+ case BN: {
+ /*
+ * The section 5.2 adjustment to rule X6 says that we
+ * apply it to BN just like any other class. But I think
+ * this can't possibly give the same results as the
+ * unmodified algorithm.
+ *
+ * Proof: adding RLO BN or LRO BN at the end of a
+ * paragraph should not change the output of the standard
+ * algorithm, because the override doesn't affect the BN
+ * in rule X6, and then rule X9 removes both. But with the
+ * modified rule X6, the BN is changed into R or L, and
+ * then rule X9 doesn't remove it, and then you've added a
+ * strong type that will set eos for the level run just
+ * before the override. And whatever the standard
+ * algorithm set eos to, _one_ of these override sequences
+ * will disagree with it.
+ *
+ * So I think we just set the BN's level, and don't change
+ * its type.
+ */
+ ctx->levels[i] = stk->level;
+ break;
+ }
+
+ default: {
+ /* Rule X6. */
+ ctx->levels[i] = stk->level;
+ if (stk->override != DO_NEUTRAL)
+ ctx->types[i] = (stk->override == DO_LTR ? L : R);
+ break;
+ }
+ }
+ }
+
+ #undef stk
+}
+
+static void remove_embedding_characters(BidiContext *ctx)
+{
+#ifndef REMOVE_FORMATTING_CHARS
+ /*
+ * Rule X9, as modified by section 5.2: turn embedding (but not
+ * isolate) characters into BN.
+ */
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ BidiType t = ctx->types[i];
+ if (typeIsRemovedDuringProcessing(t)) {
+ ctx->types[i] = BN;
+
+ /*
+ * My own adjustment to the section 5.2 mods: a sequence
+ * of contiguous BN generated by this setup should never
+ * be at different levels from each other.
+ *
+ * An example where this goes wrong is if you open two
+ * LREs in sequence, then close them again:
+ *
+ * ... LRE LRE PDF PDF ...
+ *
+ * The initial level assignment gives level 0 to the outer
+ * LRE/PDF pair, and level 2 to the inner one. The
+ * standard algorithm would remove all four, so this
+ * doesn't matter, and you end up with no break in the
+ * surrounding level run. But if you just rewrite the
+ * types of all those characters to BN and leave the
+ * levels in that state, then the modified algorithm will
+ * leave the middle two BN at level 2, dividing what
+ * should have been a long level run at level 0 into two
+ * separate ones.
+ */
+ if (i > 0 && ctx->types[i-1] == BN)
+ ctx->levels[i] = ctx->levels[i-1];
+ }
+ }
+#else
+ /*
+ * Rule X9, original version: completely remove embedding
+ * start/end characters and also boundary neutrals.
+ */
+ size_t outpos = 0;
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ BidiType t = ctx->types[i];
+ if (!typeIsRemovedDuringProcessing(t)) {
+ ctx->text[outpos] = ctx->text[i];
+ ctx->levels[outpos] = ctx->levels[i];
+ ctx->types[outpos] = ctx->types[i];
+ ctx->origTypes[outpos] = ctx->origTypes[i];
+ outpos++;
+ }
+ }
+ ctx->textlen = outpos;
+#endif
+}
+
+typedef void (*irs_fn_t)(BidiContext *ctx);
+
+static void find_isolating_run_sequences(BidiContext *ctx, irs_fn_t process)
+{
+ /*
+ * Rule X10 / BD13. Now that we've assigned an embedding level to
+ * each character in the text, we have to divide the text into
+ * subsequences on which to do the next stage of processing.
+ *
+ * In earlier issues of the bidi algorithm, these subsequences
+ * were contiguous in the original text, and each one was a 'level
+ * run': a maximal contiguous subsequence of characters all at the
+ * same embedding level.
+ *
+ * But now we have isolates, and the point of an (isolate
+ * initiator ... PDI) sequence is that the whole sequence should
+ * be treated like a single BN for the purposes of formatting
+ * everything outside it. As a result, we now have to recombine
+ * our level runs into longer sequences, on the principle that if
+ * a level run ends with an isolate initiator, then we bring it
+ * together with whatever later level run starts with the matching
+ * PDI.
+ *
+ * These subsequences are no longer contiguous (the whole point is
+ * that between the isolate initiator and the PDI is some other
+ * text that we've skipped over). They're called 'isolating run
+ * sequences'.
+ */
+
+ memset(ctx->irsdone, 0, ctx->textlen);
+ size_t i = 0;
+ size_t n_irs = 0;
+ size_t indexpos = 0;
+ while (i < ctx->textlen) {
+ if (ctx->irsdone[i]) {
+ i++;
+ continue;
+ }
+
+ /*
+ * Found a character not already processed. Start a new
+ * sequence here.
+ */
+ sgrowarray(ctx->irslist, ctx->irslistsize, n_irs);
+ IsolatingRunSequence *irs = &ctx->irslist[n_irs++];
+ irs->start = indexpos;
+ size_t j = i;
+ size_t irslevel = ctx->levels[i];
+ while (j < ctx->textlen) {
+ /*
+ * We expect that all level runs in this sequence will be
+ * at the same level as each other, by construction of how
+ * we set up the levels from the isolates in the first
+ * place.
+ */
+ assert(ctx->levels[j] == irslevel);
+
+ do {
+ ctx->irsdone[j] = true;
+ ctx->irsindices[indexpos++] = j++;
+ } while (j < ctx->textlen && ctx->levels[j] == irslevel);
+ if (!typeIsIsolateInitiator(ctx->types[j-1]))
+ break; /* this IRS is ended */
+ j = find_matching_pdi(ctx->types, j-1, ctx->textlen);
+ }
+ irs->end = indexpos;
+
+ /*
+ * Determine the start-of-sequence and end-of-sequence types
+ * for this sequence.
+ *
+ * These depend on the embedding levels of surrounding text.
+ * But processing each run can change those levels. That's why
+ * we have to use a two-pass strategy here, first identifying
+ * all the isolating run sequences using the input level data,
+ * and not processing any of them until we know where they all
+ * are.
+ */
+ size_t p;
+ unsigned char level_inside, level_outside, level_max;
+
+ p = i;
+ level_inside = ctx->levels[p];
+ level_outside = ctx->paragraphLevel;
+ while (p > 0) {
+ p--;
+ if (ctx->types[p] != BN) {
+ level_outside = ctx->levels[p];
+ break;
+ }
+ }
+ level_max = max(level_inside, level_outside);
+ irs->sos = (level_max % 2 ? R : L);
+
+ p = ctx->irsindices[irs->end - 1];
+ level_inside = ctx->levels[p];
+ level_outside = ctx->paragraphLevel;
+ if (typeIsIsolateInitiator(ctx->types[p])) {
+ /* Special case: if an isolating run sequence ends in an
+ * unmatched isolate initiator, then level_outside is
+ * taken to be the paragraph embedding level and the
+ * loop below is skipped. */
+ } else {
+ while (p+1 < ctx->textlen) {
+ p++;
+ if (ctx->types[p] != BN) {
+ level_outside = ctx->levels[p];
+ break;
+ }
+ }
+ }
+ level_max = max(level_inside, level_outside);
+ irs->eos = (level_max % 2 ? R : L);
+
+ irs->embeddingDirection = (irslevel % 2 ? R : L);
+
+ /*
+ * Now we've listed in ctx->irsindices[] the index of every
+ * character that's part of this isolating run sequence, and
+ * recorded an entry in irslist containing the interval of
+ * indices relevant to this IRS, plus its assorted metadata.
+ * We've also marked those locations in the input text as done
+ * in ctx->irsdone, so that we'll skip over them when the
+ * outer iteration reaches them later.
+ */
+ }
+
+ for (size_t k = 0; k < n_irs; k++) {
+ IsolatingRunSequence *irs = &ctx->irslist[k];
+ ctx->irs = ctx->irsindices + irs->start;
+ ctx->irslen = irs->end - irs->start;
+ ctx->sos = irs->sos;
+ ctx->eos = irs->eos;
+ ctx->embeddingDirection = irs->embeddingDirection;
+ process(ctx);
+ }
+
+ /* Reset irslen to 0 when we've finished. This means any other
+ * functions that absentmindedly try to use irslen at all will end
+ * up doing nothing at all, which should be easier to detect and
+ * debug than if they run on subtly the wrong subset of the
+ * text. */
+ ctx->irslen = 0;
+}
+
+static void remove_nsm(BidiContext *ctx)
+{
+ /* Rule W1: NSM gains the type of the previous character, or sos
+ * at the start of the run, with the exception that isolation
+ * boundaries turn into ON. */
+ BidiType prevType = ctx->sos;
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (t == NSM) {
+ ctx->types[i] = prevType;
+ } else if (typeIsIsolateInitiatorOrPDI(t)) {
+ prevType = ON;
+#ifndef REMOVE_FORMATTING_CHARS
+ } else if (t == BN) {
+ /* section 5.2 adjustment: these don't affect prevType */
+#endif
+ } else {
+ prevType = t;
+ }
+ }
+}
+
+static void change_en_to_an(BidiContext *ctx)
+{
+ /* Rule W2: EN becomes AN if the previous strong type is AL. (The
+ * spec says that the 'previous strong type' is counted as sos at
+ * the start of the run, although it hardly matters, since sos
+ * can't be AL.) */
+ BidiType prevStrongType = ctx->sos;
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (t == EN && prevStrongType == AL) {
+ ctx->types[i] = AN;
+ } else if (typeIsStrong(t)) {
+ prevStrongType = t;
+ }
+ }
+}
+
+static void change_al_to_r(BidiContext *ctx)
+{
+ /* Rule W3: AL becomes R unconditionally. (The only difference
+ * between the two types was their effect on nearby numbers, which
+ * was dealt with in rule W2, so now we're done with the
+ * distinction.) */
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ if (ctx->types[i] == AL)
+ ctx->types[i] = R;
+ }
+}
+
+static void eliminate_separators_between_numbers(BidiContext *ctx)
+{
+ /* Rule W4: a single numeric separator between two numbers of the
+ * same type compatible with that separator takes the type of the
+ * number. ES is a separator type compatible only with EN; CS is a
+ * separator type compatible with either EN or AN.
+ *
+ * Section 5.2 adjustment: intervening BNs do not break this, so
+ * instead of simply looking at types[irs[c-1]] and types[irs[c+1]],
+ * we must track the last three indices we saw that were not BN. */
+ size_t i1 = 0, i2 = 0;
+ BidiType t0 = ON, t1 = ON, t2 = ON;
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+
+#ifndef REMOVE_FORMATTING_CHARS
+ if (t == BN)
+ continue;
+#endif
+
+ i1 = i2; i2 = i;
+ t0 = t1; t1 = t2; t2 = t;
+ if (t0 == t2 && ((t1 == ES && t0 == EN) ||
+ (t1 == CS && (t0 == EN || t0 == AN)))) {
+ ctx->types[i1] = t0;
+ }
+ }
+}
+
+static void eliminate_et_next_to_en(BidiContext *ctx)
+{
+ /* Rule W5: a sequence of ET adjacent to an EN take the type EN.
+ * This is easiest to implement with one loop in each direction.
+ *
+ * Section 5.2 adjustment: include BN with ET. (We don't need to
+ * #ifdef that out, because in the standard algorithm, we won't
+ * have any BN left in any case.) */
+
+ bool modifying = false;
+
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (t == EN) {
+ modifying = true;
+ } else if (modifying && typeIsETOrBN(t)) {
+ ctx->types[i] = EN;
+ } else {
+ modifying = false;
+ }
+ }
+
+ for (size_t c = ctx->irslen; c-- > 0 ;) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (t == EN) {
+ modifying = true;
+ } else if (modifying && typeIsETOrBN(t)) {
+ ctx->types[i] = EN;
+ } else {
+ modifying = false;
+ }
+ }
+}
+
+static void eliminate_separators_and_terminators(BidiContext *ctx)
+{
+ /* Rule W6: all separators and terminators change to ON.
+ *
+ * (The spec is not quite clear on which bidi types are included
+ * in this; one assumes ES, ET and CS, but what about S? I _think_
+ * the answer is that this is a rule in the W section, so it's
+ * implicitly supposed to only apply to types designated as weakly
+ * directional, so not S.) */
+
+#ifndef REMOVE_FORMATTING_CHARS
+ /*
+ * Section 5.2 adjustment: this also applies to any BN adjacent on
+ * either side to one of these types, which is easiest to
+ * implement with a separate double-loop converting those to an
+ * arbitrary one of the affected types, say CS.
+ *
+ * This double loop can be completely skipped in the standard
+ * algorithm.
+ */
+ bool modifying = false;
+
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (typeIsWeakSeparatorOrTerminator(t)) {
+ modifying = true;
+ } else if (modifying && t == BN) {
+ ctx->types[i] = CS;
+ } else {
+ modifying = false;
+ }
+ }
+
+ for (size_t c = ctx->irslen; c-- > 0 ;) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (typeIsWeakSeparatorOrTerminator(t)) {
+ modifying = true;
+ } else if (modifying && t == BN) {
+ ctx->types[i] = CS;
+ } else {
+ modifying = false;
+ }
+ }
+#endif
+
+ /* Now the main part of rule W6 */
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (typeIsWeakSeparatorOrTerminator(t))
+ ctx->types[i] = ON;
+ }
+}
+
+static void change_en_to_l(BidiContext *ctx)
+{
+ /* Rule W7: EN becomes L if the previous strong type (or sos) is L. */
+ BidiType prevStrongType = ctx->sos;
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (t == EN && prevStrongType == L) {
+ ctx->types[i] = L;
+ } else if (typeIsStrong(t)) {
+ prevStrongType = t;
+ }
+ }
+}
+
+typedef void (*bracket_pair_fn)(BidiContext *ctx, size_t copen, size_t cclose);
+
+static void find_bracket_pairs(BidiContext *ctx, bracket_pair_fn process)
+{
+ const size_t NO_BRACKET = ~(size_t)0;
+
+ /*
+ * Rule BD16.
+ */
+ size_t sp = 0;
+ for (size_t c = 0; c < ctx->irslen; c++)
+ ctx->bracketpos[c] = NO_BRACKET;
+
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ unsigned wc = ctx->text[i].wc;
+ BracketTypeData bt = bracket_type(wc);
+ if (bt.type == BT_OPEN) {
+ if (sp >= lenof(ctx->bstack)) {
+ /*
+ * Stack overflow. The spec says we simply give up at
+ * this point.
+ */
+ goto found_all_pairs;
+ }
+
+ ctx->bstack[sp].ch = wc;
+ ctx->bstack[sp].c = c;
+ sp++;
+ } else if (bt.type == BT_CLOSE) {
+ size_t new_sp = sp;
+
+ /*
+ * Search up the stack for an entry containing a matching
+ * open bracket. If we find it, pop that entry and
+ * everything deeper, and record a matching pair. If we
+ * reach the bottom of the stack without finding anything,
+ * leave sp where it started.
+ */
+ while (new_sp-- > 0) {
+ if (ctx->bstack[new_sp].ch == bt.partner ||
+ ctx->bstack[new_sp].ch == bt.equiv_partner) {
+ /* Found a stack element matching this one */
+ size_t cstart = ctx->bstack[new_sp].c;
+ ctx->bracketpos[cstart] = c;
+ sp = new_sp;
+ break;
+ }
+ }
+ }
+ }
+
+ found_all_pairs:
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ if (ctx->bracketpos[c] != NO_BRACKET) {
+ process(ctx, c, ctx->bracketpos[c]);
+ }
+ }
+}
+
+static BidiType get_bracket_type(BidiContext *ctx, size_t copen, size_t cclose)
+{
+ /*
+ * Rule N0: a pair of matched brackets containing at least one
+ * strong type takes on the current embedding direction, unless
+ * all of these are true at once:
+ *
+ * (a) there are no strong types inside the brackets matching the
+ * current embedding direction
+ * (b) there _is_ at least one strong type inside the brackets
+ * that is _opposite_ to the current embedding direction
+ * (c) the strong type preceding the open bracket is also
+ * opposite to the current embedding direction
+ *
+ * in which case they take on the opposite direction.
+ *
+ * For these purposes, number types (EN and AN) count as R.
+ */
+
+ bool foundOppositeTypeInside = false;
+ for (size_t c = copen + 1; c < cclose; c++) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (typeIsStrongOrNumber(t)) {
+ t = t == L ? L : R; /* numbers count as R */
+ if (t == ctx->embeddingDirection) {
+ /* Found something inside the brackets matching the
+ * current level, so (a) is violated. */
+ return ctx->embeddingDirection;
+ } else {
+ foundOppositeTypeInside = true;
+ }
+ }
+ }
+
+ if (!foundOppositeTypeInside) {
+ /* No strong types at all inside the brackets, so return ON to
+ * indicate that we're not messing with their type at all. */
+ return ON;
+ }
+
+ /* There was an opposite strong type in the brackets. Look
+ * backwards to the preceding strong type, and go with that,
+ * whichever it is. */
+ for (size_t c = copen; c-- > 0 ;) {
+ size_t i = ctx->irs[c];
+ BidiType t = ctx->types[i];
+ if (typeIsStrongOrNumber(t)) {
+ t = t == L ? L : R; /* numbers count as R */
+ return t;
+ }
+ }
+
+ /* Fallback: if the preceding strong type was not found, go with
+ * sos. */
+ return ctx->sos;
+}
+
+static void reset_bracket_type(BidiContext *ctx, size_t c, BidiType t)
+{
+ /* Final bullet point of rule N0: when we change the type of a
+ * bracket, the same change applies to any contiguous sequence of
+ * characters after it whose _original_ bidi type was NSM. */
+ do {
+ ctx->types[ctx->irs[c++]] = t;
+
+#ifndef REMOVE_FORMATTING_CHARS
+ while (c < ctx->irslen && ctx->origTypes[ctx->irs[c]] == BN) {
+ /* Section 5.2 adjustment: skip past BN in the process. */
+ c++;
+ }
+#endif
+ } while (c < ctx->irslen && ctx->origTypes[ctx->irs[c]] == NSM);
+}
+
+static void resolve_brackets(BidiContext *ctx, size_t copen, size_t cclose)
+{
+ if (typeIsNeutral(ctx->types[ctx->irs[copen]]) &&
+ typeIsNeutral(ctx->types[ctx->irs[cclose]])) {
+ BidiType t = get_bracket_type(ctx, copen, cclose);
+ if (t != ON) {
+ reset_bracket_type(ctx, copen, t);
+ reset_bracket_type(ctx, cclose, t);
+ }
+ }
+}
+
+static void remove_ni(BidiContext *ctx)
+{
+ /*
+ * Rules N1 and N2 together: neutral or isolate characters take
+ * the direction of the surrounding strong text if the nearest
+ * strong characters on each side match, and otherwise, they take
+ * the embedding direction.
+ */
+ const size_t NO_INDEX = ~(size_t)0;
+ BidiType prevStrongType = ctx->sos;
+ size_t c_ni_start = NO_INDEX;
+ for (size_t c = 0; c <= ctx->irslen; c++) {
+ BidiType t;
+
+ if (c < ctx->irslen) {
+ size_t i = ctx->irs[c];
+ t = ctx->types[i];
+ } else {
+ /* One extra loop iteration, using eos to resolve the
+ * final sequence of NI if any */
+ t = ctx->eos;
+ }
+
+ if (typeIsStrongOrNumber(t)) {
+ t = t == L ? L : R; /* numbers count as R */
+ if (c_ni_start != NO_INDEX) {
+ /* There are some NI we have to fix up */
+ BidiType ni_type = (t == prevStrongType ? t :
+ ctx->embeddingDirection);
+ for (size_t c2 = c_ni_start; c2 < c; c2++) {
+ size_t i2 = ctx->irs[c2];
+ BidiType t2 = ctx->types[i2];
+ if (typeIsNeutralOrIsolate(t2))
+ ctx->types[i2] = ni_type;
+ }
+ }
+ prevStrongType = t;
+ c_ni_start = NO_INDEX;
+ } else if (typeIsNeutralOrIsolate(t) && c_ni_start == NO_INDEX) {
+ c_ni_start = c;
+ }
+ }
+}
+
+static void resolve_implicit_levels(BidiContext *ctx)
+{
+ /* Rules I1 and I2 */
+ for (size_t c = 0; c < ctx->irslen; c++) {
+ size_t i = ctx->irs[c];
+ unsigned char level = ctx->levels[i];
+ BidiType t = ctx->types[i];
+ if (level % 2 == 0) {
+ /* Rule I1 */
+ if (t == R)
+ ctx->levels[i] += 1;
+ else if (t == AN || t == EN)
+ ctx->levels[i] += 2;
+ } else {
+ /* Rule I2 */
+ if (t == L || t == AN || t == EN)
+ ctx->levels[i] += 1;
+ }
+ }
+}
+
+static void process_isolating_run_sequence(BidiContext *ctx)
+{
+ /* Section W: resolve weak types */
+ remove_nsm(ctx);
+ change_en_to_an(ctx);
+ change_al_to_r(ctx);
+ eliminate_separators_between_numbers(ctx);
+ eliminate_et_next_to_en(ctx);
+ eliminate_separators_and_terminators(ctx);
+ change_en_to_l(ctx);
+
+ /* Section N: resolve neutral types (and isolates) */
+ find_bracket_pairs(ctx, resolve_brackets);
+ remove_ni(ctx);
+
+ /* Section I: resolve implicit levels */
+ resolve_implicit_levels(ctx);
+}
+
+static void reset_whitespace_and_separators(BidiContext *ctx)
+{
+ /*
+ * Rule L1: segment and paragraph separators, plus whitespace
+ * preceding them, all reset to the paragraph embedding level.
+ * This also applies to whitespace at the very end.
+ *
+ * This is done using the original types, not the versions that
+ * the rest of this algorithm has been merrily mutating.
+ */
+ bool modifying = true;
+ for (size_t i = ctx->textlen; i-- > 0 ;) {
+ BidiType t = ctx->origTypes[i];
+ if (typeIsSegmentOrParaSeparator(t)) {
+ ctx->levels[i] = ctx->paragraphLevel;
+ modifying = true;
+ } else if (modifying) {
+ if (typeIsWhitespaceOrIsolate(t)) {
+ ctx->levels[i] = ctx->paragraphLevel;
+ } else if (!typeIsRemovedDuringProcessing(t)) {
+ modifying = false;
+ }
+ }
+ }
+
+#ifndef REMOVE_FORMATTING_CHARS
+ /*
+ * Section 5.2 adjustment: types removed by rule X9 take the level
+ * of the character to their left.
+ */
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ BidiType t = ctx->origTypes[i];
+ if (typeIsRemovedDuringProcessing(t)) {
+ /* Section 5.2 adjustment */
+ ctx->levels[i] = (i > 0 ? ctx->levels[i-1] : ctx->paragraphLevel);
+ }
+ }
+#endif /* ! REMOVE_FORMATTING_CHARS */
+}
+
+static void reverse(BidiContext *ctx, size_t start, size_t end)
+{
+ for (size_t i = start, j = end; i < j; i++, j--) {
+ bidi_char tmp = ctx->text[i];
+ ctx->text[i] = ctx->text[j];
+ ctx->text[j] = tmp;
+ }
+}
+
+static void mirror_glyphs(BidiContext *ctx)
+{
+ /*
+ * Rule L3: any character with a mirror-image pair at an odd
+ * embedding level is replaced by its mirror image.
+ *
+ * This is specified in the standard as happening _after_ rule L2
+ * (the actual reordering of the text). But it's much easier to
+ * implement it before, while our levels[] array still matches up
+ * to the text order.
+ */
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ if (ctx->levels[i] % 2)
+ ctx->text[i].wc = mirror_glyph(ctx->text[i].wc);
+ }
+}
+
+static void reverse_sequences(BidiContext *ctx)
+{
+ /*
+ * Rule L2: every maximal contiguous sequence of characters at a
+ * given level or higher is reversed.
+ */
+ unsigned level = 0;
+ for (size_t i = 0; i < ctx->textlen; i++)
+ level = max(level, ctx->levels[i]);
+
+ for (; level >= 1; level--) {
+ for (size_t i = 0; i < ctx->textlen; i++) {
+ if (ctx->levels[i] >= level) {
+ size_t start = i;
+ while (i+1 < ctx->textlen && ctx->levels[i+1] >= level)
+ i++;
+ reverse(ctx, start, i);
+ }
+ }
+ }
+}
+
+/*
+ * The Main Bidi Function. The two wrappers below it present different
+ * external APIs for different purposes, but everything comes through
+ * here.
+ *
+ * text: a buffer of size textlen containing text to apply the
+ * Bidirectional algorithm to.
+ */
+static void do_bidi_new(BidiContext *ctx, bidi_char *text, size_t textlen)
+{
+ ensure_arrays(ctx, textlen);
+ ctx->text = text;
+ ctx->textlen = textlen;
+ setup_types(ctx);
+
+ /* Quick initial test: see if we need to bother with any work at all */
+ if (!text_needs_bidi(ctx))
+ return;
+
+ set_paragraph_level(ctx);
+ process_explicit_embeddings(ctx);
+ remove_embedding_characters(ctx);
+ find_isolating_run_sequences(ctx, process_isolating_run_sequence);
+
+ /* If this implementation distinguished paragraphs from lines,
+ * then this would be the point where we repeat the remainder of
+ * the algorithm once for each line in the paragraph. */
+
+ reset_whitespace_and_separators(ctx);
+ mirror_glyphs(ctx);
+ reverse_sequences(ctx);
+}
+
+size_t do_bidi_test(BidiContext *ctx, bidi_char *text, size_t textlen,
+ int override)
+{
+ ctx->paragraphOverride = (override > 0 ? L : override < 0 ? R : ON);
+ do_bidi_new(ctx, text, textlen);
+ return ctx->textlen;
+}
+
+void do_bidi(BidiContext *ctx, bidi_char *text, size_t textlen)
+{
+#ifdef REMOVE_FORMATTING_CHARACTERS
+ abort(); /* can't use the standard algorithm in a live terminal */
+#else
+ ctx->paragraphOverride = ON;
+ do_bidi_new(ctx, text, textlen);
+#endif
+}
diff --git a/terminal/bidi.h b/terminal/bidi.h
new file mode 100644
index 00000000..90d68e5b
--- /dev/null
+++ b/terminal/bidi.h
@@ -0,0 +1,147 @@
+/*
+ * Header file shared between bidi.c and its tests. Not used by
+ * anything outside the bidi subsystem.
+ */
+
+#ifndef PUTTY_BIDI_H
+#define PUTTY_BIDI_H
+
+#define LMASK 0x3F /* Embedding Level mask */
+#define OMASK 0xC0 /* Override mask */
+#define OISL 0x80 /* Override is L */
+#define OISR 0x40 /* Override is R */
+
+/* Shaping Helpers */
+#define STYPE(xh) ((((xh) >= SHAPE_FIRST) && ((xh) <= SHAPE_LAST)) ? \
+shapetypes[(xh)-SHAPE_FIRST].type : SU) /*))*/
+#define SISOLATED(xh) (shapetypes[(xh)-SHAPE_FIRST].form_b)
+#define SFINAL(xh) ((xh)+1)
+#define SINITIAL(xh) ((xh)+2)
+#define SMEDIAL(ch) ((ch)+3)
+
+#define leastGreaterOdd(x) ( ((x)+1) | 1 )
+#define leastGreaterEven(x) ( ((x)+2) &~ 1 )
+
+/* Function declarations used outside bidi.c */
+unsigned char bidi_getType(int ch);
+
+/* Bidi character types */
+#define BIDI_CHAR_TYPE_LIST(X) \
+ X(L) \
+ X(LRE) \
+ X(LRO) \
+ X(LRI) \
+ X(R) \
+ X(AL) \
+ X(RLE) \
+ X(RLO) \
+ X(RLI) \
+ X(PDF) \
+ X(PDI) \
+ X(FSI) \
+ X(EN) \
+ X(ES) \
+ X(ET) \
+ X(AN) \
+ X(CS) \
+ X(NSM) \
+ X(BN) \
+ X(B) \
+ X(S) \
+ X(WS) \
+ X(ON) \
+ /* end of list */
+
+/* Shaping Types */
+#define SHAPING_CHAR_TYPE_LIST(X) \
+ X(SL) /* Left-Joining, doesn't exist in U+0600 - U+06FF */ \
+ X(SR) /* Right-Joining, ie has Isolated, Final */ \
+ X(SD) /* Dual-Joining, ie has Isolated, Final, Initial, Medial */ \
+ X(SU) /* Non-Joining */ \
+ X(SC) /* Join-Causing, like U+0640 (TATWEEL) */ \
+ /* end of list */
+
+#define ENUM_DECL(name) name,
+typedef enum { BIDI_CHAR_TYPE_LIST(ENUM_DECL) N_BIDI_TYPES } BidiType;
+typedef enum { SHAPING_CHAR_TYPE_LIST(ENUM_DECL) N_SHAPING_TYPES } ShapingType;
+#undef ENUM_DECL
+
+static inline bool typeIsStrong(BidiType t)
+{
+ return ((1<<L) | (1<<R) | (1<<AL)) & (1 << t);
+}
+static inline bool typeIsWeak(BidiType t)
+{
+ return ((1<<EN) | (1<<ES) | (1<<ET) | (1<<AN) |
+ (1<<CS) | (1<<NSM) | (1<<BN)) & (1 << t);
+}
+static inline bool typeIsNeutral(BidiType t)
+{
+ return ((1<<B) | (1<<S) | (1<<WS) | (1<<ON)) & (1 << t);
+}
+static inline bool typeIsBidiActive(BidiType t)
+{
+ return ((1<<R) | (1<<AL) | (1<<AN) | (1<<RLE) | (1<<LRE) | (1<<RLO) |
+ (1<<LRO) | (1<<PDF) | (1<<RLI)) & (1 << t);
+}
+static inline bool typeIsIsolateInitiator(BidiType t)
+{
+ return ((1<<LRI) | (1<<RLI) | (1<<FSI)) & (1 << t);
+}
+static inline bool typeIsIsolateInitiatorOrPDI(BidiType t)
+{
+ return ((1<<LRI) | (1<<RLI) | (1<<FSI) | (1<<PDI)) & (1 << t);
+}
+static inline bool typeIsEmbeddingInitiator(BidiType t)
+{
+ return ((1<<LRE) | (1<<RLE) | (1<<LRO) | (1<<RLO)) & (1 << t);
+}
+static inline bool typeIsEmbeddingInitiatorOrPDF(BidiType t)
+{
+ return ((1<<LRE) | (1<<RLE) | (1<<LRO) | (1<<RLO) | (1<<PDF)) & (1 << t);
+}
+static inline bool typeIsWeakSeparatorOrTerminator(BidiType t)
+{
+ return ((1<<ES) | (1<<ET) | (1<<CS)) & (1 << t);
+}
+static inline bool typeIsNeutralOrIsolate(BidiType t)
+{
+ return ((1<<S) | (1<<WS) | (1<<ON) | (1<<FSI) | (1<<LRI) | (1<<RLI) |
+ (1<<PDI)) & (1 << t);
+}
+static inline bool typeIsSegmentOrParaSeparator(BidiType t)
+{
+ return ((1<<S) | (1<<B)) & (1 << t);
+}
+static inline bool typeIsWhitespaceOrIsolate(BidiType t)
+{
+ return ((1<<WS) | (1<<FSI) | (1<<LRI) | (1<<RLI) | (1<<PDI)) & (1 << t);
+}
+static inline bool typeIsRemovedDuringProcessing(BidiType t)
+{
+ return ((1<<RLE) | (1<<LRE) | (1<<RLO) | (1<<LRO) | (1<<PDF) |
+ (1<<BN)) & (1 << t);
+}
+static inline bool typeIsStrongOrNumber(BidiType t)
+{
+ return ((1<<L) | (1<<R) | (1<<AL) | (1<<EN) | (1<<AN)) & (1 << t);
+}
+static inline bool typeIsETOrBN(BidiType t)
+{
+ return ((1<<ET) | (1<<BN)) & (1 << t);
+}
+
+/*
+ * More featureful interface to the bidi code, for use in bidi_test.c.
+ * It returns a potentially different value of textlen (in case we're
+ * compiling in REMOVE_FORMATTING_CHARACTERS mode), and also permits
+ * you to pass in an override to the paragraph direction (because many
+ * of the UCD conformance tests use one).
+ *
+ * 'override' is 0 for no override, +1 for left-to-right, -1 for
+ * right-to-left.
+ */
+size_t do_bidi_test(BidiContext *ctx, bidi_char *text, size_t textlen,
+ int override);
+
+#endif /* PUTTY_BIDI_H */
diff --git a/terminal/bidi_gettype.c b/terminal/bidi_gettype.c
new file mode 100644
index 00000000..f3f5338e
--- /dev/null
+++ b/terminal/bidi_gettype.c
@@ -0,0 +1,33 @@
+/*
+ * Standalone test program that exposes the minibidi getType function.
+ */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "putty.h"
+#include "misc.h"
+#include "bidi.h"
+
+void out_of_memory(void)
+{
+ fprintf(stderr, "out of memory!\n");
+ exit(2);
+}
+
+#define TYPETONAME(X) #X,
+static const char *const typenames[] = { BIDI_CHAR_TYPE_LIST(TYPETONAME) };
+#undef TYPETONAME
+
+int main(int argc, char **argv)
+{
+ int i;
+
+ for (i = 1; i < argc; i++) {
+ unsigned long chr = strtoul(argv[i], NULL, 0);
+ int type = bidi_getType(chr);
+ printf("U+%04x: %s\n", (unsigned)chr, typenames[type]);
+ }
+
+ return 0;
+}
diff --git a/terminal/bidi_test.c b/terminal/bidi_test.c
new file mode 100644
index 00000000..1acd1d68
--- /dev/null
+++ b/terminal/bidi_test.c
@@ -0,0 +1,372 @@
+/*
+ * Test program that reads the Unicode bidi algorithm test case lists
+ * that form part of the Unicode Character Database:
+ *
+ * https://www.unicode.org/Public/UCD/latest/ucd/BidiTest.txt
+ * https://www.unicode.org/Public/UCD/latest/ucd/BidiCharacterTest.txt
+ */
+
+#include <ctype.h>
+
+#include "putty.h"
+#include "misc.h"
+#include "bidi.h"
+
+static int pass = 0, fail = 0;
+
+static BidiContext *ctx;
+
+static const char *extract_word(char **ptr)
+{
+ char *p = *ptr;
+ while (*p && isspace((unsigned char)*p)) p++;
+
+ char *start = p;
+ while (*p && !isspace((unsigned char)*p)) p++;
+
+ if (*p) {
+ *p++ = '\0';
+ while (*p && isspace((unsigned char)*p)) p++;
+ }
+
+ *ptr = p;
+ return start;
+}
+
+#define TYPETONAME(X) #X,
+static const char *const typenames[] = { BIDI_CHAR_TYPE_LIST(TYPETONAME) };
+#undef TYPETONAME
+
+static void run_test(const char *filename, unsigned lineno,
+ bidi_char *bcs, size_t bcs_len,
+ const unsigned *order, size_t order_len,
+ int override)
+{
+ size_t bcs_orig_len = bcs_len;
+ bidi_char *bcs_orig = snewn(bcs_orig_len, bidi_char);
+ if (bcs_orig_len)
+ memcpy(bcs_orig, bcs, bcs_orig_len * sizeof(bidi_char));
+
+ bcs_len = do_bidi_test(ctx, bcs, bcs_len, override);
+
+ /*
+ * TR9 revision 44 rule X9 says we remove explicit embedding
+ * controls and BN characters. So the test cases don't list them
+ * in the expected outputs. Do the same to our own output - unless
+ * we're testing the standard version of the algorithm, in which
+ * case, we expect the output to be exactly as the test cases say.
+ */
+ unsigned *our_order = snewn(bcs_len, unsigned);
+ size_t our_order_len = 0;
+ for (size_t i = 0; i < bcs_len; i++) {
+ BidiType t = bidi_getType(bcs[i].wc);
+#ifndef REMOVE_FORMATTING_CHARS
+ if (typeIsRemovedDuringProcessing(t))
+ continue;
+#endif
+ our_order[our_order_len++] = bcs[i].index;
+ }
+
+ bool ok = false;
+ if (our_order_len == order_len) {
+ ok = true;
+ for (size_t i = 0; i < our_order_len; i++)
+ if (our_order[i] != order[i])
+ ok = false;
+ }
+ if (ok) {
+ pass++;
+ } else {
+ fail++;
+ printf("%s:%u: failed order\n", filename, lineno);
+ printf(" input chars:");
+ for (size_t i = 0; i < bcs_orig_len; i++)
+ printf(" %04x", bcs_orig[i].wc);
+ printf("\n");
+ printf(" classes: ");
+ for (size_t i = 0; i < bcs_orig_len; i++)
+ printf(" %-4s", typenames[bidi_getType(bcs_orig[i].wc)]);
+ printf("\n");
+ printf(" para level = %s\n",
+ override > 0 ? "LTR" : override < 0 ? "RTL" : "auto");
+ printf(" expected:");
+ for (size_t i = 0; i < order_len; i++)
+ printf(" %u", order[i]);
+ printf("\n");
+ printf(" got: ");
+ for (size_t i = 0; i < our_order_len; i++)
+ printf(" %u", our_order[i]);
+ printf("\n");
+ }
+
+ /* Put the original data back so we can re-test with another override */
+ memcpy(bcs, bcs_orig, bcs_orig_len * sizeof(bidi_char));
+
+ sfree(bcs_orig);
+ sfree(our_order);
+}
+
+static void class_test(const char *filename, FILE *fp)
+{
+ unsigned lineno = 0;
+ size_t bcs_size = 0, bcs_len = 0;
+ bidi_char *bcs = NULL;
+ size_t order_size = 0, order_len = 0;
+ unsigned *order = NULL;
+
+ /* Preliminary: find a representative character of every bidi
+ * type. Prefer positive-width ones if available. */
+ unsigned representatives[N_BIDI_TYPES];
+ for (size_t i = 0; i < N_BIDI_TYPES; i++)
+ representatives[i] = 0;
+ for (unsigned uc = 1; uc < 0x110000; uc++) {
+ unsigned type = bidi_getType(uc);
+ if (!representatives[type] ||
+ (mk_wcwidth(representatives[type]) <= 0 && mk_wcwidth(uc) > 0))
+ representatives[type] = uc;
+ }
+
+ while (true) {
+ lineno++;
+ char *line = chomp(fgetline(fp));
+ if (!line)
+ break;
+
+ /* Skip blank lines and comments */
+ if (!line[0] || line[0] == '#') {
+ sfree(line);
+ continue;
+ }
+
+ /* Parse @Reorder lines, which tell us the expected output
+ * order for all following test cases (until superseded) */
+ if (strstartswith(line, "@Reorder:")) {
+ char *p = line;
+ extract_word(&p); /* eat the "@Reorder:" header itself */
+ order_len = 0;
+ while (1) {
+ const char *word = extract_word(&p);
+ if (!*word)
+ break;
+ sgrowarray(order, order_size, order_len);
+ order[order_len++] = strtoul(word, NULL, 0);
+ }
+
+ sfree(line);
+ continue;
+ }
+
+ /* Skip @Levels lines, which we don't (yet?) do anything with */
+ if (strstartswith(line, "@Levels:")) {
+ sfree(line);
+ continue;
+ }
+
+ /* Everything remaining should be an actual test */
+ char *semicolon = strchr(line, ';');
+ if (!semicolon) {
+ printf("%s:%u: bad test line': no bitmap\n", filename, lineno);
+ sfree(line);
+ continue;
+ }
+ *semicolon++ = '\0';
+ unsigned bitmask = strtoul(semicolon, NULL, 0);
+ char *p = line;
+ bcs_len = 0;
+ bool test_ok = true;
+ while (1) {
+ const char *word = extract_word(&p);
+ if (!*word)
+ break;
+ unsigned type;
+ for (type = 0; type < N_BIDI_TYPES; type++)
+ if (!strcmp(word, typenames[type]))
+ break;
+ if (type == N_BIDI_TYPES) {
+ printf("%s:%u: bad test line: bad bidi type '%s'\n",
+ filename, lineno, word);
+ test_ok = false;
+ break;
+ }
+ sgrowarray(bcs, bcs_size, bcs_len);
+ bcs[bcs_len].wc = representatives[type];
+ bcs[bcs_len].origwc = bcs[bcs_len].wc;
+ bcs[bcs_len].index = bcs_len;
+ bcs[bcs_len].nchars = 1;
+ bcs_len++;
+ }
+
+ if (!test_ok) {
+ sfree(line);
+ continue;
+ }
+
+ if (bitmask & 1)
+ run_test(filename, lineno, bcs, bcs_len, order, order_len, 0);
+ if (bitmask & 2)
+ run_test(filename, lineno, bcs, bcs_len, order, order_len, +1);
+ if (bitmask & 4)
+ run_test(filename, lineno, bcs, bcs_len, order, order_len, -1);
+
+ sfree(line);
+ }
+
+ sfree(bcs);
+ sfree(order);
+}
+
+static void char_test(const char *filename, FILE *fp)
+{
+ unsigned lineno = 0;
+ size_t bcs_size = 0, bcs_len = 0;
+ bidi_char *bcs = NULL;
+ size_t order_size = 0, order_len = 0;
+ unsigned *order = NULL;
+
+ while (true) {
+ lineno++;
+ char *line = chomp(fgetline(fp));
+ if (!line)
+ break;
+
+ /* Skip blank lines and comments */
+ if (!line[0] || line[0] == '#') {
+ sfree(line);
+ continue;
+ }
+
+ /* Break each test line up into its main fields */
+ ptrlen input_pl, para_dir_pl, order_pl;
+ {
+ ptrlen pl = ptrlen_from_asciz(line);
+ input_pl = ptrlen_get_word(&pl, ";");
+ para_dir_pl = ptrlen_get_word(&pl, ";");
+ ptrlen_get_word(&pl, ";"); /* paragraph level, which we ignore */
+ ptrlen_get_word(&pl, ";"); /* embedding levels, which we ignore */
+ order_pl = ptrlen_get_word(&pl, ";");
+ }
+
+ int override;
+ {
+ char *para_dir_str = mkstr(para_dir_pl);
+ unsigned para_dir = strtoul(para_dir_str, NULL, 0);
+ sfree(para_dir_str);
+
+ override = (para_dir == 0 ? +1 : para_dir == 1 ? -1 : 0);
+ }
+
+ /* Break up the input into Unicode characters */
+ bcs_len = 0;
+ {
+ ptrlen pl = input_pl;
+ while (pl.len) {
+ ptrlen chr = ptrlen_get_word(&pl, " ");
+ char *chrstr = mkstr(chr);
+ sgrowarray(bcs, bcs_size, bcs_len);
+ bcs[bcs_len].wc = strtoul(chrstr, NULL, 16);
+ bcs[bcs_len].origwc = bcs[bcs_len].wc;
+ bcs[bcs_len].index = bcs_len;
+ bcs[bcs_len].nchars = 1;
+ bcs_len++;
+ sfree(chrstr);
+ }
+ }
+
+ /* Ditto the expected output order */
+ order_len = 0;
+ {
+ ptrlen pl = order_pl;
+ while (pl.len) {
+ ptrlen chr = ptrlen_get_word(&pl, " ");
+ char *chrstr = mkstr(chr);
+ sgrowarray(order, order_size, order_len);
+ order[order_len++] = strtoul(chrstr, NULL, 0);
+ sfree(chrstr);
+ }
+ }
+
+ run_test(filename, lineno, bcs, bcs_len, order, order_len, override);
+ sfree(line);
+ }
+
+ sfree(bcs);
+ sfree(order);
+}
+
+void out_of_memory(void)
+{
+ fprintf(stderr, "out of memory!\n");
+ exit(2);
+}
+
+static void usage(FILE *fp)
+{
+ fprintf(fp, "\
+usage: bidi_test ( ( --class | --char ) infile... )...\n\
+e.g.: bidi_test --class BidiTest.txt --char BidiCharacterTest.txt\n\
+also: --help display this text\n\
+");
+}
+
+int main(int argc, char **argv)
+{
+ void (*testfn)(const char *, FILE *) = NULL;
+ bool doing_opts = true;
+ const char *filename = NULL;
+ bool done_something = false;
+
+ ctx = bidi_new_context();
+
+ while (--argc > 0) {
+ const char *arg = *++argv;
+ if (doing_opts && arg[0] == '-' && arg[1]) {
+ if (!strcmp(arg, "--")) {
+ doing_opts = false;
+ } else if (!strcmp(arg, "--class")) {
+ testfn = class_test;
+ } else if (!strcmp(arg, "--char")) {
+ testfn = char_test;
+ } else if (!strcmp(arg, "--help")) {
+ usage(stdout);
+ return 0;
+ } else {
+ fprintf(stderr, "unrecognised option '%s'\n", arg);
+ return 1;
+ }
+ } else {
+ const char *filename = arg;
+
+ if (!testfn) {
+ fprintf(stderr, "no mode argument provided before filename "
+ "'%s'\n", filename);
+ return 1;
+ }
+
+ if (!strcmp(filename, "-")) {
+ testfn("<standard input>", stdin);
+ } else {
+ FILE *fp = fopen(filename, "r");
+ if (!fp) {
+ fprintf(stderr, "unable to open '%s'\n", filename);
+ return 1;
+ }
+ testfn(filename, fp);
+ fclose(fp);
+ }
+ done_something = true;
+ }
+ }
+
+ if (!done_something) {
+ usage(stderr);
+ return 1;
+ }
+
+ if (!filename)
+ filename = "-";
+
+ printf("pass %d fail %d total %d\n", pass, fail, pass + fail);
+
+ bidi_free_context(ctx);
+ return fail != 0;
+}
diff --git a/terminal/terminal.c b/terminal/terminal.c
new file mode 100644
index 00000000..37fa3513
--- /dev/null
+++ b/terminal/terminal.c
@@ -0,0 +1,7910 @@
+/*
+ * Terminal emulator.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+#include <wchar.h>
+
+#include <time.h>
+#include <assert.h>
+#include "putty.h"
+#include "terminal.h"
+
+#define VT52_PLUS
+
+#define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */
+#define CL_VT100 0x0002 /* VT100 */
+#define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */
+#define CL_VT102 0x0008 /* VT102 */
+#define CL_VT220 0x0010 /* VT220 */
+#define CL_VT320 0x0020 /* VT320 */
+#define CL_VT420 0x0040 /* VT420 */
+#define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */
+#define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */
+#define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */
+#define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */
+#define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */
+
+#define TM_VT100 (CL_ANSIMIN|CL_VT100)
+#define TM_VT100AVO (TM_VT100|CL_VT100AVO)
+#define TM_VT102 (TM_VT100AVO|CL_VT102)
+#define TM_VT220 (TM_VT102|CL_VT220)
+#define TM_VTXXX (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320)
+#define TM_SCOANSI (CL_ANSIMIN|CL_SCOANSI)
+
+#define TM_PUTTY (0xFFFF)
+
+#define UPDATE_DELAY ((TICKSPERSEC+49)/50)/* ticks to defer window update */
+#define TBLINK_DELAY ((TICKSPERSEC*9+19)/20)/* ticks between text blinks*/
+#define CBLINK_DELAY (CURSORBLINK) /* ticks between cursor blinks */
+#define VBELL_DELAY (VBELL_TIMEOUT) /* visual bell timeout in ticks */
+
+#define compatibility(x) \
+ if ( ((CL_##x)&term->compatibility_level) == 0 ) { \
+ term->termstate=TOPLEVEL; \
+ break; \
+ }
+#define compatibility2(x,y) \
+ if ( ((CL_##x|CL_##y)&term->compatibility_level) == 0 ) { \
+ term->termstate=TOPLEVEL; \
+ break; \
+ }
+
+#define has_compat(x) ( ((CL_##x)&term->compatibility_level) != 0 )
+
+static const char *const EMPTY_WINDOW_TITLE = "";
+
+static const char sco2ansicolour[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+
+#define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t))
+static const wchar_t sel_nl[] = SEL_NL;
+
+/*
+ * Fetch the character at a particular position in a line array,
+ * for purposes of `wordtype'. The reason this isn't just a simple
+ * array reference is that if the character we find is UCSWIDE,
+ * then we must look one space further to the left.
+ */
+#define UCSGET(a, x) \
+ ( (x)>0 && (a)[(x)].chr == UCSWIDE ? (a)[(x)-1].chr : (a)[(x)].chr )
+
+/*
+ * Detect the various aliases of U+0020 SPACE.
+ */
+#define IS_SPACE_CHR(chr) \
+ ((chr) == 0x20 || (DIRECT_CHAR(chr) && ((chr) & 0xFF) == 0x20))
+
+/*
+ * Spot magic CSETs.
+ */
+#define CSET_OF(chr) (DIRECT_CHAR(chr)||DIRECT_FONT(chr) ? (chr)&CSET_MASK : 0)
+
+/*
+ * Internal prototypes.
+ */
+static void resizeline(Terminal *, termline *, int);
+static termline *lineptr(Terminal *, int, int, int);
+static void unlineptr(termline *);
+static void check_line_size(Terminal *, termline *);
+static void do_paint(Terminal *);
+static void erase_lots(Terminal *, bool, bool, bool);
+static int find_last_nonempty_line(Terminal *, tree234 *);
+static void swap_screen(Terminal *, int, bool, bool);
+static void update_sbar(Terminal *);
+static void deselect(Terminal *);
+static void term_print_finish(Terminal *);
+static void scroll(Terminal *, int, int, int, bool);
+static void parse_optionalrgb(optionalrgb *out, unsigned *values);
+static void term_added_data(Terminal *term, bool);
+static void term_update_raw_mouse_mode(Terminal *term);
+static void term_out_cb(void *);
+
+static termline *newtermline(Terminal *term, int cols, bool bce)
+{
+ termline *line;
+ int j;
+
+ line = snew(termline);
+ line->chars = snewn(cols, termchar);
+ for (j = 0; j < cols; j++)
+ line->chars[j] = (bce ? term->erase_char : term->basic_erase_char);
+ line->cols = line->size = cols;
+ line->lattr = LATTR_NORM;
+ line->trusted = false;
+ line->temporary = false;
+ line->cc_free = 0;
+
+ return line;
+}
+
+static void freetermline(termline *line)
+{
+ if (line) {
+ sfree(line->chars);
+ sfree(line);
+ }
+}
+
+static void unlineptr(termline *line)
+{
+ if (line->temporary)
+ freetermline(line);
+}
+
+const int colour_indices_conf_to_oscp[CONF_NCOLOURS] = {
+ #define COLOUR_ENTRY(id,name) OSCP_COLOUR_##id,
+ CONF_COLOUR_LIST(COLOUR_ENTRY)
+ #undef COLOUR_ENTRY
+};
+
+const int colour_indices_conf_to_osc4[CONF_NCOLOURS] = {
+ #define COLOUR_ENTRY(id,name) OSC4_COLOUR_##id,
+ CONF_COLOUR_LIST(COLOUR_ENTRY)
+ #undef COLOUR_ENTRY
+};
+
+const int colour_indices_oscp_to_osc4[OSCP_NCOLOURS] = {
+ #define COLOUR_ENTRY(id) OSC4_COLOUR_##id,
+ OSCP_COLOUR_LIST(COLOUR_ENTRY)
+ #undef COLOUR_ENTRY
+};
+
+#ifdef TERM_CC_DIAGS
+/*
+ * Diagnostic function: verify that a termline has a correct
+ * combining character structure.
+ *
+ * This is a performance-intensive check, so it's no longer enabled
+ * by default.
+ */
+static void cc_check(termline *line)
+{
+ unsigned char *flags;
+ int i, j;
+
+ assert(line->size >= line->cols);
+
+ flags = snewn(line->size, unsigned char);
+
+ for (i = 0; i < line->size; i++)
+ flags[i] = (i < line->cols);
+
+ for (i = 0; i < line->cols; i++) {
+ j = i;
+ while (line->chars[j].cc_next) {
+ j += line->chars[j].cc_next;
+ assert(j >= line->cols && j < line->size);
+ assert(!flags[j]);
+ flags[j] = true;
+ }
+ }
+
+ j = line->cc_free;
+ if (j) {
+ while (1) {
+ assert(j >= line->cols && j < line->size);
+ assert(!flags[j]);
+ flags[j] = true;
+ if (line->chars[j].cc_next)
+ j += line->chars[j].cc_next;
+ else
+ break;
+ }
+ }
+
+ j = 0;
+ for (i = 0; i < line->size; i++)
+ j += (flags[i] != 0);
+
+ assert(j == line->size);
+
+ sfree(flags);
+}
+#endif
+
+static void clear_cc(termline *line, int col);
+
+/*
+ * Add a combining character to a character cell.
+ */
+static void add_cc(termline *line, int col, unsigned long chr)
+{
+ int newcc;
+
+ assert(col >= 0 && col < line->cols);
+
+ /*
+ * Don't add combining characters at all to U+FFFD REPLACEMENT
+ * CHARACTER. (Partly it's a slightly incoherent idea in the first
+ * place; mostly, U+FFFD is what we generate if a cell already has
+ * too many ccs, in which case we want it to be a fixed point when
+ * further ccs are added.)
+ */
+ if (line->chars[col].chr == 0xFFFD)
+ return;
+
+ /*
+ * Walk the cc list of the cell in question to find its current
+ * end point.
+ */
+ size_t ncc = 0;
+ int origcol = col;
+ while (line->chars[col].cc_next) {
+ col += line->chars[col].cc_next;
+ if (++ncc >= CC_LIMIT) {
+ /*
+ * There are already too many combining characters in this
+ * character cell. Change strategy: throw out the entire
+ * chain and replace the main character with U+FFFD.
+ *
+ * (Rationale: extrapolating from UTR #36 section 3.6.2
+ * suggests the principle that it's better to substitute
+ * U+FFFD than to _ignore_ input completely. Also, if the
+ * user copies and pastes an overcombined character cell,
+ * this way it will clearly indicate that we haven't
+ * reproduced the writer's original intentions, instead of
+ * looking as if it was the _writer's_ fault that the 33rd
+ * cc is missing.)
+ *
+ * Per the code above, this will also prevent any further
+ * ccs from being added to this cell.
+ */
+ clear_cc(line, origcol);
+ line->chars[origcol].chr = 0xFFFD;
+ return;
+ }
+ }
+
+ /*
+ * Extend the cols array if the free list is empty.
+ */
+ if (!line->cc_free) {
+ int n = line->size;
+
+ size_t tmpsize = line->size;
+ sgrowarray(line->chars, tmpsize, tmpsize);
+ assert(tmpsize <= INT_MAX);
+ line->size = tmpsize;
+
+ line->cc_free = n;
+ while (n < line->size) {
+ if (n+1 < line->size)
+ line->chars[n].cc_next = 1;
+ else
+ line->chars[n].cc_next = 0;
+ n++;
+ }
+ }
+
+ /*
+ * `col' now points at the last cc currently in this cell; so
+ * we simply add another one.
+ */
+ newcc = line->cc_free;
+ if (line->chars[newcc].cc_next)
+ line->cc_free = newcc + line->chars[newcc].cc_next;
+ else
+ line->cc_free = 0;
+ line->chars[newcc].cc_next = 0;
+ line->chars[newcc].chr = chr;
+ line->chars[col].cc_next = newcc - col;
+
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
+}
+
+/*
+ * Clear the combining character list in a character cell.
+ */
+static void clear_cc(termline *line, int col)
+{
+ int oldfree, origcol = col;
+
+ assert(col >= 0 && col < line->cols);
+
+ if (!line->chars[col].cc_next)
+ return; /* nothing needs doing */
+
+ oldfree = line->cc_free;
+ line->cc_free = col + line->chars[col].cc_next;
+ while (line->chars[col].cc_next)
+ col += line->chars[col].cc_next;
+ if (oldfree)
+ line->chars[col].cc_next = oldfree - col;
+ else
+ line->chars[col].cc_next = 0;
+
+ line->chars[origcol].cc_next = 0;
+
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
+}
+
+/*
+ * Compare two character cells for equality. Special case required
+ * in do_paint() where we override what we expect the chr and attr
+ * fields to be.
+ */
+static bool termchars_equal_override(termchar *a, termchar *b,
+ unsigned long bchr, unsigned long battr)
+{
+ /* FULL-TERMCHAR */
+ if (!truecolour_equal(a->truecolour, b->truecolour))
+ return false;
+ if (a->chr != bchr)
+ return false;
+ if ((a->attr &~ DATTR_MASK) != (battr &~ DATTR_MASK))
+ return false;
+ while (a->cc_next || b->cc_next) {
+ if (!a->cc_next || !b->cc_next)
+ return false; /* one cc-list ends, other does not */
+ a += a->cc_next;
+ b += b->cc_next;
+ if (a->chr != b->chr)
+ return false;
+ }
+ return true;
+}
+
+static bool termchars_equal(termchar *a, termchar *b)
+{
+ return termchars_equal_override(a, b, b->chr, b->attr);
+}
+
+/*
+ * Copy a character cell. (Requires a pointer to the destination
+ * termline, so as to access its free list.)
+ */
+static void copy_termchar(termline *destline, int x, termchar *src)
+{
+ clear_cc(destline, x);
+
+ destline->chars[x] = *src; /* copy everything except cc-list */
+ destline->chars[x].cc_next = 0; /* and make sure this is zero */
+
+ while (src->cc_next) {
+ src += src->cc_next;
+ add_cc(destline, x, src->chr);
+ }
+
+#ifdef TERM_CC_DIAGS
+ cc_check(destline);
+#endif
+}
+
+/*
+ * Move a character cell within its termline.
+ */
+static void move_termchar(termline *line, termchar *dest, termchar *src)
+{
+ /* First clear the cc list from the original char, just in case. */
+ clear_cc(line, dest - line->chars);
+
+ /* Move the character cell and adjust its cc_next. */
+ *dest = *src; /* copy everything except cc-list */
+ if (src->cc_next)
+ dest->cc_next = src->cc_next - (dest-src);
+
+ /* Ensure the original cell doesn't have a cc list. */
+ src->cc_next = 0;
+
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
+}
+
+/*
+ * Compress and decompress a termline into an RLE-based format for
+ * storing in scrollback. (Since scrollback almost never needs to
+ * be modified and exists in huge quantities, this is a sensible
+ * tradeoff, particularly since it allows us to continue adding
+ * features to the main termchar structure without proportionally
+ * bloating the terminal emulator's memory footprint unless those
+ * features are in constant use.)
+ */
+static void makerle(strbuf *b, termline *ldata,
+ void (*makeliteral)(strbuf *b, termchar *c,
+ unsigned long *state))
+{
+ int hdrpos, hdrsize, n, prevlen, prevpos, thislen, thispos;
+ bool prev2;
+ termchar *c = ldata->chars;
+ unsigned long state = 0, oldstate;
+
+ n = ldata->cols;
+
+ hdrpos = b->len;
+ hdrsize = 0;
+ put_byte(b, 0);
+ prevlen = prevpos = 0;
+ prev2 = false;
+
+ while (n-- > 0) {
+ thispos = b->len;
+ makeliteral(b, c++, &state);
+ thislen = b->len - thispos;
+ if (thislen == prevlen &&
+ !memcmp(b->u + prevpos, b->u + thispos, thislen)) {
+ /*
+ * This literal precisely matches the previous one.
+ * Turn it into a run if it's worthwhile.
+ *
+ * With one-byte literals, it costs us two bytes to
+ * encode a run, plus another byte to write the header
+ * to resume normal output; so a three-element run is
+ * neutral, and anything beyond that is unconditionally
+ * worthwhile. With two-byte literals or more, even a
+ * 2-run is a win.
+ */
+ if (thislen > 1 || prev2) {
+ int runpos, runlen;
+
+ /*
+ * It's worth encoding a run. Start at prevpos,
+ * unless hdrsize==0 in which case we can back up
+ * another one and start by overwriting hdrpos.
+ */
+
+ hdrsize--; /* remove the literal at prevpos */
+ if (prev2) {
+ assert(hdrsize > 0);
+ hdrsize--;
+ prevpos -= prevlen;/* and possibly another one */
+ }
+
+ if (hdrsize == 0) {
+ assert(prevpos == hdrpos + 1);
+ runpos = hdrpos;
+ strbuf_shrink_to(b, prevpos+prevlen);
+ } else {
+ memmove(b->u + prevpos+1, b->u + prevpos, prevlen);
+ runpos = prevpos;
+ strbuf_shrink_to(b, prevpos+prevlen+1);
+ /*
+ * Terminate the previous run of ordinary
+ * literals.
+ */
+ assert(hdrsize >= 1 && hdrsize <= 128);
+ b->u[hdrpos] = hdrsize - 1;
+ }
+
+ runlen = prev2 ? 3 : 2;
+
+ while (n > 0 && runlen < 129) {
+ int tmppos, tmplen;
+ tmppos = b->len;
+ oldstate = state;
+ makeliteral(b, c, &state);
+ tmplen = b->len - tmppos;
+ bool match = tmplen == thislen &&
+ !memcmp(b->u + runpos+1, b->u + tmppos, tmplen);
+ strbuf_shrink_to(b, tmppos);
+ if (!match) {
+ state = oldstate;
+ break; /* run over */
+ }
+ n--, c++, runlen++;
+ }
+
+ assert(runlen >= 2 && runlen <= 129);
+ b->u[runpos] = runlen + 0x80 - 2;
+
+ hdrpos = b->len;
+ hdrsize = 0;
+ put_byte(b, 0);
+ /* And ensure this run doesn't interfere with the next. */
+ prevlen = prevpos = 0;
+ prev2 = false;
+
+ continue;
+ } else {
+ /*
+ * Just flag that the previous two literals were
+ * identical, in case we find a third identical one
+ * we want to turn into a run.
+ */
+ prev2 = true;
+ prevlen = thislen;
+ prevpos = thispos;
+ }
+ } else {
+ prev2 = false;
+ prevlen = thislen;
+ prevpos = thispos;
+ }
+
+ /*
+ * This character isn't (yet) part of a run. Add it to
+ * hdrsize.
+ */
+ hdrsize++;
+ if (hdrsize == 128) {
+ b->u[hdrpos] = hdrsize - 1;
+ hdrpos = b->len;
+ hdrsize = 0;
+ put_byte(b, 0);
+ prevlen = prevpos = 0;
+ prev2 = false;
+ }
+ }
+
+ /*
+ * Clean up.
+ */
+ if (hdrsize > 0) {
+ assert(hdrsize <= 128);
+ b->u[hdrpos] = hdrsize - 1;
+ } else {
+ strbuf_shrink_to(b, hdrpos);
+ }
+}
+static void makeliteral_chr(strbuf *b, termchar *c, unsigned long *state)
+{
+ /*
+ * My encoding for characters is UTF-8-like, in that it stores
+ * 7-bit ASCII in one byte and uses high-bit-set bytes as
+ * introducers to indicate a longer sequence. However, it's
+ * unlike UTF-8 in that it doesn't need to be able to
+ * resynchronise, and therefore I don't want to waste two bits
+ * per byte on having recognisable continuation characters.
+ * Also I don't want to rule out the possibility that I may one
+ * day use values 0x80000000-0xFFFFFFFF for interesting
+ * purposes, so unlike UTF-8 I need a full 32-bit range.
+ * Accordingly, here is my encoding:
+ *
+ * 00000000-0000007F: 0xxxxxxx (but see below)
+ * 00000080-00003FFF: 10xxxxxx xxxxxxxx
+ * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx
+ * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ *
+ * (`Z' is like `x' but is always going to be zero since the
+ * values I'm encoding don't go above 2^32. In principle the
+ * five-byte form of the encoding could extend to 2^35, and
+ * there could be six-, seven-, eight- and nine-byte forms as
+ * well to allow up to 64-bit values to be encoded. But that's
+ * completely unnecessary for these purposes!)
+ *
+ * The encoding as written above would be very simple, except
+ * that 7-bit ASCII can occur in several different ways in the
+ * terminal data; sometimes it crops up in the D800 page
+ * (CSET_ASCII) but at other times it's in the 0000 page (real
+ * Unicode). Therefore, this encoding is actually _stateful_:
+ * the one-byte encoding of 00-7F actually indicates `reuse the
+ * upper three bytes of the last character', and to encode an
+ * absolute value of 00-7F you need to use the two-byte form
+ * instead.
+ */
+ if ((c->chr & ~0x7F) == *state) {
+ put_byte(b, (unsigned char)(c->chr & 0x7F));
+ } else if (c->chr < 0x4000) {
+ put_byte(b, (unsigned char)(((c->chr >> 8) & 0x3F) | 0x80));
+ put_byte(b, (unsigned char)(c->chr & 0xFF));
+ } else if (c->chr < 0x200000) {
+ put_byte(b, (unsigned char)(((c->chr >> 16) & 0x1F) | 0xC0));
+ put_uint16(b, c->chr & 0xFFFF);
+ } else if (c->chr < 0x10000000) {
+ put_byte(b, (unsigned char)(((c->chr >> 24) & 0x0F) | 0xE0));
+ put_byte(b, (unsigned char)((c->chr >> 16) & 0xFF));
+ put_uint16(b, c->chr & 0xFFFF);
+ } else {
+ put_byte(b, 0xF0);
+ put_uint32(b, c->chr);
+ }
+ *state = c->chr & ~0xFF;
+}
+static void makeliteral_attr(strbuf *b, termchar *c, unsigned long *state)
+{
+ /*
+ * My encoding for attributes is 16-bit-granular and assumes
+ * that the top bit of the word is never required. I either
+ * store a two-byte value with the top bit clear (indicating
+ * just that value), or a four-byte value with the top bit set
+ * (indicating the same value with its top bit clear).
+ *
+ * However, first I permute the bits of the attribute value, so
+ * that the eight bits of colour (four in each of fg and bg)
+ * which are never non-zero unless xterm 256-colour mode is in
+ * use are placed higher up the word than everything else. This
+ * ensures that attribute values remain 16-bit _unless_ the
+ * user uses extended colour.
+ */
+ unsigned attr, colourbits;
+
+ attr = c->attr;
+
+ assert(ATTR_BGSHIFT > ATTR_FGSHIFT);
+
+ colourbits = (attr >> (ATTR_BGSHIFT + 4)) & 0xF;
+ colourbits <<= 4;
+ colourbits |= (attr >> (ATTR_FGSHIFT + 4)) & 0xF;
+
+ attr = (((attr >> (ATTR_BGSHIFT + 8)) << (ATTR_BGSHIFT + 4)) |
+ (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));
+ attr = (((attr >> (ATTR_FGSHIFT + 8)) << (ATTR_FGSHIFT + 4)) |
+ (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));
+
+ attr |= (colourbits << (32-9));
+
+ if (attr < 0x8000) {
+ put_byte(b, (unsigned char)((attr >> 8) & 0xFF));
+ put_byte(b, (unsigned char)(attr & 0xFF));
+ } else {
+ put_byte(b, (unsigned char)(((attr >> 24) & 0x7F) | 0x80));
+ put_byte(b, (unsigned char)((attr >> 16) & 0xFF));
+ put_byte(b, (unsigned char)((attr >> 8) & 0xFF));
+ put_byte(b, (unsigned char)(attr & 0xFF));
+ }
+}
+static void makeliteral_truecolour(strbuf *b, termchar *c, unsigned long *state)
+{
+ /*
+ * Put the used parts of the colour info into the buffer.
+ */
+ put_byte(b, ((c->truecolour.fg.enabled ? 1 : 0) |
+ (c->truecolour.bg.enabled ? 2 : 0)));
+ if (c->truecolour.fg.enabled) {
+ put_byte(b, c->truecolour.fg.r);
+ put_byte(b, c->truecolour.fg.g);
+ put_byte(b, c->truecolour.fg.b);
+ }
+ if (c->truecolour.bg.enabled) {
+ put_byte(b, c->truecolour.bg.r);
+ put_byte(b, c->truecolour.bg.g);
+ put_byte(b, c->truecolour.bg.b);
+ }
+}
+static void makeliteral_cc(strbuf *b, termchar *c, unsigned long *state)
+{
+ /*
+ * For combining characters, I just encode a bunch of ordinary
+ * chars using makeliteral_chr, and terminate with a \0
+ * character (which I know won't come up as a combining char
+ * itself).
+ *
+ * I don't use the stateful encoding in makeliteral_chr.
+ */
+ unsigned long zstate;
+ termchar z;
+
+ while (c->cc_next) {
+ c += c->cc_next;
+
+ assert(c->chr != 0);
+
+ zstate = 0;
+ makeliteral_chr(b, c, &zstate);
+ }
+
+ z.chr = 0;
+ zstate = 0;
+ makeliteral_chr(b, &z, &zstate);
+}
+
+typedef struct compressed_scrollback_line {
+ size_t len;
+} compressed_scrollback_line;
+
+static termline *decompressline(compressed_scrollback_line *line);
+
+static compressed_scrollback_line *compressline(termline *ldata)
+{
+ strbuf *b = strbuf_new();
+
+ /* Leave space for the header structure */
+ strbuf_append(b, sizeof(compressed_scrollback_line));
+
+ /*
+ * First, store the column count, 7 bits at a time, least
+ * significant `digit' first, with the high bit set on all but
+ * the last.
+ */
+ {
+ int n = ldata->cols;
+ while (n >= 128) {
+ put_byte(b, (unsigned char)((n & 0x7F) | 0x80));
+ n >>= 7;
+ }
+ put_byte(b, (unsigned char)(n));
+ }
+
+ /*
+ * Next store the lattrs; same principle. We add one extra bit to
+ * this to indicate the trust state of the line.
+ */
+ {
+ int n = ldata->lattr | (ldata->trusted ? 0x10000 : 0);
+ while (n >= 128) {
+ put_byte(b, (unsigned char)((n & 0x7F) | 0x80));
+ n >>= 7;
+ }
+ put_byte(b, (unsigned char)(n));
+ }
+
+ /*
+ * Now we store a sequence of separate run-length encoded
+ * fragments, each containing exactly as many symbols as there
+ * are columns in the ldata.
+ *
+ * All of these have a common basic format:
+ *
+ * - a byte 00-7F indicates that X+1 literals follow it
+ * - a byte 80-FF indicates that a single literal follows it
+ * and expects to be repeated (X-0x80)+2 times.
+ *
+ * The format of the `literals' varies between the fragments.
+ */
+ makerle(b, ldata, makeliteral_chr);
+ makerle(b, ldata, makeliteral_attr);
+ makerle(b, ldata, makeliteral_truecolour);
+ makerle(b, ldata, makeliteral_cc);
+
+ size_t linelen = b->len - sizeof(compressed_scrollback_line);
+ compressed_scrollback_line *line =
+ (compressed_scrollback_line *)strbuf_to_str(b);
+ line->len = linelen;
+
+ /*
+ * Diagnostics: ensure that the compressed data really does
+ * decompress to the right thing.
+ *
+ * This is a bit performance-heavy for production code.
+ */
+#ifdef TERM_CC_DIAGS
+#ifndef CHECK_SB_COMPRESSION
+ {
+ termline *dcl;
+ int i;
+
+#ifdef DIAGNOSTIC_SB_COMPRESSION
+ for (i = 0; i < b->len; i++) {
+ printf(" %02x ", b->data[i]);
+ }
+ printf("\n");
+#endif
+
+ dcl = decompressline(line);
+ assert(ldata->cols == dcl->cols);
+ assert(ldata->lattr == dcl->lattr);
+ for (i = 0; i < ldata->cols; i++)
+ assert(termchars_equal(&ldata->chars[i], &dcl->chars[i]));
+
+#ifdef DIAGNOSTIC_SB_COMPRESSION
+ printf("%d cols (%d bytes) -> %d bytes (factor of %g)\n",
+ ldata->cols, 4 * ldata->cols, dused,
+ (double)dused / (4 * ldata->cols));
+#endif
+
+ freetermline(dcl);
+ }
+#endif
+#endif /* TERM_CC_DIAGS */
+
+ return line;
+}
+
+static void readrle(BinarySource *bs, termline *ldata,
+ void (*readliteral)(BinarySource *bs, termchar *c,
+ termline *ldata, unsigned long *state))
+{
+ int n = 0;
+ unsigned long state = 0;
+
+ while (n < ldata->cols) {
+ int hdr = get_byte(bs);
+
+ if (hdr >= 0x80) {
+ /* A run. */
+
+ size_t pos = bs->pos, count = hdr + 2 - 0x80;
+ while (count--) {
+ assert(n < ldata->cols);
+ bs->pos = pos;
+ readliteral(bs, ldata->chars + n, ldata, &state);
+ n++;
+ }
+ } else {
+ /* Just a sequence of consecutive literals. */
+
+ int count = hdr + 1;
+ while (count--) {
+ assert(n < ldata->cols);
+ readliteral(bs, ldata->chars + n, ldata, &state);
+ n++;
+ }
+ }
+ }
+
+ assert(n == ldata->cols);
+}
+static void readliteral_chr(BinarySource *bs, termchar *c, termline *ldata,
+ unsigned long *state)
+{
+ int byte;
+
+ /*
+ * 00000000-0000007F: 0xxxxxxx
+ * 00000080-00003FFF: 10xxxxxx xxxxxxxx
+ * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx
+ * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ */
+
+ byte = get_byte(bs);
+ if (byte < 0x80) {
+ c->chr = byte | *state;
+ } else if (byte < 0xC0) {
+ c->chr = (byte &~ 0xC0) << 8;
+ c->chr |= get_byte(bs);
+ } else if (byte < 0xE0) {
+ c->chr = (byte &~ 0xE0) << 16;
+ c->chr |= get_uint16(bs);
+ } else if (byte < 0xF0) {
+ c->chr = (byte &~ 0xF0) << 24;
+ c->chr |= get_byte(bs) << 16;
+ c->chr |= get_uint16(bs);
+ } else {
+ assert(byte == 0xF0);
+ c->chr = get_uint32(bs);
+ }
+ *state = c->chr & ~0xFF;
+}
+static void readliteral_attr(BinarySource *bs, termchar *c, termline *ldata,
+ unsigned long *state)
+{
+ unsigned val, attr, colourbits;
+
+ val = get_uint16(bs);
+
+ if (val >= 0x8000) {
+ val &= ~0x8000;
+ val <<= 16;
+ val |= get_uint16(bs);
+ }
+
+ colourbits = (val >> (32-9)) & 0xFF;
+ attr = (val & ((1<<(32-9))-1));
+
+ attr = (((attr >> (ATTR_FGSHIFT + 4)) << (ATTR_FGSHIFT + 8)) |
+ (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));
+ attr = (((attr >> (ATTR_BGSHIFT + 4)) << (ATTR_BGSHIFT + 8)) |
+ (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));
+
+ attr |= (colourbits >> 4) << (ATTR_BGSHIFT + 4);
+ attr |= (colourbits & 0xF) << (ATTR_FGSHIFT + 4);
+
+ c->attr = attr;
+}
+static void readliteral_truecolour(
+ BinarySource *bs, termchar *c, termline *ldata, unsigned long *state)
+{
+ int flags = get_byte(bs);
+
+ if (flags & 1) {
+ c->truecolour.fg.enabled = true;
+ c->truecolour.fg.r = get_byte(bs);
+ c->truecolour.fg.g = get_byte(bs);
+ c->truecolour.fg.b = get_byte(bs);
+ } else {
+ c->truecolour.fg = optionalrgb_none;
+ }
+
+ if (flags & 2) {
+ c->truecolour.bg.enabled = true;
+ c->truecolour.bg.r = get_byte(bs);
+ c->truecolour.bg.g = get_byte(bs);
+ c->truecolour.bg.b = get_byte(bs);
+ } else {
+ c->truecolour.bg = optionalrgb_none;
+ }
+}
+static void readliteral_cc(BinarySource *bs, termchar *c, termline *ldata,
+ unsigned long *state)
+{
+ termchar n;
+ unsigned long zstate;
+ int x = c - ldata->chars;
+
+ c->cc_next = 0;
+
+ while (1) {
+ zstate = 0;
+ readliteral_chr(bs, &n, ldata, &zstate);
+ if (!n.chr)
+ break;
+ add_cc(ldata, x, n.chr);
+ }
+}
+
+static termline *decompressline(compressed_scrollback_line *line)
+{
+ int ncols, byte, shift;
+ BinarySource bs[1];
+ termline *ldata;
+
+ BinarySource_BARE_INIT(bs, line+1, line->len);
+
+ /*
+ * First read in the column count.
+ */
+ ncols = shift = 0;
+ do {
+ byte = get_byte(bs);
+ ncols |= (byte & 0x7F) << shift;
+ shift += 7;
+ } while (byte & 0x80);
+
+ /*
+ * Now create the output termline.
+ */
+ ldata = snew(termline);
+ ldata->chars = snewn(ncols, termchar);
+ ldata->cols = ldata->size = ncols;
+ ldata->temporary = true;
+ ldata->cc_free = 0;
+
+ /*
+ * We must set all the cc pointers in ldata->chars to 0 right
+ * now, so that cc diagnostics that verify the integrity of the
+ * whole line will make sense while we're in the middle of
+ * building it up.
+ */
+ {
+ int i;
+ for (i = 0; i < ldata->cols; i++)
+ ldata->chars[i].cc_next = 0;
+ }
+
+ /*
+ * Now read in the lattr.
+ */
+ int lattr = shift = 0;
+ do {
+ byte = get_byte(bs);
+ lattr |= (byte & 0x7F) << shift;
+ shift += 7;
+ } while (byte & 0x80);
+ ldata->lattr = lattr & 0xFFFF;
+ ldata->trusted = (lattr & 0x10000) != 0;
+
+ /*
+ * Now we read in each of the RLE streams in turn.
+ */
+ readrle(bs, ldata, readliteral_chr);
+ readrle(bs, ldata, readliteral_attr);
+ readrle(bs, ldata, readliteral_truecolour);
+ readrle(bs, ldata, readliteral_cc);
+
+ /* And we always expect that we ended up exactly at the end of the
+ * compressed data. */
+ assert(!get_err(bs));
+ assert(get_avail(bs) == 0);
+
+ return ldata;
+}
+
+/*
+ * Resize a line to make it `cols' columns wide.
+ */
+static void resizeline(Terminal *term, termline *line, int cols)
+{
+ int i, oldcols;
+
+ if (line->cols != cols) {
+
+ oldcols = line->cols;
+
+ /*
+ * This line is the wrong length, which probably means it
+ * hasn't been accessed since a resize. Resize it now.
+ *
+ * First, go through all the characters that will be thrown
+ * out in the resize (if we're shrinking the line) and
+ * return their cc lists to the cc free list.
+ */
+ for (i = cols; i < oldcols; i++)
+ clear_cc(line, i);
+
+ /*
+ * If we're shrinking the line, we now bodily move the
+ * entire cc section from where it started to where it now
+ * needs to be. (We have to do this before the resize, so
+ * that the data we're copying is still there. However, if
+ * we're expanding, we have to wait until _after_ the
+ * resize so that the space we're copying into is there.)
+ */
+ if (cols < oldcols)
+ memmove(line->chars + cols, line->chars + oldcols,
+ (line->size - line->cols) * TSIZE);
+
+ /*
+ * Now do the actual resize, leaving the _same_ amount of
+ * cc space as there was to begin with.
+ */
+ line->size += cols - oldcols;
+ line->chars = sresize(line->chars, line->size, TTYPE);
+ line->cols = cols;
+
+ /*
+ * If we're expanding the line, _now_ we move the cc
+ * section.
+ */
+ if (cols > oldcols)
+ memmove(line->chars + cols, line->chars + oldcols,
+ (line->size - line->cols) * TSIZE);
+
+ /*
+ * Go through what's left of the original line, and adjust
+ * the first cc_next pointer in each list. (All the
+ * subsequent ones are still valid because they are
+ * relative offsets within the cc block.) Also do the same
+ * to the head of the cc_free list.
+ */
+ for (i = 0; i < oldcols && i < cols; i++)
+ if (line->chars[i].cc_next)
+ line->chars[i].cc_next += cols - oldcols;
+ if (line->cc_free)
+ line->cc_free += cols - oldcols;
+
+ /*
+ * And finally fill in the new space with erase chars. (We
+ * don't have to worry about cc lists here, because we
+ * _know_ the erase char doesn't have one.)
+ */
+ for (i = oldcols; i < cols; i++)
+ line->chars[i] = term->basic_erase_char;
+
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
+ }
+}
+
+/*
+ * Get the number of lines in the scrollback.
+ */
+static int sblines(Terminal *term)
+{
+ int sblines = count234(term->scrollback);
+ if (term->erase_to_scrollback &&
+ term->alt_which && term->alt_screen) {
+ sblines += term->alt_sblines;
+ }
+ return sblines;
+}
+
+static void null_line_error(Terminal *term, int y, int lineno,
+ tree234 *whichtree, int treeindex,
+ const char *varname)
+{
+ modalfatalbox("%s==NULL in terminal.c\n"
+ "lineno=%d y=%d w=%d h=%d\n"
+ "count(scrollback=%p)=%d\n"
+ "count(screen=%p)=%d\n"
+ "count(alt=%p)=%d alt_sblines=%d\n"
+ "whichtree=%p treeindex=%d\n"
+ "commitid=%s\n\n"
+ "Please contact <putty@projects.tartarus.org> "
+ "and pass on the above information.",
+ varname, lineno, y, term->cols, term->rows,
+ term->scrollback, count234(term->scrollback),
+ term->screen, count234(term->screen),
+ term->alt_screen, count234(term->alt_screen),
+ term->alt_sblines, whichtree, treeindex, commitid);
+}
+
+/*
+ * Retrieve a line of the screen or of the scrollback, according to
+ * whether the y coordinate is non-negative or negative
+ * (respectively).
+ */
+static termline *lineptr(Terminal *term, int y, int lineno, int screen)
+{
+ termline *line;
+ tree234 *whichtree;
+ int treeindex;
+
+ if (y >= 0) {
+ whichtree = term->screen;
+ treeindex = y;
+ } else {
+ int altlines = 0;
+
+ assert(!screen);
+
+ if (term->erase_to_scrollback &&
+ term->alt_which && term->alt_screen) {
+ altlines = term->alt_sblines;
+ }
+ if (y < -altlines) {
+ whichtree = term->scrollback;
+ treeindex = y + altlines + count234(term->scrollback);
+ } else {
+ whichtree = term->alt_screen;
+ treeindex = y + term->alt_sblines;
+ /* treeindex = y + count234(term->alt_screen); */
+ }
+ }
+ if (whichtree == term->scrollback) {
+ compressed_scrollback_line *cline = index234(whichtree, treeindex);
+ if (!cline)
+ null_line_error(term, y, lineno, whichtree, treeindex, "cline");
+ line = decompressline(cline);
+ } else {
+ line = index234(whichtree, treeindex);
+ }
+
+ /* We assume that we don't screw up and retrieve something out of range. */
+ if (line == NULL)
+ null_line_error(term, y, lineno, whichtree, treeindex, "line");
+ assert(line != NULL);
+
+ /*
+ * Here we resize lines to _at least_ the right length, but we
+ * don't truncate them. Truncation is done as a side effect of
+ * modifying the line.
+ *
+ * The point of this policy is to try to arrange that resizing the
+ * terminal window repeatedly - e.g. successive steps in an X11
+ * opaque window-resize drag, or resizing as a side effect of
+ * retiling by tiling WMs such as xmonad - does not throw away
+ * data gratuitously. Specifically, we want a sequence of resize
+ * operations with no terminal output between them to have the
+ * same effect as a single resize to the ultimate terminal size,
+ * and also (for the case in which xmonad narrows a window that's
+ * scrolling things) we want scrolling up new text at the bottom
+ * of a narrowed window to avoid truncating lines further up when
+ * the window is re-widened.
+ */
+ if (term->cols > line->cols)
+ resizeline(term, line, term->cols);
+
+ return line;
+}
+
+#define lineptr(x) (lineptr)(term,x,__LINE__,0)
+#define scrlineptr(x) (lineptr)(term,x,__LINE__,1)
+
+/*
+ * Coerce a termline to the terminal's current width. Unlike the
+ * optional resize in lineptr() above, this is potentially destructive
+ * of text, since it can shrink as well as grow the line.
+ *
+ * We call this whenever a termline is actually going to be modified.
+ * Helpfully, putting a single call to this function in check_boundary
+ * deals with _nearly_ all such cases, leaving only a few things like
+ * bulk erase and ESC#8 to handle separately.
+ */
+static void check_line_size(Terminal *term, termline *line)
+{
+ if (term->cols != line->cols) /* trivial optimisation */
+ resizeline(term, line, term->cols);
+}
+
+static void term_schedule_tblink(Terminal *term);
+static void term_schedule_cblink(Terminal *term);
+static void term_update_callback(void *ctx);
+
+static void term_timer(void *ctx, unsigned long now)
+{
+ Terminal *term = (Terminal *)ctx;
+
+ if (term->tblink_pending && now == term->next_tblink) {
+ term->tblinker = !term->tblinker;
+ term->tblink_pending = false;
+ term_schedule_tblink(term);
+ term->window_update_pending = true;
+ }
+
+ if (term->cblink_pending && now == term->next_cblink) {
+ term->cblinker = !term->cblinker;
+ term->cblink_pending = false;
+ term_schedule_cblink(term);
+ term->window_update_pending = true;
+ }
+
+ if (term->in_vbell && now == term->vbell_end) {
+ term->in_vbell = false;
+ term->window_update_pending = true;
+ }
+
+ if (term->window_update_cooldown &&
+ now == term->window_update_cooldown_end) {
+ term->window_update_cooldown = false;
+ }
+
+ if (term->window_update_pending)
+ term_update_callback(term);
+}
+
+static void term_update_callback(void *ctx)
+{
+ Terminal *term = (Terminal *)ctx;
+ if (!term->window_update_pending)
+ return;
+ if (!term->window_update_cooldown) {
+ term_update(term);
+ term->window_update_cooldown = true;
+ term->window_update_cooldown_end = schedule_timer(
+ UPDATE_DELAY, term_timer, term);
+ }
+}
+
+static void term_schedule_update(Terminal *term)
+{
+ if (!term->window_update_pending) {
+ term->window_update_pending = true;
+ queue_toplevel_callback(term_update_callback, term);
+ }
+}
+
+/*
+ * Call this whenever the terminal window state changes, to queue
+ * an update.
+ */
+static void seen_disp_event(Terminal *term)
+{
+ term->seen_disp_event = true; /* for scrollback-reset-on-activity */
+ term_schedule_update(term);
+}
+
+/*
+ * Call when the terminal's blinking-text settings change, or when
+ * a text blink has just occurred.
+ */
+static void term_schedule_tblink(Terminal *term)
+{
+ if (term->blink_is_real) {
+ if (!term->tblink_pending)
+ term->next_tblink = schedule_timer(TBLINK_DELAY, term_timer, term);
+ term->tblink_pending = true;
+ } else {
+ term->tblinker = true; /* reset when not in use */
+ term->tblink_pending = false;
+ }
+}
+
+/*
+ * Likewise with cursor blinks.
+ */
+static void term_schedule_cblink(Terminal *term)
+{
+ if (term->blink_cur && term->has_focus) {
+ if (!term->cblink_pending)
+ term->next_cblink = schedule_timer(CBLINK_DELAY, term_timer, term);
+ term->cblink_pending = true;
+ } else {
+ term->cblinker = true; /* reset when not in use */
+ term->cblink_pending = false;
+ }
+}
+
+/*
+ * Call to reset cursor blinking on new output.
+ */
+static void term_reset_cblink(Terminal *term)
+{
+ seen_disp_event(term);
+ term->cblinker = true;
+ term->cblink_pending = false;
+ term_schedule_cblink(term);
+}
+
+/*
+ * Call to begin a visual bell.
+ */
+static void term_schedule_vbell(Terminal *term, bool already_started,
+ long startpoint)
+{
+ long ticks_already_gone;
+
+ if (already_started)
+ ticks_already_gone = GETTICKCOUNT() - startpoint;
+ else
+ ticks_already_gone = 0;
+
+ if (ticks_already_gone < VBELL_DELAY) {
+ term->in_vbell = true;
+ term->vbell_end = schedule_timer(VBELL_DELAY - ticks_already_gone,
+ term_timer, term);
+ } else {
+ term->in_vbell = false;
+ }
+}
+
+/*
+ * Set up power-on settings for the terminal.
+ * If 'clear' is false, don't actually clear the primary screen, and
+ * position the cursor below the last non-blank line (scrolling if
+ * necessary).
+ */
+static void power_on(Terminal *term, bool clear)
+{
+ term->alt_x = term->alt_y = 0;
+ term->savecurs.x = term->savecurs.y = 0;
+ term->alt_savecurs.x = term->alt_savecurs.y = 0;
+ term->alt_t = term->marg_t = 0;
+ if (term->rows != -1)
+ term->alt_b = term->marg_b = term->rows - 1;
+ else
+ term->alt_b = term->marg_b = 0;
+ if (term->cols != -1) {
+ int i;
+ for (i = 0; i < term->cols; i++)
+ term->tabs[i] = (i % 8 == 0 ? true : false);
+ }
+ term->alt_om = term->dec_om = conf_get_bool(term->conf, CONF_dec_om);
+ term->alt_ins = false;
+ term->insert = false;
+ term->alt_wnext = false;
+ term->wrapnext = false;
+ term->save_wnext = false;
+ term->alt_save_wnext = false;
+ term->alt_wrap = term->wrap = conf_get_bool(term->conf, CONF_wrap_mode);
+ term->alt_cset = term->cset = term->save_cset = term->alt_save_cset = 0;
+ term->alt_utf = false;
+ term->utf = false;
+ term->save_utf = false;
+ term->alt_save_utf = false;
+ term->utf8.state = 0;
+ term->alt_sco_acs = term->sco_acs =
+ term->save_sco_acs = term->alt_save_sco_acs = 0;
+ term->cset_attr[0] = term->cset_attr[1] =
+ term->save_csattr = term->alt_save_csattr = CSET_ASCII;
+ term->rvideo = false;
+ term->in_vbell = false;
+ term->cursor_on = true;
+ term->big_cursor = false;
+ term->default_attr = term->save_attr =
+ term->alt_save_attr = term->curr_attr = ATTR_DEFAULT;
+ term->curr_truecolour.fg = term->curr_truecolour.bg = optionalrgb_none;
+ term->save_truecolour = term->alt_save_truecolour = term->curr_truecolour;
+ term->app_cursor_keys = conf_get_bool(term->conf, CONF_app_cursor);
+ term->app_keypad_keys = conf_get_bool(term->conf, CONF_app_keypad);
+ term->use_bce = conf_get_bool(term->conf, CONF_bce);
+ term->blink_is_real = conf_get_bool(term->conf, CONF_blinktext);
+ term->erase_char = term->basic_erase_char;
+ term->alt_which = 0;
+ term_print_finish(term);
+ term->xterm_mouse = 0;
+ term->xterm_extended_mouse = false;
+ term->urxvt_extended_mouse = false;
+ win_set_raw_mouse_mode(term->win, false);
+ term->win_pointer_shape_pending = true;
+ term->win_pointer_shape_raw = false;
+ term->bracketed_paste = false;
+ term->srm_echo = false;
+ {
+ int i;
+ for (i = 0; i < 256; i++)
+ term->wordness[i] = conf_get_int_int(term->conf, CONF_wordness, i);
+ }
+ if (term->screen) {
+ swap_screen(term, 1, false, false);
+ erase_lots(term, false, true, true);
+ swap_screen(term, 0, false, false);
+ if (clear)
+ erase_lots(term, false, true, true);
+ term->curs.y = find_last_nonempty_line(term, term->screen) + 1;
+ if (term->curs.y == term->rows) {
+ term->curs.y--;
+ scroll(term, 0, term->rows - 1, 1, true);
+ }
+ } else {
+ term->curs.y = 0;
+ }
+ term->curs.x = 0;
+ term_schedule_tblink(term);
+ term_schedule_cblink(term);
+ term_schedule_update(term);
+}
+
+/*
+ * Force a screen update.
+ */
+void term_update(Terminal *term)
+{
+ term->window_update_pending = false;
+
+ if (term->win_move_pending) {
+ win_move(term->win, term->win_move_pending_x,
+ term->win_move_pending_y);
+ term->win_move_pending = false;
+ }
+ if (term->win_resize_pending == WIN_RESIZE_NEED_SEND) {
+ term->win_resize_pending = WIN_RESIZE_AWAIT_REPLY;
+ win_request_resize(term->win, term->win_resize_pending_w,
+ term->win_resize_pending_h);
+ }
+ if (term->win_zorder_pending) {
+ win_set_zorder(term->win, term->win_zorder_top);
+ term->win_zorder_pending = false;
+ }
+ if (term->win_minimise_pending) {
+ win_set_minimised(term->win, term->win_minimise_enable);
+ term->win_minimise_pending = false;
+ }
+ if (term->win_maximise_pending) {
+ win_set_maximised(term->win, term->win_maximise_enable);
+ term->win_maximise_pending = false;
+ }
+ if (term->win_title_pending) {
+ win_set_title(term->win, term->window_title,
+ term->wintitle_codepage);
+ term->win_title_pending = false;
+ }
+ if (term->win_icon_title_pending) {
+ win_set_icon_title(term->win, term->icon_title,
+ term->icontitle_codepage);
+ term->win_icon_title_pending = false;
+ }
+ if (term->win_pointer_shape_pending) {
+ win_set_raw_mouse_mode_pointer(term->win, term->win_pointer_shape_raw);
+ term->win_pointer_shape_pending = false;
+ }
+ if (term->win_refresh_pending) {
+ win_refresh(term->win);
+ term->win_refresh_pending = false;
+ }
+ if (term->win_palette_pending) {
+ unsigned start = term->win_palette_pending_min;
+ unsigned ncolours = term->win_palette_pending_limit - start;
+ win_palette_set(term->win, start, ncolours, term->palette + start);
+ term->win_palette_pending = false;
+ }
+
+ if (win_setup_draw_ctx(term->win)) {
+ bool need_sbar_update = term->seen_disp_event ||
+ term->win_scrollbar_update_pending;
+ term->win_scrollbar_update_pending = false;
+ if (term->seen_disp_event && term->scroll_on_disp) {
+ term->disptop = 0; /* return to main screen */
+ term->seen_disp_event = false;
+ need_sbar_update = true;
+ }
+
+ if (need_sbar_update)
+ update_sbar(term);
+ do_paint(term);
+ win_set_cursor_pos(
+ term->win, term->curs.x, term->curs.y - term->disptop);
+ win_free_draw_ctx(term->win);
+ }
+}
+
+/*
+ * Called from front end when a keypress occurs, to trigger
+ * anything magical that needs to happen in that situation.
+ */
+void term_seen_key_event(Terminal *term)
+{
+ /*
+ * On any keypress, clear the bell overload mechanism
+ * completely, on the grounds that large numbers of
+ * beeps coming from deliberate key action are likely
+ * to be intended (e.g. beeps from filename completion
+ * blocking repeatedly).
+ */
+ term->beep_overloaded = false;
+ while (term->beephead) {
+ struct beeptime *tmp = term->beephead;
+ term->beephead = tmp->next;
+ sfree(tmp);
+ }
+ term->beeptail = NULL;
+ term->nbeeps = 0;
+
+ /*
+ * Reset the scrollback on keypress, if we're doing that.
+ */
+ if (term->scroll_on_key) {
+ term->disptop = 0; /* return to main screen */
+ seen_disp_event(term);
+ }
+}
+
+/*
+ * Same as power_on(), but an external function.
+ */
+void term_pwron(Terminal *term, bool clear)
+{
+ power_on(term, clear);
+ if (term->ldisc) /* cause ldisc to notice changes */
+ ldisc_echoedit_update(term->ldisc);
+ term->disptop = 0;
+ deselect(term);
+ term_update(term);
+}
+
+static void set_erase_char(Terminal *term)
+{
+ term->erase_char = term->basic_erase_char;
+ if (term->use_bce) {
+ term->erase_char.attr = (term->curr_attr &
+ (ATTR_FGMASK | ATTR_BGMASK));
+ term->erase_char.truecolour.bg = term->curr_truecolour.bg;
+ }
+}
+
+/*
+ * We copy a bunch of stuff out of the Conf structure into local
+ * fields in the Terminal structure, to avoid the repeated tree234
+ * lookups which would be involved in fetching them from the former
+ * every time.
+ */
+static void term_copy_stuff_from_conf(Terminal *term)
+{
+ term->ansi_colour = conf_get_bool(term->conf, CONF_ansi_colour);
+ term->no_arabicshaping = conf_get_bool(term->conf, CONF_no_arabicshaping);
+ term->beep = conf_get_int(term->conf, CONF_beep);
+ term->bellovl = conf_get_bool(term->conf, CONF_bellovl);
+ term->bellovl_n = conf_get_int(term->conf, CONF_bellovl_n);
+ term->bellovl_s = conf_get_int(term->conf, CONF_bellovl_s);
+ term->bellovl_t = conf_get_int(term->conf, CONF_bellovl_t);
+ term->no_bidi = conf_get_bool(term->conf, CONF_no_bidi);
+ term->bksp_is_delete = conf_get_bool(term->conf, CONF_bksp_is_delete);
+ term->blink_cur = conf_get_bool(term->conf, CONF_blink_cur);
+ term->blinktext = conf_get_bool(term->conf, CONF_blinktext);
+ term->cjk_ambig_wide = conf_get_bool(term->conf, CONF_cjk_ambig_wide);
+ term->conf_height = conf_get_int(term->conf, CONF_height);
+ term->conf_width = conf_get_int(term->conf, CONF_width);
+ term->crhaslf = conf_get_bool(term->conf, CONF_crhaslf);
+ term->erase_to_scrollback = conf_get_bool(term->conf, CONF_erase_to_scrollback);
+ term->funky_type = conf_get_int(term->conf, CONF_funky_type);
+ term->sharrow_type = conf_get_int(term->conf, CONF_sharrow_type);
+ term->lfhascr = conf_get_bool(term->conf, CONF_lfhascr);
+ term->logflush = conf_get_bool(term->conf, CONF_logflush);
+ term->logtype = conf_get_int(term->conf, CONF_logtype);
+ term->mouse_override = conf_get_bool(term->conf, CONF_mouse_override);
+ term->nethack_keypad = conf_get_bool(term->conf, CONF_nethack_keypad);
+ term->no_alt_screen = conf_get_bool(term->conf, CONF_no_alt_screen);
+ term->no_applic_c = conf_get_bool(term->conf, CONF_no_applic_c);
+ term->no_applic_k = conf_get_bool(term->conf, CONF_no_applic_k);
+ term->no_dbackspace = conf_get_bool(term->conf, CONF_no_dbackspace);
+ term->no_mouse_rep = conf_get_bool(term->conf, CONF_no_mouse_rep);
+ term->no_remote_charset = conf_get_bool(term->conf, CONF_no_remote_charset);
+ term->no_remote_resize = conf_get_bool(term->conf, CONF_no_remote_resize);
+ term->no_remote_wintitle = conf_get_bool(term->conf, CONF_no_remote_wintitle);
+ term->no_remote_clearscroll = conf_get_bool(term->conf, CONF_no_remote_clearscroll);
+ term->rawcnp = conf_get_bool(term->conf, CONF_rawcnp);
+ term->utf8linedraw = conf_get_bool(term->conf, CONF_utf8linedraw);
+ term->rect_select = conf_get_bool(term->conf, CONF_rect_select);
+ term->remote_qtitle_action = conf_get_int(term->conf, CONF_remote_qtitle_action);
+ term->rxvt_homeend = conf_get_bool(term->conf, CONF_rxvt_homeend);
+ term->scroll_on_disp = conf_get_bool(term->conf, CONF_scroll_on_disp);
+ term->scroll_on_key = conf_get_bool(term->conf, CONF_scroll_on_key);
+ term->xterm_mouse_forbidden = conf_get_bool(term->conf, CONF_no_mouse_rep);
+ term->xterm_256_colour = conf_get_bool(term->conf, CONF_xterm_256_colour);
+ term->true_colour = conf_get_bool(term->conf, CONF_true_colour);
+
+ /*
+ * Parse the control-character escapes in the configured
+ * answerback string.
+ */
+ {
+ char *answerback = conf_get_str(term->conf, CONF_answerback);
+ int maxlen = strlen(answerback);
+
+ term->answerback = snewn(maxlen, char);
+ term->answerbacklen = 0;
+
+ while (*answerback) {
+ char *n;
+ char c = ctrlparse(answerback, &n);
+ if (n) {
+ term->answerback[term->answerbacklen++] = c;
+ answerback = n;
+ } else {
+ term->answerback[term->answerbacklen++] = *answerback++;
+ }
+ }
+ }
+}
+
+void term_pre_reconfig(Terminal *term, Conf *conf)
+{
+
+ /*
+ * Copy the current window title into the stored previous
+ * configuration, so that doing nothing to the window title field
+ * in the config box doesn't reset the title to its startup state.
+ */
+ conf_set_str(conf, CONF_wintitle, term->window_title);
+}
+
+/*
+ * When the user reconfigures us, we need to check the forbidden-
+ * alternate-screen config option, disable raw mouse mode if the
+ * user has disabled mouse reporting, and abandon a print job if
+ * the user has disabled printing.
+ */
+void term_reconfig(Terminal *term, Conf *conf)
+{
+ /*
+ * Before adopting the new config, check all those terminal
+ * settings which control power-on defaults; and if they've
+ * changed, we will modify the current state as well as the
+ * default one. The full list is: Auto wrap mode, DEC Origin
+ * Mode, BCE, blinking text, character classes.
+ */
+ bool reset_wrap, reset_decom, reset_bce, reset_tblink, reset_charclass;
+ bool palette_changed = false;
+ int i;
+
+ reset_wrap = (conf_get_bool(term->conf, CONF_wrap_mode) !=
+ conf_get_bool(conf, CONF_wrap_mode));
+ reset_decom = (conf_get_bool(term->conf, CONF_dec_om) !=
+ conf_get_bool(conf, CONF_dec_om));
+ reset_bce = (conf_get_bool(term->conf, CONF_bce) !=
+ conf_get_bool(conf, CONF_bce));
+ reset_tblink = (conf_get_bool(term->conf, CONF_blinktext) !=
+ conf_get_bool(conf, CONF_blinktext));
+ reset_charclass = false;
+ for (i = 0; i < 256; i++)
+ if (conf_get_int_int(term->conf, CONF_wordness, i) !=
+ conf_get_int_int(conf, CONF_wordness, i))
+ reset_charclass = true;
+
+ /*
+ * If the bidi or shaping settings have changed, flush the bidi
+ * cache completely.
+ */
+ if (conf_get_bool(term->conf, CONF_no_arabicshaping) !=
+ conf_get_bool(conf, CONF_no_arabicshaping) ||
+ conf_get_bool(term->conf, CONF_no_bidi) !=
+ conf_get_bool(conf, CONF_no_bidi)) {
+ for (i = 0; i < term->bidi_cache_size; i++) {
+ sfree(term->pre_bidi_cache[i].chars);
+ sfree(term->post_bidi_cache[i].chars);
+ term->pre_bidi_cache[i].width = -1;
+ term->pre_bidi_cache[i].chars = NULL;
+ term->post_bidi_cache[i].width = -1;
+ term->post_bidi_cache[i].chars = NULL;
+ }
+ }
+
+ {
+ const char *old_title = conf_get_str(term->conf, CONF_wintitle);
+ const char *new_title = conf_get_str(conf, CONF_wintitle);
+ if (strcmp(old_title, new_title)) {
+ sfree(term->window_title);
+ term->window_title = dupstr(new_title);
+ term->wintitle_codepage = DEFAULT_CODEPAGE;
+ term->win_title_pending = true;
+ term_schedule_update(term);
+ }
+ }
+
+ /*
+ * Just setting conf is sufficient to cause colour setting changes
+ * to appear on the next ESC]R palette reset. But we should also
+ * check whether any colour settings have been changed, so that
+ * they can be updated immediately if they haven't been overridden
+ * by some escape sequence.
+ */
+ {
+ int i, j;
+ for (i = 0; i < CONF_NCOLOURS; i++) {
+ for (j = 0; j < 3; j++)
+ if (conf_get_int_int(term->conf, CONF_colours, i*3+j) !=
+ conf_get_int_int(conf, CONF_colours, i*3+j))
+ break;
+ if (j < 3) {
+ /* Actually enacting the change has to be deferred
+ * until the new conf is installed. */
+ palette_changed = true;
+ break;
+ }
+ }
+ }
+
+ conf_free(term->conf);
+ term->conf = conf_copy(conf);
+
+ if (reset_wrap)
+ term->alt_wrap = term->wrap = conf_get_bool(term->conf, CONF_wrap_mode);
+ if (reset_decom)
+ term->alt_om = term->dec_om = conf_get_bool(term->conf, CONF_dec_om);
+ if (reset_bce) {
+ term->use_bce = conf_get_bool(term->conf, CONF_bce);
+ set_erase_char(term);
+ }
+ if (reset_tblink) {
+ term->blink_is_real = conf_get_bool(term->conf, CONF_blinktext);
+ }
+ if (reset_charclass)
+ for (i = 0; i < 256; i++)
+ term->wordness[i] = conf_get_int_int(term->conf, CONF_wordness, i);
+
+ if (conf_get_bool(term->conf, CONF_no_alt_screen))
+ swap_screen(term, 0, false, false);
+ if (conf_get_bool(term->conf, CONF_no_remote_charset)) {
+ term->cset_attr[0] = term->cset_attr[1] = CSET_ASCII;
+ term->sco_acs = term->alt_sco_acs = 0;
+ term->utf = false;
+ }
+ if (!conf_get_str(term->conf, CONF_printer)) {
+ term_print_finish(term);
+ }
+ if (palette_changed)
+ term_notify_palette_changed(term);
+ term_schedule_tblink(term);
+ term_schedule_cblink(term);
+ term_copy_stuff_from_conf(term);
+ term_update_raw_mouse_mode(term);
+}
+
+/*
+ * Clear the scrollback.
+ */
+void term_clrsb(Terminal *term)
+{
+ unsigned char *line;
+ int i;
+
+ /*
+ * Scroll forward to the current screen, if we were back in the
+ * scrollback somewhere until now.
+ */
+ term->disptop = 0;
+
+ /*
+ * Clear the actual scrollback.
+ */
+ while ((line = delpos234(term->scrollback, 0)) != NULL) {
+ sfree(line); /* this is compressed data, not a termline */
+ }
+
+ /*
+ * When clearing the scrollback, we also truncate any termlines on
+ * the current screen which have remembered data from a previous
+ * larger window size. Rationale: clearing the scrollback is
+ * sometimes done to protect privacy, so the user intention is
+ * specifically that we should not retain evidence of what
+ * previously happened in the terminal, and that ought to include
+ * evidence to the right as well as evidence above.
+ */
+ for (i = 0; i < term->rows; i++)
+ check_line_size(term, scrlineptr(i));
+
+ /*
+ * That operation has invalidated the selection, if it overlapped
+ * the scrollback at all.
+ */
+ if (term->selstate != NO_SELECTION && term->selstart.y < 0)
+ deselect(term);
+
+ /*
+ * There are now no lines of real scrollback which can be pulled
+ * back into the screen by a resize, and no lines of the alternate
+ * screen which should be displayed as if part of the scrollback.
+ */
+ term->tempsblines = 0;
+ term->alt_sblines = 0;
+
+ /*
+ * The scrollbar will need updating to reflect the new state of
+ * the world.
+ */
+ term->win_scrollbar_update_pending = true;
+ term_schedule_update(term);
+}
+
+const optionalrgb optionalrgb_none = {0, 0, 0, 0};
+
+void term_setup_window_titles(Terminal *term, const char *title_hostname)
+{
+ const char *conf_title = conf_get_str(term->conf, CONF_wintitle);
+ sfree(term->window_title);
+ sfree(term->icon_title);
+ if (*conf_title) {
+ term->window_title = dupstr(conf_title);
+ term->icon_title = dupstr(conf_title);
+ } else {
+ if (title_hostname && *title_hostname)
+ term->window_title = dupcat(title_hostname, " - ", appname);
+ else
+ term->window_title = dupstr(appname);
+ term->icon_title = dupstr(term->window_title);
+ }
+ term->wintitle_codepage = term->icontitle_codepage = DEFAULT_CODEPAGE;
+ term->win_title_pending = true;
+ term->win_icon_title_pending = true;
+}
+
+static void palette_rebuild(Terminal *term)
+{
+ unsigned min_changed = OSC4_NCOLOURS, max_changed = 0;
+
+ if (term->win_palette_pending) {
+ /* Possibly extend existing range. */
+ min_changed = term->win_palette_pending_min;
+ max_changed = term->win_palette_pending_limit - 1;
+ } else {
+ /* Start with empty range. */
+ min_changed = OSC4_NCOLOURS;
+ max_changed = 0;
+ }
+
+ for (unsigned i = 0; i < OSC4_NCOLOURS; i++) {
+ rgb new_value;
+ bool found = false;
+
+ for (unsigned j = lenof(term->subpalettes); j-- > 0 ;) {
+ if (term->subpalettes[j].present[i]) {
+ new_value = term->subpalettes[j].values[i];
+ found = true;
+ break;
+ }
+ }
+
+ assert(found); /* we expect SUBPAL_CONF to always be set */
+
+ if (new_value.r != term->palette[i].r ||
+ new_value.g != term->palette[i].g ||
+ new_value.b != term->palette[i].b) {
+ term->palette[i] = new_value;
+ if (min_changed > i)
+ min_changed = i;
+ if (max_changed < i)
+ max_changed = i;
+ }
+ }
+
+ if (min_changed <= max_changed) {
+ /*
+ * At least one colour changed (or we had an update scheduled
+ * already). Schedule a redraw event to pass the result back
+ * to the TermWin. This also requires invalidating the rest
+ * of the window, because usually all the text will need
+ * redrawing in the new colours.
+ * (If there was an update pending and this palette rebuild
+ * didn't actually change anything, we'll harmlessly reinforce
+ * the existing update request.)
+ */
+ term->win_palette_pending = true;
+ term->win_palette_pending_min = min_changed;
+ term->win_palette_pending_limit = max_changed + 1;
+ term_invalidate(term);
+ }
+}
+
+/*
+ * Rebuild the palette from configuration and platform colours.
+ * If 'keep_overrides' set, any escape-sequence-specified overrides will
+ * remain in place.
+ */
+static void palette_reset(Terminal *term, bool keep_overrides)
+{
+ for (unsigned i = 0; i < OSC4_NCOLOURS; i++)
+ term->subpalettes[SUBPAL_CONF].present[i] = true;
+
+ /*
+ * Copy all the palette information out of the Conf.
+ */
+ for (unsigned i = 0; i < CONF_NCOLOURS; i++) {
+ rgb *col = &term->subpalettes[SUBPAL_CONF].values[
+ colour_indices_conf_to_osc4[i]];
+ col->r = conf_get_int_int(term->conf, CONF_colours, i*3+0);
+ col->g = conf_get_int_int(term->conf, CONF_colours, i*3+1);
+ col->b = conf_get_int_int(term->conf, CONF_colours, i*3+2);
+ }
+
+ /*
+ * Directly invent the rest of the xterm-256 colours.
+ */
+ for (unsigned i = 0; i < 216; i++) {
+ rgb *col = &term->subpalettes[SUBPAL_CONF].values[i + 16];
+ int r = i / 36, g = (i / 6) % 6, b = i % 6;
+ col->r = r ? r * 40 + 55 : 0;
+ col->g = g ? g * 40 + 55 : 0;
+ col->b = b ? b * 40 + 55 : 0;
+ }
+ for (unsigned i = 0; i < 24; i++) {
+ rgb *col = &term->subpalettes[SUBPAL_CONF].values[i + 232];
+ int shade = i * 10 + 8;
+ col->r = col->g = col->b = shade;
+ }
+
+ /*
+ * Re-fetch any OS-local overrides.
+ */
+ for (unsigned i = 0; i < OSC4_NCOLOURS; i++)
+ term->subpalettes[SUBPAL_PLATFORM].present[i] = false;
+ win_palette_get_overrides(term->win, term);
+
+ if (!keep_overrides) {
+ /*
+ * Get rid of all escape-sequence configuration.
+ */
+ for (unsigned i = 0; i < OSC4_NCOLOURS; i++)
+ term->subpalettes[SUBPAL_SESSION].present[i] = false;
+ }
+
+ /*
+ * Rebuild the composite palette.
+ */
+ palette_rebuild(term);
+}
+
+void term_palette_override(Terminal *term, unsigned osc4_index, rgb rgb)
+{
+ /*
+ * We never expect to be called except as re-entry from our own
+ * call to win_palette_get_overrides above, so we need not mess
+ * about calling palette_rebuild.
+ */
+ term->subpalettes[SUBPAL_PLATFORM].present[osc4_index] = true;
+ term->subpalettes[SUBPAL_PLATFORM].values[osc4_index] = rgb;
+}
+
+/*
+ * Initialise the terminal.
+ */
+Terminal *term_init(Conf *myconf, struct unicode_data *ucsdata, TermWin *win)
+{
+ Terminal *term;
+
+ /*
+ * Allocate a new Terminal structure and initialise the fields
+ * that need it.
+ */
+ term = snew(Terminal);
+ term->win = win;
+ term->ucsdata = ucsdata;
+ term->conf = conf_copy(myconf);
+ term->logctx = NULL;
+ term->compatibility_level = TM_PUTTY;
+ strcpy(term->id_string, "\033[?6c");
+ term->cblink_pending = term->tblink_pending = false;
+ term->paste_buffer = NULL;
+ term->paste_len = 0;
+ bufchain_init(&term->inbuf);
+ bufchain_init(&term->printer_buf);
+ term->printing = term->only_printing = false;
+ term->print_job = NULL;
+ term->vt52_mode = false;
+ term->cr_lf_return = false;
+ term->seen_disp_event = false;
+ term->mouse_is_down = 0;
+ term->reset_132 = false;
+ term->cblinker = false;
+ term->tblinker = false;
+ term->has_focus = true;
+ term->repeat_off = false;
+ term->termstate = TOPLEVEL;
+ term->selstate = NO_SELECTION;
+ term->curstype = 0;
+
+ term_copy_stuff_from_conf(term);
+
+ term->screen = term->alt_screen = term->scrollback = NULL;
+ term->tempsblines = 0;
+ term->alt_sblines = 0;
+ term->disptop = 0;
+ term->disptext = NULL;
+ term->dispcursx = term->dispcursy = -1;
+ term->tabs = NULL;
+ deselect(term);
+ term->rows = term->cols = -1;
+ power_on(term, true);
+ term->beephead = term->beeptail = NULL;
+ term->nbeeps = 0;
+ term->lastbeep = false;
+ term->beep_overloaded = false;
+ term->attr_mask = 0xffffffff;
+ term->backend = NULL;
+ term->in_term_out = false;
+ term->ltemp = NULL;
+ term->ltemp_size = 0;
+ term->wcFrom = NULL;
+ term->wcTo = NULL;
+ term->wcFromTo_size = 0;
+
+ term->window_update_pending = false;
+ term->window_update_cooldown = false;
+
+ term->bidi_cache_size = 0;
+ term->pre_bidi_cache = term->post_bidi_cache = NULL;
+
+ /* FULL-TERMCHAR */
+ term->basic_erase_char.chr = CSET_ASCII | ' ';
+ term->basic_erase_char.attr = ATTR_DEFAULT;
+ term->basic_erase_char.cc_next = 0;
+ term->basic_erase_char.truecolour.fg = optionalrgb_none;
+ term->basic_erase_char.truecolour.bg = optionalrgb_none;
+ term->erase_char = term->basic_erase_char;
+
+ term->last_selected_text = NULL;
+ term->last_selected_attr = NULL;
+ term->last_selected_tc = NULL;
+ term->last_selected_len = 0;
+ /* TermWin implementations will typically extend these with
+ * clipboard ids they know about */
+ term->mouse_select_clipboards[0] = CLIP_LOCAL;
+ term->n_mouse_select_clipboards = 1;
+ term->mouse_paste_clipboard = CLIP_NULL;
+
+ term->last_graphic_char = 0;
+
+ term->trusted = true;
+
+ term->bracketed_paste_active = false;
+
+ term->window_title = dupstr("");
+ term->icon_title = dupstr("");
+ term->wintitle_codepage = term->icontitle_codepage = DEFAULT_CODEPAGE;
+ term->minimised = false;
+ term->winpos_x = term->winpos_y = 0;
+ term->winpixsize_x = term->winpixsize_y = 0;
+
+ term->win_move_pending = false;
+ term->win_resize_pending = WIN_RESIZE_NO;
+ term->win_zorder_pending = false;
+ term->win_minimise_pending = false;
+ term->win_maximise_pending = false;
+ term->win_title_pending = false;
+ term->win_icon_title_pending = false;
+ term->win_pointer_shape_pending = false;
+ term->win_refresh_pending = false;
+ term->win_scrollbar_update_pending = false;
+ term->win_palette_pending = false;
+
+ term->bidi_ctx = bidi_new_context();
+
+ palette_reset(term, false);
+
+ return term;
+}
+
+void term_free(Terminal *term)
+{
+ termline *line;
+ struct beeptime *beep;
+ int i;
+
+ while ((line = delpos234(term->scrollback, 0)) != NULL)
+ sfree(line); /* compressed data, not a termline */
+ freetree234(term->scrollback);
+ while ((line = delpos234(term->screen, 0)) != NULL)
+ freetermline(line);
+ freetree234(term->screen);
+ while ((line = delpos234(term->alt_screen, 0)) != NULL)
+ freetermline(line);
+ freetree234(term->alt_screen);
+ if (term->disptext) {
+ for (i = 0; i < term->rows; i++)
+ freetermline(term->disptext[i]);
+ }
+ sfree(term->disptext);
+ while (term->beephead) {
+ beep = term->beephead;
+ term->beephead = beep->next;
+ sfree(beep);
+ }
+ bufchain_clear(&term->inbuf);
+ if(term->print_job)
+ printer_finish_job(term->print_job);
+ bufchain_clear(&term->printer_buf);
+ sfree(term->paste_buffer);
+ sfree(term->ltemp);
+ sfree(term->wcFrom);
+ sfree(term->wcTo);
+ sfree(term->answerback);
+
+ for (i = 0; i < term->bidi_cache_size; i++) {
+ sfree(term->pre_bidi_cache[i].chars);
+ sfree(term->post_bidi_cache[i].chars);
+ sfree(term->post_bidi_cache[i].forward);
+ sfree(term->post_bidi_cache[i].backward);
+ }
+ sfree(term->pre_bidi_cache);
+ sfree(term->post_bidi_cache);
+
+ sfree(term->tabs);
+
+ expire_timer_context(term);
+ delete_callbacks_for_context(term);
+
+ conf_free(term->conf);
+
+ sfree(term->window_title);
+ sfree(term->icon_title);
+
+ bidi_free_context(term->bidi_ctx);
+
+ sfree(term);
+}
+
+void term_set_trust_status(Terminal *term, bool trusted)
+{
+ term->trusted = trusted;
+}
+
+void term_get_cursor_position(Terminal *term, int *x, int *y)
+{
+ *x = term->curs.x;
+ *y = term->curs.y;
+}
+
+/*
+ * Set up the terminal for a given size.
+ */
+void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
+{
+ tree234 *newalt;
+ termline **newdisp, *line;
+ int i, j, oldrows = term->rows;
+ int sblen;
+ int save_alt_which = term->alt_which;
+
+ if (newrows == term->rows && newcols == term->cols &&
+ newsavelines == term->savelines)
+ return; /* nothing to do */
+
+ /* Behave sensibly if we're given zero (or negative) rows/cols */
+
+ if (newrows < 1) newrows = 1;
+ if (newcols < 1) newcols = 1;
+
+ deselect(term);
+ swap_screen(term, 0, false, false);
+
+ term->alt_t = term->marg_t = 0;
+ term->alt_b = term->marg_b = newrows - 1;
+
+ if (term->rows == -1) {
+ term->scrollback = newtree234(NULL);
+ term->screen = newtree234(NULL);
+ term->tempsblines = 0;
+ term->rows = 0;
+ }
+
+ /*
+ * Resize the screen and scrollback. We only need to shift
+ * lines around within our data structures, because lineptr()
+ * will take care of resizing each individual line if
+ * necessary. So:
+ *
+ * - If the new screen is longer, we shunt lines in from temporary
+ * scrollback if possible, otherwise we add new blank lines at
+ * the bottom.
+ *
+ * - If the new screen is shorter, we remove any blank lines at
+ * the bottom if possible, otherwise shunt lines above the cursor
+ * to scrollback if possible, otherwise delete lines below the
+ * cursor.
+ *
+ * - Then, if the new scrollback length is less than the
+ * amount of scrollback we actually have, we must throw some
+ * away.
+ */
+ sblen = count234(term->scrollback);
+ /* Do this loop to expand the screen if newrows > rows */
+ assert(term->rows == count234(term->screen));
+ while (term->rows < newrows) {
+ if (term->tempsblines > 0) {
+ compressed_scrollback_line *cline;
+ /* Insert a line from the scrollback at the top of the screen. */
+ assert(sblen >= term->tempsblines);
+ cline = delpos234(term->scrollback, --sblen);
+ line = decompressline(cline);
+ sfree(cline);
+ line->temporary = false; /* reconstituted line is now real */
+ term->tempsblines -= 1;
+ addpos234(term->screen, line, 0);
+ term->curs.y += 1;
+ term->savecurs.y += 1;
+ term->alt_y += 1;
+ term->alt_savecurs.y += 1;
+ } else {
+ /* Add a new blank line at the bottom of the screen. */
+ line = newtermline(term, newcols, false);
+ addpos234(term->screen, line, count234(term->screen));
+ }
+ term->rows += 1;
+ }
+ /* Do this loop to shrink the screen if newrows < rows */
+ while (term->rows > newrows) {
+ if (term->curs.y < term->rows - 1) {
+ /* delete bottom row, unless it contains the cursor */
+ line = delpos234(term->screen, term->rows - 1);
+ freetermline(line);
+ } else {
+ /* push top row to scrollback */
+ line = delpos234(term->screen, 0);
+ addpos234(term->scrollback, compressline(line), sblen++);
+ freetermline(line);
+ term->tempsblines += 1;
+ term->curs.y -= 1;
+ term->savecurs.y -= 1;
+ term->alt_y -= 1;
+ term->alt_savecurs.y -= 1;
+ }
+ term->rows -= 1;
+ }
+ assert(term->rows == newrows);
+ assert(count234(term->screen) == newrows);
+
+ /* Delete any excess lines from the scrollback. */
+ while (sblen > newsavelines) {
+ line = delpos234(term->scrollback, 0);
+ sfree(line);
+ sblen--;
+ }
+ if (sblen < term->tempsblines)
+ term->tempsblines = sblen;
+ assert(count234(term->scrollback) <= newsavelines);
+ assert(count234(term->scrollback) >= term->tempsblines);
+ term->disptop = 0;
+
+ /* Make a new displayed text buffer. */
+ newdisp = snewn(newrows, termline *);
+ for (i = 0; i < newrows; i++) {
+ newdisp[i] = newtermline(term, newcols, false);
+ for (j = 0; j < newcols; j++)
+ newdisp[i]->chars[j].attr = ATTR_INVALID;
+ }
+ if (term->disptext) {
+ for (i = 0; i < oldrows; i++)
+ freetermline(term->disptext[i]);
+ }
+ sfree(term->disptext);
+ term->disptext = newdisp;
+ term->dispcursx = term->dispcursy = -1;
+
+ /* Make a new alternate screen. */
+ newalt = newtree234(NULL);
+ for (i = 0; i < newrows; i++) {
+ line = newtermline(term, newcols, true);
+ addpos234(newalt, line, i);
+ }
+ if (term->alt_screen) {
+ while (NULL != (line = delpos234(term->alt_screen, 0)))
+ freetermline(line);
+ freetree234(term->alt_screen);
+ }
+ term->alt_screen = newalt;
+ term->alt_sblines = 0;
+
+ term->tabs = sresize(term->tabs, newcols, unsigned char);
+ {
+ int i;
+ for (i = (term->cols > 0 ? term->cols : 0); i < newcols; i++)
+ term->tabs[i] = (i % 8 == 0 ? true : false);
+ }
+
+ /* Check that the cursor positions are still valid. */
+ if (term->savecurs.y < 0)
+ term->savecurs.y = 0;
+ if (term->savecurs.y >= newrows)
+ term->savecurs.y = newrows - 1;
+ if (term->savecurs.x >= newcols)
+ term->savecurs.x = newcols - 1;
+ if (term->alt_savecurs.y < 0)
+ term->alt_savecurs.y = 0;
+ if (term->alt_savecurs.y >= newrows)
+ term->alt_savecurs.y = newrows - 1;
+ if (term->alt_savecurs.x >= newcols)
+ term->alt_savecurs.x = newcols - 1;
+ if (term->curs.y < 0)
+ term->curs.y = 0;
+ if (term->curs.y >= newrows)
+ term->curs.y = newrows - 1;
+ if (term->curs.x >= newcols)
+ term->curs.x = newcols - 1;
+ if (term->alt_y < 0)
+ term->alt_y = 0;
+ if (term->alt_y >= newrows)
+ term->alt_y = newrows - 1;
+ if (term->alt_x >= newcols)
+ term->alt_x = newcols - 1;
+ term->alt_x = term->alt_y = 0;
+ term->wrapnext = false;
+ term->alt_wnext = false;
+
+ term->rows = newrows;
+ term->cols = newcols;
+ term->savelines = newsavelines;
+
+ swap_screen(term, save_alt_which, false, false);
+
+ term->win_scrollbar_update_pending = true;
+ term_schedule_update(term);
+ if (term->backend)
+ backend_size(term->backend, term->cols, term->rows);
+}
+
+void term_resize_request_completed(Terminal *term)
+{
+ assert(term->win_resize_pending == WIN_RESIZE_AWAIT_REPLY);
+ term->win_resize_pending = WIN_RESIZE_NO;
+ queue_toplevel_callback(term_out_cb, term);
+}
+
+/*
+ * Hand a backend to the terminal, so it can be notified of resizes.
+ */
+void term_provide_backend(Terminal *term, Backend *backend)
+{
+ term->backend = backend;
+ if (term->backend && term->cols > 0 && term->rows > 0)
+ backend_size(term->backend, term->cols, term->rows);
+}
+
+/* Find the bottom line on the screen that has any content.
+ * If only the top line has content, returns 0.
+ * If no lines have content, return -1.
+ */
+static int find_last_nonempty_line(Terminal *term, tree234 *screen)
+{
+ int i;
+ for (i = count234(screen) - 1; i >= 0; i--) {
+ termline *line = index234(screen, i);
+ int j;
+ for (j = 0; j < line->cols; j++)
+ if (!termchars_equal(&line->chars[j], &term->erase_char))
+ break;
+ if (j != line->cols) break;
+ }
+ return i;
+}
+
+/*
+ * Swap screens. If `reset' is true and we have been asked to
+ * switch to the alternate screen, we must bring most of its
+ * configuration from the main screen and erase the contents of the
+ * alternate screen completely. (This is even true if we're already
+ * on it! Blame xterm.)
+ */
+static void swap_screen(Terminal *term, int which,
+ bool reset, bool keep_cur_pos)
+{
+ int t;
+ bool bt;
+ pos tp;
+ truecolour ttc;
+ tree234 *ttr;
+
+ if (!which)
+ reset = false; /* do no weird resetting if which==0 */
+
+ if (which != term->alt_which) {
+ if (term->erase_to_scrollback && term->alt_screen &&
+ term->alt_which && term->disptop < 0) {
+ /*
+ * We're swapping away from the alternate screen, so some
+ * lines are about to vanish from the virtual scrollback.
+ * Adjust disptop by that much, so that (if we're not
+ * resetting the scrollback anyway on a display event) the
+ * current scroll position still ends up pointing at the
+ * same text.
+ */
+ term->disptop += term->alt_sblines;
+ if (term->disptop > 0)
+ term->disptop = 0;
+ }
+
+ term->alt_which = which;
+
+ ttr = term->alt_screen;
+ term->alt_screen = term->screen;
+ term->screen = ttr;
+ term->alt_sblines = (
+ term->alt_screen ?
+ find_last_nonempty_line(term, term->alt_screen) + 1 : 0);
+ t = term->curs.x;
+ if (!reset && !keep_cur_pos)
+ term->curs.x = term->alt_x;
+ term->alt_x = t;
+ t = term->curs.y;
+ if (!reset && !keep_cur_pos)
+ term->curs.y = term->alt_y;
+ term->alt_y = t;
+ t = term->marg_t;
+ if (!reset) term->marg_t = term->alt_t;
+ term->alt_t = t;
+ t = term->marg_b;
+ if (!reset) term->marg_b = term->alt_b;
+ term->alt_b = t;
+ bt = term->dec_om;
+ if (!reset) term->dec_om = term->alt_om;
+ term->alt_om = bt;
+ bt = term->wrap;
+ if (!reset) term->wrap = term->alt_wrap;
+ term->alt_wrap = bt;
+ bt = term->wrapnext;
+ if (!reset) term->wrapnext = term->alt_wnext;
+ term->alt_wnext = bt;
+ bt = term->insert;
+ if (!reset) term->insert = term->alt_ins;
+ term->alt_ins = bt;
+ t = term->cset;
+ if (!reset) term->cset = term->alt_cset;
+ term->alt_cset = t;
+ bt = term->utf;
+ if (!reset) term->utf = term->alt_utf;
+ term->alt_utf = bt;
+ t = term->sco_acs;
+ if (!reset) term->sco_acs = term->alt_sco_acs;
+ term->alt_sco_acs = t;
+
+ tp = term->savecurs;
+ if (!reset)
+ term->savecurs = term->alt_savecurs;
+ term->alt_savecurs = tp;
+ t = term->save_cset;
+ if (!reset)
+ term->save_cset = term->alt_save_cset;
+ term->alt_save_cset = t;
+ t = term->save_csattr;
+ if (!reset)
+ term->save_csattr = term->alt_save_csattr;
+ term->alt_save_csattr = t;
+ t = term->save_attr;
+ if (!reset)
+ term->save_attr = term->alt_save_attr;
+ term->alt_save_attr = t;
+ ttc = term->save_truecolour;
+ if (!reset)
+ term->save_truecolour = term->alt_save_truecolour;
+ term->alt_save_truecolour = ttc;
+ bt = term->save_utf;
+ if (!reset)
+ term->save_utf = term->alt_save_utf;
+ term->alt_save_utf = bt;
+ bt = term->save_wnext;
+ if (!reset)
+ term->save_wnext = term->alt_save_wnext;
+ term->alt_save_wnext = bt;
+ t = term->save_sco_acs;
+ if (!reset)
+ term->save_sco_acs = term->alt_save_sco_acs;
+ term->alt_save_sco_acs = t;
+
+ if (term->erase_to_scrollback && term->alt_screen &&
+ term->alt_which && term->disptop < 0) {
+ /*
+ * Inverse of the adjustment at the top of this function.
+ * This time, we're swapping _to_ the alternate screen, so
+ * some lines are about to _appear_ in the virtual
+ * scrollback, and we adjust disptop in the other
+ * direction.
+ *
+ * Both these adjustments depend on the value stored in
+ * term->alt_sblines while the alt screen is selected,
+ * which is why we had to do one _before_ switching away
+ * from it and the other _after_ switching to it.
+ */
+ term->disptop -= term->alt_sblines;
+ int limit = -sblines(term);
+ if (term->disptop < limit)
+ term->disptop = limit;
+ }
+ }
+
+ if (reset && term->screen) {
+ /*
+ * Yes, this _is_ supposed to honour background-colour-erase.
+ */
+ erase_lots(term, false, true, true);
+ }
+}
+
+/*
+ * Update the scroll bar.
+ */
+static void update_sbar(Terminal *term)
+{
+ int nscroll = sblines(term);
+ win_set_scrollbar(term->win, nscroll + term->rows,
+ nscroll + term->disptop, term->rows);
+}
+
+/*
+ * Check whether the region bounded by the two pointers intersects
+ * the scroll region, and de-select the on-screen selection if so.
+ */
+static void check_selection(Terminal *term, pos from, pos to)
+{
+ if (poslt(from, term->selend) && poslt(term->selstart, to))
+ deselect(term);
+}
+
+static void clear_line(Terminal *term, termline *line)
+{
+ resizeline(term, line, term->cols);
+ for (int i = 0; i < term->cols; i++)
+ copy_termchar(line, i, &term->erase_char);
+ line->lattr = LATTR_NORM;
+}
+
+static void check_trust_status(Terminal *term, termline *line)
+{
+ if (line->trusted != term->trusted) {
+ /*
+ * If we're displaying trusted output on a previously
+ * untrusted line, or vice versa, we need to switch the
+ * 'trusted' attribute on this terminal line, and also clear
+ * all its previous contents.
+ */
+ clear_line(term, line);
+ line->trusted = term->trusted;
+ }
+}
+
+/*
+ * Scroll the screen. (`lines' is +ve for scrolling forward, -ve
+ * for backward.) `sb' is true if the scrolling is permitted to
+ * affect the scrollback buffer.
+ */
+static void scroll(Terminal *term, int topline, int botline,
+ int lines, bool sb)
+{
+ termline *line;
+ int seltop, scrollwinsize;
+
+ if (topline != 0 || term->alt_which != 0)
+ sb = false;
+
+ scrollwinsize = botline - topline + 1;
+
+ if (lines < 0) {
+ lines = -lines;
+ if (lines > scrollwinsize)
+ lines = scrollwinsize;
+ while (lines-- > 0) {
+ line = delpos234(term->screen, botline);
+ resizeline(term, line, term->cols);
+ clear_line(term, line);
+ addpos234(term->screen, line, topline);
+
+ if (term->selstart.y >= topline && term->selstart.y <= botline) {
+ term->selstart.y++;
+ if (term->selstart.y > botline) {
+ term->selstart.y = botline + 1;
+ term->selstart.x = 0;
+ }
+ }
+ if (term->selend.y >= topline && term->selend.y <= botline) {
+ term->selend.y++;
+ if (term->selend.y > botline) {
+ term->selend.y = botline + 1;
+ term->selend.x = 0;
+ }
+ }
+ }
+ } else {
+ if (lines > scrollwinsize)
+ lines = scrollwinsize;
+ while (lines-- > 0) {
+ line = delpos234(term->screen, topline);
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
+ if (sb && term->savelines > 0) {
+ int sblen = count234(term->scrollback);
+ /*
+ * We must add this line to the scrollback. We'll
+ * remove a line from the top of the scrollback if
+ * the scrollback is full.
+ */
+ if (sblen == term->savelines) {
+ unsigned char *cline;
+
+ sblen--;
+ cline = delpos234(term->scrollback, 0);
+ sfree(cline);
+ } else
+ term->tempsblines += 1;
+
+ addpos234(term->scrollback, compressline(line), sblen);
+
+ /* now `line' itself can be reused as the bottom line */
+
+ /*
+ * If the user is currently looking at part of the
+ * scrollback, and they haven't enabled any options
+ * that are going to reset the scrollback as a
+ * result of this movement, then the chances are
+ * they'd like to keep looking at the same line. So
+ * we move their viewpoint at the same rate as the
+ * scroll, at least until their viewpoint hits the
+ * top end of the scrollback buffer, at which point
+ * we don't have the choice any more.
+ *
+ * Thanks to Jan Holmen Holsten for the idea and
+ * initial implementation.
+ */
+ if (term->disptop > -term->savelines && term->disptop < 0)
+ term->disptop--;
+ }
+ resizeline(term, line, term->cols);
+ clear_line(term, line);
+ line->trusted = false;
+ addpos234(term->screen, line, botline);
+
+ /*
+ * If the selection endpoints move into the scrollback,
+ * we keep them moving until they hit the top. However,
+ * of course, if the line _hasn't_ moved into the
+ * scrollback then we don't do this, and cut them off
+ * at the top of the scroll region.
+ *
+ * This applies to selstart and selend (for an existing
+ * selection), and also selanchor (for one being
+ * selected as we speak).
+ */
+ seltop = sb ? -term->savelines : topline;
+
+ if (term->selstate != NO_SELECTION) {
+ if (term->selstart.y >= seltop &&
+ term->selstart.y <= botline) {
+ term->selstart.y--;
+ if (term->selstart.y < seltop) {
+ term->selstart.y = seltop;
+ term->selstart.x = 0;
+ }
+ }
+ if (term->selend.y >= seltop && term->selend.y <= botline) {
+ term->selend.y--;
+ if (term->selend.y < seltop) {
+ term->selend.y = seltop;
+ term->selend.x = 0;
+ }
+ }
+ if (term->selanchor.y >= seltop &&
+ term->selanchor.y <= botline) {
+ term->selanchor.y--;
+ if (term->selanchor.y < seltop) {
+ term->selanchor.y = seltop;
+ term->selanchor.x = 0;
+ }
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Move the cursor to a given position, clipping at boundaries. We
+ * may or may not want to clip at the scroll margin: marg_clip is 0
+ * not to, 1 to disallow _passing_ the margins, and 2 to disallow
+ * even _being_ outside the margins.
+ */
+static void move(Terminal *term, int x, int y, int marg_clip)
+{
+ if (x < 0)
+ x = 0;
+ if (x >= term->cols)
+ x = term->cols - 1;
+ if (marg_clip) {
+ if ((term->curs.y >= term->marg_t || marg_clip == 2) &&
+ y < term->marg_t)
+ y = term->marg_t;
+ if ((term->curs.y <= term->marg_b || marg_clip == 2) &&
+ y > term->marg_b)
+ y = term->marg_b;
+ }
+ if (y < 0)
+ y = 0;
+ if (y >= term->rows)
+ y = term->rows - 1;
+ term->curs.x = x;
+ term->curs.y = y;
+ term->wrapnext = false;
+}
+
+/*
+ * Save or restore the cursor and SGR mode.
+ */
+static void save_cursor(Terminal *term, bool save)
+{
+ if (save) {
+ term->savecurs = term->curs;
+ term->save_attr = term->curr_attr;
+ term->save_truecolour = term->curr_truecolour;
+ term->save_cset = term->cset;
+ term->save_utf = term->utf;
+ term->save_wnext = term->wrapnext;
+ term->save_csattr = term->cset_attr[term->cset];
+ term->save_sco_acs = term->sco_acs;
+ } else {
+ term->curs = term->savecurs;
+ /* Make sure the window hasn't shrunk since the save */
+ if (term->curs.x >= term->cols)
+ term->curs.x = term->cols - 1;
+ if (term->curs.y >= term->rows)
+ term->curs.y = term->rows - 1;
+
+ term->curr_attr = term->save_attr;
+ term->curr_truecolour = term->save_truecolour;
+ term->cset = term->save_cset;
+ term->utf = term->save_utf;
+ term->wrapnext = term->save_wnext;
+ /*
+ * wrapnext might reset to False if the x position is no
+ * longer at the rightmost edge.
+ */
+ if (term->wrapnext && term->curs.x < term->cols-1)
+ term->wrapnext = false;
+ term->cset_attr[term->cset] = term->save_csattr;
+ term->sco_acs = term->save_sco_acs;
+ set_erase_char(term);
+ }
+}
+
+/*
+ * This function is called before doing _anything_ which affects
+ * only part of a line of text. It is used to mark the boundary
+ * between two character positions, and it indicates that some sort
+ * of effect is going to happen on only one side of that boundary.
+ *
+ * The effect of this function is to check whether a CJK
+ * double-width character is straddling the boundary, and to remove
+ * it and replace it with two spaces if so. (Of course, one or
+ * other of those spaces is then likely to be replaced with
+ * something else again, as a result of whatever happens next.)
+ *
+ * Also, if the boundary is at the right-hand _edge_ of the screen,
+ * it implies something deliberate is being done to the rightmost
+ * column position; hence we must clear LATTR_WRAPPED2.
+ *
+ * The input to the function is the coordinates of the _second_
+ * character of the pair.
+ */
+static void check_boundary(Terminal *term, int x, int y)
+{
+ termline *ldata;
+
+ /* Validate input coordinates, just in case. */
+ if (x <= 0 || x > term->cols)
+ return;
+
+ ldata = scrlineptr(y);
+ check_trust_status(term, ldata);
+ check_line_size(term, ldata);
+ if (x == term->cols) {
+ ldata->lattr &= ~LATTR_WRAPPED2;
+ } else {
+ if (ldata->chars[x].chr == UCSWIDE) {
+ clear_cc(ldata, x-1);
+ clear_cc(ldata, x);
+ ldata->chars[x-1].chr = ' ' | CSET_ASCII;
+ ldata->chars[x] = ldata->chars[x-1];
+ }
+ }
+}
+
+/*
+ * Erase a large portion of the screen: the whole screen, or the
+ * whole line, or parts thereof.
+ */
+static void erase_lots(Terminal *term,
+ bool line_only, bool from_begin, bool to_end)
+{
+ pos start, end;
+ bool erase_lattr;
+ bool erasing_lines_from_top = false;
+
+ if (line_only) {
+ start.y = term->curs.y;
+ start.x = 0;
+ end.y = term->curs.y + 1;
+ end.x = 0;
+ erase_lattr = false;
+ } else {
+ start.y = 0;
+ start.x = 0;
+ end.y = term->rows;
+ end.x = 0;
+ erase_lattr = true;
+ }
+
+ /* This is the endpoint of the clearing operation that is not
+ * either the start or end of the line / screen. */
+ pos boundary = term->curs;
+
+ if (!from_begin) {
+ /*
+ * If we're erasing from the current char to the end of
+ * line/screen, then we take account of wrapnext, so as to
+ * maintain the invariant that writing a printing character
+ * followed by ESC[K should not overwrite the character you
+ * _just wrote_. That is, when wrapnext says the cursor is
+ * 'logically' at the very rightmost edge of the screen
+ * instead of just before the last printing char, ESC[K should
+ * do nothing at all, and ESC[J should clear the next line but
+ * leave this one unchanged.
+ *
+ * This adjusted position will also be the position we use for
+ * check_boundary (i.e. the thing we ensure isn't in the
+ * middle of a double-width printing char).
+ */
+ if (term->wrapnext)
+ incpos(boundary);
+
+ start = boundary;
+ }
+ if (!to_end) {
+ /*
+ * If we're erasing from the start of (at least) the line _to_
+ * the current position, then that is taken to mean 'inclusive
+ * of the cell under the cursor', which means we don't
+ * consider wrapnext at all: whether it's set or not, we still
+ * clear the cell under the cursor.
+ *
+ * Again, that incremented boundary position is where we
+ * should be careful of a straddling wide character.
+ */
+ incpos(boundary);
+ end = boundary;
+ }
+ if (!from_begin || !to_end)
+ check_boundary(term, boundary.x, boundary.y);
+ check_selection(term, start, end);
+
+ /* Clear screen also forces a full window redraw, just in case. */
+ if (start.y == 0 && start.x == 0 && end.y == term->rows)
+ term_invalidate(term);
+
+ /* Lines scrolled away shouldn't be brought back on if the terminal
+ * resizes. */
+ if (start.y == 0 && start.x == 0 && end.x == 0 && erase_lattr)
+ erasing_lines_from_top = true;
+
+ if (term->erase_to_scrollback && erasing_lines_from_top) {
+ /* If it's a whole number of lines, starting at the top, and
+ * we're fully erasing them, erase by scrolling and keep the
+ * lines in the scrollback. */
+ int scrolllines = end.y;
+ if (end.y == term->rows) {
+ /* Shrink until we find a non-empty row.*/
+ scrolllines = find_last_nonempty_line(term, term->screen) + 1;
+ }
+ if (scrolllines > 0)
+ scroll(term, 0, scrolllines - 1, scrolllines, true);
+ } else {
+ termline *ldata = scrlineptr(start.y);
+ check_trust_status(term, ldata);
+ while (poslt(start, end)) {
+ check_line_size(term, ldata);
+ if (start.x == term->cols) {
+ if (!erase_lattr)
+ ldata->lattr &= ~(LATTR_WRAPPED | LATTR_WRAPPED2);
+ else
+ ldata->lattr = LATTR_NORM;
+ } else {
+ copy_termchar(ldata, start.x, &term->erase_char);
+ }
+ if (incpos(start) && start.y < term->rows) {
+ ldata = scrlineptr(start.y);
+ check_trust_status(term, ldata);
+ }
+ }
+ }
+
+ /* After an erase of lines from the top of the screen, we shouldn't
+ * bring the lines back again if the terminal enlarges (since the user or
+ * application has explicitly thrown them away). */
+ if (erasing_lines_from_top && !(term->alt_which))
+ term->tempsblines = 0;
+}
+
+/*
+ * Insert or delete characters within the current line. n is +ve if
+ * insertion is desired, and -ve for deletion.
+ */
+static void insch(Terminal *term, int n)
+{
+ int dir = (n < 0 ? -1 : +1);
+ int m, j;
+ pos eol;
+ termline *ldata;
+
+ n = (n < 0 ? -n : n);
+ if (n > term->cols - term->curs.x)
+ n = term->cols - term->curs.x;
+ m = term->cols - term->curs.x - n;
+
+ /*
+ * We must de-highlight the selection if it overlaps any part of
+ * the region affected by this operation, i.e. the region from the
+ * current cursor position to end-of-line, _unless_ the entirety
+ * of the selection is going to be moved to the left or right by
+ * this operation but otherwise unchanged, in which case we can
+ * simply move the highlight with the text.
+ */
+ eol.y = term->curs.y;
+ eol.x = term->cols;
+ if (poslt(term->curs, term->selend) && poslt(term->selstart, eol)) {
+ pos okstart = term->curs;
+ pos okend = eol;
+ if (dir > 0) {
+ /* Insertion: n characters at EOL will be splatted. */
+ okend.x -= n;
+ } else {
+ /* Deletion: n characters at cursor position will be splatted. */
+ okstart.x += n;
+ }
+ if (posle(okstart, term->selstart) && posle(term->selend, okend)) {
+ /* Selection is contained entirely in the interval
+ * [okstart,okend), so we need only adjust the selection
+ * bounds. */
+ term->selstart.x += dir * n;
+ term->selend.x += dir * n;
+ assert(term->selstart.x >= term->curs.x);
+ assert(term->selstart.x < term->cols);
+ assert(term->selend.x > term->curs.x);
+ assert(term->selend.x <= term->cols);
+ } else {
+ /* Selection is not wholly contained in that interval, so
+ * we must unhighlight it. */
+ deselect(term);
+ }
+ }
+
+ check_boundary(term, term->curs.x, term->curs.y);
+ if (dir < 0)
+ check_boundary(term, term->curs.x + n, term->curs.y);
+ ldata = scrlineptr(term->curs.y);
+ check_trust_status(term, ldata);
+ if (dir < 0) {
+ for (j = 0; j < m; j++)
+ move_termchar(ldata,
+ ldata->chars + term->curs.x + j,
+ ldata->chars + term->curs.x + j + n);
+ while (n--)
+ copy_termchar(ldata, term->curs.x + m++, &term->erase_char);
+ } else {
+ for (j = m; j-- ;)
+ move_termchar(ldata,
+ ldata->chars + term->curs.x + j + n,
+ ldata->chars + term->curs.x + j);
+ while (n--)
+ copy_termchar(ldata, term->curs.x + n, &term->erase_char);
+ }
+}
+
+static void term_update_raw_mouse_mode(Terminal *term)
+{
+ bool want_raw = (term->xterm_mouse != 0 && !term->xterm_mouse_forbidden);
+ win_set_raw_mouse_mode(term->win, want_raw);
+ term->win_pointer_shape_pending = true;
+ term->win_pointer_shape_raw = want_raw;
+ term_schedule_update(term);
+}
+
+static void term_request_resize(Terminal *term, int cols, int rows)
+{
+ if (term->cols == cols && term->rows == rows)
+ return; /* don't need to do anything */
+
+ term->win_resize_pending = WIN_RESIZE_NEED_SEND;
+ term->win_resize_pending_w = cols;
+ term->win_resize_pending_h = rows;
+ term_schedule_update(term);
+}
+
+/*
+ * Toggle terminal mode `mode' to state `state'. (`query' indicates
+ * whether the mode is a DEC private one or a normal one.)
+ */
+static void toggle_mode(Terminal *term, int mode, int query, bool state)
+{
+ if (query == 1) {
+ switch (mode) {
+ case 1: /* DECCKM: application cursor keys */
+ term->app_cursor_keys = state;
+ break;
+ case 2: /* DECANM: VT52 mode */
+ term->vt52_mode = !state;
+ if (term->vt52_mode) {
+ term->blink_is_real = false;
+ term->vt52_bold = false;
+ } else {
+ term->blink_is_real = term->blinktext;
+ }
+ term_schedule_tblink(term);
+ break;
+ case 3: /* DECCOLM: 80/132 columns */
+ deselect(term);
+ if (!term->no_remote_resize)
+ term_request_resize(term, state ? 132 : 80, term->rows);
+ term->reset_132 = state;
+ term->alt_t = term->marg_t = 0;
+ term->alt_b = term->marg_b = term->rows - 1;
+ move(term, 0, 0, 0);
+ erase_lots(term, false, true, true);
+ break;
+ case 5: /* DECSCNM: reverse video */
+ /*
+ * Toggle reverse video. If we receive an OFF within the
+ * visual bell timeout period after an ON, we trigger an
+ * effective visual bell, so that ESC[?5hESC[?5l will
+ * always be an actually _visible_ visual bell.
+ */
+ if (term->rvideo && !state) {
+ /* This is an OFF, so set up a vbell */
+ term_schedule_vbell(term, true, term->rvbell_startpoint);
+ } else if (!term->rvideo && state) {
+ /* This is an ON, so we notice the time and save it. */
+ term->rvbell_startpoint = GETTICKCOUNT();
+ }
+ term->rvideo = state;
+ seen_disp_event(term);
+ break;
+ case 6: /* DECOM: DEC origin mode */
+ term->dec_om = state;
+ break;
+ case 7: /* DECAWM: auto wrap */
+ term->wrap = state;
+ break;
+ case 8: /* DECARM: auto key repeat */
+ term->repeat_off = !state;
+ break;
+ case 25: /* DECTCEM: enable/disable cursor */
+ compatibility2(OTHER, VT220);
+ term->cursor_on = state;
+ seen_disp_event(term);
+ break;
+ case 47: /* alternate screen */
+ compatibility(OTHER);
+ deselect(term);
+ swap_screen(term, term->no_alt_screen ? 0 : state, false, false);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 1000: /* xterm mouse 1 (normal) */
+ term->xterm_mouse = state ? 1 : 0;
+ term_update_raw_mouse_mode(term);
+ break;
+ case 1002: /* xterm mouse 2 (inc. button drags) */
+ term->xterm_mouse = state ? 2 : 0;
+ term_update_raw_mouse_mode(term);
+ break;
+ case 1006: /* xterm extended mouse */
+ term->xterm_extended_mouse = state;
+ break;
+ case 1015: /* urxvt extended mouse */
+ term->urxvt_extended_mouse = state;
+ break;
+ case 1047: /* alternate screen */
+ compatibility(OTHER);
+ deselect(term);
+ swap_screen(term, term->no_alt_screen ? 0 : state, true, true);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 1048: /* save/restore cursor */
+ if (!term->no_alt_screen)
+ save_cursor(term, state);
+ if (!state) seen_disp_event(term);
+ break;
+ case 1049: /* cursor & alternate screen */
+ if (state && !term->no_alt_screen)
+ save_cursor(term, state);
+ if (!state) seen_disp_event(term);
+ compatibility(OTHER);
+ deselect(term);
+ swap_screen(term, term->no_alt_screen ? 0 : state, true, false);
+ if (!state && !term->no_alt_screen)
+ save_cursor(term, state);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 2004: /* xterm bracketed paste */
+ term->bracketed_paste = state ? true : false;
+ break;
+ }
+ } else if (query == 0) {
+ switch (mode) {
+ case 4: /* IRM: set insert mode */
+ compatibility(VT102);
+ term->insert = state;
+ break;
+ case 12: /* SRM: set echo mode */
+ term->srm_echo = !state;
+ break;
+ case 20: /* LNM: Return sends ... */
+ term->cr_lf_return = state;
+ break;
+ case 34: /* WYULCURM: Make cursor BIG */
+ compatibility2(OTHER, VT220);
+ term->big_cursor = !state;
+ }
+ }
+}
+
+/*
+ * Process an OSC sequence: set window title or icon name.
+ */
+static void do_osc(Terminal *term)
+{
+ if (term->osc_w) {
+ while (term->osc_strlen--)
+ term->wordness[(unsigned char)term->osc_string[term->osc_strlen]] =
+ term->esc_args[0];
+ } else {
+ term->osc_string[term->osc_strlen] = '\0';
+ switch (term->esc_args[0]) {
+ case 0:
+ case 1:
+ if (!term->no_remote_wintitle) {
+ sfree(term->icon_title);
+ term->icon_title = dupstr(term->osc_string);
+ term->icontitle_codepage = term->ucsdata->line_codepage;
+ term->win_icon_title_pending = true;
+ term_schedule_update(term);
+ }
+ if (term->esc_args[0] == 1)
+ break;
+ /* fall through: parameter 0 means set both */
+ case 2:
+ case 21:
+ if (!term->no_remote_wintitle) {
+ sfree(term->window_title);
+ term->window_title = dupstr(term->osc_string);
+ term->wintitle_codepage = term->ucsdata->line_codepage;
+ term->win_title_pending = true;
+ term_schedule_update(term);
+ }
+ break;
+ case 4:
+ if (term->ldisc && !strcmp(term->osc_string, "?")) {
+ unsigned index = term->esc_args[1];
+ if (index < OSC4_NCOLOURS) {
+ rgb colour = term->palette[index];
+ char *reply_buf = dupprintf(
+ "\033]4;%u;rgb:%04x/%04x/%04x\007", index,
+ (unsigned)colour.r * 0x0101,
+ (unsigned)colour.g * 0x0101,
+ (unsigned)colour.b * 0x0101);
+ ldisc_send(term->ldisc, reply_buf, strlen(reply_buf),
+ false);
+ sfree(reply_buf);
+ }
+ }
+ break;
+ }
+ }
+}
+
+/*
+ * ANSI printing routines.
+ */
+static void term_print_setup(Terminal *term, char *printer)
+{
+ bufchain_clear(&term->printer_buf);
+ term->print_job = printer_start_job(printer);
+}
+static void term_print_flush(Terminal *term)
+{
+ size_t size;
+ while ((size = bufchain_size(&term->printer_buf)) > 5) {
+ ptrlen data = bufchain_prefix(&term->printer_buf);
+ if (data.len > size-5)
+ data.len = size-5;
+ printer_job_data(term->print_job, data.ptr, data.len);
+ bufchain_consume(&term->printer_buf, data.len);
+ }
+}
+static void term_print_finish(Terminal *term)
+{
+ size_t size;
+ char c;
+
+ if (!term->printing && !term->only_printing)
+ return; /* we need do nothing */
+
+ term_print_flush(term);
+ while ((size = bufchain_size(&term->printer_buf)) > 0) {
+ ptrlen data = bufchain_prefix(&term->printer_buf);
+ c = *(char *)data.ptr;
+ if (c == '\033' || c == '\233') {
+ bufchain_consume(&term->printer_buf, size);
+ break;
+ } else {
+ printer_job_data(term->print_job, &c, 1);
+ bufchain_consume(&term->printer_buf, 1);
+ }
+ }
+ printer_finish_job(term->print_job);
+ term->print_job = NULL;
+ term->printing = term->only_printing = false;
+}
+
+static void term_display_graphic_char(Terminal *term, unsigned long c)
+{
+ termline *cline = scrlineptr(term->curs.y);
+ int width = 0;
+ if (DIRECT_CHAR(c))
+ width = 1;
+ if (!width)
+ width = term_char_width(term, c);
+
+ if (term->wrapnext && term->wrap && width > 0) {
+ cline->lattr |= LATTR_WRAPPED;
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ term->curs.x = 0;
+ term->wrapnext = false;
+ cline = scrlineptr(term->curs.y);
+ }
+ if (term->insert && width > 0)
+ insch(term, width);
+ if (term->selstate != NO_SELECTION) {
+ pos cursplus = term->curs;
+ incpos(cursplus);
+ check_selection(term, term->curs, cursplus);
+ }
+ if (((c & CSET_MASK) == CSET_ASCII ||
+ (c & CSET_MASK) == 0) && term->logctx)
+ logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
+
+ check_trust_status(term, cline);
+
+ int linecols = term->cols;
+ if (cline->trusted)
+ linecols -= TRUST_SIGIL_WIDTH;
+
+ /*
+ * Preliminary check: if the terminal is only one character cell
+ * wide, then we cannot display any double-width character at all.
+ * Substitute single-width REPLACEMENT CHARACTER instead.
+ */
+ if (width == 2 && linecols < 2) {
+ width = 1;
+ c = 0xFFFD;
+ }
+
+ switch (width) {
+ case 2:
+ /*
+ * If we're about to display a double-width character starting
+ * in the rightmost column, then we do something special
+ * instead. We must print a space in the last column of the
+ * screen, then wrap; and we also set LATTR_WRAPPED2 which
+ * instructs subsequent cut-and-pasting not only to splice
+ * this line to the one after it, but to ignore the space in
+ * the last character position as well. (Because what was
+ * actually output to the terminal was presumably just a
+ * sequence of CJK characters, and we don't want a space to be
+ * pasted in the middle of those just because they had the
+ * misfortune to start in the wrong parity column. xterm
+ * concurs.)
+ */
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+2, term->curs.y);
+ if (term->curs.x >= linecols-1) {
+ copy_termchar(cline, term->curs.x,
+ &term->erase_char);
+ cline->lattr |= LATTR_WRAPPED | LATTR_WRAPPED2;
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b,
+ 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ term->curs.x = 0;
+ cline = scrlineptr(term->curs.y);
+ /* Now we must check_boundary again, of course. */
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+2, term->curs.y);
+ }
+
+ /* FULL-TERMCHAR */
+ clear_cc(cline, term->curs.x);
+ cline->chars[term->curs.x].chr = c;
+ cline->chars[term->curs.x].attr = term->curr_attr;
+ cline->chars[term->curs.x].truecolour =
+ term->curr_truecolour;
+
+ term->curs.x++;
+
+ /* FULL-TERMCHAR */
+ clear_cc(cline, term->curs.x);
+ cline->chars[term->curs.x].chr = UCSWIDE;
+ cline->chars[term->curs.x].attr = term->curr_attr;
+ cline->chars[term->curs.x].truecolour =
+ term->curr_truecolour;
+
+ break;
+ case 1:
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+1, term->curs.y);
+
+ /* FULL-TERMCHAR */
+ clear_cc(cline, term->curs.x);
+ cline->chars[term->curs.x].chr = c;
+ cline->chars[term->curs.x].attr = term->curr_attr;
+ cline->chars[term->curs.x].truecolour =
+ term->curr_truecolour;
+
+ break;
+ case 0:
+ if (term->curs.x > 0) {
+ int x = term->curs.x - 1;
+
+ /* If we're in wrapnext state, the character to combine
+ * with is _here_, not to our left. */
+ if (term->wrapnext)
+ x++;
+
+ /*
+ * If the previous character is UCSWIDE, back up another
+ * one.
+ */
+ if (cline->chars[x].chr == UCSWIDE) {
+ assert(x > 0);
+ x--;
+ }
+
+ add_cc(cline, x, c);
+ seen_disp_event(term);
+ }
+ return;
+ default:
+ return;
+ }
+ term->curs.x++;
+ if (term->curs.x >= linecols) {
+ term->curs.x = linecols - 1;
+ term->wrapnext = true;
+ if (term->wrap && term->vt52_mode) {
+ cline->lattr |= LATTR_WRAPPED;
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ term->curs.x = 0;
+ term->wrapnext = false;
+ }
+ }
+ seen_disp_event(term);
+}
+
+static strbuf *term_input_data_from_unicode(
+ Terminal *term, const wchar_t *widebuf, int len)
+{
+ strbuf *buf = strbuf_new();
+
+ if (in_utf(term)) {
+ /*
+ * Translate input wide characters into UTF-8 to go in the
+ * terminal's input data queue.
+ */
+ for (int i = 0; i < len; i++) {
+ unsigned long ch = widebuf[i];
+
+ if (IS_SURROGATE(ch)) {
+#ifdef PLATFORM_IS_UTF16
+ if (i+1 < len) {
+ unsigned long ch2 = widebuf[i+1];
+ if (IS_SURROGATE_PAIR(ch, ch2)) {
+ ch = FROM_SURROGATES(ch, ch2);
+ i++;
+ }
+ } else
+#endif
+ {
+ /* Unrecognised UTF-16 sequence */
+ ch = '.';
+ }
+ }
+
+ char utf8_chr[6];
+ put_data(buf, utf8_chr, encode_utf8(utf8_chr, ch));
+ }
+ } else {
+ /*
+ * Call to the character-set subsystem to translate into
+ * whatever charset the terminal is currently configured in.
+ *
+ * Since the terminal doesn't currently support any multibyte
+ * character set other than UTF-8, we can assume here that
+ * there will be at most one output byte per input wchar_t.
+ * (But also we must allow space for the trailing NUL that
+ * wc_to_mb will write.)
+ */
+ char *bufptr = strbuf_append(buf, len + 1);
+ int rv;
+ rv = wc_to_mb(term->ucsdata->line_codepage, 0, widebuf, len,
+ bufptr, len + 1, NULL);
+ strbuf_shrink_to(buf, rv < 0 ? 0 : rv);
+ }
+
+ return buf;
+}
+
+static strbuf *term_input_data_from_charset(
+ Terminal *term, int codepage, const char *str, int len)
+{
+ strbuf *buf;
+
+ if (codepage < 0) {
+ buf = strbuf_new();
+ put_data(buf, str, len);
+ } else {
+ int widesize = len * 2; /* allow for UTF-16 surrogates */
+ wchar_t *widebuf = snewn(widesize, wchar_t);
+ int widelen = mb_to_wc(codepage, 0, str, len, widebuf, widesize);
+ buf = term_input_data_from_unicode(term, widebuf, widelen);
+ sfree(widebuf);
+ }
+
+ return buf;
+}
+
+static inline void term_bracketed_paste_start(Terminal *term)
+{
+ ptrlen seq = PTRLEN_LITERAL("\033[200~");
+ if (term->ldisc)
+ ldisc_send(term->ldisc, seq.ptr, seq.len, false);
+ term->bracketed_paste_active = true;
+}
+
+static inline void term_bracketed_paste_stop(Terminal *term)
+{
+ if (!term->bracketed_paste_active)
+ return;
+
+ ptrlen seq = PTRLEN_LITERAL("\033[201~");
+ if (term->ldisc)
+ ldisc_send(term->ldisc, seq.ptr, seq.len, false);
+ term->bracketed_paste_active = false;
+}
+
+static inline void term_keyinput_internal(
+ Terminal *term, const void *buf, int len, bool interactive)
+{
+ if (term->srm_echo) {
+ /*
+ * Implement the terminal-level local echo behaviour that
+ * ECMA-48 specifies when terminal mode 12 is configured off
+ * (ESC[12l). In this mode, data input to the terminal via the
+ * keyboard is also added to the output buffer. But this
+ * doesn't apply to escape sequences generated as session
+ * input _within_ the terminal, e.g. in response to terminal
+ * query sequences, or the bracketing sequences of bracketed
+ * paste mode. Those will be sent directly via
+ * ldisc_send(term->ldisc, ...) and won't go through this
+ * function.
+ */
+
+ /* Mimic the special case of negative length in ldisc_send */
+ int true_len = len >= 0 ? len : strlen(buf);
+
+ bufchain_add(&term->inbuf, buf, true_len);
+ term_added_data(term, false);
+ }
+ if (interactive)
+ term_bracketed_paste_stop(term);
+ if (term->ldisc)
+ ldisc_send(term->ldisc, buf, len, interactive);
+ term_seen_key_event(term);
+}
+
+unsigned long term_translate(
+ Terminal *term, struct term_utf8_decode *utf8, unsigned char c)
+{
+ if (in_utf(term)) {
+ switch (utf8->state) {
+ case 0:
+ if (c < 0x80) {
+ /* UTF-8 must be stateless so we ignore iso2022. */
+ if (term->ucsdata->unitab_ctrl[c] != 0xFF) {
+ return term->ucsdata->unitab_ctrl[c];
+ } else if ((term->utf8linedraw) &&
+ (term->cset_attr[term->cset] == CSET_LINEDRW)) {
+ /* Linedraw characters are explicitly enabled */
+ return c | CSET_LINEDRW;
+ } else {
+ return c | CSET_ASCII;
+ }
+ } else if ((c & 0xe0) == 0xc0) {
+ utf8->size = utf8->state = 1;
+ utf8->chr = (c & 0x1f);
+ } else if ((c & 0xf0) == 0xe0) {
+ utf8->size = utf8->state = 2;
+ utf8->chr = (c & 0x0f);
+ } else if ((c & 0xf8) == 0xf0) {
+ utf8->size = utf8->state = 3;
+ utf8->chr = (c & 0x07);
+ } else if ((c & 0xfc) == 0xf8) {
+ utf8->size = utf8->state = 4;
+ utf8->chr = (c & 0x03);
+ } else if ((c & 0xfe) == 0xfc) {
+ utf8->size = utf8->state = 5;
+ utf8->chr = (c & 0x01);
+ } else {
+ return UCSINVALID;
+ }
+ return UCSINCOMPLETE;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ if ((c & 0xC0) != 0x80) {
+ utf8->state = 0;
+ return UCSTRUNCATED; /* caller will then give us the
+ * same byte again */
+ }
+ utf8->chr = (utf8->chr << 6) | (c & 0x3f);
+ if (--utf8->state)
+ return UCSINCOMPLETE;
+
+ unsigned long t = utf8->chr;
+
+ /* Is somebody trying to be evil! */
+ if (t < 0x80 ||
+ (t < 0x800 && utf8->size >= 2) ||
+ (t < 0x10000 && utf8->size >= 3) ||
+ (t < 0x200000 && utf8->size >= 4) ||
+ (t < 0x4000000 && utf8->size >= 5))
+ return UCSINVALID;
+
+ /* Unicode line separator and paragraph separator are CR-LF */
+ if (t == 0x2028 || t == 0x2029)
+ return 0x85;
+
+ /* High controls are probably a Baaad idea too. */
+ if (t < 0xA0)
+ return 0xFFFD;
+
+ /* The UTF-16 surrogates are not nice either. */
+ /* The standard give the option of decoding these:
+ * I don't want to! */
+ if (t >= 0xD800 && t < 0xE000)
+ return UCSINVALID;
+
+ /* ISO 10646 characters now limited to UTF-16 range. */
+ if (t > 0x10FFFF)
+ return UCSINVALID;
+
+ /* This is currently a TagPhobic application.. */
+ if (t >= 0xE0000 && t <= 0xE007F)
+ return UCSINCOMPLETE;
+
+ /* U+FEFF is best seen as a null. */
+ if (t == 0xFEFF)
+ return UCSINCOMPLETE;
+ /* But U+FFFE is an error. */
+ if (t == 0xFFFE || t == 0xFFFF)
+ return UCSINVALID;
+
+ return t;
+ }
+ } else if (term->sco_acs &&
+ (c!='\033' && c!='\012' && c!='\015' && c!='\b')) {
+ /* Are we in the nasty ACS mode? Note: no sco in utf mode. */
+ if (term->sco_acs == 2)
+ c |= 0x80;
+
+ return c | CSET_SCOACS;
+ } else {
+ switch (term->cset_attr[term->cset]) {
+ /*
+ * Linedraw characters are different from 'ESC ( B'
+ * only for a small range. For ones outside that
+ * range, make sure we use the same font as well as
+ * the same encoding.
+ */
+ case CSET_LINEDRW:
+ if (term->ucsdata->unitab_ctrl[c] != 0xFF)
+ return term->ucsdata->unitab_ctrl[c];
+ else
+ return c | CSET_LINEDRW;
+ break;
+
+ case CSET_GBCHR:
+ /* If UK-ASCII, make the '#' a LineDraw Pound */
+ if (c == '#')
+ return '}' | CSET_LINEDRW;
+ /* fall through */
+
+ case CSET_ASCII:
+ if (term->ucsdata->unitab_ctrl[c] != 0xFF)
+ return term->ucsdata->unitab_ctrl[c];
+ else
+ return c | CSET_ASCII;
+ break;
+ case CSET_SCOACS:
+ if (c >= ' ')
+ return c | CSET_SCOACS;
+ break;
+ }
+ }
+ return c;
+}
+
+/*
+ * Remove everything currently in `inbuf' and stick it up on the
+ * in-memory display. There's a big state machine in here to
+ * process escape sequences...
+ */
+static void term_out(Terminal *term, bool called_from_term_data)
+{
+ unsigned long c;
+ int unget;
+ const unsigned char *chars;
+ size_t nchars_got = 0, nchars_used = 0;
+
+ /*
+ * During drag-selects, we do not process terminal input, because
+ * the user will want the screen to hold still to be selected.
+ */
+ if (term->selstate == DRAGGING)
+ return;
+
+ unget = -1;
+
+ chars = NULL; /* placate compiler warnings */
+ while (nchars_got < nchars_used ||
+ unget != -1 ||
+ bufchain_size(&term->inbuf) > 0) {
+ if (unget != -1) {
+ /*
+ * Handle a character we left in 'unget' the last time
+ * round this loop. This happens if a UTF-8 sequence is
+ * aborted early, by containing fewer continuation bytes
+ * than its introducer expected: the non-continuation byte
+ * that interrupted the sequence must now be processed
+ * as a fresh piece of input in its own right.
+ */
+ c = unget;
+ unget = -1;
+ } else {
+ /*
+ * If we're waiting for a terminal resize triggered by an
+ * escape sequence, we defer processing the terminal
+ * output until we receive acknowledgment from the front
+ * end that the resize has happened, so that further
+ * output will be processed in the context of the new
+ * size.
+ *
+ * This test goes inside the main while-loop, so that we
+ * exit early if we encounter a resize escape sequence
+ * part way through term->inbuf.
+ *
+ * It's also in the branch of this if statement that
+ * doesn't deal with a character left in 'unget' by the
+ * previous loop iteration, because if we break out of
+ * this loop with an ungot character still pending, we'll
+ * lose it. (And in any case, if the previous thing that
+ * happened was a truncated UTF-8 sequence, then it won't
+ * have scheduled a pending resize.)
+ */
+ if (term->win_resize_pending != WIN_RESIZE_NO)
+ break;
+
+ if (nchars_got == nchars_used) {
+ /* Delete the previous chunk from the bufchain */
+ bufchain_consume(&term->inbuf, nchars_used);
+ nchars_used = 0;
+
+ if (bufchain_size(&term->inbuf) == 0)
+ break; /* no more data */
+
+ ptrlen data = bufchain_prefix(&term->inbuf);
+ chars = data.ptr;
+ nchars_got = data.len;
+ assert(chars != NULL);
+ assert(nchars_used < nchars_got);
+ }
+ c = chars[nchars_used++];
+
+ /*
+ * Optionally log the session traffic to a file. Useful for
+ * debugging and possibly also useful for actual logging.
+ */
+ if (term->logtype == LGTYP_DEBUG && term->logctx)
+ logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG);
+ }
+
+ /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even
+ * be able to display 8-bit characters, but I'll let that go 'cause
+ * of i18n.
+ */
+
+ /*
+ * If we're printing, add the character to the printer
+ * buffer.
+ */
+ if (term->printing) {
+ bufchain_add(&term->printer_buf, &c, 1);
+
+ /*
+ * If we're in print-only mode, we use a much simpler
+ * state machine designed only to recognise the ESC[4i
+ * termination sequence.
+ */
+ if (term->only_printing) {
+ if (c == '\033')
+ term->print_state = 1;
+ else if (c == (unsigned char)'\233')
+ term->print_state = 2;
+ else if (c == '[' && term->print_state == 1)
+ term->print_state = 2;
+ else if (c == '4' && term->print_state == 2)
+ term->print_state = 3;
+ else if (c == 'i' && term->print_state == 3)
+ term->print_state = 4;
+ else
+ term->print_state = 0;
+ if (term->print_state == 4) {
+ term_print_finish(term);
+ }
+ continue;
+ }
+ }
+
+ /* Do character-set translation. */
+ if (term->termstate == TOPLEVEL) {
+ unsigned long t = term_translate(term, &term->utf8, c);
+ switch (t) {
+ case UCSINCOMPLETE:
+ continue; /* didn't complete a multibyte char */
+ case UCSTRUNCATED:
+ unget = c;
+ /* fall through */
+ case UCSINVALID:
+ c = UCSERR;
+ break;
+ default:
+ c = t;
+ break;
+ }
+ }
+
+ /*
+ * How about C1 controls?
+ * Explicitly ignore SCI (0x9a), which we don't translate to DECID.
+ */
+ if ((c & -32) == 0x80 && term->termstate < DO_CTRLS &&
+ !term->vt52_mode && has_compat(VT220)) {
+ if (c == 0x9a)
+ c = 0;
+ else {
+ term->termstate = SEEN_ESC;
+ term->esc_query = 0;
+ c = '@' + (c & 0x1F);
+ }
+ }
+
+ /* Or the GL control. */
+ if (c == '\177' && term->termstate < DO_CTRLS && has_compat(OTHER)) {
+ if (term->curs.x && !term->wrapnext)
+ term->curs.x--;
+ term->wrapnext = false;
+ /* destructive backspace might be disabled */
+ if (!term->no_dbackspace) {
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+1, term->curs.y);
+ copy_termchar(scrlineptr(term->curs.y),
+ term->curs.x, &term->erase_char);
+ }
+ } else
+ /* Or normal C0 controls. */
+ if ((c & ~0x1F) == 0 && term->termstate < DO_CTRLS) {
+ switch (c) {
+ case '\005': /* ENQ: terminal type query */
+ /*
+ * Strictly speaking this is VT100 but a VT100 defaults to
+ * no response. Other terminals respond at their option.
+ *
+ * Don't put a CR in the default string as this tends to
+ * upset some weird software.
+ */
+ compatibility(ANSIMIN);
+ if (term->ldisc) {
+ strbuf *buf = term_input_data_from_charset(
+ term, DEFAULT_CODEPAGE,
+ term->answerback, term->answerbacklen);
+ ldisc_send(term->ldisc, buf->s, buf->len, false);
+ strbuf_free(buf);
+ }
+ break;
+ case '\007': { /* BEL: Bell */
+ if (term->termstate == SEEN_OSC ||
+ term->termstate == SEEN_OSC_W) {
+ /*
+ * In an OSC context, BEL is one of the ways to terminate
+ * the whole sequence. We process it as such even if we
+ * haven't got into the final OSC_STRING state yet, so that
+ * OSC sequences without a string will be handled cleanly.
+ */
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ }
+
+ struct beeptime *newbeep;
+ unsigned long ticks;
+
+ ticks = GETTICKCOUNT();
+
+ if (!term->beep_overloaded) {
+ newbeep = snew(struct beeptime);
+ newbeep->ticks = ticks;
+ newbeep->next = NULL;
+ if (!term->beephead)
+ term->beephead = newbeep;
+ else
+ term->beeptail->next = newbeep;
+ term->beeptail = newbeep;
+ term->nbeeps++;
+ }
+
+ /*
+ * Throw out any beeps that happened more than
+ * t seconds ago.
+ */
+ while (term->beephead &&
+ term->beephead->ticks < ticks - term->bellovl_t) {
+ struct beeptime *tmp = term->beephead;
+ term->beephead = tmp->next;
+ sfree(tmp);
+ if (!term->beephead)
+ term->beeptail = NULL;
+ term->nbeeps--;
+ }
+
+ if (term->bellovl && term->beep_overloaded &&
+ ticks - term->lastbeep >= (unsigned)term->bellovl_s) {
+ /*
+ * If we're currently overloaded and the
+ * last beep was more than s seconds ago,
+ * leave overload mode.
+ */
+ term->beep_overloaded = false;
+ } else if (term->bellovl && !term->beep_overloaded &&
+ term->nbeeps >= term->bellovl_n) {
+ /*
+ * Now, if we have n or more beeps
+ * remaining in the queue, go into overload
+ * mode.
+ */
+ term->beep_overloaded = true;
+ }
+ term->lastbeep = ticks;
+
+ /*
+ * Perform an actual beep if we're not overloaded.
+ */
+ if (!term->bellovl || !term->beep_overloaded) {
+ win_bell(term->win, term->beep);
+
+ if (term->beep == BELL_VISUAL) {
+ term_schedule_vbell(term, false, 0);
+ }
+ }
+ seen_disp_event(term);
+ break;
+ }
+ case '\b': /* BS: Back space */
+ if (term->curs.x == 0 && (term->curs.y == 0 || !term->wrap))
+ /* do nothing */ ;
+ else if (term->curs.x == 0 && term->curs.y > 0)
+ term->curs.x = term->cols - 1, term->curs.y--;
+ else if (term->wrapnext)
+ term->wrapnext = false;
+ else
+ term->curs.x--;
+ seen_disp_event(term);
+ break;
+ case '\016': /* LS1: Locking-shift one */
+ compatibility(VT100);
+ term->cset = 1;
+ break;
+ case '\017': /* LS0: Locking-shift zero */
+ compatibility(VT100);
+ term->cset = 0;
+ break;
+ case '\033': /* ESC: Escape */
+ if (term->vt52_mode)
+ term->termstate = VT52_ESC;
+ else if (term->termstate == SEEN_OSC ||
+ term->termstate == SEEN_OSC_W) {
+ /* Be prepared to terminate an OSC early */
+ term->termstate = OSC_MAYBE_ST;
+ } else {
+ compatibility(ANSIMIN);
+ term->termstate = SEEN_ESC;
+ term->esc_query = 0;
+ }
+ break;
+ case '\015': /* CR: Carriage return */
+ term->curs.x = 0;
+ term->wrapnext = false;
+ seen_disp_event(term);
+
+ if (term->crhaslf) {
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ }
+ if (term->logctx)
+ logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
+ break;
+ case '\014': /* FF: Form feed */
+ if (has_compat(SCOANSI)) {
+ move(term, 0, 0, 0);
+ erase_lots(term, false, false, true);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ }
+ case '\013': /* VT: Line tabulation */
+ compatibility(VT100);
+ case '\012': /* LF: Line feed */
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ if (term->lfhascr)
+ term->curs.x = 0;
+ term->wrapnext = false;
+ seen_disp_event(term);
+ if (term->logctx)
+ logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
+ break;
+ case '\t': { /* HT: Character tabulation */
+ pos old_curs = term->curs;
+ termline *ldata = scrlineptr(term->curs.y);
+
+ do {
+ term->curs.x++;
+ } while (term->curs.x < term->cols - 1 &&
+ !term->tabs[term->curs.x]);
+
+ if ((ldata->lattr & LATTR_MODE) != LATTR_NORM) {
+ if (term->curs.x >= term->cols / 2)
+ term->curs.x = term->cols / 2 - 1;
+ } else {
+ if (term->curs.x >= term->cols)
+ term->curs.x = term->cols - 1;
+ }
+
+ check_selection(term, old_curs, term->curs);
+ seen_disp_event(term);
+ break;
+ }
+ }
+ } else
+ switch (term->termstate) {
+ case TOPLEVEL:
+ /* Only graphic characters get this far;
+ * ctrls are stripped above */
+ term_display_graphic_char(term, c);
+ term->last_graphic_char = c;
+ break;
+
+ case OSC_MAYBE_ST:
+ /*
+ * This state is virtually identical to SEEN_ESC, with the
+ * exception that we have an OSC sequence in the pipeline,
+ * and _if_ we see a backslash, we process it.
+ */
+ if (c == '\\') {
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ }
+ /* else fall through */
+ case SEEN_ESC:
+ if (c >= ' ' && c <= '/') {
+ if (term->esc_query)
+ term->esc_query = -1;
+ else
+ term->esc_query = c;
+ break;
+ }
+ term->termstate = TOPLEVEL;
+ switch (ANSI(c, term->esc_query)) {
+ case '[': /* enter CSI mode */
+ term->termstate = SEEN_CSI;
+ term->esc_nargs = 1;
+ term->esc_args[0] = ARG_DEFAULT;
+ term->esc_query = 0;
+ break;
+ case ']': /* OSC: xterm escape sequences */
+ /* Compatibility is nasty here, xterm, linux, decterm yuk! */
+ compatibility(OTHER);
+ term->termstate = SEEN_OSC;
+ term->osc_strlen = 0;
+ term->esc_args[0] = 0;
+ term->esc_nargs = 1;
+ break;
+ case '7': /* DECSC: save cursor */
+ compatibility(VT100);
+ save_cursor(term, true);
+ break;
+ case '8': /* DECRC: restore cursor */
+ compatibility(VT100);
+ save_cursor(term, false);
+ seen_disp_event(term);
+ break;
+ case '=': /* DECKPAM: Keypad application mode */
+ compatibility(VT100);
+ term->app_keypad_keys = true;
+ break;
+ case '>': /* DECKPNM: Keypad numeric mode */
+ compatibility(VT100);
+ term->app_keypad_keys = false;
+ break;
+ case 'D': /* IND: exactly equivalent to LF */
+ compatibility(VT100);
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ case 'E': /* NEL: exactly equivalent to CR-LF */
+ compatibility(VT100);
+ term->curs.x = 0;
+ if (term->curs.y == term->marg_b)
+ scroll(term, term->marg_t, term->marg_b, 1, true);
+ else if (term->curs.y < term->rows - 1)
+ term->curs.y++;
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ case 'M': /* RI: reverse index - backwards LF */
+ compatibility(VT100);
+ if (term->curs.y == term->marg_t)
+ scroll(term, term->marg_t, term->marg_b, -1, true);
+ else if (term->curs.y > 0)
+ term->curs.y--;
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ case 'Z': /* DECID: terminal type query */
+ compatibility(VT100);
+ if (term->ldisc)
+ ldisc_send(term->ldisc, term->id_string,
+ strlen(term->id_string), false);
+ break;
+ case 'c': /* RIS: restore power-on settings */
+ compatibility(VT100);
+ power_on(term, true);
+ if (term->ldisc) /* cause ldisc to notice changes */
+ ldisc_echoedit_update(term->ldisc);
+ if (term->reset_132) {
+ if (!term->no_remote_resize)
+ term_request_resize(term, 80, term->rows);
+ term->reset_132 = false;
+ }
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ seen_disp_event(term);
+ break;
+ case 'H': /* HTS: set a tab */
+ compatibility(VT100);
+ term->tabs[term->curs.x] = true;
+ break;
+
+ case ANSI('8', '#'): { /* DECALN: fills screen with Es :-) */
+ compatibility(VT100);
+ termline *ldata;
+ int i, j;
+ pos scrtop, scrbot;
+
+ for (i = 0; i < term->rows; i++) {
+ ldata = scrlineptr(i);
+ check_line_size(term, ldata);
+ for (j = 0; j < term->cols; j++) {
+ copy_termchar(ldata, j,
+ &term->basic_erase_char);
+ ldata->chars[j].chr = 'E';
+ }
+ ldata->lattr = LATTR_NORM;
+ }
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ seen_disp_event(term);
+ scrtop.x = scrtop.y = 0;
+ scrbot.x = 0;
+ scrbot.y = term->rows;
+ check_selection(term, scrtop, scrbot);
+ break;
+ }
+
+ case ANSI('3', '#'):
+ case ANSI('4', '#'):
+ case ANSI('5', '#'):
+ case ANSI('6', '#'): {
+ compatibility(VT100);
+ int nlattr;
+ termline *ldata;
+
+ switch (ANSI(c, term->esc_query)) {
+ case ANSI('3', '#'): /* DECDHL: 2*height, top */
+ nlattr = LATTR_TOP;
+ break;
+ case ANSI('4', '#'): /* DECDHL: 2*height, bottom */
+ nlattr = LATTR_BOT;
+ break;
+ case ANSI('5', '#'): /* DECSWL: normal */
+ nlattr = LATTR_NORM;
+ break;
+ default: /* case ANSI('6', '#'): DECDWL: 2*width */
+ nlattr = LATTR_WIDE;
+ break;
+ }
+ ldata = scrlineptr(term->curs.y);
+ check_line_size(term, ldata);
+ check_trust_status(term, ldata);
+ ldata->lattr = nlattr;
+ break;
+ }
+ /* GZD4: G0 designate 94-set */
+ case ANSI('A', '('):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[0] = CSET_GBCHR;
+ break;
+ case ANSI('B', '('):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[0] = CSET_ASCII;
+ break;
+ case ANSI('0', '('):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[0] = CSET_LINEDRW;
+ break;
+ case ANSI('U', '('):
+ compatibility(OTHER);
+ if (!term->no_remote_charset)
+ term->cset_attr[0] = CSET_SCOACS;
+ break;
+ /* G1D4: G1-designate 94-set */
+ case ANSI('A', ')'):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[1] = CSET_GBCHR;
+ break;
+ case ANSI('B', ')'):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[1] = CSET_ASCII;
+ break;
+ case ANSI('0', ')'):
+ compatibility(VT100);
+ if (!term->no_remote_charset)
+ term->cset_attr[1] = CSET_LINEDRW;
+ break;
+ case ANSI('U', ')'):
+ compatibility(OTHER);
+ if (!term->no_remote_charset)
+ term->cset_attr[1] = CSET_SCOACS;
+ break;
+ /* DOCS: Designate other coding system */
+ case ANSI('8', '%'): /* Old Linux code */
+ case ANSI('G', '%'):
+ compatibility(OTHER);
+ if (!term->no_remote_charset)
+ term->utf = true;
+ break;
+ case ANSI('@', '%'):
+ compatibility(OTHER);
+ if (!term->no_remote_charset)
+ term->utf = false;
+ break;
+ }
+ break;
+ case SEEN_CSI:
+ term->termstate = TOPLEVEL; /* default */
+ if (isdigit(c)) {
+ if (term->esc_nargs <= ARGS_MAX) {
+ if (term->esc_args[term->esc_nargs - 1] == ARG_DEFAULT)
+ term->esc_args[term->esc_nargs - 1] = 0;
+ if (term->esc_args[term->esc_nargs - 1] <=
+ UINT_MAX / 10 &&
+ term->esc_args[term->esc_nargs - 1] * 10 <=
+ UINT_MAX - c - '0')
+ term->esc_args[term->esc_nargs - 1] =
+ 10 * term->esc_args[term->esc_nargs - 1] +
+ c - '0';
+ else
+ term->esc_args[term->esc_nargs - 1] = UINT_MAX;
+ }
+ term->termstate = SEEN_CSI;
+ } else if (c == ';') {
+ if (term->esc_nargs < ARGS_MAX)
+ term->esc_args[term->esc_nargs++] = ARG_DEFAULT;
+ term->termstate = SEEN_CSI;
+ } else if (c < '@') {
+ if (term->esc_query)
+ term->esc_query = -1;
+ else if (c == '?')
+ term->esc_query = 1;
+ else
+ term->esc_query = c;
+ term->termstate = SEEN_CSI;
+ } else
+#define CLAMP(arg, lim) ((arg) = ((arg) > (lim)) ? (lim) : (arg))
+ switch (ANSI(c, term->esc_query)) {
+ case 'A': /* CUU: move up N lines */
+ CLAMP(term->esc_args[0], term->rows);
+ move(term, term->curs.x,
+ term->curs.y - def(term->esc_args[0], 1), 1);
+ seen_disp_event(term);
+ break;
+ case 'e': /* VPR: move down N lines */
+ compatibility(ANSI);
+ /* FALLTHROUGH */
+ case 'B': /* CUD: Cursor down */
+ CLAMP(term->esc_args[0], term->rows);
+ move(term, term->curs.x,
+ term->curs.y + def(term->esc_args[0], 1), 1);
+ seen_disp_event(term);
+ break;
+ case 'b': /* REP: repeat previous grap */
+ CLAMP(term->esc_args[0], term->rows * term->cols);
+ if (term->last_graphic_char) {
+ unsigned i;
+ for (i = 0; i < term->esc_args[0]; i++)
+ term_display_graphic_char(
+ term, term->last_graphic_char);
+ }
+ break;
+ case ANSI('c', '>'): /* DA: report xterm version */
+ compatibility(OTHER);
+ /* this reports xterm version 136 so that VIM can
+ use the drag messages from the mouse reporting */
+ if (term->ldisc)
+ ldisc_send(term->ldisc, "\033[>0;136;0c", 11,
+ false);
+ break;
+ case 'a': /* HPR: move right N cols */
+ compatibility(ANSI);
+ /* FALLTHROUGH */
+ case 'C': /* CUF: Cursor right */
+ CLAMP(term->esc_args[0], term->cols);
+ move(term, term->curs.x + def(term->esc_args[0], 1),
+ term->curs.y, 1);
+ seen_disp_event(term);
+ break;
+ case 'D': /* CUB: move left N cols */
+ CLAMP(term->esc_args[0], term->cols);
+ move(term, term->curs.x - def(term->esc_args[0], 1),
+ term->curs.y, 1);
+ seen_disp_event(term);
+ break;
+ case 'E': /* CNL: move down N lines and CR */
+ compatibility(ANSI);
+ CLAMP(term->esc_args[0], term->rows);
+ move(term, 0,
+ term->curs.y + def(term->esc_args[0], 1), 1);
+ seen_disp_event(term);
+ break;
+ case 'F': /* CPL: move up N lines and CR */
+ compatibility(ANSI);
+ CLAMP(term->esc_args[0], term->rows);
+ move(term, 0,
+ term->curs.y - def(term->esc_args[0], 1), 1);
+ seen_disp_event(term);
+ break;
+ case 'G': /* CHA */
+ case '`': /* HPA: set horizontal posn */
+ compatibility(ANSI);
+ CLAMP(term->esc_args[0], term->cols);
+ move(term, def(term->esc_args[0], 1) - 1,
+ term->curs.y, 0);
+ seen_disp_event(term);
+ break;
+ case 'd': /* VPA: set vertical posn */
+ compatibility(ANSI);
+ CLAMP(term->esc_args[0], term->rows);
+ move(term, term->curs.x,
+ ((term->dec_om ? term->marg_t : 0) +
+ def(term->esc_args[0], 1) - 1),
+ (term->dec_om ? 2 : 0));
+ seen_disp_event(term);
+ break;
+ case 'H': /* CUP */
+ case 'f': /* HVP: set horz and vert posns at once */
+ if (term->esc_nargs < 2)
+ term->esc_args[1] = ARG_DEFAULT;
+ CLAMP(term->esc_args[0], term->rows);
+ CLAMP(term->esc_args[1], term->cols);
+ move(term, def(term->esc_args[1], 1) - 1,
+ ((term->dec_om ? term->marg_t : 0) +
+ def(term->esc_args[0], 1) - 1),
+ (term->dec_om ? 2 : 0));
+ seen_disp_event(term);
+ break;
+ case 'J': { /* ED: erase screen or parts of it */
+ unsigned int i = def(term->esc_args[0], 0);
+ if (i == 3) {
+ /* Erase Saved Lines (xterm)
+ * This follows Thomas Dickey's xterm. */
+ if (!term->no_remote_clearscroll)
+ term_clrsb(term);
+ } else {
+ i++;
+ if (i > 3)
+ i = 0;
+ erase_lots(term, false, !!(i & 2), !!(i & 1));
+ }
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ seen_disp_event(term);
+ break;
+ }
+ case 'K': { /* EL: erase line or parts of it */
+ unsigned int i = def(term->esc_args[0], 0) + 1;
+ if (i > 3)
+ i = 0;
+ erase_lots(term, true, !!(i & 2), !!(i & 1));
+ seen_disp_event(term);
+ break;
+ }
+ case 'L': /* IL: insert lines */
+ compatibility(VT102);
+ CLAMP(term->esc_args[0], term->rows);
+ if (term->curs.y <= term->marg_b)
+ scroll(term, term->curs.y, term->marg_b,
+ -def(term->esc_args[0], 1), false);
+ seen_disp_event(term);
+ break;
+ case 'M': /* DL: delete lines */
+ compatibility(VT102);
+ CLAMP(term->esc_args[0], term->rows);
+ if (term->curs.y <= term->marg_b)
+ scroll(term, term->curs.y, term->marg_b,
+ def(term->esc_args[0], 1),
+ true);
+ seen_disp_event(term);
+ break;
+ case '@': /* ICH: insert chars */
+ /* XXX VTTEST says this is vt220, vt510 manual says vt102 */
+ compatibility(VT102);
+ CLAMP(term->esc_args[0], term->cols);
+ insch(term, def(term->esc_args[0], 1));
+ seen_disp_event(term);
+ break;
+ case 'P': /* DCH: delete chars */
+ compatibility(VT102);
+ CLAMP(term->esc_args[0], term->cols);
+ insch(term, -def(term->esc_args[0], 1));
+ seen_disp_event(term);
+ break;
+ case 'c': /* DA: terminal type query */
+ compatibility(VT100);
+ /* This is the response for a VT102 */
+ if (term->ldisc)
+ ldisc_send(term->ldisc, term->id_string,
+ strlen(term->id_string), false);
+ break;
+ case 'n': /* DSR: cursor position query */
+ if (term->ldisc) {
+ if (term->esc_args[0] == 6) {
+ char buf[32];
+ sprintf(buf, "\033[%d;%dR", term->curs.y + 1,
+ term->curs.x + 1);
+ ldisc_send(term->ldisc, buf, strlen(buf),
+ false);
+ } else if (term->esc_args[0] == 5) {
+ ldisc_send(term->ldisc, "\033[0n", 4, false);
+ }
+ }
+ break;
+ case 'h': /* SM: toggle modes to high */
+ case ANSI_QUE('h'):
+ compatibility(VT100);
+ for (int i = 0; i < term->esc_nargs; i++)
+ toggle_mode(term, term->esc_args[i],
+ term->esc_query, true);
+ break;
+ case 'i': /* MC: Media copy */
+ case ANSI_QUE('i'): {
+ compatibility(VT100);
+ char *printer;
+ if (term->esc_nargs != 1) break;
+ if (term->esc_args[0] == 5 &&
+ (printer = conf_get_str(term->conf,
+ CONF_printer))[0]) {
+ term->printing = true;
+ term->only_printing = !term->esc_query;
+ term->print_state = 0;
+ term_print_setup(term, printer);
+ } else if (term->esc_args[0] == 4 &&
+ term->printing) {
+ term_print_finish(term);
+ }
+ break;
+ }
+ case 'l': /* RM: toggle modes to low */
+ case ANSI_QUE('l'):
+ compatibility(VT100);
+ for (int i = 0; i < term->esc_nargs; i++)
+ toggle_mode(term, term->esc_args[i],
+ term->esc_query, false);
+ break;
+ case 'g': /* TBC: clear tabs */
+ compatibility(VT100);
+ if (term->esc_nargs == 1) {
+ if (term->esc_args[0] == 0) {
+ term->tabs[term->curs.x] = false;
+ } else if (term->esc_args[0] == 3) {
+ int i;
+ for (i = 0; i < term->cols; i++)
+ term->tabs[i] = false;
+ }
+ }
+ break;
+ case 'r': /* DECSTBM: set scroll margins */
+ compatibility(VT100);
+ if (term->esc_nargs <= 2) {
+ int top, bot;
+ CLAMP(term->esc_args[0], term->rows);
+ CLAMP(term->esc_args[1], term->rows);
+ top = def(term->esc_args[0], 1) - 1;
+ bot = (term->esc_nargs <= 1
+ || term->esc_args[1] == 0 ?
+ term->rows :
+ def(term->esc_args[1], term->rows)) - 1;
+ if (bot >= term->rows)
+ bot = term->rows - 1;
+ /* VTTEST Bug 9 - if region is less than 2 lines
+ * don't change region.
+ */
+ if (bot - top > 0) {
+ term->marg_t = top;
+ term->marg_b = bot;
+ term->curs.x = 0;
+ /*
+ * I used to think the cursor should be
+ * placed at the top of the newly marginned
+ * area. Apparently not: VMS TPU falls over
+ * if so.
+ *
+ * Well actually it should for
+ * Origin mode - RDB
+ */
+ term->curs.y = (term->dec_om ?
+ term->marg_t : 0);
+ seen_disp_event(term);
+ }
+ }
+ break;
+ case 'm': /* SGR: set graphics rendition */
+ /*
+ * A VT100 without the AVO only had one
+ * attribute, either underline or reverse
+ * video depending on the cursor type, this
+ * was selected by CSI 7m.
+ *
+ * case 2:
+ * This is sometimes DIM, eg on the GIGI and
+ * Linux
+ * case 8:
+ * This is sometimes INVIS various ANSI.
+ * case 21:
+ * This like 22 disables BOLD, DIM and INVIS
+ *
+ * The ANSI colours appear on any terminal
+ * that has colour (obviously) but the
+ * interaction between sgr0 and the colours
+ * varies but is usually related to the
+ * background colour erase item. The
+ * interaction between colour attributes and
+ * the mono ones is also very implementation
+ * dependent.
+ *
+ * The 39 and 49 attributes are likely to be
+ * unimplemented.
+ */
+ for (int i = 0; i < term->esc_nargs; i++)
+ switch (def(term->esc_args[i], 0)) {
+ case 0: /* restore defaults */
+ term->curr_attr = term->default_attr;
+ term->curr_truecolour =
+ term->basic_erase_char.truecolour;
+ break;
+ case 1: /* enable bold */
+ compatibility(VT100AVO);
+ term->curr_attr |= ATTR_BOLD;
+ break;
+ case 2: /* enable dim */
+ compatibility(OTHER);
+ term->curr_attr |= ATTR_DIM;
+ break;
+ case 21: /* (enable double underline) */
+ compatibility(OTHER);
+ case 4: /* enable underline */
+ compatibility(VT100AVO);
+ term->curr_attr |= ATTR_UNDER;
+ break;
+ case 5: /* enable blink */
+ compatibility(VT100AVO);
+ term->curr_attr |= ATTR_BLINK;
+ break;
+ case 6: /* SCO light bkgrd */
+ compatibility(SCOANSI);
+ term->blink_is_real = false;
+ term->curr_attr |= ATTR_BLINK;
+ term_schedule_tblink(term);
+ break;
+ case 7: /* enable reverse video */
+ term->curr_attr |= ATTR_REVERSE;
+ break;
+ case 9: /* enable strikethrough */
+ term->curr_attr |= ATTR_STRIKE;
+ break;
+ case 10: /* SCO acs off */
+ compatibility(SCOANSI);
+ if (term->no_remote_charset) break;
+ term->sco_acs = 0; break;
+ case 11: /* SCO acs on */
+ compatibility(SCOANSI);
+ if (term->no_remote_charset) break;
+ term->sco_acs = 1; break;
+ case 12: /* SCO acs on, |0x80 */
+ compatibility(SCOANSI);
+ if (term->no_remote_charset) break;
+ term->sco_acs = 2; break;
+ case 22: /* disable bold and dim */
+ compatibility2(OTHER, VT220);
+ term->curr_attr &= ~(ATTR_BOLD | ATTR_DIM);
+ break;
+ case 24: /* disable underline */
+ compatibility2(OTHER, VT220);
+ term->curr_attr &= ~ATTR_UNDER;
+ break;
+ case 25: /* disable blink */
+ compatibility2(OTHER, VT220);
+ term->curr_attr &= ~ATTR_BLINK;
+ break;
+ case 27: /* disable reverse video */
+ compatibility2(OTHER, VT220);
+ term->curr_attr &= ~ATTR_REVERSE;
+ break;
+ case 29: /* disable strikethrough */
+ term->curr_attr &= ~ATTR_STRIKE;
+ break;
+ case 30:
+ case 31:
+ case 32:
+ case 33:
+ case 34:
+ case 35:
+ case 36:
+ case 37:
+ /* foreground */
+ term->curr_truecolour.fg.enabled = false;
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |=
+ (term->esc_args[i] - 30)<<ATTR_FGSHIFT;
+ break;
+ case 90:
+ case 91:
+ case 92:
+ case 93:
+ case 94:
+ case 95:
+ case 96:
+ case 97:
+ /* aixterm-style bright foreground */
+ term->curr_truecolour.fg.enabled = false;
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i] - 90 + 8)
+ << ATTR_FGSHIFT);
+ break;
+ case 39: /* default-foreground */
+ term->curr_truecolour.fg.enabled = false;
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |= ATTR_DEFFG;
+ break;
+ case 40:
+ case 41:
+ case 42:
+ case 43:
+ case 44:
+ case 45:
+ case 46:
+ case 47:
+ /* background */
+ term->curr_truecolour.bg.enabled = false;
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |=
+ (term->esc_args[i] - 40)<<ATTR_BGSHIFT;
+ break;
+ case 100:
+ case 101:
+ case 102:
+ case 103:
+ case 104:
+ case 105:
+ case 106:
+ case 107:
+ /* aixterm-style bright background */
+ term->curr_truecolour.bg.enabled = false;
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i] - 100 + 8)
+ << ATTR_BGSHIFT);
+ break;
+ case 49: /* default-background */
+ term->curr_truecolour.bg.enabled = false;
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |= ATTR_DEFBG;
+ break;
+
+ /*
+ * 256-colour and true-colour
+ * sequences. A 256-colour
+ * foreground is selected by a
+ * sequence of 3 arguments in the
+ * form 38;5;n, where n is in the
+ * range 0-255. A true-colour RGB
+ * triple is selected by 5 args of
+ * the form 38;2;r;g;b. Replacing
+ * the initial 38 with 48 in both
+ * cases selects the same colour
+ * as the background.
+ */
+ case 38:
+ if (i+2 < term->esc_nargs &&
+ term->esc_args[i+1] == 5) {
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i+2] & 0xFF)
+ << ATTR_FGSHIFT);
+ term->curr_truecolour.fg =
+ optionalrgb_none;
+ i += 2;
+ }
+ if (i + 4 < term->esc_nargs &&
+ term->esc_args[i + 1] == 2) {
+ parse_optionalrgb(
+ &term->curr_truecolour.fg,
+ term->esc_args + (i+2));
+ i += 4;
+ }
+ break;
+ case 48:
+ if (i+2 < term->esc_nargs &&
+ term->esc_args[i+1] == 5) {
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i+2] & 0xFF)
+ << ATTR_BGSHIFT);
+ term->curr_truecolour.bg =
+ optionalrgb_none;
+ i += 2;
+ }
+ if (i + 4 < term->esc_nargs &&
+ term->esc_args[i+1] == 2) {
+ parse_optionalrgb(
+ &term->curr_truecolour.bg,
+ term->esc_args + (i+2));
+ i += 4;
+ }
+ break;
+ }
+ set_erase_char(term);
+ break;
+ case 's': /* save cursor */
+ save_cursor(term, true);
+ break;
+ case 'u': /* restore cursor */
+ save_cursor(term, false);
+ seen_disp_event(term);
+ break;
+ case 't': /* DECSLPP: set page size - ie window height */
+ /*
+ * VT340/VT420 sequence DECSLPP, DEC only allows values
+ * 24/25/36/48/72/144 other emulators (eg dtterm) use
+ * illegal values (eg first arg 1..9) for window changing
+ * and reports.
+ */
+ if (term->esc_nargs <= 1
+ && (term->esc_args[0] < 1 ||
+ term->esc_args[0] >= 24)) {
+ compatibility(VT340TEXT);
+ if (!term->no_remote_resize)
+ term_request_resize(term, term->cols, 24);
+ deselect(term);
+ } else if (term->esc_nargs >= 1 &&
+ term->esc_args[0] >= 1 &&
+ term->esc_args[0] < 24) {
+ compatibility(OTHER);
+
+ switch (term->esc_args[0]) {
+ int len;
+ char buf[80];
+ const char *p;
+ case 1:
+ term->win_minimise_pending = true;
+ term->win_minimise_enable = false;
+ term_schedule_update(term);
+ break;
+ case 2:
+ term->win_minimise_pending = true;
+ term->win_minimise_enable = true;
+ term_schedule_update(term);
+ break;
+ case 3:
+ if (term->esc_nargs >= 3) {
+ if (!term->no_remote_resize) {
+ term->win_move_pending = true;
+ term->win_move_pending_x =
+ def(term->esc_args[1], 0);
+ term->win_move_pending_y =
+ def(term->esc_args[2], 0);
+ term_schedule_update(term);
+ }
+ }
+ break;
+ case 4:
+ /* We should resize the window to a given
+ * size in pixels here, but currently our
+ * resizing code isn't healthy enough to
+ * manage it. */
+ break;
+ case 5:
+ /* move to top */
+ term->win_zorder_pending = true;
+ term->win_zorder_top = true;
+ term_schedule_update(term);
+ break;
+ case 6:
+ /* move to bottom */
+ term->win_zorder_pending = true;
+ term->win_zorder_top = false;
+ term_schedule_update(term);
+ break;
+ case 7:
+ term->win_refresh_pending = true;
+ term_schedule_update(term);
+ break;
+ case 8:
+ if (term->esc_nargs >= 3 &&
+ !term->no_remote_resize) {
+ term_request_resize(
+ term,
+ def(term->esc_args[2],
+ term->conf_width),
+ def(term->esc_args[1],
+ term->conf_height));
+ }
+ break;
+ case 9:
+ if (term->esc_nargs >= 2) {
+ term->win_maximise_pending = true;
+ term->win_maximise_enable =
+ term->esc_args[1];
+ term_schedule_update(term);
+ }
+ break;
+ case 11:
+ if (term->ldisc)
+ ldisc_send(term->ldisc, term->minimised ?
+ "\033[2t" : "\033[1t", 4,
+ false);
+ break;
+ case 13:
+ if (term->ldisc) {
+ len = sprintf(buf, "\033[3;%u;%ut",
+ term->winpos_x,
+ term->winpos_y);
+ ldisc_send(term->ldisc, buf, len, false);
+ }
+ break;
+ case 14:
+ if (term->ldisc) {
+ len = sprintf(buf, "\033[4;%u;%ut",
+ term->winpixsize_y,
+ term->winpixsize_x);
+ ldisc_send(term->ldisc, buf, len, false);
+ }
+ break;
+ case 18:
+ if (term->ldisc) {
+ len = sprintf(buf, "\033[8;%d;%dt",
+ term->rows, term->cols);
+ ldisc_send(term->ldisc, buf, len, false);
+ }
+ break;
+ case 19:
+ /*
+ * Hmmm. Strictly speaking we
+ * should return `the size of the
+ * screen in characters', but
+ * that's not easy: (a) window
+ * furniture being what it is it's
+ * hard to compute, and (b) in
+ * resize-font mode maximising the
+ * window wouldn't change the
+ * number of characters. *shrug*. I
+ * think we'll ignore it for the
+ * moment and see if anyone
+ * complains, and then ask them
+ * what they would like it to do.
+ */
+ break;
+ case 20:
+ if (term->ldisc &&
+ term->remote_qtitle_action != TITLE_NONE) {
+ if(term->remote_qtitle_action == TITLE_REAL)
+ p = term->icon_title;
+ else
+ p = EMPTY_WINDOW_TITLE;
+ len = strlen(p);
+ ldisc_send(term->ldisc, "\033]L", 3,
+ false);
+ ldisc_send(term->ldisc, p, len, false);
+ ldisc_send(term->ldisc, "\033\\", 2,
+ false);
+ }
+ break;
+ case 21:
+ if (term->ldisc &&
+ term->remote_qtitle_action != TITLE_NONE) {
+ if(term->remote_qtitle_action == TITLE_REAL)
+ p = term->window_title;
+ else
+ p = EMPTY_WINDOW_TITLE;
+ len = strlen(p);
+ ldisc_send(term->ldisc, "\033]l", 3,
+ false);
+ ldisc_send(term->ldisc, p, len, false);
+ ldisc_send(term->ldisc, "\033\\", 2,
+ false);
+ }
+ break;
+ }
+ }
+ break;
+ case 'S': /* SU: Scroll up */
+ CLAMP(term->esc_args[0], term->rows);
+ compatibility(SCOANSI);
+ scroll(term, term->marg_t, term->marg_b,
+ def(term->esc_args[0], 1), true);
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ case 'T': /* SD: Scroll down */
+ CLAMP(term->esc_args[0], term->rows);
+ compatibility(SCOANSI);
+ scroll(term, term->marg_t, term->marg_b,
+ -def(term->esc_args[0], 1), true);
+ term->wrapnext = false;
+ seen_disp_event(term);
+ break;
+ case ANSI('|', '*'): /* DECSNLS */
+ /*
+ * Set number of lines on screen
+ * VT420 uses VGA like hardware and can
+ * support any size in reasonable range
+ * (24..49 AIUI) with no default specified.
+ */
+ compatibility(VT420);
+ if (term->esc_nargs == 1 && term->esc_args[0] > 0) {
+ if (!term->no_remote_resize)
+ term_request_resize(
+ term,
+ term->cols,
+ def(term->esc_args[0], term->conf_height));
+ deselect(term);
+ }
+ break;
+ case ANSI('|', '$'): /* DECSCPP */
+ /*
+ * Set number of columns per page
+ * Docs imply range is only 80 or 132, but
+ * I'll allow any.
+ */
+ compatibility(VT340TEXT);
+ if (term->esc_nargs <= 1) {
+ if (!term->no_remote_resize)
+ term_request_resize(
+ term,
+ def(term->esc_args[0], term->conf_width),
+ term->rows);
+ deselect(term);
+ }
+ break;
+ case 'X': { /* ECH: write N spaces w/o moving cursor */
+ /* XXX VTTEST says this is vt220, vt510 manual
+ * says vt100 */
+ compatibility(ANSIMIN);
+ CLAMP(term->esc_args[0], term->cols);
+ int n = def(term->esc_args[0], 1);
+ pos cursplus;
+ int p = term->curs.x;
+ termline *cline = scrlineptr(term->curs.y);
+
+ check_trust_status(term, cline);
+ if (n > term->cols - term->curs.x)
+ n = term->cols - term->curs.x;
+ cursplus = term->curs;
+ cursplus.x += n;
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+n, term->curs.y);
+ check_selection(term, term->curs, cursplus);
+ while (n--)
+ copy_termchar(cline, p++,
+ &term->erase_char);
+ seen_disp_event(term);
+ break;
+ }
+ case 'x': /* DECREQTPARM: report terminal characteristics */
+ compatibility(VT100);
+ if (term->ldisc) {
+ char buf[32];
+ int i = def(term->esc_args[0], 0);
+ if (i == 0 || i == 1) {
+ strcpy(buf, "\033[2;1;1;112;112;1;0x");
+ buf[2] += i;
+ ldisc_send(term->ldisc, buf, 20, false);
+ }
+ }
+ break;
+ case 'Z': { /* CBT */
+ compatibility(OTHER);
+ CLAMP(term->esc_args[0], term->cols);
+ int i = def(term->esc_args[0], 1);
+ pos old_curs = term->curs;
+
+ for(;i>0 && term->curs.x>0; i--) {
+ do {
+ term->curs.x--;
+ } while (term->curs.x >0 &&
+ !term->tabs[term->curs.x]);
+ }
+ check_selection(term, old_curs, term->curs);
+ break;
+ }
+ case ANSI('c', '='): /* Hide or Show Cursor */
+ compatibility(SCOANSI);
+ switch(term->esc_args[0]) {
+ case 0: /* hide cursor */
+ term->cursor_on = false;
+ break;
+ case 1: /* restore cursor */
+ term->big_cursor = false;
+ term->cursor_on = true;
+ break;
+ case 2: /* block cursor */
+ term->big_cursor = true;
+ term->cursor_on = true;
+ break;
+ }
+ break;
+ case ANSI('C', '='):
+ /*
+ * set cursor start on scanline esc_args[0] and
+ * end on scanline esc_args[1].If you set
+ * the bottom scan line to a value less than
+ * the top scan line, the cursor will disappear.
+ */
+ compatibility(SCOANSI);
+ if (term->esc_nargs >= 2) {
+ if (term->esc_args[0] > term->esc_args[1])
+ term->cursor_on = false;
+ else
+ term->cursor_on = true;
+ }
+ break;
+ case ANSI('D', '='):
+ compatibility(SCOANSI);
+ term->blink_is_real = false;
+ term_schedule_tblink(term);
+ if (term->esc_args[0]>=1)
+ term->curr_attr |= ATTR_BLINK;
+ else
+ term->curr_attr &= ~ATTR_BLINK;
+ break;
+ case ANSI('E', '='):
+ compatibility(SCOANSI);
+ term->blink_is_real = (term->esc_args[0] >= 1);
+ term_schedule_tblink(term);
+ break;
+ case ANSI('F', '='): /* set normal foreground */
+ compatibility(SCOANSI);
+ if (term->esc_args[0] < 16) {
+ long colour =
+ (sco2ansicolour[term->esc_args[0] & 0x7] |
+ (term->esc_args[0] & 0x8)) <<
+ ATTR_FGSHIFT;
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |= colour;
+ term->curr_truecolour.fg = optionalrgb_none;
+ term->default_attr &= ~ATTR_FGMASK;
+ term->default_attr |= colour;
+ set_erase_char(term);
+ }
+ break;
+ case ANSI('G', '='): /* set normal background */
+ compatibility(SCOANSI);
+ if (term->esc_args[0] < 16) {
+ long colour =
+ (sco2ansicolour[term->esc_args[0] & 0x7] |
+ (term->esc_args[0] & 0x8)) <<
+ ATTR_BGSHIFT;
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |= colour;
+ term->curr_truecolour.bg = optionalrgb_none;
+ term->default_attr &= ~ATTR_BGMASK;
+ term->default_attr |= colour;
+ set_erase_char(term);
+ }
+ break;
+ case ANSI('L', '='):
+ compatibility(SCOANSI);
+ term->use_bce = (term->esc_args[0] <= 0);
+ set_erase_char(term);
+ break;
+ case ANSI('p', '"'): /* DECSCL: set compat level */
+ /*
+ * Allow the host to make this emulator a
+ * 'perfect' VT102. This first appeared in
+ * the VT220, but we do need to get back to
+ * PuTTY mode so I won't check it.
+ *
+ * The arg in 40..42,50 are a PuTTY extension.
+ * The 2nd arg, 8bit vs 7bit is not checked.
+ *
+ * Setting VT102 mode should also change
+ * the Fkeys to generate PF* codes as a
+ * real VT102 has no Fkeys. The VT220 does
+ * this, F11..F13 become ESC,BS,LF other
+ * Fkeys send nothing.
+ *
+ * Note ESC c will NOT change this!
+ */
+
+ switch (term->esc_args[0]) {
+ case 61:
+ term->compatibility_level &= ~TM_VTXXX;
+ term->compatibility_level |= TM_VT102;
+ break;
+ case 62:
+ term->compatibility_level &= ~TM_VTXXX;
+ term->compatibility_level |= TM_VT220;
+ break;
+
+ default:
+ if (term->esc_args[0] > 60 &&
+ term->esc_args[0] < 70)
+ term->compatibility_level |= TM_VTXXX;
+ break;
+
+ case 40:
+ term->compatibility_level &= TM_VTXXX;
+ break;
+ case 41:
+ term->compatibility_level = TM_PUTTY;
+ break;
+ case 42:
+ term->compatibility_level = TM_SCOANSI;
+ break;
+
+ case ARG_DEFAULT:
+ term->compatibility_level = TM_PUTTY;
+ break;
+ case 50:
+ break;
+ }
+
+ /* Change the response to CSI c */
+ if (term->esc_args[0] == 50) {
+ int i;
+ char lbuf[64];
+ strcpy(term->id_string, "\033[?");
+ for (i = 1; i < term->esc_nargs; i++) {
+ if (i != 1)
+ strcat(term->id_string, ";");
+ sprintf(lbuf, "%u", term->esc_args[i]);
+ strcat(term->id_string, lbuf);
+ }
+ strcat(term->id_string, "c");
+ }
+#if 0
+ /* Is this a good idea ?
+ * Well we should do a soft reset at this point ...
+ */
+ if (!has_compat(VT420) && has_compat(VT100)) {
+ if (!term->no_remote_resize)
+ term_request_resize(term,
+ term->reset_132 ? 132 : 80,
+ 24);
+ }
+#endif
+ break;
+ }
+ break;
+ case SEEN_OSC:
+ term->osc_w = false;
+ switch (c) {
+ case 'P': /* Linux palette sequence */
+ term->termstate = SEEN_OSC_P;
+ term->osc_strlen = 0;
+ break;
+ case 'R': /* Linux palette reset */
+ palette_reset(term, false);
+ term_invalidate(term);
+ term->termstate = TOPLEVEL;
+ break;
+ case 'W': /* word-set */
+ term->termstate = SEEN_OSC_W;
+ term->osc_w = true;
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (term->esc_args[term->esc_nargs-1] <= UINT_MAX / 10 &&
+ term->esc_args[term->esc_nargs-1] * 10 <= UINT_MAX - c - '0')
+ term->esc_args[term->esc_nargs-1] =
+ 10 * term->esc_args[term->esc_nargs-1] + c - '0';
+ else
+ term->esc_args[term->esc_nargs-1] = UINT_MAX;
+ break;
+ case 0x9C:
+ /* Terminate even though we aren't in OSC_STRING yet */
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ case 0xC2:
+ if (in_utf(term)) {
+ /* Or be prepared for the UTF-8 version of that */
+ term->termstate = OSC_MAYBE_ST_UTF8;
+ }
+ break;
+ default:
+ /*
+ * _Most_ other characters here terminate the
+ * immediate parsing of the OSC sequence and go
+ * into OSC_STRING state, but we deal with a
+ * couple of exceptions first.
+ */
+ if (c == 'L' && term->esc_args[0] == 2) {
+ /*
+ * Grotty hack to support xterm and DECterm title
+ * sequences concurrently.
+ */
+ term->esc_args[0] = 1;
+ } else if (c == ';' && term->esc_nargs == 1 &&
+ term->esc_args[0] == 4) {
+ /*
+ * xterm's OSC 4 sequence to query the current
+ * RGB value of a colour takes a second
+ * numeric argument which is easiest to parse
+ * using the existing system rather than in
+ * do_osc.
+ */
+ term->esc_args[term->esc_nargs++] = 0;
+ } else {
+ term->termstate = OSC_STRING;
+ term->osc_strlen = 0;
+ }
+ }
+ break;
+ case OSC_STRING:
+ /*
+ * OSC sequences can be terminated or aborted in
+ * various ways.
+ *
+ * The official way to terminate an OSC, per written
+ * standards, is the String Terminator, SC. That can
+ * appear in a 7-bit two-character form ESC \, or as
+ * an 8-bit C1 control 0x9C.
+ *
+ * We only accept 0x9C in circumstances where it
+ * doesn't interfere with our main character set
+ * processing: so in ISO 8859-1, for example, the byte
+ * 0x9C is interpreted as ST, but in CP437 it's
+ * interpreted as an ordinary printing character (as
+ * it happens, the pound sign), because you might
+ * perfectly well want to put it in the window title
+ * like any other printing character.
+ *
+ * In particular, in UTF-8 mode, 0x9C is a perfectly
+ * valid continuation byte for an ordinary printing
+ * character, so we don't accept the C1 control form
+ * of ST unless it appears as a full UTF-8 character
+ * in its own right, i.e. bytes 0xC2 0x9C.
+ *
+ * BEL is also treated as a clean termination of OSC,
+ * which I believe was a behaviour introduced by
+ * xterm.
+ *
+ * To prevent run-on storage of OSC data forever if
+ * emission of a control sequence is interrupted, we
+ * also treat various control characters as illegal,
+ * so that they abort the OSC without processing it
+ * and return to TOPLEVEL state. These are CR, LF, and
+ * any ESC that is *not* followed by \.
+ */
+
+ if (c == '\012' || c == '\015') {
+ /* CR or LF aborts */
+ term->termstate = TOPLEVEL;
+ break;
+ }
+
+ if (c == '\033') {
+ /* ESC goes into a state where we wait to see if
+ * the next character is \ */
+ term->termstate = OSC_MAYBE_ST;
+ break;
+ }
+
+ if (c == '\007' || (c == 0x9C && !in_utf(term) &&
+ term->ucsdata->unitab_ctrl[c] != 0xFF)) {
+ /* BEL, or the C1 ST appearing as a one-byte
+ * encoding, cleanly terminates the OSC right here */
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ }
+
+ if (c == 0xC2 && in_utf(term)) {
+ /* 0xC2 is the UTF-8 character that might
+ * introduce the encoding of C1 ST */
+ term->termstate = OSC_MAYBE_ST_UTF8;
+ break;
+ }
+
+ /* Anything else gets added to the string */
+ if (term->osc_strlen < OSC_STR_MAX)
+ term->osc_string[term->osc_strlen++] = (char)c;
+ break;
+ case OSC_MAYBE_ST_UTF8:
+ /* In UTF-8 mode, we've seen C2, so are we now seeing
+ * 9C? */
+ if (c == 0x9C) {
+ /* Yes, so cleanly terminate the OSC */
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ }
+ /* No, so append the pending C2 byte to the OSC string
+ * followed by the current character, and go back to
+ * OSC string accumulation */
+ if (term->osc_strlen < OSC_STR_MAX)
+ term->osc_string[term->osc_strlen++] = 0xC2;
+ if (term->osc_strlen < OSC_STR_MAX)
+ term->osc_string[term->osc_strlen++] = (char)c;
+ term->termstate = OSC_STRING;
+ break;
+ case SEEN_OSC_P: {
+ int max = (term->osc_strlen == 0 ? 21 : 15);
+ int val;
+ if ((int)c >= '0' && (int)c <= '9')
+ val = c - '0';
+ else if ((int)c >= 'A' && (int)c <= 'A' + max - 10)
+ val = c - 'A' + 10;
+ else if ((int)c >= 'a' && (int)c <= 'a' + max - 10)
+ val = c - 'a' + 10;
+ else {
+ term->termstate = TOPLEVEL;
+ break;
+ }
+ term->osc_string[term->osc_strlen++] = val;
+ if (term->osc_strlen >= 7) {
+ unsigned oscp_index = term->osc_string[0];
+ assert(oscp_index < OSCP_NCOLOURS);
+ unsigned osc4_index =
+ colour_indices_oscp_to_osc4[oscp_index];
+
+ rgb *value = &term->subpalettes[SUBPAL_SESSION].values[
+ osc4_index];
+ value->r = term->osc_string[1] * 16 + term->osc_string[2];
+ value->g = term->osc_string[3] * 16 + term->osc_string[4];
+ value->b = term->osc_string[5] * 16 + term->osc_string[6];
+ term->subpalettes[SUBPAL_SESSION].present[
+ osc4_index] = true;
+
+ palette_rebuild(term);
+
+ term->termstate = TOPLEVEL;
+ }
+ break;
+ }
+ case SEEN_OSC_W:
+ switch (c) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (term->esc_args[0] <= UINT_MAX / 10 &&
+ term->esc_args[0] * 10 <= UINT_MAX - c - '0')
+ term->esc_args[0] = 10 * term->esc_args[0] + c - '0';
+ else
+ term->esc_args[0] = UINT_MAX;
+ break;
+ case 0x9C:
+ /* Terminate even though we aren't in OSC_STRING yet */
+ do_osc(term);
+ term->termstate = TOPLEVEL;
+ break;
+ case 0xC2:
+ if (in_utf(term)) {
+ /* Or be prepared for the UTF-8 version of that */
+ term->termstate = OSC_MAYBE_ST_UTF8;
+ }
+ break;
+ default:
+ term->termstate = OSC_STRING;
+ term->osc_strlen = 0;
+ }
+ break;
+ case VT52_ESC:
+ term->termstate = TOPLEVEL;
+ seen_disp_event(term);
+ switch (c) {
+ case 'A':
+ move(term, term->curs.x, term->curs.y - 1, 1);
+ break;
+ case 'B':
+ move(term, term->curs.x, term->curs.y + 1, 1);
+ break;
+ case 'C':
+ move(term, term->curs.x + 1, term->curs.y, 1);
+ break;
+ case 'D':
+ move(term, term->curs.x - 1, term->curs.y, 1);
+ break;
+ /*
+ * From the VT100 Manual
+ * NOTE: The special graphics characters in the VT100
+ * are different from those in the VT52
+ *
+ * From VT102 manual:
+ * 137 _ Blank - Same
+ * 140 ` Reserved - Humm.
+ * 141 a Solid rectangle - Similar
+ * 142 b 1/ - Top half of fraction for the
+ * 143 c 3/ - subscript numbers below.
+ * 144 d 5/
+ * 145 e 7/
+ * 146 f Degrees - Same
+ * 147 g Plus or minus - Same
+ * 150 h Right arrow
+ * 151 i Ellipsis (dots)
+ * 152 j Divide by
+ * 153 k Down arrow
+ * 154 l Bar at scan 0
+ * 155 m Bar at scan 1
+ * 156 n Bar at scan 2
+ * 157 o Bar at scan 3 - Similar
+ * 160 p Bar at scan 4 - Similar
+ * 161 q Bar at scan 5 - Similar
+ * 162 r Bar at scan 6 - Same
+ * 163 s Bar at scan 7 - Similar
+ * 164 t Subscript 0
+ * 165 u Subscript 1
+ * 166 v Subscript 2
+ * 167 w Subscript 3
+ * 170 x Subscript 4
+ * 171 y Subscript 5
+ * 172 z Subscript 6
+ * 173 { Subscript 7
+ * 174 | Subscript 8
+ * 175 } Subscript 9
+ * 176 ~ Paragraph
+ *
+ */
+ case 'F':
+ term->cset_attr[term->cset = 0] = CSET_LINEDRW;
+ break;
+ case 'G':
+ term->cset_attr[term->cset = 0] = CSET_ASCII;
+ break;
+ case 'H':
+ move(term, 0, 0, 0);
+ break;
+ case 'I':
+ if (term->curs.y == 0)
+ scroll(term, 0, term->rows - 1, -1, true);
+ else if (term->curs.y > 0)
+ term->curs.y--;
+ term->wrapnext = false;
+ break;
+ case 'J':
+ erase_lots(term, false, false, true);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 'K':
+ erase_lots(term, true, false, true);
+ break;
+#if 0
+ case 'V':
+ /* XXX Print cursor line */
+ break;
+ case 'W':
+ /* XXX Start controller mode */
+ break;
+ case 'X':
+ /* XXX Stop controller mode */
+ break;
+#endif
+ case 'Y':
+ term->termstate = VT52_Y1;
+ break;
+ case 'Z':
+ if (term->ldisc)
+ ldisc_send(term->ldisc, "\033/Z", 3, false);
+ break;
+ case '=':
+ term->app_keypad_keys = true;
+ break;
+ case '>':
+ term->app_keypad_keys = false;
+ break;
+ case '<':
+ /* XXX This should switch to VT100 mode not current or default
+ * VT mode. But this will only have effect in a VT220+
+ * emulation.
+ */
+ term->vt52_mode = false;
+ term->blink_is_real = term->blinktext;
+ term_schedule_tblink(term);
+ break;
+#if 0
+ case '^':
+ /* XXX Enter auto print mode */
+ break;
+ case '_':
+ /* XXX Exit auto print mode */
+ break;
+ case ']':
+ /* XXX Print screen */
+ break;
+#endif
+
+#ifdef VT52_PLUS
+ case 'E':
+ /* compatibility(ATARI) */
+ move(term, 0, 0, 0);
+ erase_lots(term, false, false, true);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 'L':
+ /* compatibility(ATARI) */
+ if (term->curs.y <= term->marg_b)
+ scroll(term, term->curs.y, term->marg_b, -1, false);
+ break;
+ case 'M':
+ /* compatibility(ATARI) */
+ if (term->curs.y <= term->marg_b)
+ scroll(term, term->curs.y, term->marg_b, 1, true);
+ break;
+ case 'b':
+ /* compatibility(ATARI) */
+ term->termstate = VT52_FG;
+ break;
+ case 'c':
+ /* compatibility(ATARI) */
+ term->termstate = VT52_BG;
+ break;
+ case 'd':
+ /* compatibility(ATARI) */
+ erase_lots(term, false, true, false);
+ if (term->scroll_on_disp)
+ term->disptop = 0;
+ break;
+ case 'e':
+ /* compatibility(ATARI) */
+ term->cursor_on = true;
+ break;
+ case 'f':
+ /* compatibility(ATARI) */
+ term->cursor_on = false;
+ break;
+ /* case 'j': Save cursor position - broken on ST */
+ /* case 'k': Restore cursor position */
+ case 'l':
+ /* compatibility(ATARI) */
+ erase_lots(term, true, true, true);
+ term->curs.x = 0;
+ term->wrapnext = false;
+ break;
+ case 'o':
+ /* compatibility(ATARI) */
+ erase_lots(term, true, true, false);
+ break;
+ case 'p':
+ /* compatibility(ATARI) */
+ term->curr_attr |= ATTR_REVERSE;
+ break;
+ case 'q':
+ /* compatibility(ATARI) */
+ term->curr_attr &= ~ATTR_REVERSE;
+ break;
+ case 'v': /* wrap Autowrap on - Wyse style */
+ /* compatibility(ATARI) */
+ term->wrap = true;
+ break;
+ case 'w': /* Autowrap off */
+ /* compatibility(ATARI) */
+ term->wrap = false;
+ break;
+
+ case 'R':
+ /* compatibility(OTHER) */
+ term->vt52_bold = false;
+ term->curr_attr = ATTR_DEFAULT;
+ term->curr_truecolour.fg = optionalrgb_none;
+ term->curr_truecolour.bg = optionalrgb_none;
+ set_erase_char(term);
+ break;
+ case 'S':
+ /* compatibility(VI50) */
+ term->curr_attr |= ATTR_UNDER;
+ break;
+ case 'W':
+ /* compatibility(VI50) */
+ term->curr_attr &= ~ATTR_UNDER;
+ break;
+ case 'U':
+ /* compatibility(VI50) */
+ term->vt52_bold = true;
+ term->curr_attr |= ATTR_BOLD;
+ break;
+ case 'T':
+ /* compatibility(VI50) */
+ term->vt52_bold = false;
+ term->curr_attr &= ~ATTR_BOLD;
+ break;
+#endif
+ }
+ break;
+ case VT52_Y1:
+ term->termstate = VT52_Y2;
+ move(term, term->curs.x, c - ' ', 0);
+ break;
+ case VT52_Y2:
+ term->termstate = TOPLEVEL;
+ move(term, c - ' ', term->curs.y, 0);
+ break;
+
+#ifdef VT52_PLUS
+ case VT52_FG:
+ term->termstate = TOPLEVEL;
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr &= ~ATTR_BOLD;
+ term->curr_attr |= (c & 0xF) << ATTR_FGSHIFT;
+ set_erase_char(term);
+ break;
+ case VT52_BG:
+ term->termstate = TOPLEVEL;
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr &= ~ATTR_BLINK;
+ term->curr_attr |= (c & 0xF) << ATTR_BGSHIFT;
+ set_erase_char(term);
+ break;
+#endif
+ default: break; /* placate gcc warning about enum use */
+ }
+ if (term->selstate != NO_SELECTION) {
+ pos cursplus = term->curs;
+ incpos(cursplus);
+ check_selection(term, term->curs, cursplus);
+ }
+ }
+
+ bufchain_consume(&term->inbuf, nchars_used);
+
+ if (!called_from_term_data)
+ win_unthrottle(term->win, bufchain_size(&term->inbuf));
+
+ term_print_flush(term);
+ if (term->logflush && term->logctx)
+ logflush(term->logctx);
+}
+
+/* Wrapper on term_out with the right prototype to be a toplevel callback */
+void term_out_cb(void *ctx)
+{
+ term_out((Terminal *)ctx, false);
+}
+
+/*
+ * Small subroutine to parse three consecutive escape-sequence
+ * arguments representing a true-colour RGB triple into an
+ * optionalrgb.
+ */
+static void parse_optionalrgb(optionalrgb *out, unsigned *values)
+{
+ out->enabled = true;
+ out->r = values[0] < 256 ? values[0] : 0;
+ out->g = values[1] < 256 ? values[1] : 0;
+ out->b = values[2] < 256 ? values[2] : 0;
+}
+
+/*
+ * To prevent having to run the reasonably tricky bidi algorithm
+ * too many times, we maintain a cache of the last lineful of data
+ * fed to the algorithm on each line of the display.
+ */
+static bool term_bidi_cache_hit(Terminal *term, int line,
+ termchar *lbefore, int width, bool trusted)
+{
+ int i;
+
+ if (!term->pre_bidi_cache)
+ return false; /* cache doesn't even exist yet! */
+
+ if (line >= term->bidi_cache_size)
+ return false; /* cache doesn't have this many lines */
+
+ if (!term->pre_bidi_cache[line].chars)
+ return false; /* cache doesn't contain _this_ line */
+
+ if (term->pre_bidi_cache[line].width != width)
+ return false; /* line is wrong width */
+
+ if (term->pre_bidi_cache[line].trusted != trusted)
+ return false; /* line has wrong trust state */
+
+ for (i = 0; i < width; i++)
+ if (!termchars_equal(term->pre_bidi_cache[line].chars+i, lbefore+i))
+ return false; /* line doesn't match cache */
+
+ return true; /* it didn't match. */
+}
+
+static void term_bidi_cache_store(Terminal *term, int line, termchar *lbefore,
+ termchar *lafter, bidi_char *wcTo,
+ int width, int size, bool trusted)
+{
+ size_t i, j;
+
+ if (!term->pre_bidi_cache || term->bidi_cache_size <= line) {
+ j = term->bidi_cache_size;
+ sgrowarray(term->pre_bidi_cache, term->bidi_cache_size, line);
+ term->post_bidi_cache = sresize(term->post_bidi_cache,
+ term->bidi_cache_size,
+ struct bidi_cache_entry);
+ while (j < term->bidi_cache_size) {
+ term->pre_bidi_cache[j].chars =
+ term->post_bidi_cache[j].chars = NULL;
+ term->pre_bidi_cache[j].width =
+ term->post_bidi_cache[j].width = -1;
+ term->pre_bidi_cache[j].trusted = false;
+ term->post_bidi_cache[j].trusted = false;
+ term->pre_bidi_cache[j].forward =
+ term->post_bidi_cache[j].forward = NULL;
+ term->pre_bidi_cache[j].backward =
+ term->post_bidi_cache[j].backward = NULL;
+ j++;
+ }
+ }
+
+ sfree(term->pre_bidi_cache[line].chars);
+ sfree(term->post_bidi_cache[line].chars);
+ sfree(term->post_bidi_cache[line].forward);
+ sfree(term->post_bidi_cache[line].backward);
+
+ term->pre_bidi_cache[line].width = width;
+ term->pre_bidi_cache[line].trusted = trusted;
+ term->pre_bidi_cache[line].chars = snewn(size, termchar);
+ term->post_bidi_cache[line].width = width;
+ term->post_bidi_cache[line].trusted = trusted;
+ term->post_bidi_cache[line].chars = snewn(size, termchar);
+ term->post_bidi_cache[line].forward = snewn(width, int);
+ term->post_bidi_cache[line].backward = snewn(width, int);
+
+ memcpy(term->pre_bidi_cache[line].chars, lbefore, size * TSIZE);
+ memcpy(term->post_bidi_cache[line].chars, lafter, size * TSIZE);
+ memset(term->post_bidi_cache[line].forward, 0, width * sizeof(int));
+ memset(term->post_bidi_cache[line].backward, 0, width * sizeof(int));
+
+ for (i = j = 0; j < width; j += wcTo[i].nchars, i++) {
+ int p = wcTo[i].index;
+
+ if (p != BIDI_CHAR_INDEX_NONE) {
+ assert(0 <= p && p < width);
+
+ for (int x = 0; x < wcTo[i].nchars; x++) {
+ term->post_bidi_cache[line].backward[j+x] = p+x;
+ term->post_bidi_cache[line].forward[p+x] = j+x;
+ }
+ }
+ }
+}
+
+/*
+ * Prepare the bidi information for a screen line. Returns the
+ * transformed list of termchars, or NULL if no transformation at
+ * all took place (because bidi is disabled). If return was
+ * non-NULL, auxiliary information such as the forward and reverse
+ * mappings of permutation position are available in
+ * term->post_bidi_cache[scr_y].*.
+ */
+static termchar *term_bidi_line(Terminal *term, struct termline *ldata,
+ int scr_y)
+{
+ termchar *lchars;
+ int it;
+
+ /* Do Arabic shaping and bidi. */
+ if (!term->no_bidi || !term->no_arabicshaping ||
+ (ldata->trusted && term->cols > TRUST_SIGIL_WIDTH)) {
+
+ if (!term_bidi_cache_hit(term, scr_y, ldata->chars, term->cols,
+ ldata->trusted)) {
+
+ if (term->wcFromTo_size < term->cols) {
+ term->wcFromTo_size = term->cols;
+ term->wcFrom = sresize(term->wcFrom, term->wcFromTo_size,
+ bidi_char);
+ term->wcTo = sresize(term->wcTo, term->wcFromTo_size,
+ bidi_char);
+ }
+
+ for(it=0; it<term->cols ; it++)
+ {
+ unsigned long uc = (ldata->chars[it].chr);
+
+ switch (uc & CSET_MASK) {
+ case CSET_LINEDRW:
+ if (!term->rawcnp) {
+ uc = term->ucsdata->unitab_xterm[uc & 0xFF];
+ break;
+ }
+ case CSET_ASCII:
+ uc = term->ucsdata->unitab_line[uc & 0xFF];
+ break;
+ case CSET_SCOACS:
+ uc = term->ucsdata->unitab_scoacs[uc&0xFF];
+ break;
+ }
+ switch (uc & CSET_MASK) {
+ case CSET_ACP:
+ uc = term->ucsdata->unitab_font[uc & 0xFF];
+ break;
+ case CSET_OEMCP:
+ uc = term->ucsdata->unitab_oemcp[uc & 0xFF];
+ break;
+ }
+
+ term->wcFrom[it].origwc = term->wcFrom[it].wc =
+ (unsigned int)uc;
+ term->wcFrom[it].index = it;
+ term->wcFrom[it].nchars = 1;
+ }
+
+ if (ldata->trusted && term->cols > TRUST_SIGIL_WIDTH) {
+ memmove(
+ term->wcFrom + TRUST_SIGIL_WIDTH, term->wcFrom,
+ (term->cols - TRUST_SIGIL_WIDTH) * sizeof(*term->wcFrom));
+ for (it = 0; it < TRUST_SIGIL_WIDTH; it++) {
+ term->wcFrom[it].origwc = term->wcFrom[it].wc =
+ (it == 0 ? TRUST_SIGIL_CHAR :
+ it == 1 ? UCSWIDE : ' ');
+ term->wcFrom[it].index = BIDI_CHAR_INDEX_NONE;
+ term->wcFrom[it].nchars = 1;
+ }
+ }
+
+ int nbc = 0;
+ for (it = 0; it < term->cols; it++) {
+ term->wcFrom[nbc] = term->wcFrom[it];
+ if (it+1 < term->cols && term->wcFrom[it+1].wc == UCSWIDE) {
+ term->wcFrom[nbc].nchars++;
+ it++;
+ }
+ nbc++;
+ }
+
+ if(!term->no_bidi)
+ do_bidi(term->bidi_ctx, term->wcFrom, nbc);
+
+ if(!term->no_arabicshaping) {
+ do_shape(term->wcFrom, term->wcTo, nbc);
+ } else {
+ /* If we're not calling do_shape, we must copy the
+ * data into wcTo anyway, unchanged */
+ memcpy(term->wcTo, term->wcFrom, nbc * sizeof(*term->wcTo));
+ }
+
+ if (term->ltemp_size < ldata->size) {
+ term->ltemp_size = ldata->size;
+ term->ltemp = sresize(term->ltemp, term->ltemp_size,
+ termchar);
+ }
+
+ memcpy(term->ltemp, ldata->chars, ldata->size * TSIZE);
+
+ int opos = 0;
+ for (it=0; it<nbc; it++) {
+ int ipos = term->wcTo[it].index;
+ for (int j = 0; j < term->wcTo[it].nchars; j++) {
+ if (ipos != BIDI_CHAR_INDEX_NONE) {
+ term->ltemp[opos] = ldata->chars[ipos];
+ if (term->ltemp[opos].cc_next)
+ term->ltemp[opos].cc_next -= opos - ipos;
+
+ if (j > 0)
+ term->ltemp[opos].chr = UCSWIDE;
+ else if (term->wcTo[it].origwc != term->wcTo[it].wc)
+ term->ltemp[opos].chr = term->wcTo[it].wc;
+ } else {
+ term->ltemp[opos] = term->basic_erase_char;
+ term->ltemp[opos].chr =
+ j > 0 ? UCSWIDE : term->wcTo[it].origwc;
+ }
+ opos++;
+ }
+ }
+ assert(opos == term->cols);
+ term_bidi_cache_store(term, scr_y, ldata->chars,
+ term->ltemp, term->wcTo,
+ term->cols, ldata->size, ldata->trusted);
+
+ lchars = term->ltemp;
+ } else {
+ lchars = term->post_bidi_cache[scr_y].chars;
+ }
+ } else {
+ lchars = NULL;
+ }
+
+ return lchars;
+}
+
+static void do_paint_draw(Terminal *term, termline *ldata, int x, int y,
+ wchar_t *ch, int ccount,
+ unsigned long attr, truecolour tc)
+{
+ if (ch[0] == TRUST_SIGIL_CHAR) {
+ assert(ldata->trusted);
+ assert(ccount == 1);
+ assert(attr & ATTR_WIDE);
+ wchar_t tch[2];
+ tch[0] = tch[1] = L' ';
+ win_draw_text(term->win, x, y, tch, 2, term->basic_erase_char.attr,
+ ldata->lattr, term->basic_erase_char.truecolour);
+ win_draw_trust_sigil(term->win, x, y);
+ } else {
+ win_draw_text(term->win, x, y, ch, ccount, attr, ldata->lattr, tc);
+ if (attr & (TATTR_ACTCURS | TATTR_PASCURS))
+ win_draw_cursor(term->win, x, y, ch, ccount,
+ attr, ldata->lattr, tc);
+ }
+}
+
+/*
+ * Given a context, update the window.
+ */
+static void do_paint(Terminal *term)
+{
+ int i, j, our_curs_y, our_curs_x;
+ int rv, cursor;
+ pos scrpos;
+ wchar_t *ch;
+ size_t chlen;
+ termchar *newline;
+
+ chlen = 1024;
+ ch = snewn(chlen, wchar_t);
+
+ newline = snewn(term->cols, termchar);
+
+ rv = (!term->rvideo ^ !term->in_vbell ? ATTR_REVERSE : 0);
+
+ /* Depends on:
+ * screen array, disptop, scrtop,
+ * selection, rv,
+ * blinkpc, blink_is_real, tblinker,
+ * curs.y, curs.x, cblinker, blink_cur, cursor_on, has_focus, wrapnext
+ */
+
+ /* Has the cursor position or type changed ? */
+ if (term->cursor_on) {
+ if (term->has_focus) {
+ if (term->cblinker || !term->blink_cur)
+ cursor = TATTR_ACTCURS;
+ else
+ cursor = 0;
+ } else
+ cursor = TATTR_PASCURS;
+ if (term->wrapnext)
+ cursor |= TATTR_RIGHTCURS;
+ } else
+ cursor = 0;
+ our_curs_y = term->curs.y - term->disptop;
+ {
+ /*
+ * Adjust the cursor position:
+ * - for bidi
+ * - in the case where it's resting on the right-hand half
+ * of a CJK wide character. xterm's behaviour here,
+ * which seems adequate to me, is to display the cursor
+ * covering the _whole_ character, exactly as if it were
+ * one space to the left.
+ */
+ termline *ldata = lineptr(term->curs.y);
+ termchar *lchars;
+
+ our_curs_x = term->curs.x;
+
+ if ( (lchars = term_bidi_line(term, ldata, our_curs_y)) != NULL) {
+ our_curs_x = term->post_bidi_cache[our_curs_y].forward[our_curs_x];
+ } else
+ lchars = ldata->chars;
+
+ if (our_curs_x > 0 &&
+ lchars[our_curs_x].chr == UCSWIDE)
+ our_curs_x--;
+
+ unlineptr(ldata);
+ }
+
+ /*
+ * If the cursor is not where it was last time we painted, and
+ * its previous position is visible on screen, invalidate its
+ * previous position.
+ */
+ if (term->dispcursy >= 0 &&
+ (term->curstype != cursor ||
+ term->dispcursy != our_curs_y ||
+ term->dispcursx != our_curs_x)) {
+ termchar *dispcurs = term->disptext[term->dispcursy]->chars +
+ term->dispcursx;
+
+ if (term->dispcursx > 0 && dispcurs->chr == UCSWIDE)
+ dispcurs[-1].attr |= ATTR_INVALID;
+ if (term->dispcursx < term->cols-1 && dispcurs[1].chr == UCSWIDE)
+ dispcurs[1].attr |= ATTR_INVALID;
+ dispcurs->attr |= ATTR_INVALID;
+
+ term->curstype = 0;
+ }
+ term->dispcursx = term->dispcursy = -1;
+
+ /* The normal screen data */
+ for (i = 0; i < term->rows; i++) {
+ termline *ldata;
+ termchar *lchars;
+ bool dirty_line, dirty_run, selected;
+ unsigned long attr = 0, cset = 0;
+ int start = 0;
+ int ccount = 0;
+ bool last_run_dirty = false;
+ int laststart;
+ bool dirtyrect;
+ int *backward;
+ truecolour tc;
+
+ scrpos.y = i + term->disptop;
+ ldata = lineptr(scrpos.y);
+
+ /* Do Arabic shaping and bidi. */
+ lchars = term_bidi_line(term, ldata, i);
+ if (lchars) {
+ backward = term->post_bidi_cache[i].backward;
+ } else {
+ lchars = ldata->chars;
+ backward = NULL;
+ }
+
+ /*
+ * First loop: work along the line deciding what we want
+ * each character cell to look like.
+ */
+ for (j = 0; j < term->cols; j++) {
+ unsigned long tattr, tchar;
+ termchar *d = lchars + j;
+ scrpos.x = backward ? backward[j] : j;
+
+ tchar = d->chr;
+ tattr = d->attr;
+
+ if (!term->ansi_colour)
+ tattr = (tattr & ~(ATTR_FGMASK | ATTR_BGMASK)) |
+ ATTR_DEFFG | ATTR_DEFBG;
+
+ if (!term->xterm_256_colour) {
+ int colour;
+ colour = (tattr & ATTR_FGMASK) >> ATTR_FGSHIFT;
+ if (colour >= 16 && colour < 256)
+ tattr = (tattr &~ ATTR_FGMASK) | ATTR_DEFFG;
+ colour = (tattr & ATTR_BGMASK) >> ATTR_BGSHIFT;
+ if (colour >= 16 && colour < 256)
+ tattr = (tattr &~ ATTR_BGMASK) | ATTR_DEFBG;
+ }
+
+ if (term->true_colour) {
+ tc = d->truecolour;
+ } else {
+ tc.fg = tc.bg = optionalrgb_none;
+ }
+
+ switch (tchar & CSET_MASK) {
+ case CSET_ASCII:
+ tchar = term->ucsdata->unitab_line[tchar & 0xFF];
+ break;
+ case CSET_LINEDRW:
+ tchar = term->ucsdata->unitab_xterm[tchar & 0xFF];
+ break;
+ case CSET_SCOACS:
+ tchar = term->ucsdata->unitab_scoacs[tchar&0xFF];
+ break;
+ }
+ if (j < term->cols-1 && d[1].chr == UCSWIDE)
+ tattr |= ATTR_WIDE;
+
+ /* Video reversing things */
+ if (term->selstate == DRAGGING || term->selstate == SELECTED) {
+ if (term->seltype == LEXICOGRAPHIC)
+ selected = (posle(term->selstart, scrpos) &&
+ poslt(scrpos, term->selend));
+ else
+ selected = (posPle(term->selstart, scrpos) &&
+ posPle_left(scrpos, term->selend));
+ } else
+ selected = false;
+ tattr = (tattr ^ rv
+ ^ (selected ? ATTR_REVERSE : 0));
+
+ /* 'Real' blinking ? */
+ if (term->blink_is_real && (tattr & ATTR_BLINK)) {
+ if (term->has_focus && term->tblinker) {
+ tchar = term->ucsdata->unitab_line[(unsigned char)' '];
+ }
+ tattr &= ~ATTR_BLINK;
+ }
+
+ /*
+ * Check the font we'll _probably_ be using to see if
+ * the character is wide when we don't want it to be.
+ */
+ if (tchar != term->disptext[i]->chars[j].chr ||
+ tattr != (term->disptext[i]->chars[j].attr &~
+ (ATTR_NARROW | DATTR_MASK))) {
+ if ((tattr & ATTR_WIDE) == 0 &&
+ win_char_width(term->win, tchar) == 2)
+ tattr |= ATTR_NARROW;
+ } else if (term->disptext[i]->chars[j].attr & ATTR_NARROW)
+ tattr |= ATTR_NARROW;
+
+ if (i == our_curs_y && j == our_curs_x) {
+ tattr |= cursor;
+ term->curstype = cursor;
+ term->dispcursx = j;
+ term->dispcursy = i;
+ }
+
+ /* FULL-TERMCHAR */
+ newline[j].attr = tattr;
+ newline[j].chr = tchar;
+ newline[j].truecolour = tc;
+ /* Combining characters are still read from lchars */
+ newline[j].cc_next = 0;
+ }
+
+ /*
+ * Now loop over the line again, noting where things have
+ * changed.
+ *
+ * During this loop, we keep track of where we last saw
+ * DATTR_STARTRUN. Any mismatch automatically invalidates
+ * _all_ of the containing run that was last printed: that
+ * is, any rectangle that was drawn in one go in the
+ * previous update should be either left completely alone
+ * or overwritten in its entirety. This, along with the
+ * expectation that front ends clip all text runs to their
+ * bounding rectangle, should solve any possible problems
+ * with fonts that overflow their character cells.
+ */
+ laststart = 0;
+ dirtyrect = false;
+ for (j = 0; j < term->cols; j++) {
+ if (term->disptext[i]->chars[j].attr & DATTR_STARTRUN) {
+ laststart = j;
+ dirtyrect = false;
+ }
+
+ if (term->disptext[i]->chars[j].chr != newline[j].chr ||
+ (term->disptext[i]->chars[j].attr &~ DATTR_MASK)
+ != newline[j].attr) {
+ int k;
+
+ if (!dirtyrect) {
+ for (k = laststart; k < j; k++)
+ term->disptext[i]->chars[k].attr |= ATTR_INVALID;
+
+ dirtyrect = true;
+ }
+ }
+
+ if (dirtyrect)
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+ }
+
+ /*
+ * Finally, loop once more and actually do the drawing.
+ */
+ dirty_run = dirty_line = (ldata->lattr !=
+ term->disptext[i]->lattr);
+ term->disptext[i]->lattr = ldata->lattr;
+
+ tc = term->erase_char.truecolour;
+ for (j = 0; j < term->cols; j++) {
+ unsigned long tattr, tchar;
+ bool break_run, do_copy;
+ termchar *d = lchars + j;
+
+ tattr = newline[j].attr;
+ tchar = newline[j].chr;
+
+ if ((term->disptext[i]->chars[j].attr ^ tattr) & ATTR_WIDE)
+ dirty_line = true;
+
+ break_run = ((tattr ^ attr) & term->attr_mask) != 0;
+
+ if (!truecolour_equal(newline[j].truecolour, tc))
+ break_run = true;
+
+#ifdef USES_VTLINE_HACK
+ /* Special hack for VT100 Linedraw glyphs */
+ if ((tchar >= 0x23BA && tchar <= 0x23BD) ||
+ (j > 0 && (newline[j-1].chr >= 0x23BA &&
+ newline[j-1].chr <= 0x23BD)))
+ break_run = true;
+#endif
+
+ /*
+ * Separate out sequences of characters that have the
+ * same CSET, if that CSET is a magic one.
+ */
+ if (CSET_OF(tchar) != cset)
+ break_run = true;
+
+ /*
+ * Break on both sides of any combined-character cell.
+ */
+ if (d->cc_next != 0 ||
+ (j > 0 && d[-1].cc_next != 0))
+ break_run = true;
+
+ /*
+ * Break on both sides of a trust sigil.
+ */
+ if (d->chr == TRUST_SIGIL_CHAR ||
+ (j >= 2 && d[-1].chr == UCSWIDE &&
+ d[-2].chr == TRUST_SIGIL_CHAR))
+ break_run = true;
+
+ if (!term->ucsdata->dbcs_screenfont && !dirty_line) {
+ if (term->disptext[i]->chars[j].chr == tchar &&
+ (term->disptext[i]->chars[j].attr &~ DATTR_MASK)==tattr &&
+ truecolour_equal(
+ term->disptext[i]->chars[j].truecolour, tc))
+ break_run = true;
+ else if (!dirty_run && ccount == 1)
+ break_run = true;
+ }
+
+ if (break_run) {
+ if ((dirty_run || last_run_dirty) && ccount > 0)
+ do_paint_draw(term, ldata, start, i, ch, ccount, attr, tc);
+ start = j;
+ ccount = 0;
+ attr = tattr;
+ tc = newline[j].truecolour;
+ cset = CSET_OF(tchar);
+ if (term->ucsdata->dbcs_screenfont)
+ last_run_dirty = dirty_run;
+ dirty_run = dirty_line;
+ }
+
+ do_copy = false;
+ if (!termchars_equal_override(&term->disptext[i]->chars[j],
+ d, tchar, tattr)) {
+ do_copy = true;
+ dirty_run = true;
+ }
+
+ sgrowarrayn(ch, chlen, ccount, 2);
+
+#ifdef PLATFORM_IS_UTF16
+ if (tchar > 0x10000 && tchar < 0x110000) {
+ ch[ccount++] = (wchar_t) HIGH_SURROGATE_OF(tchar);
+ ch[ccount++] = (wchar_t) LOW_SURROGATE_OF(tchar);
+ } else
+#endif /* PLATFORM_IS_UTF16 */
+ ch[ccount++] = (wchar_t) tchar;
+
+ if (d->cc_next) {
+ termchar *dd = d;
+
+ while (dd->cc_next) {
+ unsigned long schar;
+
+ dd += dd->cc_next;
+
+ schar = dd->chr;
+ switch (schar & CSET_MASK) {
+ case CSET_ASCII:
+ schar = term->ucsdata->unitab_line[schar & 0xFF];
+ break;
+ case CSET_LINEDRW:
+ schar = term->ucsdata->unitab_xterm[schar & 0xFF];
+ break;
+ case CSET_SCOACS:
+ schar = term->ucsdata->unitab_scoacs[schar&0xFF];
+ break;
+ }
+
+ sgrowarrayn(ch, chlen, ccount, 2);
+
+#ifdef PLATFORM_IS_UTF16
+ if (schar > 0x10000 && schar < 0x110000) {
+ ch[ccount++] = (wchar_t) HIGH_SURROGATE_OF(schar);
+ ch[ccount++] = (wchar_t) LOW_SURROGATE_OF(schar);
+ } else
+#endif /* PLATFORM_IS_UTF16 */
+ ch[ccount++] = (wchar_t) schar;
+ }
+
+ attr |= TATTR_COMBINING;
+ }
+
+ if (do_copy) {
+ copy_termchar(term->disptext[i], j, d);
+ term->disptext[i]->chars[j].chr = tchar;
+ term->disptext[i]->chars[j].attr = tattr;
+ term->disptext[i]->chars[j].truecolour = tc;
+ if (start == j)
+ term->disptext[i]->chars[j].attr |= DATTR_STARTRUN;
+ }
+
+ /* If it's a wide char step along to the next one. */
+ if (tattr & ATTR_WIDE) {
+ if (++j < term->cols) {
+ d++;
+ /*
+ * By construction above, the cursor should not
+ * be on the right-hand half of this character.
+ * Ever.
+ */
+ assert(!(i == our_curs_y && j == our_curs_x));
+ if (!termchars_equal(&term->disptext[i]->chars[j], d))
+ dirty_run = true;
+ copy_termchar(term->disptext[i], j, d);
+ }
+ }
+ }
+ if (dirty_run && ccount > 0)
+ do_paint_draw(term, ldata, start, i, ch, ccount, attr, tc);
+
+ unlineptr(ldata);
+ }
+
+ sfree(newline);
+ sfree(ch);
+}
+
+/*
+ * Invalidate the whole screen so it will be repainted in full.
+ */
+void term_invalidate(Terminal *term)
+{
+ int i, j;
+
+ for (i = 0; i < term->rows; i++)
+ for (j = 0; j < term->cols; j++)
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+
+ term_schedule_update(term);
+}
+
+/*
+ * Paint the window in response to a WM_PAINT message.
+ */
+void term_paint(Terminal *term,
+ int left, int top, int right, int bottom, bool immediately)
+{
+ int i, j;
+ if (left < 0) left = 0;
+ if (top < 0) top = 0;
+ if (right >= term->cols) right = term->cols-1;
+ if (bottom >= term->rows) bottom = term->rows-1;
+
+ for (i = top; i <= bottom && i < term->rows; i++) {
+ if ((term->disptext[i]->lattr & LATTR_MODE) == LATTR_NORM)
+ for (j = left; j <= right && j < term->cols; j++)
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+ else
+ for (j = left / 2; j <= right / 2 + 1 && j < term->cols; j++)
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+ }
+
+ if (immediately) {
+ do_paint(term);
+ } else {
+ term_schedule_update(term);
+ }
+}
+
+/*
+ * Attempt to scroll the scrollback. The second parameter gives the
+ * position we want to scroll to; the first is +1 to denote that
+ * this position is relative to the beginning of the scrollback, -1
+ * to denote it is relative to the end, and 0 to denote that it is
+ * relative to the current position.
+ */
+void term_scroll(Terminal *term, int rel, int where)
+{
+ int sbtop = -sblines(term);
+
+ term->disptop = (rel < 0 ? 0 : rel > 0 ? sbtop : term->disptop) + where;
+ if (term->disptop < sbtop)
+ term->disptop = sbtop;
+ if (term->disptop > 0)
+ term->disptop = 0;
+ term->win_scrollbar_update_pending = true;
+ term_schedule_update(term);
+}
+
+/*
+ * Scroll the scrollback to centre it on the beginning or end of the
+ * current selection, if any.
+ */
+void term_scroll_to_selection(Terminal *term, int which_end)
+{
+ pos target;
+ int y;
+ int sbtop = -sblines(term);
+
+ if (term->selstate != SELECTED)
+ return;
+ if (which_end)
+ target = term->selend;
+ else
+ target = term->selstart;
+
+ y = target.y - term->rows/2;
+ if (y < sbtop)
+ y = sbtop;
+ else if (y > 0)
+ y = 0;
+ term_scroll(term, -1, y);
+}
+
+/*
+ * Helper routine for clipme(): growing buffer.
+ */
+typedef struct {
+ size_t bufsize; /* amount of allocated space in textbuf/attrbuf */
+ size_t bufpos; /* amount of actual data */
+ wchar_t *textbuf; /* buffer for copied text */
+ wchar_t *textptr; /* = textbuf + bufpos (current insertion point) */
+ int *attrbuf; /* buffer for copied attributes */
+ int *attrptr; /* = attrbuf + bufpos */
+ truecolour *tcbuf; /* buffer for copied colours */
+ truecolour *tcptr; /* = tcbuf + bufpos */
+} clip_workbuf;
+
+static void clip_addchar(clip_workbuf *b, wchar_t chr, int attr, truecolour tc)
+{
+ if (b->bufpos >= b->bufsize) {
+ sgrowarray(b->textbuf, b->bufsize, b->bufpos);
+ b->textptr = b->textbuf + b->bufpos;
+ b->attrbuf = sresize(b->attrbuf, b->bufsize, int);
+ b->attrptr = b->attrbuf + b->bufpos;
+ b->tcbuf = sresize(b->tcbuf, b->bufsize, truecolour);
+ b->tcptr = b->tcbuf + b->bufpos;
+ }
+ *b->textptr++ = chr;
+ *b->attrptr++ = attr;
+ *b->tcptr++ = tc;
+ b->bufpos++;
+}
+
+static void clipme(Terminal *term, pos top, pos bottom, bool rect, bool desel,
+ const int *clipboards, int n_clipboards)
+{
+ clip_workbuf buf;
+ int old_top_x;
+ int attr;
+ truecolour tc;
+
+ buf.bufsize = 5120;
+ buf.bufpos = 0;
+ buf.textptr = buf.textbuf = snewn(buf.bufsize, wchar_t);
+ buf.attrptr = buf.attrbuf = snewn(buf.bufsize, int);
+ buf.tcptr = buf.tcbuf = snewn(buf.bufsize, truecolour);
+
+ old_top_x = top.x; /* needed for rect==1 */
+
+ while (poslt(top, bottom)) {
+ bool nl = false;
+ termline *ldata = lineptr(top.y);
+ pos nlpos;
+
+ /*
+ * nlpos will point at the maximum position on this line we
+ * should copy up to. So we start it at the end of the
+ * line...
+ */
+ nlpos.y = top.y;
+ nlpos.x = term->cols;
+
+ /*
+ * ... move it backwards if there's unused space at the end
+ * of the line (and also set `nl' if this is the case,
+ * because in normal selection mode this means we need a
+ * newline at the end)...
+ */
+ if (!(ldata->lattr & LATTR_WRAPPED)) {
+ while (nlpos.x &&
+ IS_SPACE_CHR(ldata->chars[nlpos.x - 1].chr) &&
+ !ldata->chars[nlpos.x - 1].cc_next &&
+ poslt(top, nlpos))
+ decpos(nlpos);
+ if (poslt(nlpos, bottom))
+ nl = true;
+ } else {
+ if (ldata->trusted) {
+ /* A wrapped line with a trust sigil on it terminates
+ * a few characters earlier. */
+ nlpos.x = (nlpos.x < TRUST_SIGIL_WIDTH ? 0 :
+ nlpos.x - TRUST_SIGIL_WIDTH);
+ }
+ if (ldata->lattr & LATTR_WRAPPED2) {
+ /* Ignore the last char on the line in a WRAPPED2 line. */
+ decpos(nlpos);
+ }
+ }
+
+ /*
+ * ... and then clip it to the terminal x coordinate if
+ * we're doing rectangular selection. (In this case we
+ * still did the above, so that copying e.g. the right-hand
+ * column from a table doesn't fill with spaces on the
+ * right.)
+ */
+ if (rect) {
+ if (nlpos.x > bottom.x)
+ nlpos.x = bottom.x;
+ nl = (top.y < bottom.y);
+ }
+
+ while (poslt(top, bottom) && poslt(top, nlpos)) {
+#if 0
+ char cbuf[16], *p;
+ sprintf(cbuf, "<U+%04x>", (ldata[top.x] & 0xFFFF));
+#else
+ wchar_t cbuf[16], *p;
+ int c;
+ int x = top.x;
+
+ if (ldata->chars[x].chr == UCSWIDE) {
+ top.x++;
+ continue;
+ }
+
+ while (1) {
+ int uc = ldata->chars[x].chr;
+ attr = ldata->chars[x].attr;
+ tc = ldata->chars[x].truecolour;
+
+ switch (uc & CSET_MASK) {
+ case CSET_LINEDRW:
+ if (!term->rawcnp) {
+ uc = term->ucsdata->unitab_xterm[uc & 0xFF];
+ break;
+ }
+ case CSET_ASCII:
+ uc = term->ucsdata->unitab_line[uc & 0xFF];
+ break;
+ case CSET_SCOACS:
+ uc = term->ucsdata->unitab_scoacs[uc&0xFF];
+ break;
+ }
+ switch (uc & CSET_MASK) {
+ case CSET_ACP:
+ uc = term->ucsdata->unitab_font[uc & 0xFF];
+ break;
+ case CSET_OEMCP:
+ uc = term->ucsdata->unitab_oemcp[uc & 0xFF];
+ break;
+ }
+
+ c = (uc & ~CSET_MASK);
+#ifdef PLATFORM_IS_UTF16
+ if (uc > 0x10000 && uc < 0x110000) {
+ cbuf[0] = 0xD800 | ((uc - 0x10000) >> 10);
+ cbuf[1] = 0xDC00 | ((uc - 0x10000) & 0x3FF);
+ cbuf[2] = 0;
+ } else
+#endif
+ {
+ cbuf[0] = uc;
+ cbuf[1] = 0;
+ }
+
+ if (DIRECT_FONT(uc)) {
+ if (c >= ' ' && c != 0x7F) {
+ char buf[4];
+ WCHAR wbuf[4];
+ int rv;
+ if (is_dbcs_leadbyte(term->ucsdata->font_codepage, (BYTE) c)) {
+ buf[0] = c;
+ buf[1] = (char) (0xFF & ldata->chars[top.x + 1].chr);
+ rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 2, wbuf, 4);
+ top.x++;
+ } else {
+ buf[0] = c;
+ rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 1, wbuf, 4);
+ }
+
+ if (rv > 0) {
+ memcpy(cbuf, wbuf, rv * sizeof(wchar_t));
+ cbuf[rv] = 0;
+ }
+ }
+ }
+#endif
+
+ for (p = cbuf; *p; p++)
+ clip_addchar(&buf, *p, attr, tc);
+
+ if (ldata->chars[x].cc_next)
+ x += ldata->chars[x].cc_next;
+ else
+ break;
+ }
+ top.x++;
+ }
+ if (nl) {
+ int i;
+ for (i = 0; i < sel_nl_sz; i++)
+ clip_addchar(&buf, sel_nl[i], 0, term->basic_erase_char.truecolour);
+ }
+ top.y++;
+ top.x = rect ? old_top_x : 0;
+
+ unlineptr(ldata);
+ }
+#if SELECTION_NUL_TERMINATED
+ clip_addchar(&buf, 0, 0, term->basic_erase_char.truecolour);
+#endif
+ /* Finally, transfer all that to the clipboard(s). */
+ {
+ int i;
+ bool clip_local = false;
+ for (i = 0; i < n_clipboards; i++) {
+ if (clipboards[i] == CLIP_LOCAL) {
+ clip_local = true;
+ } else if (clipboards[i] != CLIP_NULL) {
+ win_clip_write(
+ term->win, clipboards[i], buf.textbuf, buf.attrbuf,
+ buf.tcbuf, buf.bufpos, desel);
+ }
+ }
+ if (clip_local) {
+ sfree(term->last_selected_text);
+ sfree(term->last_selected_attr);
+ sfree(term->last_selected_tc);
+ term->last_selected_text = buf.textbuf;
+ term->last_selected_attr = buf.attrbuf;
+ term->last_selected_tc = buf.tcbuf;
+ term->last_selected_len = buf.bufpos;
+ } else {
+ sfree(buf.textbuf);
+ sfree(buf.attrbuf);
+ sfree(buf.tcbuf);
+ }
+ }
+}
+
+void term_copyall(Terminal *term, const int *clipboards, int n_clipboards)
+{
+ pos top;
+ pos bottom;
+ tree234 *screen = term->screen;
+ top.y = -sblines(term);
+ top.x = 0;
+ bottom.y = find_last_nonempty_line(term, screen);
+ bottom.x = term->cols;
+ clipme(term, top, bottom, false, true, clipboards, n_clipboards);
+}
+
+static void paste_from_clip_local(void *vterm)
+{
+ Terminal *term = (Terminal *)vterm;
+ term_do_paste(term, term->last_selected_text, term->last_selected_len);
+}
+
+void term_request_copy(Terminal *term, const int *clipboards, int n_clipboards)
+{
+ int i;
+ for (i = 0; i < n_clipboards; i++) {
+ assert(clipboards[i] != CLIP_LOCAL);
+ if (clipboards[i] != CLIP_NULL) {
+ win_clip_write(term->win, clipboards[i],
+ term->last_selected_text, term->last_selected_attr,
+ term->last_selected_tc, term->last_selected_len,
+ false);
+ }
+ }
+}
+
+void term_request_paste(Terminal *term, int clipboard)
+{
+ switch (clipboard) {
+ case CLIP_NULL:
+ /* Do nothing: CLIP_NULL never has data in it. */
+ break;
+ case CLIP_LOCAL:
+ queue_toplevel_callback(paste_from_clip_local, term);
+ break;
+ default:
+ win_clip_request_paste(term->win, clipboard);
+ break;
+ }
+}
+
+/*
+ * The wordness array is mainly for deciding the disposition of the
+ * US-ASCII characters.
+ */
+static int wordtype(Terminal *term, int uc)
+{
+ struct ucsword {
+ int start, end, ctype;
+ };
+ static const struct ucsword ucs_words[] = {
+ {
+ 128, 160, 0}, {
+ 161, 191, 1}, {
+ 215, 215, 1}, {
+ 247, 247, 1}, {
+ 0x037e, 0x037e, 1}, /* Greek question mark */
+ {
+ 0x0387, 0x0387, 1}, /* Greek ano teleia */
+ {
+ 0x055a, 0x055f, 1}, /* Armenian punctuation */
+ {
+ 0x0589, 0x0589, 1}, /* Armenian full stop */
+ {
+ 0x0700, 0x070d, 1}, /* Syriac punctuation */
+ {
+ 0x104a, 0x104f, 1}, /* Myanmar punctuation */
+ {
+ 0x10fb, 0x10fb, 1}, /* Georgian punctuation */
+ {
+ 0x1361, 0x1368, 1}, /* Ethiopic punctuation */
+ {
+ 0x166d, 0x166e, 1}, /* Canadian Syl. punctuation */
+ {
+ 0x17d4, 0x17dc, 1}, /* Khmer punctuation */
+ {
+ 0x1800, 0x180a, 1}, /* Mongolian punctuation */
+ {
+ 0x2000, 0x200a, 0}, /* Various spaces */
+ {
+ 0x2070, 0x207f, 2}, /* superscript */
+ {
+ 0x2080, 0x208f, 2}, /* subscript */
+ {
+ 0x200b, 0x27ff, 1}, /* punctuation and symbols */
+ {
+ 0x3000, 0x3000, 0}, /* ideographic space */
+ {
+ 0x3001, 0x3020, 1}, /* ideographic punctuation */
+ {
+ 0x303f, 0x309f, 3}, /* Hiragana */
+ {
+ 0x30a0, 0x30ff, 3}, /* Katakana */
+ {
+ 0x3300, 0x9fff, 3}, /* CJK Ideographs */
+ {
+ 0xac00, 0xd7a3, 3}, /* Hangul Syllables */
+ {
+ 0xf900, 0xfaff, 3}, /* CJK Ideographs */
+ {
+ 0xfe30, 0xfe6b, 1}, /* punctuation forms */
+ {
+ 0xff00, 0xff0f, 1}, /* half/fullwidth ASCII */
+ {
+ 0xff1a, 0xff20, 1}, /* half/fullwidth ASCII */
+ {
+ 0xff3b, 0xff40, 1}, /* half/fullwidth ASCII */
+ {
+ 0xff5b, 0xff64, 1}, /* half/fullwidth ASCII */
+ {
+ 0xfff0, 0xffff, 0}, /* half/fullwidth ASCII */
+ {
+ 0, 0, 0}
+ };
+ const struct ucsword *wptr;
+
+ switch (uc & CSET_MASK) {
+ case CSET_LINEDRW:
+ uc = term->ucsdata->unitab_xterm[uc & 0xFF];
+ break;
+ case CSET_ASCII:
+ uc = term->ucsdata->unitab_line[uc & 0xFF];
+ break;
+ case CSET_SCOACS:
+ uc = term->ucsdata->unitab_scoacs[uc&0xFF];
+ break;
+ }
+ switch (uc & CSET_MASK) {
+ case CSET_ACP:
+ uc = term->ucsdata->unitab_font[uc & 0xFF];
+ break;
+ case CSET_OEMCP:
+ uc = term->ucsdata->unitab_oemcp[uc & 0xFF];
+ break;
+ }
+
+ /* For DBCS fonts I can't do anything useful. Even this will sometimes
+ * fail as there's such a thing as a double width space. :-(
+ */
+ if (term->ucsdata->dbcs_screenfont &&
+ term->ucsdata->font_codepage == term->ucsdata->line_codepage)
+ return (uc != ' ');
+
+ if (uc < 0x80)
+ return term->wordness[uc];
+
+ for (wptr = ucs_words; wptr->start; wptr++) {
+ if (uc >= wptr->start && uc <= wptr->end)
+ return wptr->ctype;
+ }
+
+ return 2;
+}
+
+static int line_cols(Terminal *term, termline *ldata)
+{
+ int cols = term->cols;
+ if (ldata->trusted) {
+ cols -= TRUST_SIGIL_WIDTH;
+ }
+ if (ldata->lattr & LATTR_WRAPPED2)
+ cols--;
+ if (cols < 0)
+ cols = 0;
+ return cols;
+}
+
+/*
+ * Spread the selection outwards according to the selection mode.
+ */
+static pos sel_spread_half(Terminal *term, pos p, int dir)
+{
+ termline *ldata;
+ short wvalue;
+ int topy = -sblines(term);
+
+ ldata = lineptr(p.y);
+
+ switch (term->selmode) {
+ case SM_CHAR:
+ /*
+ * In this mode, every character is a separate unit, except
+ * for runs of spaces at the end of a non-wrapping line.
+ */
+ if (!(ldata->lattr & LATTR_WRAPPED)) {
+ termchar *q = ldata->chars + line_cols(term, ldata);
+ while (q > ldata->chars &&
+ IS_SPACE_CHR(q[-1].chr) && !q[-1].cc_next)
+ q--;
+ if (q == ldata->chars + term->cols)
+ q--;
+ if (p.x >= q - ldata->chars)
+ p.x = (dir == -1 ? q - ldata->chars : term->cols - 1);
+ }
+ break;
+ case SM_WORD:
+ /*
+ * In this mode, the units are maximal runs of characters
+ * whose `wordness' has the same value.
+ */
+ wvalue = wordtype(term, UCSGET(ldata->chars, p.x));
+ if (dir == +1) {
+ while (1) {
+ int maxcols = line_cols(term, ldata);
+ if (p.x < maxcols-1) {
+ if (wordtype(term, UCSGET(ldata->chars, p.x+1)) == wvalue)
+ p.x++;
+ else
+ break;
+ } else {
+ if (p.y+1 < term->rows &&
+ (ldata->lattr & LATTR_WRAPPED)) {
+ termline *ldata2;
+ ldata2 = lineptr(p.y+1);
+ if (wordtype(term, UCSGET(ldata2->chars, 0))
+ == wvalue) {
+ p.x = 0;
+ p.y++;
+ unlineptr(ldata);
+ ldata = ldata2;
+ } else {
+ unlineptr(ldata2);
+ break;
+ }
+ } else
+ break;
+ }
+ }
+ } else {
+ while (1) {
+ if (p.x > 0) {
+ if (wordtype(term, UCSGET(ldata->chars, p.x-1)) == wvalue)
+ p.x--;
+ else
+ break;
+ } else {
+ termline *ldata2;
+ int maxcols;
+ if (p.y <= topy)
+ break;
+ ldata2 = lineptr(p.y-1);
+ maxcols = line_cols(term, ldata2);
+ if (ldata2->lattr & LATTR_WRAPPED) {
+ if (wordtype(term, UCSGET(ldata2->chars, maxcols-1))
+ == wvalue) {
+ p.x = maxcols-1;
+ p.y--;
+ unlineptr(ldata);
+ ldata = ldata2;
+ } else {
+ unlineptr(ldata2);
+ break;
+ }
+ } else
+ break;
+ }
+ }
+ }
+ break;
+ case SM_LINE:
+ /*
+ * In this mode, every line is a unit.
+ */
+ p.x = (dir == -1 ? 0 : term->cols - 1);
+ break;
+ }
+
+ unlineptr(ldata);
+ return p;
+}
+
+static void sel_spread(Terminal *term)
+{
+ if (term->seltype == LEXICOGRAPHIC) {
+ term->selstart = sel_spread_half(term, term->selstart, -1);
+ decpos(term->selend);
+ term->selend = sel_spread_half(term, term->selend, +1);
+ incpos(term->selend);
+ }
+}
+
+static void term_paste_callback(void *vterm)
+{
+ Terminal *term = (Terminal *)vterm;
+
+ if (term->paste_len == 0)
+ return;
+
+ while (term->paste_pos < term->paste_len) {
+ int n = 0;
+ while (n + term->paste_pos < term->paste_len) {
+ if (term->paste_buffer[term->paste_pos + n++] == '\015')
+ break;
+ }
+ if (term->ldisc) {
+ strbuf *buf = term_input_data_from_unicode(
+ term, term->paste_buffer + term->paste_pos, n);
+ term_keyinput_internal(term, buf->s, buf->len, false);
+ strbuf_free(buf);
+ }
+ term->paste_pos += n;
+
+ if (term->paste_pos < term->paste_len) {
+ queue_toplevel_callback(term_paste_callback, term);
+ return;
+ }
+ }
+ term_bracketed_paste_stop(term);
+ sfree(term->paste_buffer);
+ term->paste_buffer = NULL;
+ term->paste_len = 0;
+}
+
+/*
+ * Specialist string compare function. Returns true if the buffer of
+ * alen wide characters starting at a has as a prefix the buffer of
+ * blen characters starting at b.
+ */
+static bool wstartswith(const wchar_t *a, size_t alen,
+ const wchar_t *b, size_t blen)
+{
+ return alen >= blen && !wcsncmp(a, b, blen);
+}
+
+void term_do_paste(Terminal *term, const wchar_t *data, int len)
+{
+ const wchar_t *p;
+ bool paste_controls = conf_get_bool(term->conf, CONF_paste_controls);
+
+ /*
+ * Pasting data into the terminal counts as a keyboard event (for
+ * purposes of the 'Reset scrollback on keypress' config option),
+ * unless the paste is zero-length.
+ */
+ if (len == 0)
+ return;
+ term_seen_key_event(term);
+
+ if (term->paste_buffer)
+ sfree(term->paste_buffer);
+ term->paste_pos = term->paste_len = 0;
+ term->paste_buffer = snewn(len + 12, wchar_t);
+
+ if (term->bracketed_paste)
+ term_bracketed_paste_start(term);
+
+ p = data;
+ while (p < data + len) {
+ wchar_t wc = *p++;
+
+ if (wc == sel_nl[0] &&
+ wstartswith(p-1, data+len-(p-1), sel_nl, sel_nl_sz)) {
+ /*
+ * This is the (platform-dependent) sequence that the host
+ * OS uses to represent newlines in clipboard data.
+ * Normalise it to a press of CR.
+ */
+ p += sel_nl_sz - 1;
+ wc = '\015';
+ }
+
+ if ((wc & ~(wint_t)0x9F) == 0) {
+ /*
+ * This is a control code, either in the range 0x00-0x1F
+ * or 0x80-0x9F. We reject all of these in pastecontrols
+ * mode, except for a small set of permitted ones.
+ */
+ if (!paste_controls) {
+ /* In line with xterm 292, accepted control chars are:
+ * CR, LF, tab, backspace. (And DEL, i.e. 0x7F, but
+ * that's permitted by virtue of not matching the bit
+ * mask that got us into this if statement, so we
+ * don't have to permit it here. */
+ static const unsigned mask =
+ (1<<13) | (1<<10) | (1<<9) | (1<<8);
+
+ if (wc > 15 || !((mask >> wc) & 1))
+ continue;
+ }
+
+ if (wc == '\033' && term->bracketed_paste &&
+ wstartswith(p-1, data+len-(p-1), L"\033[201~", 6)) {
+ /*
+ * Also, in bracketed-paste mode, reject the ESC
+ * character that begins the end-of-paste sequence.
+ */
+ continue;
+ }
+ }
+
+ term->paste_buffer[term->paste_len++] = wc;
+ }
+
+ /* Assume a small paste will be OK in one go. */
+ if (term->paste_len < 256) {
+ if (term->ldisc) {
+ strbuf *buf = term_input_data_from_unicode(
+ term, term->paste_buffer, term->paste_len);
+ term_keyinput_internal(term, buf->s, buf->len, false);
+ strbuf_free(buf);
+ }
+ if (term->paste_buffer)
+ sfree(term->paste_buffer);
+ term_bracketed_paste_stop(term);
+ term->paste_buffer = NULL;
+ term->paste_pos = term->paste_len = 0;
+ }
+
+ queue_toplevel_callback(term_paste_callback, term);
+}
+
+void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
+ Mouse_Action a, int x, int y, bool shift, bool ctrl, bool alt)
+{
+ pos selpoint;
+ termline *ldata;
+ bool raw_mouse = (term->xterm_mouse &&
+ !term->no_mouse_rep &&
+ !(term->mouse_override && shift));
+ int default_seltype;
+
+ if (y < 0) {
+ y = 0;
+ if (a == MA_DRAG && !raw_mouse)
+ term_scroll(term, 0, -1);
+ }
+ if (y >= term->rows) {
+ y = term->rows - 1;
+ if (a == MA_DRAG && !raw_mouse)
+ term_scroll(term, 0, +1);
+ }
+ if (x < 0) {
+ if (y > 0 && !raw_mouse && term->seltype != RECTANGULAR) {
+ /*
+ * When we're using the mouse for normal raster-based
+ * selection, dragging off the left edge of a terminal row
+ * is treated the same as the right-hand end of the
+ * previous row, in that it's considered to identify a
+ * point _before_ the first character on row y.
+ *
+ * But if the mouse action is going to be used for
+ * anything else - rectangular selection, or xterm mouse
+ * tracking - then we disable this special treatment.
+ */
+ x = term->cols - 1;
+ y--;
+ } else
+ x = 0;
+ }
+ if (x >= term->cols)
+ x = term->cols - 1;
+
+ selpoint.y = y + term->disptop;
+ ldata = lineptr(selpoint.y);
+
+ if ((ldata->lattr & LATTR_MODE) != LATTR_NORM)
+ x /= 2;
+
+ /*
+ * Transform x through the bidi algorithm to find the _logical_
+ * click point from the physical one.
+ */
+ if (term_bidi_line(term, ldata, y) != NULL) {
+ x = term->post_bidi_cache[y].backward[x];
+ }
+
+ selpoint.x = x;
+ unlineptr(ldata);
+
+ /*
+ * If we're in the middle of a selection operation, we ignore raw
+ * mouse mode until it's done (we must have been not in raw mouse
+ * mode when it started).
+ * This makes use of Shift for selection reliable, and avoids the
+ * host seeing mouse releases for which they never saw corresponding
+ * presses.
+ */
+ if (raw_mouse &&
+ (term->selstate != ABOUT_TO) && (term->selstate != DRAGGING)) {
+ int encstate = 0, r, c;
+ bool wheel;
+ char abuf[32];
+ int len = 0;
+
+ if (term->ldisc) {
+
+ switch (braw) {
+ case MBT_LEFT:
+ encstate = 0x00; /* left button down */
+ wheel = false;
+ break;
+ case MBT_MIDDLE:
+ encstate = 0x01;
+ wheel = false;
+ break;
+ case MBT_RIGHT:
+ encstate = 0x02;
+ wheel = false;
+ break;
+ case MBT_WHEEL_UP:
+ encstate = 0x40;
+ wheel = true;
+ break;
+ case MBT_WHEEL_DOWN:
+ encstate = 0x41;
+ wheel = true;
+ break;
+ default:
+ return;
+ }
+ if (wheel) {
+ /* For mouse wheel buttons, we only ever expect to see
+ * MA_CLICK actions, and we don't try to keep track of
+ * the buttons being 'pressed' (since without matching
+ * click/release pairs that's pointless). */
+ if (a != MA_CLICK)
+ return;
+ } else switch (a) {
+ case MA_DRAG:
+ if (term->xterm_mouse == 1)
+ return;
+ encstate += 0x20;
+ break;
+ case MA_RELEASE:
+ /* If multiple extensions are enabled, the xterm 1006 is used, so it's okay to check for only that */
+ if (!term->xterm_extended_mouse)
+ encstate = 0x03;
+ term->mouse_is_down = 0;
+ break;
+ case MA_CLICK:
+ if (term->mouse_is_down == braw)
+ return;
+ term->mouse_is_down = braw;
+ break;
+ default:
+ return;
+ }
+ if (shift)
+ encstate += 0x04;
+ if (ctrl)
+ encstate += 0x10;
+ r = y + 1;
+ c = x + 1;
+
+ /* Check the extensions in decreasing order of preference. Encoding the release event above assumes that 1006 comes first. */
+ if (term->xterm_extended_mouse) {
+ len = sprintf(abuf, "\033[<%d;%d;%d%c", encstate, c, r, a == MA_RELEASE ? 'm' : 'M');
+ } else if (term->urxvt_extended_mouse) {
+ len = sprintf(abuf, "\033[%d;%d;%dM", encstate + 32, c, r);
+ } else if (c <= 223 && r <= 223) {
+ len = sprintf(abuf, "\033[M%c%c%c", encstate + 32, c + 32, r + 32);
+ }
+ if (len > 0)
+ ldisc_send(term->ldisc, abuf, len, false);
+ }
+ return;
+ }
+
+ /*
+ * Set the selection type (rectangular or normal) at the start
+ * of a selection attempt, from the state of Alt.
+ */
+ if (!alt ^ !term->rect_select)
+ default_seltype = RECTANGULAR;
+ else
+ default_seltype = LEXICOGRAPHIC;
+
+ if (term->selstate == NO_SELECTION) {
+ term->seltype = default_seltype;
+ }
+
+ if (bcooked == MBT_SELECT && a == MA_CLICK) {
+ deselect(term);
+ term->selstate = ABOUT_TO;
+ term->seltype = default_seltype;
+ term->selanchor = selpoint;
+ term->selmode = SM_CHAR;
+ } else if (bcooked == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) {
+ deselect(term);
+ term->selmode = (a == MA_2CLK ? SM_WORD : SM_LINE);
+ term->selstate = DRAGGING;
+ term->selstart = term->selanchor = selpoint;
+ term->selend = term->selstart;
+ incpos(term->selend);
+ sel_spread(term);
+ } else if ((bcooked == MBT_SELECT && a == MA_DRAG) ||
+ (bcooked == MBT_EXTEND && a != MA_RELEASE)) {
+ if (a == MA_DRAG &&
+ (term->selstate == NO_SELECTION || term->selstate == SELECTED)) {
+ /*
+ * This can happen if a front end has passed us a MA_DRAG
+ * without a prior MA_CLICK. OS X GTK does so, for
+ * example, if the initial button press was eaten by the
+ * WM when it activated the window in the first place. The
+ * nicest thing to do in this situation is to ignore
+ * further drags, and wait for the user to click in the
+ * window again properly if they want to select.
+ */
+ return;
+ }
+ if (term->selstate == ABOUT_TO && poseq(term->selanchor, selpoint))
+ return;
+ if (bcooked == MBT_EXTEND && a != MA_DRAG &&
+ term->selstate == SELECTED) {
+ if (term->seltype == LEXICOGRAPHIC) {
+ /*
+ * For normal selection, we extend by moving
+ * whichever end of the current selection is closer
+ * to the mouse.
+ */
+ if (posdiff(selpoint, term->selstart) <
+ posdiff(term->selend, term->selstart) / 2) {
+ term->selanchor = term->selend;
+ decpos(term->selanchor);
+ } else {
+ term->selanchor = term->selstart;
+ }
+ } else {
+ /*
+ * For rectangular selection, we have a choice of
+ * _four_ places to put selanchor and selpoint: the
+ * four corners of the selection.
+ */
+ if (2*selpoint.x < term->selstart.x + term->selend.x)
+ term->selanchor.x = term->selend.x-1;
+ else
+ term->selanchor.x = term->selstart.x;
+
+ if (2*selpoint.y < term->selstart.y + term->selend.y)
+ term->selanchor.y = term->selend.y;
+ else
+ term->selanchor.y = term->selstart.y;
+ }
+ term->selstate = DRAGGING;
+ }
+ if (term->selstate != ABOUT_TO && term->selstate != DRAGGING)
+ term->selanchor = selpoint;
+ term->selstate = DRAGGING;
+ if (term->seltype == LEXICOGRAPHIC) {
+ /*
+ * For normal selection, we set (selstart,selend) to
+ * (selpoint,selanchor) in some order.
+ */
+ if (poslt(selpoint, term->selanchor)) {
+ term->selstart = selpoint;
+ term->selend = term->selanchor;
+ incpos(term->selend);
+ } else {
+ term->selstart = term->selanchor;
+ term->selend = selpoint;
+ incpos(term->selend);
+ }
+ } else {
+ /*
+ * For rectangular selection, we may need to
+ * interchange x and y coordinates (if the user has
+ * dragged in the -x and +y directions, or vice versa).
+ */
+ term->selstart.x = min(term->selanchor.x, selpoint.x);
+ term->selend.x = 1+max(term->selanchor.x, selpoint.x);
+ term->selstart.y = min(term->selanchor.y, selpoint.y);
+ term->selend.y = max(term->selanchor.y, selpoint.y);
+ }
+ sel_spread(term);
+ } else if ((bcooked == MBT_SELECT || bcooked == MBT_EXTEND) &&
+ a == MA_RELEASE) {
+ if (term->selstate == DRAGGING) {
+ /*
+ * We've completed a selection. We now transfer the
+ * data to the clipboard.
+ */
+ clipme(term, term->selstart, term->selend,
+ (term->seltype == RECTANGULAR), false,
+ term->mouse_select_clipboards,
+ term->n_mouse_select_clipboards);
+ term->selstate = SELECTED;
+ } else
+ term->selstate = NO_SELECTION;
+ } else if (bcooked == MBT_PASTE
+ && (a == MA_CLICK
+#if MULTICLICK_ONLY_EVENT
+ || a == MA_2CLK || a == MA_3CLK
+#endif
+ )) {
+ term_request_paste(term, term->mouse_paste_clipboard);
+ }
+
+ /*
+ * Since terminal output is suppressed during drag-selects, we
+ * should make sure to write any pending output if one has just
+ * finished.
+ */
+ term_out(term, false);
+ term_schedule_update(term);
+}
+
+void term_cancel_selection_drag(Terminal *term)
+{
+ /*
+ * In unusual circumstances, a mouse drag might be interrupted by
+ * something that steals the rest of the mouse gesture. An example
+ * is the GTK popup menu appearing. In that situation, we'll never
+ * receive the MA_RELEASE that finishes the DRAGGING state, which
+ * means terminal output could be suppressed indefinitely. Call
+ * this function from the front end in such situations to restore
+ * sensibleness.
+ */
+ if (term->selstate == DRAGGING)
+ term->selstate = NO_SELECTION;
+ term_out(term, false);
+ term_schedule_update(term);
+}
+
+static int shift_bitmap(bool shift, bool ctrl, bool alt, bool *consumed_alt)
+{
+ int bitmap = (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0);
+ if (bitmap)
+ bitmap++;
+ if (alt && consumed_alt)
+ *consumed_alt = true;
+ return bitmap;
+}
+
+int format_arrow_key(char *buf, Terminal *term, int xkey,
+ bool shift, bool ctrl, bool alt, bool *consumed_alt)
+{
+ char *p = buf;
+
+ if (term->vt52_mode)
+ p += sprintf(p, "\x1B%c", xkey);
+ else {
+ bool app_flg = (term->app_cursor_keys && !term->no_applic_c);
+#if 0
+ /*
+ * RDB: VT100 & VT102 manuals both state the app cursor
+ * keys only work if the app keypad is on.
+ *
+ * SGT: That may well be true, but xterm disagrees and so
+ * does at least one application, so I've #if'ed this out
+ * and the behaviour is back to PuTTY's original: app
+ * cursor and app keypad are independently switchable
+ * modes. If anyone complains about _this_ I'll have to
+ * put in a configurable option.
+ */
+ if (!term->app_keypad_keys)
+ app_flg = 0;
+#endif
+
+ int bitmap = 0;
+
+ /* Adjustment based on Shift, Ctrl and/or Alt */
+ switch (term->sharrow_type) {
+ case SHARROW_APPLICATION:
+ if (ctrl)
+ app_flg = !app_flg;
+ break;
+ case SHARROW_BITMAP:
+ bitmap = shift_bitmap(shift, ctrl, alt, consumed_alt);
+ break;
+ }
+
+ if (app_flg)
+ p += sprintf(p, "\x1BO%c", xkey);
+ else if (bitmap)
+ p += sprintf(p, "\x1B[1;%d%c", bitmap, xkey);
+ else
+ p += sprintf(p, "\x1B[%c", xkey);
+ }
+
+ return p - buf;
+}
+
+int format_function_key(char *buf, Terminal *term, int key_number,
+ bool shift, bool ctrl, bool alt, bool *consumed_alt)
+{
+ char *p = buf;
+
+ static const int key_number_to_tilde_code[] = {
+ -1, /* no such key as F0 */
+ 11, 12, 13, 14, 15, /*gap*/ 17, 18, 19, 20, 21, /*gap*/
+ 23, 24, 25, 26, /*gap*/ 28, 29, /*gap*/ 31, 32, 33, 34,
+ };
+
+ assert(key_number > 0);
+ assert(key_number < lenof(key_number_to_tilde_code));
+
+ int index = key_number;
+ if (term->funky_type != FUNKY_XTERM_216 && term->funky_type != FUNKY_SCO) {
+ if (shift && index <= 10) {
+ shift = false;
+ index += 10;
+ }
+ }
+
+ int code = key_number_to_tilde_code[index];
+
+ if (term->funky_type == FUNKY_SCO) {
+ /* SCO function keys */
+ static const char sco_codes[] =
+ "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@[\\]^_`{";
+ index = (key_number >= 1 && key_number <= 12) ? key_number - 1 : 0;
+ if (shift) index += 12;
+ if (ctrl) index += 24;
+ p += sprintf(p, "\x1B[%c", sco_codes[index]);
+ } else if ((term->vt52_mode || term->funky_type == FUNKY_VT100P) &&
+ code >= 11 && code <= 24) {
+ int offt = 0;
+ if (code > 15)
+ offt++;
+ if (code > 21)
+ offt++;
+ if (term->vt52_mode)
+ p += sprintf(p, "\x1B%c", code + 'P' - 11 - offt);
+ else
+ p += sprintf(p, "\x1BO%c", code + 'P' - 11 - offt);
+ } else if (term->funky_type == FUNKY_LINUX && code >= 11 && code <= 15) {
+ p += sprintf(p, "\x1B[[%c", code + 'A' - 11);
+ } else if ((term->funky_type == FUNKY_XTERM ||
+ term->funky_type == FUNKY_XTERM_216) &&
+ code >= 11 && code <= 14) {
+ if (term->vt52_mode)
+ p += sprintf(p, "\x1B%c", code + 'P' - 11);
+ else {
+ int bitmap = 0;
+ if (term->funky_type == FUNKY_XTERM_216)
+ bitmap = shift_bitmap(shift, ctrl, alt, consumed_alt);
+ if (bitmap)
+ p += sprintf(p, "\x1B[1;%d%c", bitmap, code + 'P' - 11);
+ else
+ p += sprintf(p, "\x1BO%c", code + 'P' - 11);
+ }
+ } else {
+ int bitmap = 0;
+ if (term->funky_type == FUNKY_XTERM_216)
+ bitmap = shift_bitmap(shift, ctrl, alt, consumed_alt);
+ if (bitmap)
+ p += sprintf(p, "\x1B[%d;%d~", code, bitmap);
+ else
+ p += sprintf(p, "\x1B[%d~", code);
+ }
+
+ return p - buf;
+}
+
+int format_small_keypad_key(char *buf, Terminal *term, SmallKeypadKey key,
+ bool shift, bool ctrl, bool alt,
+ bool *consumed_alt)
+{
+ char *p = buf;
+
+ int code;
+ switch (key) {
+ case SKK_HOME: code = 1; break;
+ case SKK_INSERT: code = 2; break;
+ case SKK_DELETE: code = 3; break;
+ case SKK_END: code = 4; break;
+ case SKK_PGUP: code = 5; break;
+ case SKK_PGDN: code = 6; break;
+ default: unreachable("bad small keypad key enum value");
+ }
+
+ /* Reorder edit keys to physical order */
+ if (term->funky_type == FUNKY_VT400 && code <= 6)
+ code = "\0\2\1\4\5\3\6"[code];
+
+ if (term->vt52_mode && code > 0 && code <= 6) {
+ p += sprintf(p, "\x1B%c", " HLMEIG"[code]);
+ } else if (term->funky_type == FUNKY_SCO) {
+ static const char codes[] = "HL.FIG";
+ if (code == 3) {
+ *p++ = '\x7F';
+ } else {
+ p += sprintf(p, "\x1B[%c", codes[code-1]);
+ }
+ } else if ((code == 1 || code == 4) && term->rxvt_homeend) {
+ p += sprintf(p, code == 1 ? "\x1B[H" : "\x1BOw");
+ } else {
+ if (term->vt52_mode) {
+ p += sprintf(p, "\x1B[%d~", code);
+ } else {
+ int bitmap = 0;
+ if (term->funky_type == FUNKY_XTERM_216)
+ bitmap = shift_bitmap(shift, ctrl, alt, consumed_alt);
+ if (bitmap)
+ p += sprintf(p, "\x1B[%d;%d~", code, bitmap);
+ else
+ p += sprintf(p, "\x1B[%d~", code);
+ }
+ }
+
+ return p - buf;
+}
+
+int format_numeric_keypad_key(char *buf, Terminal *term, char key,
+ bool shift, bool ctrl)
+{
+ char *p = buf;
+ bool app_keypad = (term->app_keypad_keys && !term->no_applic_k);
+
+ if (term->nethack_keypad && (key >= '1' && key <= '9')) {
+ static const char nh_base[] = "bjnh.lyku";
+ char c = nh_base[key - '1'];
+ if (ctrl && c != '.')
+ c &= 0x1F;
+ else if (shift && c != '.')
+ c += 'A'-'a';
+ *p++ = c;
+ } else {
+ int xkey = 0;
+
+ if (term->funky_type == FUNKY_VT400 ||
+ (term->funky_type <= FUNKY_LINUX && app_keypad)) {
+ switch (key) {
+ case 'G': xkey = 'P'; break;
+ case '/': xkey = 'Q'; break;
+ case '*': xkey = 'R'; break;
+ case '-': xkey = 'S'; break;
+ }
+ }
+
+ if (app_keypad) {
+ switch (key) {
+ case '0': xkey = 'p'; break;
+ case '1': xkey = 'q'; break;
+ case '2': xkey = 'r'; break;
+ case '3': xkey = 's'; break;
+ case '4': xkey = 't'; break;
+ case '5': xkey = 'u'; break;
+ case '6': xkey = 'v'; break;
+ case '7': xkey = 'w'; break;
+ case '8': xkey = 'x'; break;
+ case '9': xkey = 'y'; break;
+ case '.': xkey = 'n'; break;
+ case '\r': xkey = 'M'; break;
+
+ case '+':
+ /*
+ * Keypad + is tricky. It covers a space that would
+ * be taken up on the VT100 by _two_ keys; so we
+ * let Shift select between the two. Worse still,
+ * in xterm function key mode we change which two...
+ */
+ if (term->funky_type == FUNKY_XTERM)
+ xkey = shift ? 'l' : 'k';
+ else
+ xkey = shift ? 'm' : 'l';
+ break;
+
+ case '/':
+ if (term->funky_type == FUNKY_XTERM)
+ xkey = 'o';
+ break;
+ case '*':
+ if (term->funky_type == FUNKY_XTERM)
+ xkey = 'j';
+ break;
+ case '-':
+ if (term->funky_type == FUNKY_XTERM)
+ xkey = 'm';
+ break;
+ }
+ }
+
+ if (xkey) {
+ if (term->vt52_mode) {
+ if (xkey >= 'P' && xkey <= 'S')
+ p += sprintf(p, "\x1B%c", xkey);
+ else
+ p += sprintf(p, "\x1B?%c", xkey);
+ } else
+ p += sprintf(p, "\x1BO%c", xkey);
+ }
+ }
+
+ return p - buf;
+}
+
+void term_keyinputw(Terminal *term, const wchar_t *widebuf, int len)
+{
+ strbuf *buf = term_input_data_from_unicode(term, widebuf, len);
+ if (buf->len)
+ term_keyinput_internal(term, buf->s, buf->len, true);
+ strbuf_free(buf);
+}
+
+void term_keyinput(Terminal *term, int codepage, const void *str, int len)
+{
+ if (codepage < 0 || codepage == term->ucsdata->line_codepage) {
+ /*
+ * This text needs no translation, either because it's already
+ * in the right character set, or because we got the special
+ * codepage value -1 from our caller which means 'this data
+ * should be charset-agnostic, just send it raw' (for really
+ * simple things like control characters).
+ */
+ term_keyinput_internal(term, str, len, true);
+ } else {
+ strbuf *buf = term_input_data_from_charset(term, codepage, str, len);
+ if (buf->len)
+ term_keyinput_internal(term, buf->s, buf->len, true);
+ strbuf_free(buf);
+ }
+}
+
+void term_nopaste(Terminal *term)
+{
+ if (term->paste_len == 0)
+ return;
+ sfree(term->paste_buffer);
+ term_bracketed_paste_stop(term);
+ term->paste_buffer = NULL;
+ term->paste_len = 0;
+}
+
+static void deselect(Terminal *term)
+{
+ term->selstate = NO_SELECTION;
+ term->selstart.x = term->selstart.y = term->selend.x = term->selend.y = 0;
+}
+
+void term_lost_clipboard_ownership(Terminal *term, int clipboard)
+{
+ if (!(term->n_mouse_select_clipboards > 1 &&
+ clipboard == term->mouse_select_clipboards[1]))
+ return;
+
+ deselect(term);
+ term_update(term);
+
+ /*
+ * Since terminal output is suppressed during drag-selects, we
+ * should make sure to write any pending output if one has just
+ * finished.
+ */
+ term_out(term, false);
+}
+
+static void term_added_data(Terminal *term, bool called_from_term_data)
+{
+ if (!term->in_term_out) {
+ term->in_term_out = true;
+ term_reset_cblink(term);
+ term_out(term, called_from_term_data);
+ term->in_term_out = false;
+ }
+}
+
+size_t term_data(Terminal *term, const void *data, size_t len)
+{
+ bufchain_add(&term->inbuf, data, len);
+ term_added_data(term, true);
+ return bufchain_size(&term->inbuf);
+}
+
+void term_provide_logctx(Terminal *term, LogContext *logctx)
+{
+ term->logctx = logctx;
+}
+
+void term_set_focus(Terminal *term, bool has_focus)
+{
+ term->has_focus = has_focus;
+ term_schedule_cblink(term);
+}
+
+/*
+ * Provide "auto" settings for remote tty modes, suitable for an
+ * application with a terminal window.
+ */
+char *term_get_ttymode(Terminal *term, const char *mode)
+{
+ const char *val = NULL;
+ if (strcmp(mode, "ERASE") == 0) {
+ val = term->bksp_is_delete ? "^?" : "^H";
+ } else if (strcmp(mode, "IUTF8") == 0) {
+ val = (term->ucsdata->line_codepage == CP_UTF8) ? "yes" : "no";
+ }
+ /* FIXME: perhaps we should set ONLCR based on lfhascr as well? */
+ /* FIXME: or ECHO and friends based on local echo state? */
+ return dupstr(val);
+}
+
+struct term_userpass_state {
+ size_t curr_prompt;
+ bool done_prompt; /* printed out prompt yet? */
+};
+
+/* Tiny wrapper to make it easier to write lots of little strings */
+static inline void term_write(Terminal *term, ptrlen data)
+{
+ term_data(term, data.ptr, data.len);
+}
+
+/*
+ * Signal that a prompts_t is done. This involves sending a
+ * notification to the caller, and also turning off our own callback
+ * that listens for more data arriving in the ldisc's input queue.
+ */
+static inline SeatPromptResult signal_prompts_t(Terminal *term, prompts_t *p,
+ SeatPromptResult spr)
+{
+ assert(p->callback && "Asynchronous userpass input requires a callback");
+ queue_toplevel_callback(p->callback, p->callback_ctx);
+ if (term->ldisc)
+ ldisc_enable_prompt_callback(term->ldisc, NULL);
+ p->spr = spr;
+ return spr;
+}
+
+/*
+ * Process some terminal data in the course of username/password
+ * input.
+ */
+SeatPromptResult term_get_userpass_input(Terminal *term, prompts_t *p)
+{
+ if (!term->ldisc) {
+ /* Can't handle interactive prompts without an ldisc */
+ return signal_prompts_t(term, p, SPR_SW_ABORT(
+ "Terminal not prepared for interactive prompts"));
+ }
+
+ if (p->spr.kind != SPRK_INCOMPLETE) {
+ /* We've already finished these prompts, so return the same
+ * result again */
+ return p->spr;
+ }
+
+ struct term_userpass_state *s = (struct term_userpass_state *)p->data;
+
+ if (!s) {
+ /*
+ * First call. Set some stuff up.
+ */
+ p->data = s = snew(struct term_userpass_state);
+ p->spr = SPR_INCOMPLETE;
+ s->curr_prompt = 0;
+ s->done_prompt = false;
+ /* We only print the `name' caption if we have to... */
+ if (p->name_reqd && p->name) {
+ ptrlen plname = ptrlen_from_asciz(p->name);
+ term_write(term, plname);
+ if (!ptrlen_endswith(plname, PTRLEN_LITERAL("\n"), NULL))
+ term_write(term, PTRLEN_LITERAL("\r\n"));
+ }
+ /* ...but we always print any `instruction'. */
+ if (p->instruction) {
+ ptrlen plinst = ptrlen_from_asciz(p->instruction);
+ term_write(term, plinst);
+ if (!ptrlen_endswith(plinst, PTRLEN_LITERAL("\n"), NULL))
+ term_write(term, PTRLEN_LITERAL("\r\n"));
+ }
+ /*
+ * Zero all the results, in case we abort half-way through.
+ */
+ {
+ int i;
+ for (i = 0; i < (int)p->n_prompts; i++)
+ prompt_set_result(p->prompts[i], "");
+ }
+ }
+
+ while (s->curr_prompt < p->n_prompts) {
+
+ prompt_t *pr = p->prompts[s->curr_prompt];
+ bool finished_prompt = false;
+
+ if (!s->done_prompt) {
+ term_write(term, ptrlen_from_asciz(pr->prompt));
+ s->done_prompt = true;
+ }
+
+ /* Breaking out here ensures that the prompt is printed even
+ * if we're now waiting for user data. */
+ if (!ldisc_has_input_buffered(term->ldisc))
+ break;
+
+ /* FIXME: should we be using local-line-editing code instead? */
+ while (!finished_prompt && ldisc_has_input_buffered(term->ldisc)) {
+ LdiscInputToken tok = ldisc_get_input_token(term->ldisc);
+
+ char c;
+ if (tok.is_special) {
+ switch (tok.code) {
+ case SS_EOL: c = 13; break;
+ case SS_EC: c = 8; break;
+ case SS_IP: c = 3; break;
+ case SS_EOF: c = 3; break;
+ default: continue;
+ }
+ } else {
+ c = tok.chr;
+ }
+
+ switch (c) {
+ case 10:
+ case 13:
+ term_write(term, PTRLEN_LITERAL("\r\n"));
+ /* go to next prompt, if any */
+ s->curr_prompt++;
+ s->done_prompt = false;
+ finished_prompt = true; /* break out */
+ break;
+ case 8:
+ case 127:
+ if (pr->result->len > 0) {
+ if (pr->echo)
+ term_write(term, PTRLEN_LITERAL("\b \b"));
+ strbuf_shrink_by(pr->result, 1);
+ }
+ break;
+ case 21:
+ case 27:
+ while (pr->result->len > 0) {
+ if (pr->echo)
+ term_write(term, PTRLEN_LITERAL("\b \b"));
+ strbuf_shrink_by(pr->result, 1);
+ }
+ break;
+ case 3:
+ case 4:
+ /* Immediate abort. */
+ term_write(term, PTRLEN_LITERAL("\r\n"));
+ sfree(s);
+ p->data = NULL;
+ return signal_prompts_t(term, p, SPR_USER_ABORT);
+ default:
+ /*
+ * This simplistic check for printability is disabled
+ * when we're doing password input, because some people
+ * have control characters in their passwords.
+ */
+ if (!pr->echo || (c >= ' ' && c <= '~') ||
+ ((unsigned char) c >= 160)) {
+ put_byte(pr->result, c);
+ if (pr->echo)
+ term_write(term, make_ptrlen(&c, 1));
+ }
+ break;
+ }
+ }
+
+ }
+
+ if (s->curr_prompt < p->n_prompts) {
+ ldisc_enable_prompt_callback(term->ldisc, p);
+ return SPR_INCOMPLETE;
+ } else {
+ sfree(s);
+ p->data = NULL;
+ return signal_prompts_t(term, p, SPR_OK);
+ }
+}
+
+void term_notify_minimised(Terminal *term, bool minimised)
+{
+ term->minimised = minimised;
+}
+
+void term_notify_palette_changed(Terminal *term)
+{
+ palette_reset(term, true);
+}
+
+void term_notify_window_pos(Terminal *term, int x, int y)
+{
+ term->winpos_x = x;
+ term->winpos_y = y;
+}
+
+void term_notify_window_size_pixels(Terminal *term, int x, int y)
+{
+ term->winpixsize_x = x;
+ term->winpixsize_y = y;
+}
diff --git a/terminal/terminal.h b/terminal/terminal.h
new file mode 100644
index 00000000..3f918b22
--- /dev/null
+++ b/terminal/terminal.h
@@ -0,0 +1,563 @@
+/*
+ * Internals of the Terminal structure, for those other modules
+ * which need to look inside it. It would be nice if this could be
+ * folded back into terminal.c in future, with an abstraction layer
+ * to handle everything that other modules need to know about it;
+ * but for the moment, this will do.
+ */
+
+#ifndef PUTTY_TERMINAL_H
+#define PUTTY_TERMINAL_H
+
+#include "tree234.h"
+
+struct beeptime {
+ struct beeptime *next;
+ unsigned long ticks;
+};
+
+#define TRUST_SIGIL_WIDTH 3
+#define TRUST_SIGIL_CHAR 0xDFFE
+
+typedef struct {
+ int y, x;
+} pos;
+
+typedef struct termchar termchar;
+typedef struct termline termline;
+
+struct termchar {
+ /*
+ * Any code in terminal.c which definitely needs to be changed
+ * when extra fields are added here is labelled with a comment
+ * saying FULL-TERMCHAR.
+ */
+ unsigned long chr;
+ unsigned long attr;
+ truecolour truecolour;
+
+ /*
+ * The cc_next field is used to link multiple termchars
+ * together into a list, so as to fit more than one character
+ * into a character cell (Unicode combining characters).
+ *
+ * cc_next is a relative offset into the current array of
+ * termchars. I.e. to advance to the next character in a list,
+ * one does `tc += tc->next'.
+ *
+ * Zero means end of list.
+ */
+ int cc_next;
+};
+
+struct termline {
+ unsigned short lattr;
+ int cols; /* number of real columns on the line */
+ int size; /* number of allocated termchars
+ * (cc-lists may make this > cols) */
+ bool temporary; /* true if decompressed from scrollback */
+ int cc_free; /* offset to first cc in free list */
+ struct termchar *chars;
+ bool trusted;
+};
+
+struct bidi_cache_entry {
+ int width;
+ bool trusted;
+ struct termchar *chars;
+ int *forward, *backward; /* the permutations of line positions */
+};
+
+struct term_utf8_decode {
+ int state; /* Is there a pending UTF-8 character */
+ int chr; /* and what is it so far? */
+ int size; /* The size of the UTF character. */
+};
+
+struct terminal_tag {
+
+ int compatibility_level;
+
+ tree234 *scrollback; /* lines scrolled off top of screen */
+ tree234 *screen; /* lines on primary screen */
+ tree234 *alt_screen; /* lines on alternate screen */
+ int disptop; /* distance scrolled back (0 or -ve) */
+ int tempsblines; /* number of lines of .scrollback that
+ can be retrieved onto the terminal
+ ("temporary scrollback") */
+
+ termline **disptext; /* buffer of text on real screen */
+ int dispcursx, dispcursy; /* location of cursor on real screen */
+ int curstype; /* type of cursor on real screen */
+
+#define VBELL_TIMEOUT (TICKSPERSEC/10) /* visual bell lasts 1/10 sec */
+
+ struct beeptime *beephead, *beeptail;
+ int nbeeps;
+ bool beep_overloaded;
+ long lastbeep;
+
+#define TTYPE termchar
+#define TSIZE (sizeof(TTYPE))
+
+ int default_attr, curr_attr, save_attr;
+ truecolour curr_truecolour, save_truecolour;
+ termchar basic_erase_char, erase_char;
+
+ bufchain inbuf; /* terminal input buffer */
+
+ pos curs; /* cursor */
+ pos savecurs; /* saved cursor position */
+ int marg_t, marg_b; /* scroll margins */
+ bool dec_om; /* DEC origin mode flag */
+ bool wrap, wrapnext; /* wrap flags */
+ bool insert; /* insert-mode flag */
+ int cset; /* 0 or 1: which char set */
+ int save_cset, save_csattr; /* saved with cursor position */
+ bool save_utf, save_wnext; /* saved with cursor position */
+ bool rvideo; /* global reverse video flag */
+ unsigned long rvbell_startpoint; /* for ESC[?5hESC[?5l vbell */
+ bool cursor_on; /* cursor enabled flag */
+ bool reset_132; /* Flag ESC c resets to 80 cols */
+ bool use_bce; /* Use Background coloured erase */
+ bool cblinker; /* When blinking is the cursor on ? */
+ bool tblinker; /* When the blinking text is on */
+ bool blink_is_real; /* Actually blink blinking text */
+ int sco_acs, save_sco_acs; /* CSI 10,11,12m -> OEM charset */
+ bool vt52_bold; /* Force bold on non-bold colours */
+ bool utf; /* Are we in toggleable UTF-8 mode? */
+ term_utf8_decode utf8; /* If so, here's our decoding state */
+ bool printing, only_printing; /* Are we doing ANSI printing? */
+ int print_state; /* state of print-end-sequence scan */
+ bufchain printer_buf; /* buffered data for printer */
+ printer_job *print_job;
+
+ /* ESC 7 saved state for the alternate screen */
+ pos alt_savecurs;
+ int alt_save_attr;
+ truecolour alt_save_truecolour;
+ int alt_save_cset, alt_save_csattr;
+ bool alt_save_utf;
+ bool alt_save_wnext;
+ int alt_save_sco_acs;
+
+ int rows, cols, savelines;
+ bool has_focus;
+ bool in_vbell;
+ long vbell_end;
+ bool app_cursor_keys, app_keypad_keys, vt52_mode;
+ bool repeat_off, srm_echo, cr_lf_return;
+ bool seen_disp_event;
+ bool big_cursor;
+
+ bool xterm_mouse_forbidden;
+ int xterm_mouse; /* send mouse messages to host */
+ bool xterm_extended_mouse;
+ bool urxvt_extended_mouse;
+ int mouse_is_down; /* used while tracking mouse buttons */
+
+ bool bracketed_paste, bracketed_paste_active;
+
+ int cset_attr[2];
+
+/*
+ * Saved settings on the alternate screen.
+ */
+ int alt_x, alt_y;
+ bool alt_wnext, alt_ins;
+ bool alt_om, alt_wrap;
+ int alt_cset, alt_sco_acs;
+ bool alt_utf;
+ int alt_t, alt_b;
+ int alt_which;
+ int alt_sblines; /* # of lines on alternate screen that should be used for scrollback. */
+
+#define ARGS_MAX 32 /* max # of esc sequence arguments */
+#define ARG_DEFAULT 0 /* if an arg isn't specified */
+#define def(a,d) ( (a) == ARG_DEFAULT ? (d) : (a) )
+ unsigned esc_args[ARGS_MAX];
+ int esc_nargs;
+ int esc_query;
+#define ANSI(x,y) ((x)+((y)*256))
+#define ANSI_QUE(x) ANSI(x,1)
+
+#define OSC_STR_MAX 2048
+ int osc_strlen;
+ char osc_string[OSC_STR_MAX + 1];
+ bool osc_w;
+
+ char id_string[1024];
+
+ unsigned char *tabs;
+
+ enum {
+ TOPLEVEL,
+ SEEN_ESC,
+ SEEN_CSI,
+ SEEN_OSC,
+ SEEN_OSC_W,
+
+ DO_CTRLS,
+
+ SEEN_OSC_P,
+ OSC_STRING, OSC_MAYBE_ST, OSC_MAYBE_ST_UTF8,
+ VT52_ESC,
+ VT52_Y1,
+ VT52_Y2,
+ VT52_FG,
+ VT52_BG
+ } termstate;
+
+ enum {
+ NO_SELECTION, ABOUT_TO, DRAGGING, SELECTED
+ } selstate;
+ enum {
+ LEXICOGRAPHIC, RECTANGULAR
+ } seltype;
+ enum {
+ SM_CHAR, SM_WORD, SM_LINE
+ } selmode;
+ pos selstart, selend, selanchor;
+
+ short wordness[256];
+
+ /* Mask of attributes to pay attention to when painting. */
+ int attr_mask;
+
+ wchar_t *paste_buffer;
+ int paste_len, paste_pos;
+
+ Backend *backend;
+
+ Ldisc *ldisc;
+
+ TermWin *win;
+
+ LogContext *logctx;
+
+ struct unicode_data *ucsdata;
+
+ unsigned long last_graphic_char;
+
+ /*
+ * We maintain a full copy of a Conf here, not merely a pointer
+ * to it. That way, when we're passed a new one for
+ * reconfiguration, we can check the differences and adjust the
+ * _current_ setting of (e.g.) auto wrap mode rather than only
+ * the default.
+ */
+ Conf *conf;
+
+ /*
+ * GUI implementations of seat_output call term_out, but it can
+ * also be called from the ldisc if the ldisc is called _within_
+ * term_out. So we have to guard against re-entrancy - if
+ * seat_output is called recursively like this, it will simply add
+ * data to the end of the buffer term_out is in the process of
+ * working through.
+ */
+ bool in_term_out;
+
+ /*
+ * We don't permit window updates too close together, to avoid CPU
+ * churn pointlessly redrawing the window faster than the user can
+ * read. So after an update, we set window_update_cooldown = true
+ * and schedule a timer to reset it to false. In between those
+ * times, window updates are not performed, and instead we set
+ * window_update_pending = true, which will remind us to perform
+ * the deferred redraw when the cooldown period ends and
+ * window_update_cooldown is reset to false.
+ */
+ bool window_update_pending, window_update_cooldown;
+ long window_update_cooldown_end;
+
+ /*
+ * Track pending blinks and tblinks.
+ */
+ bool tblink_pending, cblink_pending;
+ long next_tblink, next_cblink;
+
+ /*
+ * These are buffers used by the bidi and Arabic shaping code.
+ */
+ termchar *ltemp;
+ int ltemp_size;
+ bidi_char *wcFrom, *wcTo;
+ int wcFromTo_size;
+ struct bidi_cache_entry *pre_bidi_cache, *post_bidi_cache;
+ size_t bidi_cache_size;
+
+ /*
+ * Current trust state, used to annotate every line of the
+ * terminal that a graphic character is output to.
+ */
+ bool trusted;
+
+ /*
+ * We copy a bunch of stuff out of the Conf structure into local
+ * fields in the Terminal structure, to avoid the repeated
+ * tree234 lookups which would be involved in fetching them from
+ * the former every time.
+ */
+ bool ansi_colour;
+ char *answerback;
+ int answerbacklen;
+ bool no_arabicshaping;
+ int beep;
+ bool bellovl;
+ int bellovl_n;
+ int bellovl_s;
+ int bellovl_t;
+ bool no_bidi;
+ bool bksp_is_delete;
+ bool blink_cur;
+ bool blinktext;
+ bool cjk_ambig_wide;
+ int conf_height;
+ int conf_width;
+ bool crhaslf;
+ bool erase_to_scrollback;
+ int funky_type, sharrow_type;
+ bool lfhascr;
+ bool logflush;
+ int logtype;
+ bool mouse_override;
+ bool nethack_keypad;
+ bool no_alt_screen;
+ bool no_applic_c;
+ bool no_applic_k;
+ bool no_dbackspace;
+ bool no_mouse_rep;
+ bool no_remote_charset;
+ bool no_remote_resize;
+ bool no_remote_wintitle;
+ bool no_remote_clearscroll;
+ bool rawcnp;
+ bool utf8linedraw;
+ bool rect_select;
+ int remote_qtitle_action;
+ bool rxvt_homeend;
+ bool scroll_on_disp;
+ bool scroll_on_key;
+ bool xterm_256_colour;
+ bool true_colour;
+
+ wchar_t *last_selected_text;
+ int *last_selected_attr;
+ truecolour *last_selected_tc;
+ size_t last_selected_len;
+ int mouse_select_clipboards[N_CLIPBOARDS];
+ int n_mouse_select_clipboards;
+ int mouse_paste_clipboard;
+
+ char *window_title, *icon_title;
+ int wintitle_codepage, icontitle_codepage;
+ bool minimised;
+
+ BidiContext *bidi_ctx;
+
+ /* Multi-layered colour palette. The colours from Conf (plus the
+ * default xterm-256 ones that don't have Conf ids at all) have
+ * lowest priority, followed by platform overrides if any,
+ * followed by escape-sequence overrides during the session. */
+ struct term_subpalette {
+ rgb values[OSC4_NCOLOURS];
+ bool present[OSC4_NCOLOURS];
+ } subpalettes[3];
+#define SUBPAL_CONF 0
+#define SUBPAL_PLATFORM 1
+#define SUBPAL_SESSION 2
+
+ /* The composite palette that we make out of the above */
+ rgb palette[OSC4_NCOLOURS];
+
+ unsigned winpos_x, winpos_y, winpixsize_x, winpixsize_y;
+
+ /*
+ * Assorted 'pending' flags for ancillary window changes performed
+ * in term_update. Generally, to trigger one of these operations,
+ * you set the pending flag and/or the parameters here, then call
+ * term_schedule_update.
+ */
+ bool win_move_pending;
+ int win_move_pending_x, win_move_pending_y;
+ bool win_zorder_pending;
+ bool win_zorder_top;
+ bool win_minimise_pending;
+ bool win_minimise_enable;
+ bool win_maximise_pending;
+ bool win_maximise_enable;
+ bool win_title_pending, win_icon_title_pending;
+ bool win_pointer_shape_pending;
+ bool win_pointer_shape_raw;
+ bool win_refresh_pending;
+ bool win_scrollbar_update_pending;
+ bool win_palette_pending;
+ unsigned win_palette_pending_min, win_palette_pending_limit;
+
+ /*
+ * Unlike the rest of the above 'pending' flags, the one for
+ * window resizing has to be more complicated, because it's very
+ * likely that a server sending a window-resize escape sequence is
+ * going to follow it up immediately with further terminal output
+ * that draws a full-screen application expecting the terminal to
+ * be the new size.
+ *
+ * So, once we've requested a window resize from the TermWin, we
+ * have to stop processing terminal data until we get back the
+ * notification that our window really has changed size (or until
+ * we find out that it's not going to).
+ *
+ * Hence, window resizes go through a small state machine with two
+ * different kinds of 'pending'. NEED_SEND is the state where
+ * we've received an escape sequence asking for a new size but not
+ * yet sent it to the TermWin via win_request_resize; AWAIT_REPLY
+ * is the state where we've sent it to the TermWin and are
+ * expecting a call back to term_size().
+ *
+ * So _both_ of those 'pending' states inhibit terminal output
+ * processing.
+ *
+ * (Hence, once we're in either state, we should never handle
+ * another resize sequence, so the only possible path through this
+ * state machine is to get all the way back to the ground state
+ * before doing anything else interesting.)
+ */
+ enum {
+ WIN_RESIZE_NO, WIN_RESIZE_NEED_SEND, WIN_RESIZE_AWAIT_REPLY
+ } win_resize_pending;
+ int win_resize_pending_w, win_resize_pending_h;
+};
+
+static inline bool in_utf(Terminal *term)
+{
+ return term->utf || term->ucsdata->line_codepage == CP_UTF8;
+}
+
+unsigned long term_translate(
+ Terminal *term, term_utf8_decode *utf8, unsigned char c);
+static inline int term_char_width(Terminal *term, unsigned int c)
+{
+ return term->cjk_ambig_wide ? mk_wcwidth_cjk(c) : mk_wcwidth(c);
+}
+
+/*
+ * UCSINCOMPLETE is returned from term_translate if it's successfully
+ * absorbed a byte but not emitted a complete character yet.
+ * UCSTRUNCATED indicates a truncated multibyte sequence (so the
+ * caller emits an error character and then calls term_translate again
+ * with the same input byte). UCSINVALID indicates some other invalid
+ * multibyte sequence, such as an overlong synonym, or a standalone
+ * continuation byte, or a completely illegal thing like 0xFE. These
+ * values are not stored in the terminal data structures at all.
+ */
+#define UCSINCOMPLETE 0x8000003FU /* '?' */
+#define UCSTRUNCATED 0x80000021U /* '!' */
+#define UCSINVALID 0x8000002AU /* '*' */
+
+/*
+ * Maximum number of combining characters we're willing to store in a
+ * character cell. Our linked-list data representation permits an
+ * unlimited number of these in principle, but if we allowed that in
+ * practice then it would be an easy DoS to just squirt a squillion
+ * identical combining characters to someone's terminal and cause
+ * their PuTTY or pterm to consume lots of memory and CPU pointlessly.
+ *
+ * The precise figure of 32 is more or less arbitrary, but one point
+ * supporting it is UAX #15's comment that 30 combining characters is
+ * "significantly beyond what is required for any linguistic or
+ * technical usage".
+ */
+#define CC_LIMIT 32
+
+/* ----------------------------------------------------------------------
+ * Helper functions for dealing with the small 'pos' structure.
+ */
+
+static inline bool poslt(pos p1, pos p2)
+{
+ if (p1.y != p2.y)
+ return p1.y < p2.y;
+ return p1.x < p2.x;
+}
+
+static inline bool posle(pos p1, pos p2)
+{
+ if (p1.y != p2.y)
+ return p1.y < p2.y;
+ return p1.x <= p2.x;
+}
+
+static inline bool poseq(pos p1, pos p2)
+{
+ return p1.y == p2.y && p1.x == p2.x;
+}
+
+static inline int posdiff_fn(pos p1, pos p2, int cols)
+{
+ return (p1.y - p2.y) * (cols+1) + (p1.x - p2.x);
+}
+
+/* Convenience wrapper on posdiff_fn which uses the 'Terminal *term'
+ * that more or less every function in terminal.c will have in scope.
+ * For safety's sake I include a TYPECHECK that ensures it really is a
+ * structure pointer of the right type. */
+#define GET_TERM_COLS TYPECHECK(term == (Terminal *)0, term->cols)
+#define posdiff(p1,p2) posdiff_fn(p1, p2, GET_TERM_COLS)
+
+/* Product-order comparisons for rectangular block selection. */
+
+static inline bool posPle(pos p1, pos p2)
+{
+ return p1.y <= p2.y && p1.x <= p2.x;
+}
+
+static inline bool posPle_left(pos p1, pos p2)
+{
+ /*
+ * This function is used for checking whether a given character
+ * cell of the terminal ought to be highlighted as part of the
+ * selection, by comparing with term->selend. term->selend stores
+ * the location one space to the right of the last highlighted
+ * character. So we want to highlight the characters that are
+ * less-or-equal (in the product order) to the character just left
+ * of p2.
+ *
+ * (Setting up term->selend that way was the easiest way to get
+ * rectangular selection working at all, in a code base that had
+ * done lexicographic selection the way I happened to have done
+ * it.)
+ */
+ return p1.y <= p2.y && p1.x < p2.x;
+}
+
+static inline bool incpos_fn(pos *p, int cols)
+{
+ if (p->x == cols) {
+ p->x = 0;
+ p->y++;
+ return true;
+ }
+ p->x++;
+ return false;
+}
+
+static inline bool decpos_fn(pos *p, int cols)
+{
+ if (p->x == 0) {
+ p->x = cols;
+ p->y--;
+ return true;
+ }
+ p->x--;
+ return false;
+}
+
+/* Convenience wrappers on incpos and decpos which use term->cols
+ * (similarly to posdiff above), and also (for mild convenience and
+ * mostly historical inertia) let you leave off the & at every call
+ * site. */
+#define incpos(p) incpos_fn(&(p), GET_TERM_COLS)
+#define decpos(p) decpos_fn(&(p), GET_TERM_COLS)
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-15 14:09:38 +0300