@shitiandmw/node-pty 1.1.0-agent.0

package/deps/winpty/misc/UnicodeDoubleWidthTest.cc

@@ -0,0 +1,102 @@
+// Demonstrates how U+30FC is sometimes handled as a single-width character
+// when it should be handled as a double-width character.
+//
+// It only runs on computers where 932 is a valid code page.  Set the system
+// local to "Japanese (Japan)" to ensure this.
+//
+// The problem seems to happen when U+30FC is printed in a console using the
+// Lucida Console font, and only when that font is at certain sizes.
+//
+
+#include <windows.h>
+#include <assert.h>
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "TestUtil.cc"
+
+#define COUNT_OF(x) (sizeof(x) / sizeof((x)[0]))
+
+static void setFont(const wchar_t *faceName, int pxSize) {
+    CONSOLE_FONT_INFOEX infoex = {0};
+    infoex.cbSize = sizeof(infoex);
+    infoex.dwFontSize.Y = pxSize;
+    wcsncpy(infoex.FaceName, faceName, COUNT_OF(infoex.FaceName));
+    BOOL ret = SetCurrentConsoleFontEx(
+        GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &infoex);
+    assert(ret);
+}
+
+static bool performTest(const wchar_t testChar) {
+    const HANDLE conout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    SetConsoleTextAttribute(conout, 7);
+
+    system("cls");
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleW(conout, &testChar, 1, &actual, NULL);
+    assert(ret && actual == 1);
+
+    CHAR_INFO verify[2];
+    COORD bufSize = {2, 1};
+    COORD bufCoord = {0, 0};
+    const SMALL_RECT readRegion = {0, 0, 1, 0};
+    SMALL_RECT actualRegion = readRegion;
+    ret = ReadConsoleOutputW(conout, verify, bufSize, bufCoord, &actualRegion);
+    assert(ret && !memcmp(&readRegion, &actualRegion, sizeof(readRegion)));
+    assert(verify[0].Char.UnicodeChar == testChar);
+
+    if (verify[1].Char.UnicodeChar == testChar) {
+        // Typical double-width behavior with a TrueType font.  Pass.
+        assert(verify[0].Attributes == 0x107);
+        assert(verify[1].Attributes == 0x207);
+        return true;
+    } else if (verify[1].Char.UnicodeChar == 0) {
+        // Typical double-width behavior with a Raster Font.  Pass.
+        assert(verify[0].Attributes == 7);
+        assert(verify[1].Attributes == 0);
+        return true;
+    } else if (verify[1].Char.UnicodeChar == L' ') {
+        // Single-width behavior.  Fail.
+        assert(verify[0].Attributes == 7);
+        assert(verify[1].Attributes == 7);
+        return false;
+    } else {
+        // Unexpected output.
+        assert(false);
+    }
+}
+
+int main(int argc, char *argv[]) {
+    setlocale(LC_ALL, "");
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    assert(SetConsoleCP(932));
+    assert(SetConsoleOutputCP(932));
+
+    const wchar_t testChar = 0x30FC;
+    const wchar_t *const faceNames[] = {
+        L"Lucida Console",
+        L"Consolas",
+        L"ＭＳ ゴシック",
+    };
+
+    trace("Test started");
+
+    for (auto faceName : faceNames) {
+        for (int px = 1; px <= 50; ++px) {
+            setFont(faceName, px);
+            if (!performTest(testChar)) {
+                trace("FAILURE: %s %dpx", narrowString(faceName).c_str(), px);
+            }
+        }
+    }
+
+    trace("Test complete");
+    return 0;
+}

package/deps/winpty/misc/UnicodeWideTest1.cc

