codexui-android 0.1.93 → 0.1.94

package/node_modules/node-pty/deps/winpty/src/agent/UnicodeEncoding.h

@@ -0,0 +1,157 @@
+// Copyright (c) 2015 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#ifndef UNICODE_ENCODING_H
+#define UNICODE_ENCODING_H
+
+#include <stdint.h>
+
+// Encode the Unicode codepoint with UTF-8.  The buffer must be at least 4
+// bytes in size.
+static inline int encodeUtf8(char *out, uint32_t code) {
+    if (code < 0x80) {
+        out[0] = code;
+        return 1;
+    } else if (code < 0x800) {
+        out[0] = ((code >> 6) & 0x1F) | 0xC0;
+        out[1] = ((code >> 0) & 0x3F) | 0x80;
+        return 2;
+    } else if (code < 0x10000) {
+        if (code >= 0xD800 && code <= 0xDFFF) {
+            // The code points 0xD800 to 0xDFFF are reserved for UTF-16
+            // surrogate pairs and do not have an encoding in UTF-8.
+            return 0;
+        }
+        out[0] = ((code >> 12) & 0x0F) | 0xE0;
+        out[1] = ((code >>  6) & 0x3F) | 0x80;
+        out[2] = ((code >>  0) & 0x3F) | 0x80;
+        return 3;
+    } else if (code < 0x110000) {
+        out[0] = ((code >> 18) & 0x07) | 0xF0;
+        out[1] = ((code >> 12) & 0x3F) | 0x80;
+        out[2] = ((code >>  6) & 0x3F) | 0x80;
+        out[3] = ((code >>  0) & 0x3F) | 0x80;
+        return 4;
+    } else {
+        // Encoding error
+        return 0;
+    }
+}
+
+// Encode the Unicode codepoint with UTF-16.  The buffer must be large enough
+// to hold the output -- either 1 or 2 elements.
+static inline int encodeUtf16(wchar_t *out, uint32_t code) {
+    if (code < 0x10000) {
+        if (code >= 0xD800 && code <= 0xDFFF) {
+            // The code points 0xD800 to 0xDFFF are reserved for UTF-16
+            // surrogate pairs and do not have an encoding in UTF-16.
+            return 0;
+        }
+        out[0] = code;
+        return 1;
+    } else if (code < 0x110000) {
+        code -= 0x10000;
+        out[0] = 0xD800 | (code >> 10);
+        out[1] = 0xDC00 | (code & 0x3FF);
+        return 2;
+    } else {
+        // Encoding error
+        return 0;
+    }
+}
+
+// Return the byte size of a UTF-8 character using the value of the first
+// byte.
+static inline int utf8CharLength(char firstByte) {
+    // This code would probably be faster if it used __builtin_clz.
+    if ((firstByte & 0x80) == 0) {
+        return 1;
+    } else if ((firstByte & 0xE0) == 0xC0) {
+        return 2;
+    } else if ((firstByte & 0xF0) == 0xE0) {
+        return 3;
+    } else if ((firstByte & 0xF8) == 0xF0) {
+        return 4;
+    } else {
+        // Malformed UTF-8.
+        return 0;
+    }
+}
+
+// The pointer must point to 1-4 bytes, as indicated by the first byte.
+// Returns -1 on decoding error.
+static inline uint32_t decodeUtf8(const char *in) {
+    const uint32_t kInvalid = static_cast<uint32_t>(-1);
+    switch (utf8CharLength(in[0])) {
+        case 1: {
+            return in[0];
+        }
+        case 2: {
+            if ((in[1] & 0xC0) != 0x80) {
+                return kInvalid;
+            }
+            uint32_t tmp = 0;
+            tmp = (in[0] & 0x1F) << 6;
+            tmp |= (in[1] & 0x3F);
+            return tmp <= 0x7F ? kInvalid : tmp;
+        }
+        case 3: {
+            if ((in[1] & 0xC0) != 0x80 ||
+                    (in[2] & 0xC0) != 0x80) {
+                return kInvalid;
+            }
+            uint32_t tmp = 0;
+            tmp = (in[0] & 0x0F) << 12;
+            tmp |= (in[1] & 0x3F) << 6;
+            tmp |= (in[2] & 0x3F);
+            if (tmp <= 0x07FF || (tmp >= 0xD800 && tmp <= 0xDFFF)) {
+                return kInvalid;
+            } else {
+                return tmp;
+            }
+        }
+        case 4: {
+            if ((in[1] & 0xC0) != 0x80 ||
+                    (in[2] & 0xC0) != 0x80 ||
+                    (in[3] & 0xC0) != 0x80) {
+                return kInvalid;
+            }
+            uint32_t tmp = 0;
+            tmp = (in[0] & 0x07) << 18;
+            tmp |= (in[1] & 0x3F) << 12;
+            tmp |= (in[2] & 0x3F) << 6;
+            tmp |= (in[3] & 0x3F);
+            if (tmp <= 0xFFFF || tmp > 0x10FFFF) {
+                return kInvalid;
+            } else {
+                return tmp;
+            }
+        }
+        default: {
+            return kInvalid;
+        }
+    }
+}
+
+static inline uint32_t decodeSurrogatePair(wchar_t ch1, wchar_t ch2) {
+    return ((ch1 - 0xD800) << 10) + (ch2 - 0xDC00) + 0x10000;
+}
+
+#endif // UNICODE_ENCODING_H

