codexui-android 0.1.93 → 0.1.95

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

@@ -0,0 +1,246 @@
+// Copyright (c) 2011-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.
+
+#include "InputMap.h"
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "DebugShowInput.h"
+#include "SimplePool.h"
+#include "../shared/DebugClient.h"
+#include "../shared/UnixCtrlChars.h"
+#include "../shared/WinptyAssert.h"
+#include "../shared/winpty_snprintf.h"
+
+namespace {
+
+static const char *getVirtualKeyString(int virtualKey)
+{
+    switch (virtualKey) {
+#define WINPTY_GVKS_KEY(x) case VK_##x: return #x;
+        WINPTY_GVKS_KEY(RBUTTON)    WINPTY_GVKS_KEY(F9)
+        WINPTY_GVKS_KEY(CANCEL)     WINPTY_GVKS_KEY(F10)
+        WINPTY_GVKS_KEY(MBUTTON)    WINPTY_GVKS_KEY(F11)
+        WINPTY_GVKS_KEY(XBUTTON1)   WINPTY_GVKS_KEY(F12)
+        WINPTY_GVKS_KEY(XBUTTON2)   WINPTY_GVKS_KEY(F13)
+        WINPTY_GVKS_KEY(BACK)       WINPTY_GVKS_KEY(F14)
+        WINPTY_GVKS_KEY(TAB)        WINPTY_GVKS_KEY(F15)
+        WINPTY_GVKS_KEY(CLEAR)      WINPTY_GVKS_KEY(F16)
+        WINPTY_GVKS_KEY(RETURN)     WINPTY_GVKS_KEY(F17)
+        WINPTY_GVKS_KEY(SHIFT)      WINPTY_GVKS_KEY(F18)
+        WINPTY_GVKS_KEY(CONTROL)    WINPTY_GVKS_KEY(F19)
+        WINPTY_GVKS_KEY(MENU)       WINPTY_GVKS_KEY(F20)
+        WINPTY_GVKS_KEY(PAUSE)      WINPTY_GVKS_KEY(F21)
+        WINPTY_GVKS_KEY(CAPITAL)    WINPTY_GVKS_KEY(F22)
+        WINPTY_GVKS_KEY(HANGUL)     WINPTY_GVKS_KEY(F23)
+        WINPTY_GVKS_KEY(JUNJA)      WINPTY_GVKS_KEY(F24)
+        WINPTY_GVKS_KEY(FINAL)      WINPTY_GVKS_KEY(NUMLOCK)
+        WINPTY_GVKS_KEY(KANJI)      WINPTY_GVKS_KEY(SCROLL)
+        WINPTY_GVKS_KEY(ESCAPE)     WINPTY_GVKS_KEY(LSHIFT)
+        WINPTY_GVKS_KEY(CONVERT)    WINPTY_GVKS_KEY(RSHIFT)
+        WINPTY_GVKS_KEY(NONCONVERT) WINPTY_GVKS_KEY(LCONTROL)
+        WINPTY_GVKS_KEY(ACCEPT)     WINPTY_GVKS_KEY(RCONTROL)
+        WINPTY_GVKS_KEY(MODECHANGE) WINPTY_GVKS_KEY(LMENU)
+        WINPTY_GVKS_KEY(SPACE)      WINPTY_GVKS_KEY(RMENU)
+        WINPTY_GVKS_KEY(PRIOR)      WINPTY_GVKS_KEY(BROWSER_BACK)
+        WINPTY_GVKS_KEY(NEXT)       WINPTY_GVKS_KEY(BROWSER_FORWARD)
+        WINPTY_GVKS_KEY(END)        WINPTY_GVKS_KEY(BROWSER_REFRESH)
+        WINPTY_GVKS_KEY(HOME)       WINPTY_GVKS_KEY(BROWSER_STOP)
+        WINPTY_GVKS_KEY(LEFT)       WINPTY_GVKS_KEY(BROWSER_SEARCH)
+        WINPTY_GVKS_KEY(UP)         WINPTY_GVKS_KEY(BROWSER_FAVORITES)
+        WINPTY_GVKS_KEY(RIGHT)      WINPTY_GVKS_KEY(BROWSER_HOME)
+        WINPTY_GVKS_KEY(DOWN)       WINPTY_GVKS_KEY(VOLUME_MUTE)
+        WINPTY_GVKS_KEY(SELECT)     WINPTY_GVKS_KEY(VOLUME_DOWN)
+        WINPTY_GVKS_KEY(PRINT)      WINPTY_GVKS_KEY(VOLUME_UP)
+        WINPTY_GVKS_KEY(EXECUTE)    WINPTY_GVKS_KEY(MEDIA_NEXT_TRACK)
+        WINPTY_GVKS_KEY(SNAPSHOT)   WINPTY_GVKS_KEY(MEDIA_PREV_TRACK)
+        WINPTY_GVKS_KEY(INSERT)     WINPTY_GVKS_KEY(MEDIA_STOP)
+        WINPTY_GVKS_KEY(DELETE)     WINPTY_GVKS_KEY(MEDIA_PLAY_PAUSE)
+        WINPTY_GVKS_KEY(HELP)       WINPTY_GVKS_KEY(LAUNCH_MAIL)
+        WINPTY_GVKS_KEY(LWIN)       WINPTY_GVKS_KEY(LAUNCH_MEDIA_SELECT)
+        WINPTY_GVKS_KEY(RWIN)       WINPTY_GVKS_KEY(LAUNCH_APP1)
+        WINPTY_GVKS_KEY(APPS)       WINPTY_GVKS_KEY(LAUNCH_APP2)
+        WINPTY_GVKS_KEY(SLEEP)      WINPTY_GVKS_KEY(OEM_1)
+        WINPTY_GVKS_KEY(NUMPAD0)    WINPTY_GVKS_KEY(OEM_PLUS)
+        WINPTY_GVKS_KEY(NUMPAD1)    WINPTY_GVKS_KEY(OEM_COMMA)
+        WINPTY_GVKS_KEY(NUMPAD2)    WINPTY_GVKS_KEY(OEM_MINUS)
+        WINPTY_GVKS_KEY(NUMPAD3)    WINPTY_GVKS_KEY(OEM_PERIOD)
+        WINPTY_GVKS_KEY(NUMPAD4)    WINPTY_GVKS_KEY(OEM_2)
+        WINPTY_GVKS_KEY(NUMPAD5)    WINPTY_GVKS_KEY(OEM_3)
+        WINPTY_GVKS_KEY(NUMPAD6)    WINPTY_GVKS_KEY(OEM_4)
+        WINPTY_GVKS_KEY(NUMPAD7)    WINPTY_GVKS_KEY(OEM_5)
+        WINPTY_GVKS_KEY(NUMPAD8)    WINPTY_GVKS_KEY(OEM_6)
+        WINPTY_GVKS_KEY(NUMPAD9)    WINPTY_GVKS_KEY(OEM_7)
+        WINPTY_GVKS_KEY(MULTIPLY)   WINPTY_GVKS_KEY(OEM_8)
+        WINPTY_GVKS_KEY(ADD)        WINPTY_GVKS_KEY(OEM_102)
+        WINPTY_GVKS_KEY(SEPARATOR)  WINPTY_GVKS_KEY(PROCESSKEY)
+        WINPTY_GVKS_KEY(SUBTRACT)   WINPTY_GVKS_KEY(PACKET)
+        WINPTY_GVKS_KEY(DECIMAL)    WINPTY_GVKS_KEY(ATTN)
+        WINPTY_GVKS_KEY(DIVIDE)     WINPTY_GVKS_KEY(CRSEL)
+        WINPTY_GVKS_KEY(F1)         WINPTY_GVKS_KEY(EXSEL)
+        WINPTY_GVKS_KEY(F2)         WINPTY_GVKS_KEY(EREOF)
+        WINPTY_GVKS_KEY(F3)         WINPTY_GVKS_KEY(PLAY)
+        WINPTY_GVKS_KEY(F4)         WINPTY_GVKS_KEY(ZOOM)
+        WINPTY_GVKS_KEY(F5)         WINPTY_GVKS_KEY(NONAME)
+        WINPTY_GVKS_KEY(F6)         WINPTY_GVKS_KEY(PA1)
+        WINPTY_GVKS_KEY(F7)         WINPTY_GVKS_KEY(OEM_CLEAR)
+        WINPTY_GVKS_KEY(F8)
+#undef WINPTY_GVKS_KEY
+        default:                        return NULL;
+    }
+}
+
+} // anonymous namespace
+
+std::string InputMap::Key::toString() const {
+    std::string ret;
+    ret += controlKeyStatePrefix(keyState);
+    char buf[256];
+    const char *vkString = getVirtualKeyString(virtualKey);
+    if (vkString != NULL) {
+        ret += vkString;
+    } else if ((virtualKey >= 'A' && virtualKey <= 'Z') ||
+               (virtualKey >= '0' && virtualKey <= '9')) {
+        ret += static_cast<char>(virtualKey);
+    } else {
+        winpty_snprintf(buf, "%#x", virtualKey);
+        ret += buf;
+    }
+    if (unicodeChar >= 32 && unicodeChar <= 126) {
+        winpty_snprintf(buf, " ch='%c'",
+                        static_cast<char>(unicodeChar));
+    } else {
+        winpty_snprintf(buf, " ch=%#x",
+                        static_cast<unsigned int>(unicodeChar));
+    }
+    ret += buf;
+    return ret;
+}
+
+void InputMap::set(const char *encoding, int encodingLen, const Key &key) {
+    ASSERT(encodingLen > 0);
+    setHelper(m_root, encoding, encodingLen, key);
+}
+
+void InputMap::setHelper(Node &node, const char *encoding, int encodingLen, const Key &key) {
+    if (encodingLen == 0) {
+        node.key = key;
+    } else {
+        setHelper(getOrCreateChild(node, encoding[0]), encoding + 1, encodingLen - 1, key);
+    }
+}
+
+InputMap::Node &InputMap::getOrCreateChild(Node &node, unsigned char ch) {
+    Node *ret = getChild(node, ch);
+    if (ret != NULL) {
+        return *ret;
+    }
+    if (node.childCount < Node::kTinyCount) {
+        // Maintain sorted order for the sake of the InputMap dumping.
+        int insertIndex = node.childCount;
+        for (int i = 0; i < node.childCount; ++i) {
+            if (ch < node.u.tiny.values[i]) {
+                insertIndex = i;
+                break;
+            }
+        }
+        for (int j = node.childCount; j > insertIndex; --j) {
+            node.u.tiny.values[j] = node.u.tiny.values[j - 1];
+            node.u.tiny.children[j] = node.u.tiny.children[j - 1];
+        }
+        node.u.tiny.values[insertIndex] = ch;
+        node.u.tiny.children[insertIndex] = ret = m_nodePool.alloc();
+        ++node.childCount;
+        return *ret;
+    }
+    if (node.childCount == Node::kTinyCount) {
+        Branch *branch = m_branchPool.alloc();
+        for (int i = 0; i < node.childCount; ++i) {
+            branch->children[node.u.tiny.values[i]] = node.u.tiny.children[i];
+        }
+        node.u.branch = branch;
+    }
+    node.u.branch->children[ch] = ret = m_nodePool.alloc();
+    ++node.childCount;
+    return *ret;
+}
+
+// Find the longest matching key and node.
+int InputMap::lookupKey(const char *input, int inputSize,
+                        Key &keyOut, bool &incompleteOut) const {
+    keyOut = kKeyZero;
+    incompleteOut = false;
+
+    const Node *node = &m_root;
+    InputMap::Key longestMatch = kKeyZero;
+    int longestMatchLen = 0;
+
+    for (int i = 0; i < inputSize; ++i) {
+        unsigned char ch = input[i];
+        node = getChild(*node, ch);
+        if (node == NULL) {
+            keyOut = longestMatch;
+            return longestMatchLen;
+        } else if (node->hasKey()) {
+            longestMatchLen = i + 1;
+            longestMatch = node->key;
+        }
+    }
+    keyOut = longestMatch;
+    incompleteOut = node->childCount > 0;
+    return longestMatchLen;
+}
+
+void InputMap::dumpInputMap() const {
+    std::string encoding;
+    dumpInputMapHelper(m_root, encoding);
+}
+
+void InputMap::dumpInputMapHelper(
+        const Node &node, std::string &encoding) const {
+    if (node.hasKey()) {
+        trace("%s -> %s",
+            encoding.c_str(),
+            node.key.toString().c_str());
+    }
+    for (int i = 0; i < 256; ++i) {
+        const Node *child = getChild(node, i);
+        if (child != NULL) {
+            size_t oldSize = encoding.size();
+            if (!encoding.empty()) {
+                encoding.push_back(' ');
+            }
+            char ctrlChar = decodeUnixCtrlChar(i);
+            if (ctrlChar != '\0') {
+                encoding.push_back('^');
+                encoding.push_back(static_cast<char>(ctrlChar));
+            } else if (i == ' ') {
+                encoding.append("' '");
+            } else {
+                encoding.push_back(static_cast<char>(i));
+            }
+            dumpInputMapHelper(*child, encoding);
+            encoding.resize(oldSize);
+        }
+    }
+}

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