@@ -0,0 +1,246 @@
+#include <windows.h>
+
+#include <assert.h>
+#include <vector>
+
+#include "TestUtil.cc"
+
+#define COUNT_OF(x) (sizeof(x) / sizeof((x)[0]))
+
+
+CHAR_INFO ci(wchar_t ch, WORD attributes) {
+    CHAR_INFO ret;
+    ret.Char.UnicodeChar = ch;
+    ret.Attributes = attributes;
+    return ret;
+}
+
+CHAR_INFO ci(wchar_t ch) {
+    return ci(ch, 7);
+}
+
+CHAR_INFO ci() {
+    return ci(L' ');
+}
+
+bool operator==(SMALL_RECT x, SMALL_RECT y) {
+    return !memcmp(&x, &y, sizeof(x));
+}
+
+SMALL_RECT sr(COORD pt, COORD size) {
+    return {
+        pt.X, pt.Y,
+        static_cast<SHORT>(pt.X + size.X - 1),
+        static_cast<SHORT>(pt.Y + size.Y - 1)
+    };
+}
+
+static void set(
+        const COORD pt,
+        const COORD size,
+        const std::vector<CHAR_INFO> &data) {
+    assert(data.size() == size.X * size.Y);
+    SMALL_RECT writeRegion = sr(pt, size);
+    BOOL ret = WriteConsoleOutputW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), size, {0, 0}, &writeRegion);
+    assert(ret && writeRegion == sr(pt, size));
+}
+
+static void set(
+        const COORD pt,
+        const std::vector<CHAR_INFO> &data) {
+    set(pt, {static_cast<SHORT>(data.size()), 1}, data);
+}
+
+static void writeAttrsAt(
+        const COORD pt,
+        const std::vector<WORD> &data) {
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleOutputAttribute(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), data.size(), pt, &actual);
+    assert(ret && actual == data.size());
+}
+
+static void writeCharsAt(
+        const COORD pt,
+        const std::vector<wchar_t> &data) {
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleOutputCharacterW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), data.size(), pt, &actual);
+    assert(ret && actual == data.size());
+}
+
+static void writeChars(
+        const std::vector<wchar_t> &data) {
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), data.size(), &actual, NULL);
+    assert(ret && actual == data.size());
+}
+
+std::vector<CHAR_INFO> get(
+        const COORD pt,
+        const COORD size) {
+    std::vector<CHAR_INFO> data(size.X * size.Y);
+    SMALL_RECT readRegion = sr(pt, size);
+    BOOL ret = ReadConsoleOutputW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), size, {0, 0}, &readRegion);
+    assert(ret && readRegion == sr(pt, size));
+    return data;
+}
+
+std::vector<wchar_t> readCharsAt(
+        const COORD pt,
+        int size) {
+    std::vector<wchar_t> data(size);
+    DWORD actual = 0;
+    BOOL ret = ReadConsoleOutputCharacterW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        data.data(), data.size(), pt, &actual);
+    assert(ret);
+    data.resize(actual); // With double-width chars, we can read fewer than `size`.
+    return data;
+}
+
+static void dump(const COORD pt, const COORD size) {
+    for (CHAR_INFO ci : get(pt, size)) {
+        printf("%04X %04X\n", ci.Char.UnicodeChar, ci.Attributes);
+    }
+}
+
+static void dumpCharsAt(const COORD pt, int size) {
+    for (wchar_t ch : readCharsAt(pt, size)) {
+        printf("%04X\n", ch);
+    }
+}
+
+static COORD getCursorPos() {
+    CONSOLE_SCREEN_BUFFER_INFO info = { sizeof(info) };
+    assert(GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info));
+    return info.dwCursorPosition;
+}
+
+static void test1() {
+    // We write "䀀䀀", then write "䀁" in the middle of the two.  The second
+    // write turns the first and last cells into spaces.  The LEADING/TRAILING
+    // flags retain consistency.
+    printf("test1 - overlap full-width char with full-width char\n");
+    writeCharsAt({1,0}, {0x4000, 0x4000});
+    dump({0,0}, {6,1});
+    printf("\n");
+    writeCharsAt({2,0}, {0x4001});
+    dump({0,0}, {6,1});
+    printf("\n");
+}
+
+static void test2() {
+    // Like `test1`, but use a lower-level API to do the write.  Consistency is
+    // preserved here too -- the first and last cells are replaced with spaces.
+    printf("test2 - overlap full-width char with full-width char (lowlevel)\n");
+    writeCharsAt({1,0}, {0x4000, 0x4000});
+    dump({0,0}, {6,1});
+    printf("\n");
+    set({2,0}, {ci(0x4001,0x107), ci(0x4001,0x207)});
+    dump({0,0}, {6,1});
+    printf("\n");
+}
+
+static void test3() {
+    // However, the lower-level API can break the LEADING/TRAILING invariant
+    // explicitly:
+    printf("test3 - explicitly violate LEADING/TRAILING using lowlevel API\n");
+    set({1,0}, {
+        ci(0x4000, 0x207),
+        ci(0x4001, 0x107),
+        ci(0x3044, 7),
+        ci(L'X', 0x107),
+        ci(L'X', 0x207),
+    });
+    dump({0,0}, {7,1});
+}
+
+static void test4() {
+    // It is possible for the two cells of a double-width character to have two
+    // colors.
+    printf("test4 - use lowlevel to assign two colors to one full-width char\n");
+    set({0,0}, {
+        ci(0x4000, 0x142),
+        ci(0x4000, 0x224),
+    });
+    dump({0,0}, {2,1});
+}
+
+static void test5() {
+    // WriteConsoleOutputAttribute doesn't seem to affect the LEADING/TRAILING
+    // flags.
+    printf("test5 - WriteConsoleOutputAttribute cannot affect LEADING/TRAILING\n");
+
+    // Trying to clear the flags doesn't work...
+    writeCharsAt({0,0}, {0x4000});
+    dump({0,0}, {2,1});
+    writeAttrsAt({0,0}, {0x42, 0x24});
+    printf("\n");
+    dump({0,0}, {2,1});
+
+    // ... and trying to add them also doesn't work.
+    writeCharsAt({0,1}, {'A', ' '});
+    writeAttrsAt({0,1}, {0x107, 0x207});
+    printf("\n");
+    dump({0,1}, {2,1});
+}
+
+static void test6() {
+    // The cursor position may be on either cell of a double-width character.
+    // Visually, the cursor appears under both cells, regardless of which
+    // specific one has the cursor.
+    printf("test6 - cursor can be either left or right cell of full-width char\n");
+
+    writeCharsAt({2,1}, {0x4000});
+
+    setCursorPos(2, 1);
+    auto pos1 = getCursorPos();
+    Sleep(1000);
+
+    setCursorPos(3, 1);
+    auto pos2 = getCursorPos();
+    Sleep(1000);
+
+    setCursorPos(0, 15);
+    printf("%d,%d\n", pos1.X, pos1.Y);
+    printf("%d,%d\n", pos2.X, pos2.Y);
+}
+
+static void runTest(void (&test)()) {
+    system("cls");
+    setCursorPos(0, 14);
+    test();
+    system("pause");
+}
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(80, 40);
+    setWindowPos(0, 0, 80, 40);
+
+    auto cp = GetConsoleOutputCP();
+    assert(cp == 932 || cp == 936 || cp == 949 || cp == 950);
+
+    runTest(test1);
+    runTest(test2);
+    runTest(test3);
+    runTest(test4);
+    runTest(test5);
+    runTest(test6);
+
+    return 0;
+}