package/node_modules/node-pty/deps/winpty/src/agent/UnicodeEncodingTest.cc

@@ -0,0 +1,189 @@
+// Copyright (c) 2015 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+// Encode every code-point using this module and verify that it matches the
+// encoding generated using Windows WideCharToMultiByte.
+
+#include "UnicodeEncoding.h"
+
+#include <windows.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+static void correctnessByCode()
+{
+    char mbstr1[4];
+    char mbstr2[4];
+    wchar_t wch[2];
+    for (unsigned int code = 0; code < 0x110000; ++code) {
+
+        // Surrogate pair reserved region.
+        const bool isReserved = (code >= 0xD800 && code <= 0xDFFF);
+
+        int mblen1 = encodeUtf8(mbstr1, code);
+        if (isReserved ? mblen1 != 0 : mblen1 <= 0) {
+            printf("Error: 0x%04X: mblen1=%d\n", code, mblen1);
+            continue;
+        }
+
+        int wlen = encodeUtf16(wch, code);
+        if (isReserved ? wlen != 0 : wlen <= 0) {
+            printf("Error: 0x%04X: wlen=%d\n", code, wlen);
+            continue;
+        }
+
+        if (isReserved) {
+            continue;
+        }
+
+        if (mblen1 != utf8CharLength(mbstr1[0])) {
+            printf("Error: 0x%04X: mblen1=%d, utf8CharLength(mbstr1[0])=%d\n",
+                code, mblen1, utf8CharLength(mbstr1[0]));
+            continue;
+        }
+
+        if (code != decodeUtf8(mbstr1)) {
+            printf("Error: 0x%04X: decodeUtf8(mbstr1)=%u\n",
+                code, decodeUtf8(mbstr1));
+            continue;
+        }
+
+        int mblen2 = WideCharToMultiByte(CP_UTF8, 0, wch, wlen, mbstr2, 4, NULL, NULL);
+        if (mblen1 != mblen2) {
+            printf("Error: 0x%04X: mblen1=%d, mblen2=%d\n", code, mblen1, mblen2);
+            continue;
+        }
+
+        if (memcmp(mbstr1, mbstr2, mblen1) != 0) {
+            printf("Error: 0x%04x: encodings are different\n", code);
+            continue;
+        }
+    }
+}
+
+static const char *encodingStr(char (&output)[128], char (&buf)[4])
+{
+    sprintf(output, "Encoding %02X %02X %02X %02X",
+        static_cast<uint8_t>(buf[0]),
+        static_cast<uint8_t>(buf[1]),
+        static_cast<uint8_t>(buf[2]),
+        static_cast<uint8_t>(buf[3]));
+    return output;
+}
+
+// This test can take a couple of minutes to run.
+static void correctnessByUtf8Encoding()
+{
+    for (uint64_t encoding = 0; encoding <= 0xFFFFFFFF; ++encoding) {
+
+        char mb[4];
+        mb[0] = encoding;
+        mb[1] = encoding >> 8;
+        mb[2] = encoding >> 16;
+        mb[3] = encoding >> 24;
+
+        const int mblen = utf8CharLength(mb[0]);
+        if (mblen == 0) {
+            continue;
+        }
+
+        // Test this module.
+        const uint32_t code1 = decodeUtf8(mb);
+        wchar_t ws1[2] = {};
+        const int wslen1 = encodeUtf16(ws1, code1);
+
+        // Test using Windows.  We can't decode a codepoint directly; we have
+        // to do UTF8->UTF16, then decode the surrogate pair.
+        wchar_t ws2[2] = {};
+        const int wslen2 = MultiByteToWideChar(
+            CP_UTF8, MB_ERR_INVALID_CHARS, mb, mblen, ws2, 2);
+        const uint32_t code2 =
+            (wslen2 == 1 ? ws2[0] :
+             wslen2 == 2 ? decodeSurrogatePair(ws2[0], ws2[1]) :
+             static_cast<uint32_t>(-1));
+
+        // Verify that the two implementations match.
+        char prefix[128];
+        if (code1 != code2) {
+            printf("%s: code1=0x%04x code2=0x%04x\n",
+                encodingStr(prefix, mb),
+                code1, code2);
+            continue;
+        }
+        if (wslen1 != wslen2) {
+            printf("%s: wslen1=%d wslen2=%d\n",
+                encodingStr(prefix, mb),
+                wslen1, wslen2);
+            continue;
+        }
+        if (memcmp(ws1, ws2, wslen1 * sizeof(wchar_t)) != 0) {
+            printf("%s: ws1 != ws2\n", encodingStr(prefix, mb));
+            continue;
+        }
+    }
+}
+
+wchar_t g_wch_TEST[] = { 0xD840, 0xDC00 };
+char g_ch_TEST[4];
+wchar_t *volatile g_pwch = g_wch_TEST;
+char *volatile g_pch = g_ch_TEST;
+unsigned int volatile g_code = 0xA2000;
+
+static void performance()
+{
+    {
+        clock_t start = clock();
+        for (long long i = 0; i < 250000000LL; ++i) {
+            int mblen = WideCharToMultiByte(CP_UTF8, 0, g_pwch, 2, g_pch, 4, NULL, NULL);
+            assert(mblen == 4);
+        }
+        clock_t stop = clock();
+        printf("%.3fns per char\n", (double)(stop - start) / CLOCKS_PER_SEC * 4.0);
+    }
+
+    {
+        clock_t start = clock();
+        for (long long i = 0; i < 3000000000LL; ++i) {
+            int mblen = encodeUtf8(g_pch, g_code);
+            assert(mblen == 4);
+        }
+        clock_t stop = clock();
+        printf("%.3fns per char\n", (double)(stop - start) / CLOCKS_PER_SEC / 3.0);
+    }
+}
+
+int main()
+{
+    printf("Testing correctnessByCode...\n");
+    fflush(stdout);
+    correctnessByCode();
+
+    printf("Testing correctnessByUtf8Encoding... (may take a couple minutes)\n");
+    fflush(stdout);
+    correctnessByUtf8Encoding();
+
+    printf("Testing performance...\n");
+    fflush(stdout);
+    performance();
+
+    return 0;
+}

