RoApp/Assets/Lua/LuaDebug.lua

local debugger_reLoadFile =nil
xpcall(function() 
    debugger_reLoadFile = require("luaideReLoadFile")
end,function() 
    debugger_reLoadFile = function() print("未实现代码重载") end
end)
local debugger_stackInfo = nil
local coro_debugger = nil
local debugger_require = require
local debugger_exeLuaString = nil
local checkSetVar = nil
local loadstring_ = nil
local debugger_sendMsg = nil
if (loadstring) then
    loadstring_ = loadstring
else
    loadstring_ = load
end
--只针对 luadebug 调试 jit版本不存在这个问题
local setfenv = setfenv
if (not setfenv) then
    setfenv =
        function(fn, env)
        local i = 1
        while true do
            local name = debug.getupvalue(fn, i)
            if name == "_ENV" then
                debug.upvaluejoin(
                    fn,
                    i,
                    (function()
                        return env
                    end),
                    1
                )
                break
            elseif not name then
                break
            end

            i = i + 1
        end
        return fn
    end
end
local ZZBase64 = {}
local LuaDebugTool_ = nil
if (LuaDebugTool) then
    LuaDebugTool_ = LuaDebugTool
elseif (CS and CS.LuaDebugTool) then
    LuaDebugTool_ = CS.LuaDebugTool
end
local LuaDebugTool = LuaDebugTool_
local loadstring = loadstring_
local getinfo = debug.getinfo
local function createSocket()
    local base = _G
    local string = require("string")
    local math = require("math")
    local socket = require("socket.core")

    local _M = socket

    -----------------------------------------------------------------------------
    -- Exported auxiliar functions
    -----------------------------------------------------------------------------
    function _M.connect4(address, port, laddress, lport)
        return socket.connect(address, port, laddress, lport, "inet")
    end

    function _M.connect6(address, port, laddress, lport)
        return socket.connect(address, port, laddress, lport, "inet6")
    end

    if (not _M.connect) then
        function _M.connect(address, port, laddress, lport)
            local sock, err = socket.tcp()
            if not sock then
                return nil, err
            end
            if laddress then
                local res, err = sock:bind(laddress, lport, -1)
                if not res then
                    return nil, err
                end
            end
            local res, err = sock:connect(address, port)
            if not res then
                return nil, err
            end
            return sock
        end
    end
    function _M.bind(host, port, backlog)
        if host == "*" then
            host = "0.0.0.0"
        end
        local addrinfo, err = socket.dns.getaddrinfo(host)
        if not addrinfo then
            return nil, err
        end
        local sock, res
        err = "no info on address"
        for i, alt in base.ipairs(addrinfo) do
            if alt.family == "inet" then
                sock, err = socket.tcp4()
            else
                sock, err = socket.tcp6()
            end
            if not sock then
                return nil, err
            end
            sock:setoption("reuseaddr", true)
            res, err = sock:bind(alt.addr, port)
            if not res then
                sock:close()
            else
                res, err = sock:listen(backlog)
                if not res then
                    sock:close()
                else
                    return sock
                end
            end
        end
        return nil, err
    end

    _M.try = _M.newtry()

    function _M.choose(table)
        return function(name, opt1, opt2)
            if base.type(name) ~= "string" then
                name, opt1, opt2 = "default", name, opt1
            end
            local f = table[name or "nil"]
            if not f then
                base.error("unknown key (" .. base.tostring(name) .. ")", 3)
            else
                return f(opt1, opt2)
            end
        end
    end

    -----------------------------------------------------------------------------
    -- Socket sources and sinks, conforming to LTN12
    -----------------------------------------------------------------------------
    -- create namespaces inside LuaSocket namespace
    local sourcet, sinkt = {}, {}
    _M.sourcet = sourcet
    _M.sinkt = sinkt

    _M.BLOCKSIZE = 2048

    sinkt["close-when-done"] =
        function(sock)
        return base.setmetatable(
            {
                getfd = function()
                    return sock:getfd()
                end,
                dirty = function()
                    return sock:dirty()
                end
            },
            {
                __call = function(self, chunk, err)
                    if not chunk then
                        sock:close()
                        return 1
                    else
                        return sock:send(chunk)
                    end
                end
            }
        )
    end

    sinkt["keep-open"] =
        function(sock)
        return base.setmetatable(
            {
                getfd = function()
                    return sock:getfd()
                end,
                dirty = function()
                    return sock:dirty()
                end
            },
            {
                __call = function(self, chunk, err)
                    if chunk then
                        return sock:send(chunk)
                    else
                        return 1
                    end
                end
            }
        )
    end

    sinkt["default"] = sinkt["keep-open"]

    _M.sink = _M.choose(sinkt)

    sourcet["by-length"] =
        function(sock, length)
        return base.setmetatable(
            {
                getfd = function()
                    return sock:getfd()
                end,
                dirty = function()
                    return sock:dirty()
                end
            },
            {
                __call = function()
                    if length <= 0 then
                        return nil
                    end
                    local size = math.min(socket.BLOCKSIZE, length)
                    local chunk, err = sock:receive(size)
                    if err then
                        return nil, err
                    end
                    length = length - string.len(chunk)
                    return chunk
                end
            }
        )
    end

    sourcet["until-closed"] =
        function(sock)
        local done
        return base.setmetatable(
            {
                getfd = function()
                    return sock:getfd()
                end,
                dirty = function()
                    return sock:dirty()
                end
            },
            {
                __call = function()
                    if done then
                        return nil
                    end
                    local chunk, err, partial = sock:receive(socket.BLOCKSIZE)
                    if not err then
                        return chunk
                    elseif err == "closed" then
                        sock:close()
                        done = 1
                        return partial
                    else
                        return nil, err
                    end
                end
            }
        )
    end

    sourcet["default"] = sourcet["until-closed"]

    _M.source = _M.choose(sourcet)

    return _M
end