package/deps/winpty/misc/UnicodeWideTest2.cc

@@ -0,0 +1,130 @@
+//
+// Test half-width vs full-width characters.
+//
+
+#include <windows.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "TestUtil.cc"
+
+static void writeChars(const wchar_t *text) {
+    wcslen(text);
+    const int len = wcslen(text);
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        text, len, &actual, NULL);
+    trace("writeChars: ret=%d, actual=%lld", ret, (long long)actual);
+}
+
+static void dumpChars(int x, int y, int w, int h) {
+    BOOL ret;
+    const COORD bufSize = {w, h};
+    const COORD bufCoord = {0, 0};
+    const SMALL_RECT topLeft = {x, y, x + w - 1, y + h - 1};
+    CHAR_INFO mbcsData[w * h];
+    CHAR_INFO unicodeData[w * h];
+    SMALL_RECT readRegion;
+    readRegion = topLeft;
+    ret = ReadConsoleOutputW(GetStdHandle(STD_OUTPUT_HANDLE), unicodeData,
+                             bufSize, bufCoord, &readRegion);
+    assert(ret);
+    readRegion = topLeft;
+    ret = ReadConsoleOutputA(GetStdHandle(STD_OUTPUT_HANDLE), mbcsData,
+                             bufSize, bufCoord, &readRegion);
+    assert(ret);
+
+    printf("\n");
+    for (int i = 0; i < w * h; ++i) {
+        printf("(%02d,%02d) CHAR: %04x %4x -- %02x %4x\n",
+            x + i % w, y + i / w,
+            (unsigned short)unicodeData[i].Char.UnicodeChar,
+            (unsigned short)unicodeData[i].Attributes,
+            (unsigned char)mbcsData[i].Char.AsciiChar,
+            (unsigned short)mbcsData[i].Attributes);
+    }
+}
+
+int main(int argc, char *argv[]) {
+    system("cls");
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(80, 38);
+    setWindowPos(0, 0, 80, 38);
+
+    // Write text.
+    const wchar_t text1[] = {
+        0x3044, // U+3044 (HIRAGANA LETTER I)
+        0x2014, // U+2014 (EM DASH)
+        0x3044, // U+3044 (HIRAGANA LETTER I)
+        0xFF2D, // U+FF2D (FULLWIDTH LATIN CAPITAL LETTER M)
+        0x30FC, // U+30FC (KATAKANA-HIRAGANA PROLONGED SOUND MARK)
+        0x0031, // U+3031 (DIGIT ONE)
+        0x2014, // U+2014 (EM DASH)
+        0x0032, // U+0032 (DIGIT TWO)
+        0x005C, // U+005C (REVERSE SOLIDUS)
+        0x3044, // U+3044 (HIRAGANA LETTER I)
+        0
+    };
+    setCursorPos(0, 0);
+    writeChars(text1);
+
+    setCursorPos(78, 1);
+    writeChars(L"<>");
+
+    const wchar_t text2[] = {
+        0x0032, // U+3032 (DIGIT TWO)
+        0x3044, // U+3044 (HIRAGANA LETTER I)
+        0,
+    };
+    setCursorPos(78, 1);
+    writeChars(text2);
+
+    system("pause");
+
+    dumpChars(0, 0, 17, 1);
+    dumpChars(2, 0, 2, 1);
+    dumpChars(2, 0, 1, 1);
+    dumpChars(3, 0, 1, 1);
+    dumpChars(78, 1, 2, 1);
+    dumpChars(0, 2, 2, 1);
+
+    system("pause");
+    system("cls");
+
+    const wchar_t text3[] = {
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 1
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 2
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 3
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 4
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 5
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 6
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 7
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 8
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 9
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 10
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 11
+        0x30FC, 0x30FC, 0x30FC, 0xFF2D, // 12
+        L'\r', '\n',
+        L'\r', '\n',
+        0
+    };
+    writeChars(text3);
+    system("pause");
+    {
+        const COORD bufSize = {80, 2};
+        const COORD bufCoord = {0, 0};
+        SMALL_RECT readRegion = {0, 0, 79, 1};
+        CHAR_INFO unicodeData[160];
+        BOOL ret = ReadConsoleOutputW(GetStdHandle(STD_OUTPUT_HANDLE), unicodeData,
+                                 bufSize, bufCoord, &readRegion);
+        assert(ret);
+        for (int i = 0; i < 96; ++i) {
+            printf("%04x ", unicodeData[i].Char.UnicodeChar);
+        }
+        printf("\n");
+    }
+
+    return 0;
+}