package/node_modules/node-pty/deps/winpty/src/agent/Win32Console.cc

@@ -0,0 +1,107 @@
+// Copyright (c) 2011-2016 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include "Win32Console.h"
+
+#include <windows.h>
+#include <wchar.h>
+
+#include <string>
+
+#include "../shared/DebugClient.h"
+#include "../shared/WinptyAssert.h"
+
+Win32Console::Win32Console() : m_titleWorkBuf(16)
+{
+    // The console window must be non-NULL.  It is used for two purposes:
+    //  (1) "Freezing" the console to detect the exact number of lines that
+    //      have scrolled.
+    //  (2) Killing processes attached to the console, by posting a WM_CLOSE
+    //      message to the console window.
+    m_hwnd = GetConsoleWindow();
+    ASSERT(m_hwnd != nullptr);
+}
+
+std::wstring Win32Console::title()
+{
+    while (true) {
+        // Calling GetConsoleTitleW is tricky, because its behavior changed
+        // from XP->Vista, then again from Win7->Win8.  The Vista+Win7 behavior
+        // is especially broken.
+        //
+        // The MSDN documentation documents nSize as the "size of the buffer
+        // pointed to by the lpConsoleTitle parameter, in characters" and the
+        // successful return value as "the length of the console window's
+        // title, in characters."
+        //
+        // On XP, the function returns the title length, AFTER truncation
+        // (excluding the NUL terminator).  If the title is blank, the API
+        // returns 0 and does not NUL-terminate the buffer.  To accommodate
+        // XP, the function must:
+        //  * Terminate the buffer itself.
+        //  * Double the size of the title buffer in a loop.
+        //
+        // On Vista and up, the function returns the non-truncated title
+        // length (excluding the NUL terminator).
+        //
+        // On Vista and Windows 7, there is a bug where the buffer size is
+        // interpreted as a byte count rather than a wchar_t count.  To
+        // work around this, we must pass GetConsoleTitleW a buffer that is
+        // twice as large as what is actually needed.
+        //
+        // See misc/*/Test_GetConsoleTitleW.cc for tests demonstrating Windows'
+        // behavior.
+
+        DWORD count = GetConsoleTitleW(m_titleWorkBuf.data(),
+                                       m_titleWorkBuf.size());
+        const size_t needed = (count + 1) * sizeof(wchar_t);
+        if (m_titleWorkBuf.size() < needed) {
+            m_titleWorkBuf.resize(needed);
+            continue;
+        }
+        m_titleWorkBuf[count] = L'\0';
+        return m_titleWorkBuf.data();
+    }
+}
+
+void Win32Console::setTitle(const std::wstring &title)
+{
+    if (!SetConsoleTitleW(title.c_str())) {
+        trace("SetConsoleTitleW failed");
+    }
+}
+
+void Win32Console::setFrozen(bool frozen) {
+    const int SC_CONSOLE_MARK = 0xFFF2;
+    const int SC_CONSOLE_SELECT_ALL = 0xFFF5;
+    if (frozen == m_frozen) {
+        // Do nothing.
+    } else if (frozen) {
+        // Enter selection mode by activating either Mark or SelectAll.
+        const int command = m_freezeUsesMark ? SC_CONSOLE_MARK
+                                             : SC_CONSOLE_SELECT_ALL;
+        SendMessage(m_hwnd, WM_SYSCOMMAND, command, 0);
+        m_frozen = true;
+    } else {
+        // Send Escape to cancel the selection.
+        SendMessage(m_hwnd, WM_CHAR, 27, 0x00010001);
+        m_frozen = false;
+    }
+}