local function createJson()
    local math = require("math")
    local string = require("string")
    local table = require("table")
    local object = nil
    -----------------------------------------------------------------------------
    -- Module declaration
    -----------------------------------------------------------------------------
    local json = {} -- Public namespace
    local json_private = {} -- Private namespace

    -- Public constants
    json.EMPTY_ARRAY = {}
    json.EMPTY_OBJECT = {}
    -- Public functions

    -- Private functions
    local decode_scanArray
    local decode_scanComment
    local decode_scanConstant
    local decode_scanNumber
    local decode_scanObject
    local decode_scanString
    local decode_scanWhitespace
    local encodeString
    local isArray
    local isEncodable

    -----------------------------------------------------------------------------
    -- PUBLIC FUNCTIONS
    -----------------------------------------------------------------------------
    --- Encodes an arbitrary Lua object / variable.
    -- @param v The Lua object / variable to be JSON encoded.
    -- @return String containing the JSON encoding in internal Lua string format (i.e. not unicode)
    function json.encode(v)
        -- Handle nil values
        if v == nil then
            return "null"
        end

        local vtype = type(v)

        -- Handle strings
        if vtype == "string" then
            return '"' .. json_private.encodeString(v) .. '"' -- Need to handle encoding in string
        end

        -- Handle booleans
        if vtype == "number" or vtype == "boolean" then
            return tostring(v)
        end

        -- Handle tables
        if vtype == "table" then
            local rval = {}
            -- Consider arrays separately
            local bArray, maxCount = isArray(v)
            if bArray then
                for i = 1, maxCount do
                    table.insert(rval, json.encode(v[i]))
                end
            else -- An object, not an array
                for i, j in pairs(v) do
                    if isEncodable(i) and isEncodable(j) then
                        table.insert(rval, '"' .. json_private.encodeString(i) .. '":' .. json.encode(j))
                    end
                end
            end
            if bArray then
                return "[" .. table.concat(rval, ",") .. "]"
            else
                return "{" .. table.concat(rval, ",") .. "}"
            end
        end

        -- Handle null values
        if vtype == "function" and v == json.null then
            return "null"
        end

        assert(false, "encode attempt to encode unsupported type " .. vtype .. ":" .. tostring(v))
    end

    --- Decodes a JSON string and returns the decoded value as a Lua data structure / value.
    -- @param s The string to scan.
    -- @param [startPos] Optional starting position where the JSON string is located. Defaults to 1.
    -- @param Lua object, number The object that was scanned, as a Lua table / string / number / boolean or nil,
    -- and the position of the first character after
    -- the scanned JSON object.
    function json.decode(s, startPos)
        startPos = startPos and startPos or 1
        startPos = decode_scanWhitespace(s, startPos)
        assert(startPos <= string.len(s), "Unterminated JSON encoded object found at position in [" .. s .. "]")
        local curChar = string.sub(s, startPos, startPos)
        -- Object
        if curChar == "{" then
            return decode_scanObject(s, startPos)
        end
        -- Array
        if curChar == "[" then
            return decode_scanArray(s, startPos)
        end
        -- Number
        if string.find("+-0123456789.e", curChar, 1, true) then
            return decode_scanNumber(s, startPos)
        end
        -- String
        if curChar == '"' or curChar == [[']] then
            return decode_scanString(s, startPos)
        end
        if string.sub(s, startPos, startPos + 1) == "/*" then
            return json.decode(s, decode_scanComment(s, startPos))
        end
        -- Otherwise, it must be a constant
        return decode_scanConstant(s, startPos)
    end

    --- The null function allows one to specify a null value in an associative array (which is otherwise
    -- discarded if you set the value with 'nil' in Lua. Simply set t = { first=json.null }
    function json.null()
        return json.null -- so json.null() will also return null ;-)
    end
    -----------------------------------------------------------------------------
    -- Internal, PRIVATE functions.
    -- Following a Python-like convention, I have prefixed all these 'PRIVATE'
    -- functions with an underscore.
    -----------------------------------------------------------------------------
    --- Scans an array from JSON into a Lua object
    -- startPos begins at the start of the array.
    -- Returns the array and the next starting position
    -- @param s The string being scanned.
    -- @param startPos The starting position for the scan.
    -- @return table, int The scanned array as a table, and the position of the next character to scan.
    function decode_scanArray(s, startPos)
        local array = {} -- The return value
        local stringLen = string.len(s)
        assert(
            string.sub(s, startPos, startPos) == "[",
            "decode_scanArray called but array does not start at position " .. startPos .. " in string:\n" .. s
        )
        startPos = startPos + 1
        -- Infinite loop for array elements
        repeat
            startPos = decode_scanWhitespace(s, startPos)
            assert(startPos <= stringLen, "JSON String ended unexpectedly scanning array.")
            local curChar = string.sub(s, startPos, startPos)
            if (curChar == "]") then
                return array, startPos + 1
            end
            if (curChar == ",") then
                startPos = decode_scanWhitespace(s, startPos + 1)
            end
            assert(startPos <= stringLen, "JSON String ended unexpectedly scanning array.")
            object, startPos = json.decode(s, startPos)
            table.insert(array, object)
        until false
    end

    --- Scans a comment and discards the comment.
    -- Returns the position of the next character following the comment.
    -- @param string s The JSON string to scan.
    -- @param int startPos The starting position of the comment
    function decode_scanComment(s, startPos)
        assert(
            string.sub(s, startPos, startPos + 1) == "/*",
            "decode_scanComment called but comment does not start at position " .. startPos
        )
        local endPos = string.find(s, "*/", startPos + 2)
        assert(endPos ~= nil, "Unterminated comment in string at " .. startPos)
        return endPos + 2
    end

    --- Scans for given constants: true, false or null
    -- Returns the appropriate Lua type, and the position of the next character to read.
    -- @param s The string being scanned.
    -- @param startPos The position in the string at which to start scanning.
    -- @return object, int The object (true, false or nil) and the position at which the next character should be
    -- scanned.
    function decode_scanConstant(s, startPos)
        local consts = {["true"] = true, ["false"] = false, ["null"] = nil}
        local constNames = {"true", "false", "null"}

        for i, k in pairs(constNames) do
            if string.sub(s, startPos, startPos + string.len(k) - 1) == k then
                return consts[k], startPos + string.len(k)
            end
        end
        assert(nil, "Failed to scan constant from string " .. s .. " at starting position " .. startPos)
    end

    --- Scans a number from the JSON encoded string.
    -- (in fact, also is able to scan numeric +- eqns, which is not
    -- in the JSON spec.)
    -- Returns the number, and the position of the next character
    -- after the number.
    -- @param s The string being scanned.
    -- @param startPos The position at which to start scanning.
    -- @return number, int The extracted number and the position of the next character to scan.
    function decode_scanNumber(s, startPos)
        local endPos = startPos + 1
        local stringLen = string.len(s)
        local acceptableChars = "+-0123456789.e"
        while (string.find(acceptableChars, string.sub(s, endPos, endPos), 1, true) and endPos <= stringLen) do
            endPos = endPos + 1
        end
        local stringValue = "return " .. string.sub(s, startPos, endPos - 1)
        local stringEval = loadstring(stringValue)
        assert(
            stringEval,
            "Failed to scan number [ " .. stringValue .. "] in JSON string at position " .. startPos .. " : " .. endPos
        )
        return stringEval(), endPos
    end

    --- Scans a JSON object into a Lua object.
    -- startPos begins at the start of the object.
    -- Returns the object and the next starting position.
    -- @param s The string being scanned.
    -- @param startPos The starting position of the scan.
    -- @return table, int The scanned object as a table and the position of the next character to scan.
    function decode_scanObject(s, startPos)
        local object = {}
        local stringLen = string.len(s)
        local key, value
        assert(
            string.sub(s, startPos, startPos) == "{",
            "decode_scanObject called but object does not start at position " .. startPos .. " in string:\n" .. s
        )
        startPos = startPos + 1
        repeat
            startPos = decode_scanWhitespace(s, startPos)
            assert(startPos <= stringLen, "JSON string ended unexpectedly while scanning object.")
            local curChar = string.sub(s, startPos, startPos)
            if (curChar == "}") then
                return object, startPos + 1
            end
            if (curChar == ",") then
                startPos = decode_scanWhitespace(s, startPos + 1)
            end
            assert(startPos <= stringLen, "JSON string ended unexpectedly scanning object.")
            -- Scan the key
            key, startPos = json.decode(s, startPos)
            assert(startPos <= stringLen, "JSON string ended unexpectedly searching for value of key " .. key)
            startPos = decode_scanWhitespace(s, startPos)
            assert(startPos <= stringLen, "JSON string ended unexpectedly searching for value of key " .. key)
            assert(
                string.sub(s, startPos, startPos) == ":",
                "JSON object key-value assignment mal-formed at " .. startPos
            )
            startPos = decode_scanWhitespace(s, startPos + 1)
            assert(startPos <= stringLen, "JSON string ended unexpectedly searching for value of key " .. key)
            value, startPos = json.decode(s, startPos)
            object[key] = value
        until false -- infinite loop while key-value pairs are found
    end

    -- START SoniEx2
    -- Initialize some things used by decode_scanString
    -- You know, for efficiency
    local escapeSequences = {
        ["\\t"] = "\t",
        ["\\f"] = "\f",
        ["\\r"] = "\r",
        ["\\n"] = "\n",
        ["\\b"] = ""
    }
    setmetatable(
        escapeSequences,
        {
            __index = function(t, k)
                -- skip "\" aka strip escape
                return string.sub(k, 2)
            end
        }
    )
    -- END SoniEx2
    --- Scans a JSON string from the opening inverted comma or single quote to the
    -- end of the string.
    -- Returns the string extracted as a Lua string,
    -- and the position of the next non-string character
    -- (after the closing inverted comma or single quote).
    -- @param s The string being scanned.
    -- @param startPos The starting position of the scan.
    -- @return string, int The extracted string as a Lua string, and the next character to parse.
    function decode_scanString(s, startPos)
        assert(startPos, "decode_scanString(..) called without start position")
        local startChar = string.sub(s, startPos, startPos)
        -- START SoniEx2
        -- PS: I don't think single quotes are valid JSON
        assert(startChar == '"' or startChar == [[']], "decode_scanString called for a non-string")
        --assert(startPos, "String decoding failed: missing closing " .. startChar .. " for string at position " .. oldStart)
        local t = {}
        local i, j = startPos, startPos
        while string.find(s, startChar, j + 1) ~= j + 1 do
            local oldj = j
            i, j = string.find(s, "\\.", j + 1)
            local x, y = string.find(s, startChar, oldj + 1)
            if not i or x < i then
                i, j = x, y - 1
            end
            table.insert(t, string.sub(s, oldj + 1, i - 1))
            if string.sub(s, i, j) == "\\u" then
                local a = string.sub(s, j + 1, j + 4)
                j = j + 4
                local n = tonumber(a, 16)
                assert(n, "String decoding failed: bad Unicode escape " .. a .. " at position " .. i .. " : " .. j)
                -- math.floor(x/2^y) == lazy right shift
                -- a % 2^b == bitwise_and(a, (2^b)-1)
                -- 64 = 2^6
                -- 4096 = 2^12 (or 2^6 * 2^6)
                local x
                if n < 128 then
                    x = string.char(n % 128)
                elseif n < 2048 then
                    -- [110x xxxx] [10xx xxxx]
                    x = string.char(192 + (math.floor(n / 64) % 32), 128 + (n % 64))
                else
                    -- [1110 xxxx] [10xx xxxx] [10xx xxxx]
                    x = string.char(224 + (math.floor(n / 4096) % 16), 128 + (math.floor(n / 64) % 64), 128 + (n % 64))
                end
                table.insert(t, x)
            else
                table.insert(t, escapeSequences[string.sub(s, i, j)])
            end
        end
        table.insert(t, string.sub(j, j + 1))
        assert(
            string.find(s, startChar, j + 1),
            "String decoding failed: missing closing " ..
                startChar .. " at position " .. j .. "(for string at position " .. startPos .. ")"
        )
        return table.concat(t, ""), j + 2
        -- END SoniEx2
    end

    --- Scans a JSON string skipping all whitespace from the current start position.
    -- Returns the position of the first non-whitespace character, or nil if the whole end of string is reached.
    -- @param s The string being scanned
    -- @param startPos The starting position where we should begin removing whitespace.
    -- @return int The first position where non-whitespace was encountered, or string.len(s)+1 if the end of string
    -- was reached.
    function decode_scanWhitespace(s, startPos)
        local whitespace = " \n\r\t"
        local stringLen = string.len(s)
        while (string.find(whitespace, string.sub(s, startPos, startPos), 1, true) and startPos <= stringLen) do
            startPos = startPos + 1
        end
        return startPos
    end

    --- Encodes a string to be JSON-compatible.
    -- This just involves back-quoting inverted commas, back-quotes and newlines, I think ;-)
    -- @param s The string to return as a JSON encoded (i.e. backquoted string)
    -- @return The string appropriately escaped.
    local escapeList = {
        ['"'] = '\\"',
        ["\\"] = "\\\\",
        ["/"] = "\\/",
        [""] = "\\b",
        ["\f"] = "\\f",
        ["\n"] = "\\n",
        ["\r"] = "\\r",
        ["\t"] = "\\t"
    }

    function json_private.encodeString(s)
        local s = tostring(s)
        return s:gsub(
            ".",
            function(c)
                return escapeList[c]
            end
        ) -- SoniEx2: 5.0 compat
    end

    -- Determines whether the given Lua type is an array or a table / dictionary.
    -- We consider any table an array if it has indexes 1..n for its n items, and no
    -- other data in the table.
    -- I think this method is currently a little 'flaky', but can't think of a good way around it yet...
    -- @param t The table to evaluate as an array
    -- @return boolean, number True if the table can be represented as an array, false otherwise. If true,
    -- the second returned value is the maximum
    -- number of indexed elements in the array.
    function isArray(t)
        -- Next we count all the elements, ensuring that any non-indexed elements are not-encodable
        -- (with the possible exception of 'n')
        if (t == json.EMPTY_ARRAY) then
            return true, 0
        end
        if (t == json.EMPTY_OBJECT) then
            return false
        end

        local maxIndex = 0
        for k, v in pairs(t) do
            if (type(k) == "number" and math.floor(k) == k and 1 <= k) then -- k,v is an indexed pair
                if (not isEncodable(v)) then
                    return false
                end -- All array elements must be encodable
                maxIndex = math.max(maxIndex, k)
            else
                if (k == "n") then
                    if v ~= (t.n or #t) then
                        return false
                    end -- False if n does not hold the number of elements
                else -- Else of (k=='n')
                    if isEncodable(v) then
                        return false
                    end
                end -- End of (k~='n')
            end -- End of k,v not an indexed pair
        end -- End of loop across all pairs
        return true, maxIndex
    end

    --- Determines whether the given Lua object / table / variable can be JSON encoded. The only
    -- types that are JSON encodable are: string, boolean, number, nil, table and json.null.
    -- In this implementation, all other types are ignored.
    -- @param o The object to examine.
    -- @return boolean True if the object should be JSON encoded, false if it should be ignored.
    function isEncodable(o)
        local t = type(o)
        return (t == "string" or t == "boolean" or t == "number" or t == "nil" or t == "table") or
            (t == "function" and o == json.null)
    end

    return json
end
local debugger_print = print
local debug_server = nil
local breakInfoSocket = nil
local json = createJson()
local LuaDebugger = {
    fileMaps = {},
    Run = true,  --表示正常运行只检测断点
    StepIn = false,
    StepInLevel = 0,
    StepNext = false,
    StepNextLevel = 0,
    StepOut = false,
    breakInfos = {},
    runTimeType = nil,
    isHook = true,
    pathCachePaths = {},
    isProntToConsole = 1,
    isFoxGloryProject = false,
    isDebugPrint = true,
    hookType = "lrc",
    currentFileName = "",
    currentTempFunc = nil,
    --分割字符串缓存
    splitFilePaths = {},
    DebugLuaFie = "",
    version = "0.9.3",
    serVarLevel = 4
}
local debug_hook = nil
local _resume = coroutine.resume
coroutine.resume = function(co, ...)
    if (LuaDebugger.isHook) then
        if coroutine.status(co) ~= "dead" then
            debug.sethook(co, debug_hook, "lrc")
        end
    end
    return _resume(co, ...)
end

LuaDebugger.event = {
    S2C_SetBreakPoints = 1,
    C2S_SetBreakPoints = 2,
    S2C_RUN = 3,
    C2S_HITBreakPoint = 4,
    S2C_ReqVar = 5,
    C2S_ReqVar = 6,
    --单步跳过请求
    S2C_NextRequest = 7,
    --单步跳过反馈
    C2S_NextResponse = 8,
    -- 单步跳过 结束 没有下一步
    C2S_NextResponseOver = 9,
    --单步跳入
    S2C_StepInRequest = 10,
    C2S_StepInResponse = 11,
    --单步跳出
    S2C_StepOutRequest = 12,
    --单步跳出返回
    C2S_StepOutResponse = 13,
    --打印
    C2S_LuaPrint = 14,
    S2C_LoadLuaScript = 16,
    C2S_SetSocketName = 17,
    C2S_LoadLuaScript = 18,
    C2S_DebugXpCall = 20,
    S2C_DebugClose = 21,
    S2C_SerVar = 24,
    C2S_SerVar = 25,
    S2C_ReLoadFile = 26,
    C2S_ReLoadFile = 27,
}
--@region print
function print(...)
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 3) then
        debugger_print(...)
    end
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 2) then
        if (debug_server) then
            local arg = {...} --这里的...和{}符号中间需要有空格号，否则会出错
            local str = ""
            if (#arg == 0) then
                arg = {"nil"}
            end
            for k, v in pairs(arg) do
                str = str .. tostring(v) .. "\t"
            end
            local sendMsg = {
                event = LuaDebugger.event.C2S_LuaPrint,
                data = {msg = ZZBase64.encode(str), type = 1}
            }
            local sendStr = json.encode(sendMsg)
            debug_server:send(sendStr .. "__debugger_k0204__")
        end
    end
end

function luaIdePrintWarn(...)
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 3) then
        debugger_print(...)
    end
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 2) then
        if (debug_server) then
            local arg = {...} --这里的...和{}符号中间需要有空格号，否则会出错
            local str = ""
            if (#arg == 0) then
                arg = {"nil"}
            end
            for k, v in pairs(arg) do
                str = str .. tostring(v) .. "\t"
            end
            local sendMsg = {
                event = LuaDebugger.event.C2S_LuaPrint,
                data = {msg = ZZBase64.encode(str), type = 2}
            }
            local sendStr = json.encode(sendMsg)
            debug_server:send(sendStr .. "__debugger_k0204__")
        end
    end
end
function luaIdePrintErr(...)
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 3) then
        debugger_print(...)
    end
    if (LuaDebugger.isProntToConsole == 1 or LuaDebugger.isProntToConsole == 2) then
        if (debug_server) then
            local arg = {...} --这里的...和{}符号中间需要有空格号，否则会出错
            local str = ""
            if (#arg == 0) then
                arg = {"nil"}
            end
            for k, v in pairs(arg) do
                str = str .. tostring(v) .. "\t"
            end
            local sendMsg = {
                event = LuaDebugger.event.C2S_LuaPrint,
                data = {msg = ZZBase64.encode(str), type = 3}
            }
            local sendStr = json.encode(sendMsg)
            debug_server:send(sendStr .. "__debugger_k0204__")
        end
    end
end
--@endregion

--@region 辅助方法
local function debugger_lastIndex(str, p)
    local startIndex = string.find(str, p, 1)
    while startIndex do
        local findstartIndex = string.find(str, p, startIndex + 1)
        if (not findstartIndex) then
            break
        else
            startIndex = findstartIndex
        end
    end
    return startIndex
end
local function debugger_convertParentDir(dir)
    local index, endindex = string.find(dir, "/%.%./")
    if (index) then
        local file1 = string.sub(dir, 1, index - 1)
        local startIndex = debugger_lastIndex(file1, "/")
        file1 = string.sub(file1, 1, startIndex - 1)
        local file2 = string.sub(dir, endindex)
        dir = file1 .. file2
        dir = debugger_convertParentDir(dir)
        return dir
    else
        return dir
    end
end

local function debugger_getFilePathInfo(file)
    local fileName = nil
    local dir = nil
    file = file:gsub("/.\\", "/")
    file = file:gsub("\\", "/")
    file = file:gsub("//", "/")
    

    if file:find("@") == 1 then
        file = file:sub(2)
    end
    local findex = file:find("%./")
    if (findex == 1) then
        file = file:sub(3)
    end

    file = debugger_convertParentDir(file)
    local fileLength = string.len(file)
    local suffixNames = {
        ".lua",
        ".txt.lua",
        ".txt",
        ".bytes"
    }
    table.sort(
        suffixNames,
        function(name1, name2)
            return string.len(name1) > string.len(name2)
        end
    )
    local suffixLengs = {}
    for i, suffixName in ipairs(suffixNames) do
        table.insert(suffixLengs, string.len(suffixName))
    end

    local fileLength = string.len(file)
    for i, suffix in ipairs(suffixNames) do
        local suffixName = string.sub(file, fileLength - suffixLengs[i] + 1)
        if (suffixName == suffix) then
            file = string.sub(file, 1, fileLength - suffixLengs[i])
            break
        end
    end
    local fileNameStartIndex = debugger_lastIndex(file, "/")
    if (fileNameStartIndex) then
        fileName = string.sub(file, fileNameStartIndex + 1)

        dir = string.sub(file, 1, fileNameStartIndex)
        file = dir .. fileName
    else
        fileNameStartIndex = debugger_lastIndex(file, "%.")
        if (not fileNameStartIndex) then
            fileName = file
            dir = ""
        else
            dir = string.sub(file, 1, fileNameStartIndex)
            dir = dir:gsub("%.", "/")
            fileName = string.sub(file, fileNameStartIndex + 1)
            file = dir .. fileName
        end
    end

    return file, dir, fileName
end

--@endregion



----=============================工具方法=============================================
--@region 工具方法


local function debugger_strSplit(input, delimiter)
    input = tostring(input)
    delimiter = tostring(delimiter)
    if (delimiter == "") then
        return false
    end
    local pos, arr = 0, {}
    -- for each divider found
    for st, sp in function()
        return string.find(input, delimiter, pos, true)
    end do
        table.insert(arr, string.sub(input, pos, st - 1))
        pos = sp + 1
    end
    table.insert(arr, string.sub(input, pos))
    return arr
end
local function debugger_strTrim(input)
    input = string.gsub(input, "^[ \t\n\r]+", "")
    return string.gsub(input, "[ \t\n\r]+$", "")
end
local function debugger_dump(value, desciption, nesting)
    if type(nesting) ~= "number" then
        nesting = 3
    end
    local lookupTable = {}
    local result = {}
    local function _v(v)
        if type(v) == "string" then
            v = '"' .. v .. '"'
        end
        return tostring(v)
    end
    local traceback = debugger_strSplit(debug.traceback("", 2), "\n")
    print("dump from: " .. debugger_strTrim(traceback[3]))
    local function _dump(value, desciption, indent, nest, keylen)
        desciption = desciption or "<var>"
        local spc = ""
        if type(keylen) == "number" then
            spc = string.rep(" ", keylen - string.len(_v(desciption)))
        end
        if type(value) ~= "table" then
            result[#result + 1] = string.format("%s%s%s = %s", indent, _v(desciption), spc, _v(value))
        elseif lookupTable[value] then
            result[#result + 1] = string.format("%s%s%s = *REF*", indent, desciption, spc)
        else
            lookupTable[value] = true
            if nest > nesting then
                result[#result + 1] = string.format("%s%s = *MAX NESTING*", indent, desciption)
            else
                result[#result + 1] = string.format("%s%s = {", indent, _v(desciption))
                local indent2 = indent .. "    "
                local keys = {}
                local keylen = 0
                local values = {}
                for k, v in pairs(value) do
                    keys[#keys + 1] = k
                    local vk = _v(k)
                    local vkl = string.len(vk)
                    if vkl > keylen then
                        keylen = vkl
                    end
                    values[k] = v
                end
                table.sort(
                    keys,
                    function(a, b)
                        if type(a) == "number" and type(b) == "number" then
                            return a < b
                        else
                            return tostring(a) < tostring(b)
                        end
                    end
                )
                for i, k in ipairs(keys) do
                    _dump(values[k], k, indent2, nest + 1, keylen)
                end
                result[#result + 1] = string.format("%s}", indent)
            end
        end
    end
    _dump(value, desciption, "- ", 1)
    for i, line in ipairs(result) do
        print(line)
    end
end
--@endregion
local function debugger_valueToString(v)
    local vtype = type(v) 
    local vstr = nil
    if (vtype == "userdata") then
        if (LuaDebugger.isFoxGloryProject) then
           
            return "userdata",vtype
        
        else
            return tostring(v), vtype
        end
    elseif (vtype == "table" or vtype == "function" or vtype == "boolean") then
        local value = vtype
        xpcall(function() 
            value = tostring(v)
        end,function()
            value = vtype
        end)
        return value, vtype
    elseif (vtype == "number" or vtype == "string" ) then
        return v, vtype
    else
        return tostring(v), vtype
    end
end
local function debugger_setVarInfo(name, value)
    local valueStr, valueType = debugger_valueToString(value)
    local nameStr,nameType = debugger_valueToString(name)
    if(valueStr == nil) then
        valueStr = valueType
    end
    local valueInfo = {
        name =nameStr,
        valueType = valueType,
        valueStr = ZZBase64.encode(valueStr)
    }

    return valueInfo
end

local function debugger_getvalue(f)
    local i = 1
    local locals = {}
    -- get locals
    while true do
        local name, value = debug.getlocal(f, i)
        if not name then
            break
        end
        if (name ~= "(*temporary)") then
            locals[name] = value
        end
        i = i + 1
    end
    local func = getinfo(f, "f").func
    i = 1
    local ups = {}
    while func do -- check for func as it may be nil for tail calls
        local name, value = debug.getupvalue(func, i)
        if not name then
            break
        end
        if (name == "_ENV") then
            ups["_ENV_"] = value
        else
            ups[name] = value
        end
        i = i + 1
    end

	return {locals = locals, ups = ups}
end
--获取堆栈
debugger_stackInfo =
    function(ignoreCount, event)
    local datas = {}
    local stack = {}
    local varInfos = {}
    local funcs = {}
    local index = 0
    for i = ignoreCount, 100 do
        local source = getinfo(i)
        local isadd = true
        if (i == ignoreCount) then
            local file = source.source
            if (file:find(LuaDebugger.DebugLuaFie)) then
                return
            end
            if (file == "=[C]") then
                isadd = false
            end
        end
        if not source then
            break
        end
        if (isadd) then
            local fullName, dir, fileName = debugger_getFilePathInfo(source.source)
            local info = {
                src = fullName,
                scoreName = source.name,
                currentline = source.currentline,
                linedefined = source.linedefined,
                what = source.what,
                nameWhat = source.namewhat
            }
            index = i
            local vars = debugger_getvalue(i + 1)
            table.insert(stack, info)
            table.insert(varInfos, vars)
            table.insert(funcs, source.func)
        end
        if source.what == "main" then
            break
        end
	end
	
    local stackInfo = {stack = stack, vars = varInfos, funcs = funcs}
    local data = {
        stack = stackInfo.stack,
        vars = stackInfo.vars,
        funcs = stackInfo.funcs,
        event = event,
		funcsLength = #stackInfo.funcs,
        upFunc = getinfo(ignoreCount - 3, "f").func
    }
    LuaDebugger.currentTempFunc = data.funcs[1]
    return data
end

--===========================点断信息==================================================
--根据不同的游戏引擎进行定时获取断点信息
--CCDirector:sharedDirector():getScheduler()
local debugger_setBreak = nil
local function debugger_receiveDebugBreakInfo()
    if (jit) then
        if (LuaDebugger.debugLuaType ~= "jit") then
            local msg = "当前luajit版本为: " .. jit.version .. " 请使用LuaDebugjit 进行调试!"
            print(msg)
        end
    end
    if (breakInfoSocket) then
        local msg, status = breakInfoSocket:receive()
        if(LuaDebugger.isLaunch and status == "closed") then 
                os.exit()
        end
        if (msg) then
            local netData = json.decode(msg)
            if netData.event == LuaDebugger.event.S2C_SetBreakPoints then
                debugger_setBreak(netData.data)
            elseif netData.event == LuaDebugger.event.S2C_LoadLuaScript then
				LuaDebugger.loadScriptBody = netData.data
                debugger_exeLuaString()
                debugger_sendMsg(breakInfoSocket,LuaDebugger.event.C2S_LoadLuaScript,LuaDebugger.loadScriptBody)
            elseif netData.event == LuaDebugger.event.S2C_ReLoadFile then
                LuaDebugger.reLoadFileBody = netData.data
                LuaDebugger.isReLoadFile = false
                LuaDebugger.reLoadFileBody.isReLoad =  debugger_reLoadFile(LuaDebugger.reLoadFileBody)
                print("重载结果:",LuaDebugger.reLoadFileBody.isReLoad)
                LuaDebugger.reLoadFileBody.script = nil
                debugger_sendMsg(
                    breakInfoSocket,
                    LuaDebugger.event.C2S_ReLoadFile,
                    {
                        stack = LuaDebugger.reLoadFileBody
                       
                    }
				)
			end
        end
    end
end
local function splitFilePath(path)
    if (LuaDebugger.splitFilePaths[path]) then
        return LuaDebugger.splitFilePaths[path]
    end
    local pos, arr = 0, {}
    -- for each divider found
    for st, sp in function()
        return string.find(path, "/", pos, true)
    end do
        local pathStr = string.sub(path, pos, st - 1)
        table.insert(arr, pathStr)
        pos = sp + 1
    end
    local pathStr = string.sub(path, pos)
    table.insert(arr, pathStr)
    LuaDebugger.splitFilePaths[path] = arr
    return arr
end
debugger_setBreak =
    function(datas)
    local breakInfos = LuaDebugger.breakInfos
    for i, data in ipairs(datas) do
        data.fileName = string.lower(data.fileName)
        data.serverPath = string.lower(data.serverPath)
        local breakInfo = breakInfos[data.fileName]
        if (not breakInfo) then
            breakInfos[data.fileName] = {}
            breakInfo = breakInfos[data.fileName]
        end
        if (not data.breakDatas or #data.breakDatas == 0) then
            breakInfo[data.serverPath] = nil
        else
            local fileBreakInfo = breakInfo[data.serverPath]
            if (not fileBreakInfo) then
                fileBreakInfo = {
                    pathNames = splitFilePath(data.serverPath),
                    --命中次數判斷計數器
                    hitCounts = {}
                }
                breakInfo[data.serverPath] = fileBreakInfo
            end
            local lineInfos = {}
            for li, breakData in ipairs(data.breakDatas) do
                lineInfos[breakData.line] = breakData
                if (breakData.hitCondition and breakData.hitCondition ~= "") then
                    breakData.hitCondition = tonumber(breakData.hitCondition)
                else
                    breakData.hitCondition = 0
                end
                if (not fileBreakInfo.hitCounts[breakData.line]) then
                    fileBreakInfo.hitCounts[breakData.line] = 0
                end
            end
            fileBreakInfo.lines = lineInfos
            --這裡添加命中次數判斷
            for line, count in pairs(fileBreakInfo.hitCounts) do
                if (not lineInfos[line]) then
                    fileBreakInfo.hitCounts[line] = nil
                end
            end
        end
        local count = 0
        for i, linesInfo in pairs(breakInfo) do
            count = count + 1
        end
        if (count == 0) then
            breakInfos[data.fileName] = nil
        end
    end
    --debugger_dump(breakInfos, "breakInfos", 6)
    --检查是否需要断点
    local isHook = false
    for k, v in pairs(breakInfos) do
        isHook = true
        break
    end

    --这样做的原因是为了最大限度的使手机调试更加流畅 注意这里会连续的进行n次
    if (isHook) then
        if (not LuaDebugger.isHook) then
            debug.sethook(debug_hook, "lrc")
        end
        LuaDebugger.isHook = true
    else
        if (LuaDebugger.isHook) then
            debug.sethook()
        end
        LuaDebugger.isHook = false
    end
end
local function debugger_checkFileIsBreak(fileName)
    return LuaDebugger.breakInfos[fileName]
end
--=====================================断点信息 end ----------------------------------------------
local controller_host = "192.168.1.102"
local controller_port = 7003
debugger_sendMsg = function(serverSocket, eventName, data)
    local sendMsg = {
        event = eventName,
        data = data
    }
    local sendStr = json.encode(sendMsg)
    serverSocket:send(sendStr .. "__debugger_k0204__")
end
function debugger_conditionStr(condition, vars, callBack)
    local function loadScript()
        local currentTabble = {}

        local locals = vars[1].locals
        local ups = vars[1].ups
        if (ups) then
            for k, v in pairs(ups) do
                currentTabble[k] = v
            end
        end

        if (locals) then
            for k, v in pairs(locals) do
                currentTabble[k] = v
            end
        end
        setmetatable(currentTabble, {__index = _G})
        local fun = loadstring("return " .. condition)
        setfenv(fun, currentTabble)
        return fun()
    end
    local status,
        msg =
        xpcall(
        loadScript,
        function(error)
            print(error)
        end
    )
    if (status and msg) then
        callBack()
    end
end
--执行lua字符串
debugger_exeLuaString = function()
      
    local function loadScript()
       
        local script = LuaDebugger.loadScriptBody.script
        if (LuaDebugger.loadScriptBody.isBreak) then
            local currentTabble = {_G = _G}
            local frameId = LuaDebugger.loadScriptBody.frameId
            frameId = frameId
            local func = LuaDebugger.currentDebuggerData.funcs[frameId]
            local vars = LuaDebugger.currentDebuggerData.vars[frameId]
            local locals = vars.locals
            local ups = vars.ups
            for k, v in pairs(ups) do
                currentTabble[k] = v
            end
            for k, v in pairs(locals) do
                currentTabble[k] = v
            end
            setmetatable(currentTabble, {__index = _G})
    
            local fun = loadstring(script)
            setfenv(fun, currentTabble)
            fun()
        else
            local fun = loadstring(script)
            fun()
        end
    end
    local status,
        msg =
        xpcall(
        loadScript,
        function(error)
            
            -- debugger_sendMsg(debug_server, LuaDebugger.event.C2S_LoadLuaScript, LuaDebugger.loadScriptBody)
        end
    )
	LuaDebugger.loadScriptBody.script = nil
    if (LuaDebugger.loadScriptBody.isBreak) then
		LuaDebugger.serVarLevel = LuaDebugger.serVarLevel+1
		LuaDebugger.currentDebuggerData = debugger_stackInfo(LuaDebugger.serVarLevel, LuaDebugger.event.C2S_HITBreakPoint)
		LuaDebugger.loadScriptBody.stack = LuaDebugger.currentDebuggerData.stack
	end
    LuaDebugger.loadScriptBody.complete = true
   
end
--@region 调试中修改变量值


--根据key 值在 value 查找
local function debugger_getTablekey(key,keyType,value)
    if(keyType == -1) then
        return key
    elseif(keyType == 1) then
        return tonumber(key)
    elseif(keyType == 2) then
        local valueKey = nil
        for k,v in pairs(value) do
            local nameType = type(k)
            if(nameType == "userdata" or nameType == "table") then
                if (not LuaDebugger.isFoxGloryProject) then
                    valueKey = tostring(k)
                    if(key == valueKey) then
                        return k
                    end
                    break
                end
            end
        end
       
    end
end

local function debugger_setVarValue(server, data)
    
    local newValue = nil
    local level = LuaDebugger.serVarLevel+LuaDebugger.setVarBody.frameId
    local firstKeyName = data.keys[1]
    --@region vars check
    local localValueChangeIndex = -1
    local upValueChangeIndex = -1
    local upValueFun = nil
    local oldValue = nil
    local i = 1
    local locals = {}
    -- get locals
    while true do
        local name, value = debug.getlocal(level, i)
        if not name then
            break
        end
        if(firstKeyName == name) then
            localValueChangeIndex = i
            oldValue = value
        end
        if (name ~= "(*temporary)") then
            locals[name] = value
        end
        i = i + 1
    end
    local func = getinfo(level, "f").func
    i = 1
    local ups = {}
    while func do -- check for func as it may be nil for tail calls
        local name, value = debug.getupvalue(func, i)
       
        if not name then
            break
        end
        if(localValueChangeIndex == -1 and firstKeyName == name) then
            upValueFun = func
            oldValue = value
            upValueChangeIndex = i
        end
        if (name == "_ENV") then
            ups["_ENV_"] = value
        else
            ups[name] = value
        end
        i = i + 1
    end
--@endregion
   local vars = {locals = locals, ups = ups}
  
    local function loadScript()
        local currentTabble = {}
        local locals = vars.locals
        local ups = vars.ups
        if (ups) then
            for k, v in pairs(ups) do
                currentTabble[k] = v
            end
        end

        if (locals) then
            for k, v in pairs(locals) do
                currentTabble[k] = v
            end
        end
        setmetatable(currentTabble, {__index = _G})
        local fun = loadstring("return " .. data.value)
        setfenv(fun, currentTabble)
        newValue = fun()
    end
    local status,
        msg =
        xpcall(
        loadScript,
        function(error)
            print(error, "============================")
        end
    )
  
    local i = 1
   
    -- local 查找并替换
    local keyLength = #data.keys
   
    if(keyLength == 1) then
        if(localValueChangeIndex ~= -1) then
            
            debug.setlocal(level, localValueChangeIndex, newValue)
        elseif(upValueFun ~= nil) then
            debug.setupvalue( upValueFun, upValueChangeIndex, newValue )
        else
            --全局变量查找
            if(_G[firstKeyName]) then
                _G[firstKeyName] = newValue
            end
        end
    else
        if(not oldValue) then
            if(_G[firstKeyName]) then
                oldValue = _G[firstKeyName]
            end
        end
        local tempValue = oldValue
        for i=2,keyLength-1 do
            if(tempValue) then
                oldValue = oldValue[debugger_getTablekey(data.keys[i],data.numberTypes[i],oldValue)]
            end
        end
        if(tempValue) then
            oldValue[debugger_getTablekey(data.keys[keyLength],data.numberTypes[keyLength],oldValue)] = newValue
        end
    end
	local varInfo = debugger_setVarInfo(data.varName, newValue)
    data.varInfo = varInfo
    LuaDebugger.serVarLevel = LuaDebugger.serVarLevel+1
    LuaDebugger.currentDebuggerData = debugger_stackInfo(LuaDebugger.serVarLevel, LuaDebugger.event.C2S_HITBreakPoint)
    
end
--@endregion




--调试修改变量值统一的 _resume
checkSetVar =
    function()
    if (LuaDebugger.isSetVar) then
        LuaDebugger.isSetVar = false 
        debugger_setVarValue(debug_server,LuaDebugger.setVarBody)
        LuaDebugger.serVarLevel = LuaDebugger.serVarLevel+1
        _resume(coro_debugger, LuaDebugger.setVarBody)
        xpcall(
            checkSetVar,
            function(error)
                print("设置变量", error)
            end
        )
    elseif(LuaDebugger.isLoadLuaScript) then
        LuaDebugger.isLoadLuaScript = false
        debugger_exeLuaString()
        LuaDebugger.serVarLevel = LuaDebugger.serVarLevel+1
		_resume(coro_debugger, LuaDebugger.reLoadFileBody)
        xpcall(
            checkSetVar,
            function(error)
                print("执行代码", error)
            end
		)
	elseif(LuaDebugger.isReLoadFile) then
        LuaDebugger.isReLoadFile = false
        LuaDebugger.reLoadFileBody.isReLoad =  debugger_reLoadFile(LuaDebugger.reLoadFileBody)
        print("重载结果:",LuaDebugger.reLoadFileBody.isReLoad)
        LuaDebugger.reLoadFileBody.script = nil
        LuaDebugger.serVarLevel = LuaDebugger.serVarLevel+1
        _resume(coro_debugger, LuaDebugger.reLoadFileBody)
        xpcall(
            checkSetVar,
            function(error)
                print("重新加载文件", error)
            end
        )
    end
end
  


local function getSource(source)
    source = string.lower(source)
    if (LuaDebugger.pathCachePaths[source]) then
        LuaDebugger.currentLineFile = LuaDebugger.pathCachePaths[source]
        return LuaDebugger.pathCachePaths[source]
    end

    local fullName, dir, fileName = debugger_getFilePathInfo(source)
    LuaDebugger.currentLineFile = fullName
    LuaDebugger.pathCachePaths[source] = fileName

    return fileName
end
local function debugger_GeVarInfoBytUserData(server, var)
    local fileds = LuaDebugTool.getUserDataInfo(var)

    local varInfos = {}
 

    --c# vars
    for i = 1, fileds.Count do
        local filed = fileds[i - 1]
        local valueInfo = {
            name = filed.name,
            valueType = filed.valueType,
            valueStr = ZZBase64.encode(filed.valueStr),
            isValue = filed.isValue,
            csharp = true
        }

        table.insert(varInfos, valueInfo)
    end
    return varInfos
end

local function debugger_getValueByScript(value, script)
    local val = nil
    local status,
        msg =
        xpcall(
        function()
            local fun = loadstring("return " .. script)
            setfenv(fun, value)
            val = fun()
        end,
        function(error)
            print(error, "====>")
            val = nil
        end
    )

    return val
end
local function debugger_getVarByKeys(value, keys, index)
    local str = ""
    local keyLength = #keys
    for i = index, keyLength do
        local key = keys[i]
        if (key == "[metatable]") then
        else
            if (i == index) then
                if (string.find(key, "%.")) then
                    if (str == "") then
                        i = index + 1
                        value = value[key]
                    end
                    if (i >= #keys) then
                        return index, value
                    end

                    return debugger_getVarByKeys(value, keys, i)
                else
                    str = key
                end
            else
                if (string.find(key, "%[")) then
                    str = str .. key
                elseif (type(key) == "string") then
                    if (string.find(key, "table:") or string.find(key, "userdata:") or string.find(key, "function:")) then
                        if (str ~= "") then
                            local vl = debugger_getValueByScript(value, str)
                            value = vl
                            if (value) then
                                for k, v in pairs(value) do
                                    local ktype = type(k)

                                    if (ktype == "userdata" or ktype == "table" or ktype == "function") then
                                        local keyName = debugger_valueToString(k)
                                        if (keyName == key) then
                                            value = v
                                            break
                                        end
                                    end
                                end
                            end
                            str = ""
                            if (i == keyLength) then
                                return #keys, value
                            else
                                return debugger_getVarByKeys(value, keys, i + 1)
                            end
                        else
                            str = str .. '["' .. key .. '"]'
                        end
                    else
                        str = str .. '["' .. key .. '"]'
                    end
                else
                    str = str .. "[" .. key .. "]"
                end
            end
        end
    end

    local v = debugger_getValueByScript(value, str)

    return #keys, v
end
--[[
    @desc: 查找c# 值
    author:k0204
    time:2018-04-07 21:32:31
    return
]]
local function debugger_getCSharpValue(value, searchIndex, keys)
    local key = keys[searchIndex]
    local val = LuaDebugTool.getCSharpValue(value, key)
    if (val) then
        --1最后一个 直接返回
        if (searchIndex == #keys) then
            return #keys, val
        else
            --2再次获得 如果没有找到那么 进行lua 层面查找
            local vindex, val1 = debugger_getCSharpValue(val, searchIndex + 1, keys)
            if (not val1) then
                --组建新的keys
                local tempKeys = {}
                for i = vindex, #keys do
                    table.insert(tempKeys, keys[i])
                end
                local vindx, val1 = debugger_searchVarByKeys(value, searckKeys, 1)
                return vindx, val1
            else
                return vindex, val1
            end
        end
    else
        --3最终这里返回  所以2 中 没有当val1 不为空的处理
        return searchIndex, val
    end
end
local function debugger_searchVarByKeys(value, keys, searckKeys)
    local index, val = debugger_getVarByKeys(value, searckKeys, 1)

    if (not LuaDebugTool or  not LuaDebugTool.getCSharpValue or type(LuaDebugTool.getCSharpValue) ~= "function") then
        return index, val
    end
    if (val) then
        if (index == #keys) then
            return index, val
        else
            local searchStr = ""
            --进行c# 值查找
            local keysLength = #keys
            local searchIndex = index + 1
            local sindex, val = debugger_getCSharpValue(val, searchIndex, keys)
            return sindex, val
        end
    else
        --进行递减
        local tempKeys = {}
        for i = 1, #searckKeys - 1 do
            table.insert(tempKeys, keys[i])
        end
        if (#tempKeys == 0) then
            return #keys, nil
        end
        return debugger_searchVarByKeys(value, keys, tempKeys)
    end
end
--[[
    @desc: 获取metatable 信息
    author:k0204
    time:2018-04-06 20:27:12
    return
]]
local function debugger_getmetatable(value, metatable, vinfos, server, variablesReference, debugSpeedIndex, metatables)
    for i, mtable in ipairs(metatables) do
        if (metatable == mtable) then
            return vinfos
        end
    end
    table.insert(metatables, metatable)
    for k, v in pairs(metatable) do
        local val = nil
        if (type(k) == "string") then
            xpcall(
                function()
                    val = value[k]
                end,
                function(error)
                    val = nil
                end
            )
            if (val == nil) then
                xpcall(
                    function()
                        if (string.find(k, "__")) then
                            val = v
                        end
                    end,
                    function(error)
                        val = nil
                    end
                )
            end
        end
        if (val) then
            local vinfo = debugger_setVarInfo(k, val)
            table.insert(vinfos, vinfo)
            if (#vinfos > 10) then
                debugger_sendMsg(
                    server,
                    LuaDebugger.event.C2S_ReqVar,
                    {
                        variablesReference = variablesReference,
                        debugSpeedIndex = debugSpeedIndex,
                        vars = vinfos,
                        isComplete = 0
                    }
                )
                vinfos = {}
            end
        end
    end
    local m = getmetatable(metatable)
    if (m) then
        return debugger_getmetatable(value, m, vinfos, server, variablesReference, debugSpeedIndex, metatables)
    else
        return vinfos
    end
end
local function debugger_sendTableField(luatable, vinfos, server, variablesReference, debugSpeedIndex, valueType)
    if (valueType == "userdata") then
        if (tolua and tolua.getpeer) then
            luatable = tolua.getpeer(luatable)
        else
            return vinfos
        end
    end
    if (luatable == nil) then
        return vinfos
    end
    for k, v in pairs(luatable) do
        local vinfo = debugger_setVarInfo(k, v)
        table.insert(vinfos, vinfo)
        if (#vinfos > 10) then
            debugger_sendMsg(
                server,
                LuaDebugger.event.C2S_ReqVar,
                {
                    variablesReference = variablesReference,
                    debugSpeedIndex = debugSpeedIndex,
                    vars = vinfos,
                    isComplete = 0
                }
            )
            vinfos = {}
        end
    end

    return vinfos
end
local function debugger_sendTableValues(value, server, variablesReference, debugSpeedIndex)
    local vinfos = {}
    local luatable = {}
    local valueType = type(value)
    local userDataInfos = {}
    local m = nil

    if (valueType == "userdata") then
        m = getmetatable(value)
       
        vinfos = debugger_sendTableField(value, vinfos, server, variablesReference, debugSpeedIndex, valueType)
      
        if (LuaDebugTool) then
            local varInfos = debugger_GeVarInfoBytUserData(server, value, variablesReference, debugSpeedIndex)

            for i, v in ipairs(varInfos) do
                if (v.valueType == "System.Byte[]" and value[v.name] and type(value[v.name]) == "string") then
                    local valueInfo = {
                        name = v.name,
                        valueType = "string",
                        valueStr = ZZBase64.encode(value[v.name])
                    }
                    table.insert(vinfos, valueInfo)
                else
                    table.insert(vinfos, v)
                end
                if (#vinfos > 10) then
                    debugger_sendMsg(
                        server,
                        LuaDebugger.event.C2S_ReqVar,
                        {
                            variablesReference = variablesReference,
                            debugSpeedIndex = debugSpeedIndex,
                            vars = vinfos,
                            isComplete = 0
                        }
                    )
                    vinfos = {}
                end
            end
           
        end
    else
        m = getmetatable(value)
        vinfos = debugger_sendTableField(value, vinfos, server, variablesReference, debugSpeedIndex, valueType)
    end

    if (m) then
        vinfos = debugger_getmetatable(value, m, vinfos, server, variablesReference, debugSpeedIndex, {})
    end
    debugger_sendMsg(
        server,
        LuaDebugger.event.C2S_ReqVar,
        {
            variablesReference = variablesReference,
            debugSpeedIndex = debugSpeedIndex,
            vars = vinfos,
            isComplete = 1
        }
    )
end

--获取lua 变量的方法
local function debugger_getBreakVar(body, server)
    local variablesReference = body.variablesReference
    local debugSpeedIndex = body.debugSpeedIndex
    local vinfos = {}
    local function exe()
        local frameId = body.frameId
        local type_ = body.type
        local keys = body.keys
        --找到对应的var
        local vars = nil
        if (type_ == 1) then
            vars = LuaDebugger.currentDebuggerData.vars[frameId + 1]
            vars = vars.locals
        elseif (type_ == 2) then
            vars = LuaDebugger.currentDebuggerData.vars[frameId + 1]
            vars = vars.ups
        elseif (type_ == 3) then
            vars = _G
        end
        if (#keys == 0) then
            debugger_sendTableValues(vars, server, variablesReference, debugSpeedIndex)
            return
        end
        local index, value = debugger_searchVarByKeys(vars, keys, keys)
        if (value) then
            local valueType = type(value)
            if (valueType == "table" or valueType == "userdata") then

                debugger_sendTableValues(value, server, variablesReference, debugSpeedIndex)
            else
                if (valueType == "function") then
                    value = tostring(value)
                end
                debugger_sendMsg(
                    server,
                    LuaDebugger.event.C2S_ReqVar,
                    {
                        variablesReference = variablesReference,
                        debugSpeedIndex = debugSpeedIndex,
                        vars = ZZBase64.encode(value),
                        isComplete = 1,
                        varType = valueType
                    }
                )
            end
        else
            debugger_sendMsg(
                server,
                LuaDebugger.event.C2S_ReqVar,
                {
                    variablesReference = variablesReference,
                    debugSpeedIndex = debugSpeedIndex,
                    vars = {},
                    isComplete = 1,
                    varType = "nil"
                }
            )
        end
    end
    xpcall(
        exe,
        function(error)
            -- print("获取变量错误 错误消息-----------------")
            -- print(error)
            -- print(debug.traceback("", 2))
            debugger_sendMsg(
                server,
                LuaDebugger.event.C2S_ReqVar,
                {
                    variablesReference = variablesReference,
                    debugSpeedIndex = debugSpeedIndex,
                    vars = {
                        {
                            name = "error",
                            valueType = "string",
                            valueStr = ZZBase64.encode("无法获取属性值:" .. error .. "->" .. debug.traceback("", 2)),
                            isValue = false
                        }
                    },
                    isComplete = 1
                }
            )
        end
    )
end
local function ResetDebugInfo()
    LuaDebugger.Run = false
    LuaDebugger.StepIn = false
    LuaDebugger.StepNext = false
    LuaDebugger.StepOut = false
    LuaDebugger.StepNextLevel = 0
end
local function debugger_loop(server)
    server = debug_server
    --命令
    local command
    local eval_env = {}
    local arg
    while true do
        local line, status = server:receive()
        if (status == "closed") then
        if(LuaDebugger.isLaunch) then
            os.exit()
        else
            debug.sethook()
            coroutine.yield()
        end
        end
        if (line) then
            local netData = json.decode(line)
            local event = netData.event
            local body = netData.data
            if (event == LuaDebugger.event.S2C_DebugClose) then
            if(LuaDebugger.isLaunch) then
                os.exit()
            else
                debug.sethook()
                coroutine.yield()
            end
               
            elseif event == LuaDebugger.event.S2C_SetBreakPoints then
                --设置断点信息
                local function setB()
                    debugger_setBreak(body)
                end
                xpcall(
                    setB,
                    function(error)
                        print(error)
                    end
                )
            elseif event == LuaDebugger.event.S2C_RUN then --开始运行
                LuaDebugger.runTimeType = body.runTimeType
                LuaDebugger.isProntToConsole = body.isProntToConsole
                LuaDebugger.isFoxGloryProject = body.isFoxGloryProject
                LuaDebugger.isLaunch = body.isLaunch
                ResetDebugInfo()
                LuaDebugger.Run = true
                local data = coroutine.yield()
                LuaDebugger.serVarLevel = 4
                LuaDebugger.currentDebuggerData = data
                debugger_sendMsg(
                    server,
                    data.event,
                    {
                        stack = data.stack
                    }
                )
            elseif event == LuaDebugger.event.S2C_ReqVar then -- 获取变量信息
                --请求数据信息
                debugger_getBreakVar(body, server)
            elseif event == LuaDebugger.event.S2C_NextRequest then -- 设置单步跳过
                ResetDebugInfo()
                LuaDebugger.StepNext = true
                LuaDebugger.StepNextLevel = 0
                --设置当前文件名和当前行数
                local data = coroutine.yield()
                LuaDebugger.serVarLevel = 4
                --重置调试信息
                LuaDebugger.currentDebuggerData = data
                debugger_sendMsg(
                    server,
                    data.event,
                    {
                        stack = data.stack
                    }
                )
            elseif (event == LuaDebugger.event.S2C_StepInRequest) then --单步跳入
                --单步跳入
                ResetDebugInfo()
                LuaDebugger.StepIn = true

                local data = coroutine.yield()
                LuaDebugger.serVarLevel = 4
                --重置调试信息
                LuaDebugger.currentDebuggerData = data
                debugger_sendMsg(
                    server,
                    data.event,
                    {
                        stack = data.stack,
                        eventType = data.eventType
                    }
                )
            elseif (event == LuaDebugger.event.S2C_StepOutRequest) then
                --单步跳出
                ResetDebugInfo()
                LuaDebugger.StepOut = true
                local data = coroutine.yield()
                LuaDebugger.serVarLevel = 4
                --重置调试信息
                LuaDebugger.currentDebuggerData = data
                debugger_sendMsg(
                    server,
                    data.event,
                    {
                        stack = data.stack,
                        eventType = data.eventType
                    }
                )
            elseif event == LuaDebugger.event.S2C_LoadLuaScript then
                LuaDebugger.loadScriptBody = body
                LuaDebugger.isLoadLuaScript = true
                local data = coroutine.yield()
                debugger_sendMsg(
                    server,
                    LuaDebugger.event.C2S_LoadLuaScript,
                    LuaDebugger.loadScriptBody
                )
            elseif event == LuaDebugger.event.S2C_SerVar then
                LuaDebugger.isSetVar = true
                LuaDebugger.setVarBody = body
                local data = coroutine.yield()
                debugger_sendMsg(
                    server,
                    LuaDebugger.event.C2S_SerVar,
                    {
                        stack = data,
                        eventType = data.eventType
                    }
				)
			elseif event == LuaDebugger.event.S2C_ReLoadFile then
                LuaDebugger.isReLoadFile = true
                LuaDebugger.reLoadFileBody = body
                local data = coroutine.yield()
                debugger_sendMsg(
                    server,
                    LuaDebugger.event.C2S_ReLoadFile,
                    {
                        stack = data,
                        eventType = data.eventType
                    }
                )
            end
        end
    end
end
coro_debugger = coroutine.create(debugger_loop)
debug_hook = function(event, line)

    if(not LuaDebugger.isHook) then
        return
    end
 
    if(LuaDebugger.Run) then
        if(event == "line") then
            local isCheck = false
            for k, breakInfo in pairs(LuaDebugger.breakInfos) do

                for bk, linesInfo in pairs(breakInfo) do

                    if(linesInfo.lines and linesInfo.lines[line]) then
                        isCheck = true
                        break
                    end
                end
                if(isCheck) then
						break
				end
            end

            if(not isCheck) then
                return
            end
        else
            LuaDebugger.currentFileName = nil
            LuaDebugger.currentTempFunc = nil
            return
        end
    end
    --跳出
    if (LuaDebugger.StepOut) then
        if (event == "line" or event == "call") then
            return
        end
        local tempFun = getinfo(2, "f").func

        if (LuaDebugger.currentDebuggerData.funcsLength == 1) then
            ResetDebugInfo()
            LuaDebugger.Run = true
        else
            if (LuaDebugger.currentDebuggerData.funcs[2] == tempFun) then
                local data = debugger_stackInfo(3, LuaDebugger.event.C2S_StepInResponse)
				--挂起等待调试器作出反应    
				          
                _resume(coro_debugger, data)
                checkSetVar()
            end
        end
        return
    end
    -- debugger_dump(LuaDebugger,"LuaDebugger")
    -- print(LuaDebugger.StepNextLevel,"LuaDebugger.StepNextLevel")
    local file = nil
    if (event == "call") then
        -- end
        -- if(not LuaDebugger.StepOut) then
        if (not LuaDebugger.Run) then
            LuaDebugger.StepNextLevel = LuaDebugger.StepNextLevel + 1
        end
        -- print("stepIn",LuaDebugger.StepNextLevel)

        local stepInfo = getinfo(2, "S")
        local source = stepInfo.source
        if (source:find(LuaDebugger.DebugLuaFie) or source == "=[C]") then
            return
        end

        file = getSource(source)
        LuaDebugger.currentFileName = file
    elseif (event == "return" or event == "tail return") then
        -- end
        -- if(not LuaDebugger.StepOut) then

        if (not LuaDebugger.Run) then
            LuaDebugger.StepNextLevel = LuaDebugger.StepNextLevel - 1
        end

        LuaDebugger.currentFileName = nil
    elseif (event == "line") then
        --@region 判断命中断点
        --判断命中断点
        --判断命中断点
        --判断命中断点
        --判断命中断点
        local isHit = false
        local stepInfo = nil
        if (not LuaDebugger.currentFileName) then
            stepInfo = getinfo(2, "S")
            local source = stepInfo.source
            if (source == "=[C]" or source:find(LuaDebugger.DebugLuaFie)) then
                return
            end
            file = getSource(source)
            LuaDebugger.currentFileName = file
        end
        file = LuaDebugger.currentFileName
        
        --判断断点
        local breakInfo = LuaDebugger.breakInfos[file]
        local breakData = nil
        if (breakInfo) then
          
            local ischeck = false
            for k, lineInfo in pairs(breakInfo) do
                local lines = lineInfo.lines
                if (lines and lines[line]) then
                    ischeck = true
                    break
                end
            end
           
            if (ischeck) then
                --并且在断点中
                local info = stepInfo
                if (not info) then
                    info = getinfo(2)
                end
                local hitPathNames = splitFilePath(LuaDebugger.currentLineFile)
              
                local hitCounts = {}
                local debugHitCounts = nil
                for k, lineInfo in pairs(breakInfo) do
                    local lines = lineInfo.lines
                    local pathNames = lineInfo.pathNames
                    debugHitCounts = lineInfo.hitCounts
                    if (lines and lines[line]) then
                        breakData = lines[line]
                        --判断路径
                        hitCounts[k] = 0
                        local hitPathNamesCount = #hitPathNames
                        
                        local pathNamesCount = #pathNames
                        local checkCount = 0;
                        while (true) do
                            if (pathNames[pathNamesCount] ~= hitPathNames[hitPathNamesCount]) then
                                break
                            else
                                hitCounts[k] = hitCounts[k] + 1
                            end
                            pathNamesCount = pathNamesCount - 1
                            hitPathNamesCount = hitPathNamesCount - 1
                            checkCount = checkCount+1
                           
                            if (pathNamesCount <= 0 or hitPathNamesCount <= 0) then
                                break
                            end
                        end
                        if(checkCount>0) then
                            break;
                        end
                    else
                        breakData = nil
                    end
                end
                if (breakData) then
                    local hitFieName = ""
                    local maxCount = 0
                    for k, v in pairs(hitCounts) do
                        if (v > maxCount) then
                            maxCount = v
                            hitFieName = k
                        end
                    end
                    local hitPathNamesLength = #hitPathNames
                    if (hitPathNamesLength == 1 or (hitPathNamesLength > 1 and maxCount > 1)) then
                        if (hitFieName ~= "") then
                            local hitCount = breakData.hitCondition
                            local clientHitCount = debugHitCounts[breakData.line]
                            clientHitCount = clientHitCount + 1
                            debugHitCounts[breakData.line] = clientHitCount

                            if (clientHitCount >= hitCount) then
                                isHit = true
                            end
                        end
                    end
                end
            end
        end
        --@endregion
        if (LuaDebugger.StepIn) then
            local data = debugger_stackInfo(3, LuaDebugger.event.C2S_NextResponse)
            --挂起等待调试器作出反应
            if (data) then
                LuaDebugger.currentTempFunc = data.funcs[1]

                _resume(coro_debugger, data)
                checkSetVar()
                return
            end
        end
        if (LuaDebugger.StepNext) then
            if (LuaDebugger.StepNextLevel <= 0) then
                local data = debugger_stackInfo(3, LuaDebugger.event.C2S_NextResponse)
                -- 挂起等待调试器作出反应
                if (data) then
					LuaDebugger.currentTempFunc = data.funcs[1]   
					                 
                    _resume(coro_debugger, data)
                    checkSetVar()
                    return
                end
            end
        end
        if (isHit) then
            local data = debugger_stackInfo(3, LuaDebugger.event.C2S_HITBreakPoint)
            if (breakData and breakData.condition) then
                debugger_conditionStr(
                    breakData.condition,
                    data.vars,
                    function()
                        _resume(coro_debugger, data)
                        checkSetVar()
                    end
                )
            else
                --挂起等待调试器作出反应
                _resume(coro_debugger, data)
                checkSetVar()
            end
        end
    end
end
local function debugger_xpcall()
    --调用 coro_debugger 并传入 参数
    local data = debugger_stackInfo(4, LuaDebugger.event.C2S_HITBreakPoint)
    if(data.stack and data.stack[1]) then
        data.stack[1].isXpCall = true    
    end
    --挂起等待调试器作出反应
    _resume(coro_debugger, data)
    checkSetVar()
end
--调试开始
local function start()
    local fullName, dirName, fileName = debugger_getFilePathInfo(getinfo(1).source)
    LuaDebugger.DebugLuaFie = fileName
    local socket = createSocket()
    print(controller_host)
    print(controller_port)

    local server = socket.connect(controller_host, controller_port)
    debug_server = server
    if server then
        --创建breakInfo socket
        socket = createSocket()
        breakInfoSocket = socket.connect(controller_host, controller_port)
        if (breakInfoSocket) then
            breakInfoSocket:settimeout(0)
            debugger_sendMsg(
                breakInfoSocket,
                LuaDebugger.event.C2S_SetSocketName,
                {
                    name = "breakPointSocket"
                }
            )
            debugger_sendMsg(
                server,
                LuaDebugger.event.C2S_SetSocketName,
                {
                    name = "mainSocket",
                    version = LuaDebugger.version
                }
            )
            xpcall(
                function()
                    debug.sethook(debug_hook, "lrc")
                end,
                function(error)
                    print("error:", error)
                end
            )
            if (jit) then
                if (LuaDebugger.debugLuaType ~= "jit") then
                    print("error======================================================")
                    local msg = "当前luajit版本为: " .. jit.version .. " 请使用LuaDebugjit 进行调试!"

                    print(msg)
                end
            end
            _resume(coro_debugger, server)          
        end
    end
end
function StartDebug(host, port)
    if (not host) then
        print("error host nil")
    end
    if (not port) then
        print("error prot nil")
    end
    if (type(host) ~= "string") then
        print("error host not string")
    end
    if (type(port) ~= "number") then
        print("error host not number")
    end
    controller_host = host
    controller_port = port
    xpcall(
        start,
        function(error)
            -- body
            print(error)
        end
    )
    return debugger_receiveDebugBreakInfo, debugger_xpcall
end

--base64

local string = string

ZZBase64.__code = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
};
ZZBase64.__decode = {}
for k,v in pairs(ZZBase64.__code) do
    ZZBase64.__decode[string.byte(v,1)] = k - 1
end

function ZZBase64.encode(text)
    local len = string.len(text)
    local left = len % 3
    len = len - left
    local res = {}
    local index  = 1
    for i = 1, len, 3 do
        local a = string.byte(text, i )
        local b = string.byte(text, i + 1)
        local c = string.byte(text, i + 2)
        -- num = a<<16 + b<<8 + c
        local num = a * 65536 + b * 256 + c
        for j = 1, 4 do
            --tmp = num >> ((4 -j) * 6)
            local tmp = math.floor(num / (2 ^ ((4-j) * 6)))
            --curPos = tmp&0x3f
            local curPos = tmp % 64 + 1
            res[index] = ZZBase64.__code[curPos]
            index = index + 1
        end
    end

    if left == 1 then
        ZZBase64.__left1(res, index, text, len)
    elseif left == 2 then
        ZZBase64.__left2(res, index, text, len)
    end
    return table.concat(res)
end

function ZZBase64.__left2(res, index, text, len)
    local num1 = string.byte(text, len + 1)
    num1 = num1 * 1024 --lshift 10
    local num2 = string.byte(text, len + 2)
    num2 = num2 * 4 --lshift 2
    local num = num1 + num2

    local tmp1 = math.floor(num / 4096) --rShift 12
    local curPos = tmp1 % 64 + 1
    res[index] = ZZBase64.__code[curPos]

    local tmp2 = math.floor(num / 64)
    curPos = tmp2 % 64 + 1
    res[index + 1] = ZZBase64.__code[curPos]

    curPos = num % 64 + 1
    res[index + 2] = ZZBase64.__code[curPos]

    res[index + 3] = "="
end

function ZZBase64.__left1(res, index,text, len)
    local num = string.byte(text, len + 1)
    num = num * 16

    local tmp = math.floor(num / 64)
    local curPos = tmp % 64 + 1
    res[index ] = ZZBase64.__code[curPos]

    curPos = num % 64 + 1
    res[index + 1] = ZZBase64.__code[curPos]

    res[index + 2] = "="
    res[index + 3] = "="
end

function ZZBase64.decode(text)
    local len = string.len(text)
    local left = 0
    if string.sub(text, len - 1) == "==" then
        left = 2
        len = len - 4
    elseif string.sub(text, len) == "=" then
        left = 1
        len = len - 4
    end

    local res = {}
    local index = 1
    local decode = ZZBase64.__decode
    for i =1, len, 4 do
        local a = decode[string.byte(text,i    )] 
        local b = decode[string.byte(text,i + 1)] 
        local c = decode[string.byte(text,i + 2)] 
        local d = decode[string.byte(text,i + 3)]

        --num = a<<18 + b<<12 + c<<6 + d
        local num = a * 262144 + b * 4096 + c * 64 + d

        local e = string.char(num % 256)
        num = math.floor(num / 256)
        local f = string.char(num % 256)
        num = math.floor(num / 256)
        res[index ] = string.char(num % 256)
        res[index + 1] = f
        res[index + 2] = e
        index = index + 3
    end

    if left == 1 then
        ZZBase64.__decodeLeft1(res, index, text, len)
    elseif left == 2 then
        ZZBase64.__decodeLeft2(res, index, text, len)
    end
    return table.concat(res)
end

function ZZBase64.__decodeLeft1(res, index, text, len)
    local decode = ZZBase64.__decode
    local a = decode[string.byte(text, len + 1)]
    local b = decode[string.byte(text, len + 2)]
    local c = decode[string.byte(text, len + 3)]
    local num = a * 4096 + b * 64 + c

    local num1 = math.floor(num / 1024) % 256
    local num2 = math.floor(num / 4) % 256
    res[index] = string.char(num1)
    res[index + 1] = string.char(num2)
end

function ZZBase64.__decodeLeft2(res, index, text, len)
    local decode = ZZBase64.__decode
    local a = decode[string.byte(text, len + 1)]
    local b = decode[string.byte(text, len + 2)]
    local num = a * 64 + b
    num = math.floor(num / 16)
    res[index] = string.char(num)
end




return StartDebug