package/deps/winpty/misc/UnixEcho.cc

@@ -0,0 +1,89 @@
+/*
+ * Unix test code that puts the terminal into raw mode, then echos typed
+ * characters to stdout.  Derived from sample code in the Stevens book, posted
+ * online at http://www.lafn.org/~dave/linux/terminalIO.html.
+ */
+
+#include <termios.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "FormatChar.h"
+
+static struct termios   save_termios;
+static int              term_saved;
+
+/* RAW! mode */
+int tty_raw(int fd)
+{
+    struct termios  buf;
+
+    if (tcgetattr(fd, &save_termios) < 0) /* get the original state */
+        return -1;
+
+    buf = save_termios;
+
+    /* echo off, canonical mode off, extended input
+       processing off, signal chars off */
+    buf.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+
+    /* no SIGINT on BREAK, CR-to-NL off, input parity
+       check off, don't strip the 8th bit on input,
+       ouput flow control off */
+    buf.c_iflag &= ~(BRKINT | ICRNL | ISTRIP | IXON);
+
+    /* clear size bits, parity checking off */
+    buf.c_cflag &= ~(CSIZE | PARENB);
+
+    /* set 8 bits/char */
+    buf.c_cflag |= CS8;
+
+    /* output processing off */
+    buf.c_oflag &= ~(OPOST);
+
+    buf.c_cc[VMIN] = 1;  /* 1 byte at a time */
+    buf.c_cc[VTIME] = 0; /* no timer on input */
+
+    if (tcsetattr(fd, TCSAFLUSH, &buf) < 0)
+        return -1;
+
+    term_saved = 1;
+
+    return 0;
+}
+
+
+/* set it to normal! */
+int tty_reset(int fd)
+{
+    if (term_saved)
+        if (tcsetattr(fd, TCSAFLUSH, &save_termios) < 0)
+            return -1;
+
+    return 0;
+}
+
+
+int main()
+{
+    tty_raw(0);
+
+    int count = 0;
+    while (true) {
+        char ch;
+        char buf[16];
+        int actual = read(0, &ch, 1);
+        if (actual != 1) {
+            perror("read error");
+            break;
+        }
+        formatChar(buf, ch);
+        fputs(buf, stdout);
+        fflush(stdout);
+        if (ch == 3) // Ctrl-C
+            break;
+    }
+
+    tty_reset(0);
+    return 0;
+}