package/node_modules/node-pty/deps/winpty/src/agent/Win32Console.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2011-2016 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#ifndef AGENT_WIN32_CONSOLE_H
+#define AGENT_WIN32_CONSOLE_H
+
+#include <windows.h>
+
+#include <string>
+#include <vector>
+
+class Win32Console
+{
+public:
+    class FreezeGuard {
+    public:
+        FreezeGuard(Win32Console &console, bool frozen) :
+                m_console(console), m_previous(console.frozen()) {
+            m_console.setFrozen(frozen);
+        }
+        ~FreezeGuard() {
+            m_console.setFrozen(m_previous);
+        }
+        FreezeGuard(const FreezeGuard &other) = delete;
+        FreezeGuard &operator=(const FreezeGuard &other) = delete;
+    private:
+        Win32Console &m_console;
+        bool m_previous;
+    };
+
+    Win32Console();
+
+    HWND hwnd() { return m_hwnd; }
+    std::wstring title();
+    void setTitle(const std::wstring &title);
+    void setFreezeUsesMark(bool useMark) { m_freezeUsesMark = useMark; }
+    void setNewW10(bool isNewW10) { m_isNewW10 = isNewW10; }
+    bool isNewW10() { return m_isNewW10; }
+    void setFrozen(bool frozen=true);
+    bool frozen() { return m_frozen; }
+
+private:
+    HWND m_hwnd = nullptr;
+    bool m_frozen = false;
+    bool m_freezeUsesMark = false;
+    bool m_isNewW10 = false;
+    std::vector<wchar_t> m_titleWorkBuf;
+};
+
+#endif // AGENT_WIN32_CONSOLE_H