@@ -0,0 +1,114 @@
+// Copyright (c) 2011-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 INPUT_MAP_H
+#define INPUT_MAP_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <string>
+
+#include "SimplePool.h"
+#include "../shared/WinptyAssert.h"
+
+class InputMap {
+public:
+    struct Key {
+        uint16_t virtualKey;
+        uint32_t unicodeChar;
+        uint16_t keyState;
+
+        std::string toString() const;
+    };
+
+private:
+    struct Node;
+
+    struct Branch {
+        Branch() {
+            memset(&children, 0, sizeof(children));
+        }
+
+        Node *children[256];
+    };
+
+    struct Node {
+        Node() : childCount(0) {
+            Key zeroKey = { 0, 0, 0 };
+            key = zeroKey;
+        }
+
+        Key key;
+        int childCount;
+        enum { kTinyCount = 8 };
+        union {
+            Branch *branch;
+            struct {
+                unsigned char values[kTinyCount];
+                Node *children[kTinyCount];
+            } tiny;
+        } u;
+
+        bool hasKey() const {
+            return key.virtualKey != 0 || key.unicodeChar != 0;
+        }
+    };
+
+private:
+    SimplePool<Node, 256> m_nodePool;
+    SimplePool<Branch, 8> m_branchPool;
+    Node m_root;
+
+public:
+    void set(const char *encoding, int encodingLen, const Key &key);
+    int lookupKey(const char *input, int inputSize,
+                  Key &keyOut, bool &incompleteOut) const;
+    void dumpInputMap() const;
+
+private:
+    Node *getChild(Node &node, unsigned char ch) {
+        return const_cast<Node*>(getChild(static_cast<const Node&>(node), ch));
+    }
+
+    const Node *getChild(const Node &node, unsigned char ch) const {
+        if (node.childCount <= Node::kTinyCount) {
+            for (int i = 0; i < node.childCount; ++i) {
+                if (node.u.tiny.values[i] == ch) {
+                    return node.u.tiny.children[i];
+                }
+            }
+            return NULL;
+        } else {
+            return node.u.branch->children[ch];
+        }
+    }
+
+    void setHelper(Node &node, const char *encoding, int encodingLen, const Key &key);
+    Node &getOrCreateChild(Node &node, unsigned char ch);
+    void dumpInputMapHelper(const Node &node, std::string &encoding) const;
+};
+
+const InputMap::Key kKeyZero = { 0, 0, 0 };
+
+void dumpInputMap(InputMap &inputMap);
+
+#endif // INPUT_MAP_H

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