package/deps/winpty/misc/Utf16Echo.cc

@@ -0,0 +1,46 @@
+#include <windows.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <vector>
+#include <string>
+
+int main(int argc, char *argv[]) {
+    system("cls");
+
+    if (argc == 1) {
+        printf("Usage: %s hhhh\n", argv[0]);
+        return 0;
+    }
+
+    std::wstring dataToWrite;
+    for (int i = 1; i < argc; ++i) {
+        wchar_t ch = strtol(argv[i], NULL, 16);
+        dataToWrite.push_back(ch);
+    }
+
+    DWORD actual = 0;
+    BOOL ret = WriteConsoleW(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        dataToWrite.data(), dataToWrite.size(), &actual, NULL);
+    assert(ret && actual == dataToWrite.size());
+
+    // Read it back.
+    std::vector<CHAR_INFO> readBuffer(dataToWrite.size() * 2);
+    COORD bufSize = {static_cast<short>(readBuffer.size()), 1};
+    COORD bufCoord = {0, 0};
+    SMALL_RECT topLeft = {0, 0, static_cast<short>(readBuffer.size() - 1), 0};
+    ret = ReadConsoleOutputW(
+            GetStdHandle(STD_OUTPUT_HANDLE), readBuffer.data(),
+            bufSize, bufCoord, &topLeft);
+    assert(ret);
+
+    printf("\n");
+    for (int i = 0; i < readBuffer.size(); ++i) {
+        printf("CHAR: %04x %04x\n",
+            readBuffer[i].Char.UnicodeChar,
+            readBuffer[i].Attributes);
+    }
+    return 0;
+}