refactor serialize functions

1 files changed, 7 insertions, 139 deletions

diff --git a/xmake/core/base/string.lua b/xmake/core/base/string.lua
index d3a584f3e..30c374def 100644
--- a/xmake/core/base/string.lua
+++ b/xmake/core/base/string.lua
@@ -23,120 +23,12 @@ local string = string or {}
 
 -- load modules
 local deprecated = require("base/deprecated")
+local serialize  = require("base/serialize")
 
 -- save original interfaces
 string._dump = string._dump or string.dump
 string._trim = string._trim or string.trim
 
--- make string with the level
-function string._makestr(object, deflate, serialize, level)
-    if type(object) == "string" then
-        return serialize and string.format("%q", object) or object
-    elseif type(object) == "boolean" or type(object) == "nil" then
-        return tostring(object)
-    elseif type(object) == "number" then
-        if serialize then
-            if math.isnan(object) then
-                return "math.nan"
-            end
-            local inf = math.isinf(object)
-            if inf == 1 then
-                return "math.huge"
-            elseif inf == -1 then
-                return "-math.huge"
-            end
-        end
-        return tostring(object)
-    elseif not serialize and type(object) == "table" and (getmetatable(object) or {}).__tostring then
-        return tostring(object)
-    elseif type(object) == "table" then
-
-        local indent = ""
-        if not deflate then
-            indent = string.rep("    ", level)
-        end
-
-        -- make head
-        local s = ""
-        if deflate then
-            s = s .. "{"
-        else
-            if level > 0 then
-                s = s .. "\n"
-            end
-            s = s .. indent .. "{\n"
-        end
-
-        -- make body
-        local i = 0
-        for k, v in pairs(object) do
-
-            if deflate then
-                s = s .. (i ~= 0 and "," or "")
-            else
-                s = s .. indent
-                if i == 0 then
-                    s = s .. "    "
-                else
-                    s = s .. ",   "
-                end
-            end
-
-            -- make key = value
-            if type(k) == "string" then
-                if serialize and not k:match("^[%a_][%w_]+$") then
-                    k = string.format("[%q]", k)
-                end
-                if deflate then
-                    s = s .. k .. "="
-                else
-                    s = s .. k .. " = "
-                end
-            end
-            local substr, errors = string._makestr(v, deflate, serialize, level + 1)
-            if substr == nil then
-                return nil, errors
-            end
-            s = s .. substr
-
-            if not deflate then
-                s = s .. "\n"
-            end
-            i = i + 1
-        end
-
-        -- make tail
-        s = s .. indent .. "}"
-        return s
-    elseif serialize and type(object) == "function" then
-        return string.format("%q", string._dump(object))
-    elseif serialize then
-        return nil, "cannot serialize object: " .. type(object)
-    elseif object ~= nil then
-        return "<" .. tostring(object) .. ">"
-    else
-        return "nil"
-    end
-end
-
--- load table from string in table
-function string._loadstr(object)
-    -- only load luajit function data: e.g. "\27LJ\2\0\6=stdin"
-    if type(object) == "string" and object:startswith("\27LJ") then
-        return loadstring(object)
-    elseif type(object) == "table" then
-        for k, v in pairs(object) do
-            local value, errors = string._loadstr(v)
-            if value ~= nil then
-                object[k] = value
-            else
-                return nil, errors
-            end
-        end
-    end
-    return object
-end
-
 -- find the last substring with the given pattern
 function string:find_last(pattern, plain)
 
@@ -306,7 +198,7 @@ end
 -- 
 function string.dump(object, deflate)
     deprecated.add("utils.dump() or string.serialize()", "string.dump()")
-    return string._makestr(object, deflate, false, 0)
+    return string.serialize(object, deflate)
 end
 
 -- serialize to string from the given object
@@ -314,9 +206,10 @@ end
 -- @param deflate       deflate empty characters
 --
 -- @return              string, errors
--- 
+--
 function string.serialize(object, deflate)
-    return string._makestr(object, deflate, true, 0)
+    deflate = not not deflate
+    return serialize.save(object, { strip = deflate, indent = not deflate })
 end
 
 -- deserialize string to object
@@ -324,34 +217,9 @@ end
 -- @param str           the serialized string
 --
 -- @return              object, errors
--- 
+--
 function string:deserialize()
-
-    -- load table as script
-    local result = nil
-    local script, errors = loadstring("return " .. self)
-    if script then
-
-        -- load object
-        local ok, object = pcall(script)
-        if ok then
-            result = object
-        elseif object then
-            -- error
-            errors = object
-        else
-            -- error
-            errors = string.format("cannot deserialize string: %s", self)
-        end
-    end
-
-    -- load function from string in table
-    if result then
-        result, errors = string._loadstr(result)
-    end
-
-    -- ok?
-    return result, errors
+    return serialize.load(self)
 end
 
 -- return module: string