@@ -0,0 +1,71 @@
+// 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.
+
+#include "LargeConsoleRead.h"
+
+#include <stdlib.h>
+
+#include "../shared/WindowsVersion.h"
+#include "Scraper.h"
+#include "Win32ConsoleBuffer.h"
+
+LargeConsoleReadBuffer::LargeConsoleReadBuffer() :
+    m_rect(0, 0, 0, 0), m_rectWidth(0)
+{
+}
+
+void largeConsoleRead(LargeConsoleReadBuffer &out,
+                      Win32ConsoleBuffer &buffer,
+                      const SmallRect &readArea,
+                      WORD attributesMask) {
+    ASSERT(readArea.Left >= 0 &&
+           readArea.Top >= 0 &&
+           readArea.Right >= readArea.Left &&
+           readArea.Bottom >= readArea.Top &&
+           readArea.width() <= MAX_CONSOLE_WIDTH);
+    const size_t count = readArea.width() * readArea.height();
+    if (out.m_data.size() < count) {
+        out.m_data.resize(count);
+    }
+    out.m_rect = readArea;
+    out.m_rectWidth = readArea.width();
+
+    static const bool useLargeReads = isAtLeastWindows8();
+    if (useLargeReads) {
+        buffer.read(readArea, out.m_data.data());
+    } else {
+        const int maxReadLines = std::max(1, MAX_CONSOLE_WIDTH / readArea.width());
+        int curLine = readArea.Top;
+        while (curLine <= readArea.Bottom) {
+            const SmallRect subReadArea(
+                readArea.Left,
+                curLine,
+                readArea.width(),
+                std::min(maxReadLines, readArea.Bottom + 1 - curLine));
+            buffer.read(subReadArea, out.lineDataMut(curLine));
+            curLine = subReadArea.Bottom + 1;
+        }
+    }
+    if (attributesMask != static_cast<WORD>(~0)) {
+        for (size_t i = 0; i < count; ++i) {
+            out.m_data[i].Attributes &= attributesMask;
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+// 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 LARGE_CONSOLE_READ_H
+#define LARGE_CONSOLE_READ_H
+
+#include <windows.h>
+#include <stdlib.h>
+
+#include <vector>
+
+#include "SmallRect.h"
+#include "../shared/DebugClient.h"
+#include "../shared/WinptyAssert.h"
+
+class Win32ConsoleBuffer;
+
+class LargeConsoleReadBuffer {
+public:
+    LargeConsoleReadBuffer();
+    const SmallRect &rect() const { return m_rect; }
+    const CHAR_INFO *lineData(int line) const {
+        validateLineNumber(line);
+        return &m_data[(line - m_rect.Top) * m_rectWidth];
+    }
+
+private:
+    CHAR_INFO *lineDataMut(int line) {
+        validateLineNumber(line);
+        return &m_data[(line - m_rect.Top) * m_rectWidth];
+    }
+
+    void validateLineNumber(int line) const {
+        if (line < m_rect.Top || line > m_rect.Bottom) {
+            trace("Fatal error: LargeConsoleReadBuffer: invalid line %d for "
+                  "read rect %s", line, m_rect.toString().c_str());
+            abort();
+        }
+    }
+
+    SmallRect m_rect;
+    int m_rectWidth;
+    std::vector<CHAR_INFO> m_data;
+
+    friend void largeConsoleRead(LargeConsoleReadBuffer &out,
+                                 Win32ConsoleBuffer &buffer,
+                                 const SmallRect &readArea,
+                                 WORD attributesMask);
+};
+
+#endif // LARGE_CONSOLE_READ_H