Module:ModulePageSystem

模块文档  

local mps = {}
mps.util = require("Module:ModulePageSystem/util")
local dictionary = require("Module:Dictionary")
 
mps.FUNC_HASVALUE_TRUE = function() return true end
mps.FUNC_HASVALUE_FALSE = function() return false end
mps.FUNC_VALUE_NIL = function() return nil end
--定义一个常量，表示该节点值不存在。
mps.NOVALUE = {
    hasValue = mps.FUNC_HASVALUE_FALSE,
    value = mps.FUNC_VALUE_NIL
}
 
--[[
    验证一个节点是否是格式正确的对象。
    通过检测数个字段、函数是否存在，类型是否正确来验证节点格式是否正确。
    -----
    node - 将要验证的节点。
    validations - 指定了验证的类型，若有多个验证类型，则以空白字符分隔，验证结果将取与。
        value - 该节点支持存储值。
        sub - 该节点支持包含次级节点。
    -----
    返回：多个验证类型结果的与值。
--]]
function mps.validate(node, validations)
    if node == nil then return false
    elseif type(node) ~= "table" then return false
    end
    if type(validations) == "table" then validations = table.concat(validations, " ")
    elseif type(validations) ~= "string" then return false
    end
 
    for validation in mw.ustring.gmatch(validations, "%S+") do
        if validation == "value" then
            if type(node.hasValue) ~= "function" or
                type(node.value) ~= "function" then return false end
        elseif validation == "ref" then
            if type(node.getTarget) ~= "function" then return false end
        elseif validation == "sub" then
            if type(node.plain) ~= "function" or
                type(node.wiki) ~= "function" or
                type(node.ref) ~= "function" or
                type(node.sub) ~= "function" or
                type(node.substart) ~= "function" or
                type(node.subend) ~= "function" or
                type(node.format) ~= "function" or
                type(node.find) ~= "function" then return false end
        else
            mps.util.error(mw.ustring.format("不支持的验证类型：\"%s\"", validation), mps.util.ELID_WARNING)
            return false
        end
    end
 
    return true
end
 
--[[
    从指定的节点开始按路径查找值。
    -----
    node - 指定的节点。
    path - 路径
    -----
    返回：路径name处的值。
--]]
function mps.find(node, path, params)
    if type(params) ~= "table" then params = {} end
    if type(params.path) ~= "table" then params.path = {} end
    if type(params.basestack) ~= "table" then params.basestack = {} end
    if type(params.refhistory) ~= "table" then params.refhistory = dictionary.create() end
 
    if node == nil or type(node) == "string" then -- node为表示以这个字符串为网页路径创建的节点。
        -- 若node为空，则设为调用页面的标题。
        node = node or mw.title.getCurrentTitle().prefixedText
 
        -- 尝试加载页面。
        local root = mps.load({}, node)
        if mps.validate(node, "value") and value:hasValue(params) then
            -- 以这个字符串为基地址创建根节点。
            node = mps.create(node)
        else
            node = root
        end
    end
 
    if params.root == nil then params.root = node end -- 将自身设为查询根节点。
 
    local value
    local subpath = mps.util.pathSplit(path)
 
    -- 截取顶层目录为当前名称；其余为下级名称。
    local name = subpath[1]
    table.remove(subpath, 1)
    table.insert(params.path, name) -- 将当前名称添加到路径中。
    table.insert(params.basestack, { node.base }) -- 将当前所属页面路径添加到页面路径堆栈中。（由于所属页面路径可能为nil，故用table包裹。）
 
    -- 筛选子节点。子节点是否为底层节点将对其是否会被接受有影响。
    -- 底层节点：接受值节点；不接受含有子节点的节点。
    -- 非底层节点：接受含有子节点的节点；不接受值节点。
    local findInternal = function(_value)
        -- 获取节点值。
        if mps.validate(_value, "ref") then -- 如果是引用节点
            -- 获取引用节点指向的节点。
            _value = _value:getTarget(params)
        end
        if (params.novalidation or false) == true then -- 若忽略子节点是否为底层节点对其是否会被接受的影响。
            if #subpath == 0 then -- 仅当子节点为底层节点时生效。
                if (mps.validate(_value, "value") and _value:hasValue(params)) or mps.validate(_value, "sub") then
                    -- 仅在子节点是含有值的值节点或者含有子节点的节点时，直接返回子节点本身。
                    return _value
                end
            end
        end
 
        if #subpath == 0 and mps.validate(_value, "value") then -- 如果是底层节点，且节点是值节点。
            if _value:hasValue(params) then  -- 如果有值则返回节点。
                return _value
            end
        elseif #subpath ~= 0 and mps.validate(_value, "sub") then -- 如果不是底层节点，且节点含有子节点。
            -- 进行递归查找。
            _value = _value:find(subpath, params)
            if mps.validate(_value, "value") and _value:hasValue(params) then -- 子节点查找到值则返回节点。
                return _value
            elseif mps.validate(_value, "sub") then -- 从findInternal返回的含有子节点的节点绝对是忽略层级影响。
                return _value
            end
        elseif #subpath == 0 and not (mps.validate(_value, "value") or mps.validate(_value, "sub")) then -- 节点不是任何节点，且是底层节点。
            mps.util.error("非节点对象。", mps.util.ELID_ERROR)
        end
 
        return mps.NOVALUE -- 查找不到子节点树的值。
    end
 
    if mps.validate(node, "sub") then -- 本节点含有子节点。
        -- 寻找键name。
        if node.dic:hasKey(name) then
            value = findInternal(node.dic:getValue(name))
            if mps.validate(value, "value") and value:hasValue(params) then
                table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
                table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
                return value
            elseif mps.validate(value, "sub") then -- 从findInternal返回的含有子节点的节点绝对是忽略层级影响。
                table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
                table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
                return value
            end
        end
 
        -- 寻找通用函数formatfunc。
        if node.formatfunc ~= nil then -- 找到通用函数formatfunc。
            -- 获取处理结果。
            value = node:formatfunc(name, params)
 
            value = findInternal(value)
            if mps.validate(value, "value") and value:hasValue(params) then
                table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
                table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
                return value
            elseif mps.validate(value, "sub") then -- 从findInternal返回的含有子节点的节点绝对是忽略层级影响。
                table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
                table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
                return value
            end
        end
    end
 
    -- 尝试加载页面。
    local fullpagename = nil
    -- 沿堆栈向下查询上级节点的基路径。
    for i = #params.basestack, 1, -1 do
        if #params.basestack[i] ~= 0 then
            fullpagename = params.basestack[i][1]
            break;
        end
    end
    if fullpagename == nil then
        -- 无法获取基路径。
        mps.util.error(mw.ustring.format("无法获取节点“%s”基路径，因为上层节点均未定义基路径。", mps.util.pathCombine(params.path)), mps.util.ELID_WARNING)
    else
        fullpagename = mw.ustring.format("%s/%s", fullpagename, table.concat(mps.util.pathSplit(params.path), "/")) -- 要加载的页面。
        value = findInternal(mps.load(node, fullpagename))
        if mps.validate(value, "value") and value:hasValue(params) then -- 页面加载成功。
            table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
            table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
            return value
        elseif mps.validate(value, "sub") then -- 从findInternal返回的含有子节点的节点绝对是忽略层级影响。
            table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
            table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
            return value
        end
    end
 
    table.remove(params.path, #params.path) -- 从路径中删除最后一段名称。
    table.remove(params.basestack, #params.basestack) -- 从页面路径堆栈中删除最后一段所属页面路径。
    return mps.NOVALUE -- 查询不到值。
end
 
mps.FUNC_SUBEND_COMMON = function(self)
    mps.util.error("语法错误：subend。（当前并未处于定义子项的上下文。）", mps.util.ELID_WARNING)
    return self
end
 
--[[
    从一个页面地址创建一个节点。
    -----
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。
    -----
    返回：新节点。
--]]
function mps.create(page)
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("在create中参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL)
    elseif page == nil then -- 检测页面地址是否为空。
        mps.util.error(mw.ustring.format("页面地址为空。", page), mps.util.ELID_WARNING)
    elseif type(page) == "string" and mw.title.new(page) == nil then -- 检测页面地址是否包含不合法字符。
        mps.util.error(mw.ustring.format("页面地址“%s”包含不合法字符。", page), mps.util.ELID_ERROR)
    end
 
    local prototype = {
        dic = dictionary.create(function(k1, k2) return mps.util.normalize(k1) == mps.util.normalize(k2) end),
        base = page, -- 本节点所在的页面地址。
        inheritbase = "", -- [未启用]以定义了页面地址的最近一个上层节点开始到本节点的路径，即本节点的“继承”得到的基路径。
        plain = mps.registerPlain,
        wiki = mps.registerWiki,
        ref = mps.registerRef,
        sub = mps.registerSubpage,
        substart = mps.registerNewSubpage,
        subend = mps.FUNC_SUBEND_COMMON,
        format = mps.registerFormat,
        find = mps.find
    }
    return prototype
end
 
mps.FUNC_VALUE_PLAIN = function(self) return self.innervalue end
 
--[[
    创建一个纯文本的值节点。
    -----
    plain - 文本内容。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。
    -----
    返回：新值节点。
--]]
function mps.createPlain(plain, page)
    if plain ~= nil and type(plain) ~= "string" then mps.util.error(mw.ustring.format("参数plain的值类型错误。(应为%s，实际为%s)", "nil或string", type(plain)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL)
    elseif page == nil then -- 检测页面地址是否为空。
        mps.util.error(mw.ustring.format("页面地址为空。", page), mps.util.ELID_WARNING)
    elseif type(page) == "string" and mw.title.new(page) == nil then -- 检测页面地址是否包含不合法字符。
        mps.util.error(mw.ustring.format("页面地址“%s”包含不合法字符。", page), mps.util.ELID_ERROR)
    end
 
    return {
        base = page,
        innervalue = plain,
        hasValue = mps.FUNC_HASVALUE_TRUE,
        value = mps.FUNC_VALUE_PLAIN
    }
end
 
mps.FUNC_VALUE_WIKI = function(self, params)
    if self.innervalue == nil then return nil
    elseif params.plain then return self.innervalue
    elseif self.innerwiki ~= nil then return self.innerwiki
    elseif params == nil or params.frame == nil then
        mps.util.error(mw.ustring.format("无法获取wiki执行对象（frame的值为nil）。"), mps.util.ELID_WARNING)
    else
        self.innerwiki = params.frame:preprocess(self.innervalue)
        return self.innerwiki
    end
end
 
--[[
    创建一个Wiki内容的值节点。
    -----
    wiki - Wiki内容。
    plain - 指示wiki参数的字符串值是否是纯文本，默认为true。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。
    -----
    返回：新值节点。
--]]
function mps.createWiki(wiki, plain, page)
    if wiki ~= nil and type(wiki) ~= "string" then mps.util.error(mw.ustring.format("参数wiki的值类型错误。(应为%s，实际为%s)", "nil或string", type(wiki)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL)
    elseif page == nil then -- 检测页面地址是否为空。
        mps.util.error(mw.ustring.format("页面地址为空。", page), mps.util.ELID_WARNING)
    elseif type(page) == "string" and mw.title.new(page) == nil then -- 检测页面地址是否包含不合法字符。
        mps.util.error(mw.ustring.format("页面地址“%s”包含不合法字符。", page), mps.util.ELID_ERROR)
    end
 
    local result = {
        base = page,
        innervalue = wiki,
        innerwiki = nil,
        hasValue = mps.FUNC_HASVALUE_TRUE,
        value = mps.FUNC_VALUE_WIKI
    }
 
    if (plain or false) ~= true then result.innerwiki = wiki end -- 默认是以纯文本形式创建。
    return result
end
 
local find_ref = function(node, params)
    -- 查找引用历史，检测是否循环引用。
    local flag = false
    local path = mps.util.pathCombine(params.path)
    if params.refhistory:hasKey(path) then
        -- 检测到循环引用。
        flag = true
    else
        for _, rh_entry in params.refhistory:enum() do
            if rh_entry.value == node then
                -- 检测到循环引用。
                flag = true
                break
            end
        end
    end
 
    if flag then
        local errorinfo = {}
        for _, _entry in params.refhistory:enum() do
            table.insert(errorinfo, _entry.key)
        end
        table.insert(errorinfo, rh_entry.key)
 
        mps.util.error("形成了循环引用。（“%s”）", table.concat(errorinfo, "”→“"), mps.util.ELID_ERROR)
        return mps.NOVALUE
    end
 
    -- 构建引用目标节点的路径。
    local newPath
    if node.isabsolute then -- 绝对路径
        newPath = mps.util.pathCombine(node.innervalue)
    else -- 相对路径
        newPath = mps.util.pathCombine(params.path, mps.util.PARENTNODE, node.innervalue)
    end
    -- 构建查找引用目标节点的新参数。
    local newParams = {
        frame = params.frame,
        plain = params.plain,
        refhistory = dictionary.create(nil, params.refhistory):add(path, node), -- 新建引用历史字典的副本，并将自身添加进去。
        novalidation = true -- 忽略节点所处层级的影响。
    }
 
    return mps.find(params.root, newPath, newParams), newParams
end
 
mps.FUNC_GETTARGET_REF = function(self, params)
    local target, newParams = find_ref(self, params)
 
    -- 递归获得指向的目标节点。
    if mps.validate(target, "ref") then
        return target:getTarget(target, newParams)
    else
        return target
    end
end
 
--[[
    创建一个引用节点。
    -----
    target - 引用指向的目标。
    isabsolute - 指示target参数表示的引用目标路径是否为绝对路径，默认为true。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。
    -----
    返回：新引用节点。
--]]
function mps.createRef(target, isabsolute, page)
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL)
    elseif page == nil then -- 检测页面地址是否为空。
        mps.util.error(mw.ustring.format("页面地址为空。", page), mps.util.ELID_WARNING)
    elseif type(page) == "string" and mw.title.new(page) == nil then -- 检测页面地址是否包含不合法字符。
        mps.util.error(mw.ustring.format("页面地址“%s”包含不合法字符。", page), mps.util.ELID_ERROR)
    end
 
    return {
        base = page,
        innervalue = target,
        isabsolute = (isabsolute or false) == true,
        getTarget = mps.FUNC_GETTARGET_REF
    }
end
 
--[[
    向节点中注册一个纯文本的子值节点。
    -----
    parent - 节点本身。
    name - 子节点名称。
    plain - 文本内容。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：节点本身。（为语法糖提供支持）
--]]
function mps.registerPlain(parent, name, plain, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(name) ~= "string" then mps.util.error(mw.ustring.format("参数name的值类型错误。(应为%s，实际为%s)", "string", type(name)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    plain = mps.createPlain(plain, page or parent.page)
    if parent.dic:hasKey(name) then
        if parent.dic:getValue(name) ~= nil and parent.dic:getValue(name):hasValue() then
            mps.util.error(mw.ustring.format("在对节点\"%s\"赋值时失败，该节点已存在另外的值。", name), mps.util.ELID_ERROR)
        else
            parent.dic:setValue(name, plain)
        end
    else
        parent.dic:add(name, plain)
    end
 
    return parent
end
 
--[[
    向节点中注册一个Wiki内容的子值节点。
    -----
    parent - 节点本身。
    name - 子节点名称。
    wiki - Wiki内容。
    plain - 指示wiki参数的字符串值是否是纯文本，默认为true。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：节点本身。（为语法糖提供支持）
--]]
function mps.registerWiki(parent, name, wiki, plain, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(name) ~= "string" then mps.util.error(mw.ustring.format("参数name的值类型错误。(应为%s，实际为%s)", "string", type(name)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    wiki = mps.createWiki(wiki, plain, page or parent.page)
    if parent.dic:hasKey(name) then
        if parent.dic:getValue(name) ~= nil and parent.dic:getValue(name):hasValue() then
            mps.util.error(mw.ustring.format("在对节点\"%s\"赋值时失败，该节点已存在另外的值。", name), mps.util.ELID_ERROR)
        else
            parent.dic:setValue(name, wiki)
        end
    else
        parent.dic:add(name, wiki)
    end
 
    return parent
end
 
--[[
    向节点中注册一个引用的子值节点。
    -----
    parent - 节点本身。
    names - 所有引用子节点的名称（被指向目标的别名）。若类型为string则表示一个名称；若类型为table则表示多个名称。
    target - 引用指向的目标。
    isabsolute - 指示target参数表示的引用目标路径是否为绝对路径，默认为true。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：节点本身。（为语法糖提供支持）
--]]
function mps.registerRef(parent, names, target, isabsolute, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(names) == "string" then names = { names }
    elseif type(names) ~= "table" then mps.util.error(mw.ustring.format("参数names的值类型错误。(应为%s，实际为%s)", "string或table", type(names)), mps.util.ELID_FATAL)
    end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    local ref
    for i, name in ipairs(names) do
        if type(name) ~= "string" then
            mps.util.error(mw.ustring.format("参数names的第%d项的值类型错误。(应为%s，实际为%s)", i, "string", type(name)), mps.util.ELID_FATAL)
        else
            ref = ref or mps.createRef(target, isabsolute, page or parent.base) -- 只创建一次，整个循环使用同一且唯一的引用节点。
 
            if parent.dic:hasKey(name) then
                if parent.dic:getValue(name) ~= nil and parent.dic:getValue(name):hasValue() then
                    mps.util.error(mw.ustring.format("在对节点\"%s\"赋值时失败，该节点已存在另外的值。", name), mps.util.ELID_ERROR)
                else
                    parent.dic:setValue(name, ref)
                end
            else
                parent.dic:add(name, ref)
            end
        end
    end
 
    return parent
end
 
--[[
    向节点中注册一个现有的子节点。
    这个子节点可以是从另一个页面导入、在本地定义的——node节点、储存了纯数据的普通Lua表。
    -----
    parent - 节点本身。
    name - 子节点名称。
    node - 将作为被添加的子节点的内容。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：节点本身。（为语法糖提供支持）
--]]
function mps.registerSubpage(parent, name, node, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(name) ~= "string" then mps.util.error(mw.ustring.format("参数name的值类型错误。(应为%s，实际为%s)", "string", type(name)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    if type(node) == "string" then -- 是从指定路径的页面导入的内容。
        -- node默认是绝对路径，若需要引用节点所处页面路径则需使用“%0”。
        -- 获取绝对路径。
        local path = mw.ustring.gsub(node, "%%[%%0]", function(m)
            if m == "%%" then return "%"
            elseif m == "%0" then return parent.base
            else return ""
            end
        end)
        -- 加载页面。
        node = mps.load(parent, path)
    elseif type(node) == "table" then -- 是在本地定义的内容。
        if mps.validate(node, "sub") then -- 检测是否是含有子节点的节点对象。
            node = mps.derive(parent, node, page) -- 创建一个node的继承节点。
        elseif mps.validate(node, "value") then -- 检测是否是值节点。
            -- 设置所属页面路径。
            node.base = node.base or page or parent.base -- 取值原则：本地定义的值节点的已定义所属页面路径 → 覆盖参数parent继承的页面路径 → 参数parent继承的页面路径。
        else
            node = mps.parse(parent, node, page) -- 从一个普通Lua表转换成为节点。
        end
    end
 
    if parent.dic:hasKey(name) then
        if parent.dic:getValue(name) ~= nil and parent.dic:getValue(name):hasValue() then
            mps.util.error(mw.ustring.format("在对节点\"%s\"赋值时失败，该节点已存在另外的值。", name), mps.util.ELID_ERROR)
        else
            parent.dic:setValue(name, node)
        end
    else
        parent.dic:add(name, node)
    end
 
    return parent
end
 
mps.FUNC_SUBEND_SUB = function(self) return self.parent end
 
--[[
    向节点中注册一个子节点，并切换到子节点的上下文。
    这个子节点可以是从另一个模板导入、在本地定义的——node节点、储存了纯数据的普通Lua表。
    -----
    parent - 节点本身。
    name - 子节点名称。
    node - 将作为被添加的子节点的内容。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：子节点本身。（为语法糖提供支持）
--]]
function mps.registerNewSubpage(parent, name)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(name) ~= "string" then mps.util.error(mw.ustring.format("参数name的值类型错误。(应为%s，实际为%s)", "string", type(name)), mps.util.ELID_FATAL) end
 
    local prototype = mps.create(parent.page) -- 获取一个标准的节点对象。
    prototype.inheritbase = mps.util.pathCombine(parent.inheritbase, name) -- 继承本节点的路径组成新路径。
    prototype.parent = parent -- 将本节点保存在parent字段中
    prototype.subend = mps.FUNC_SUBEND_SUB -- 结束子节点定义，返回到其父节点，即本节点。
 
    if parent.dic:hasKey(name) then
        if parent.dic:getValue(name) ~= nil and parent.dic:getValue(name):hasValue() then
            mps.util.error(mw.ustring.format("在对节点\"%s\"赋值时失败，该节点已存在另外的值。", name), mps.util.ELID_ERROR)
        else
            parent.dic:setValue(name, prototype)
        end
    else
        parent.dic:add(name, prototype)
    end
 
    return prototype
end
 
function mps.registerFormat(parent, format)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if format == nil then return
    elseif type(format) ~= "function" then mps.util.error(mw.ustring.format("通用函数formatfunc类型错误。(应为%s，实际为%s)", "function", type(format)), mps.util.ELID_FATAL)
    end
 
    if parent.formatfunc == nil then
        parent.formatfunc = format
    else
        mps.util.error("通用函数赋值失败，该节点已存在另外的通用函数。", mps.util.ELID_ERROR)
    end
 
    return parent
end
 
--[[
    从指定页面加载节点。
    -----
    parent - 本节点。
    path - 包含节点的模块页面地址。
    -----
    返回：指定页面包含的节点。
--]]
function mps.load(parent, path)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("在load中参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(path) ~= "string" then mps.util.error(mw.ustring.format("在load中参数path的值类型错误。(应为%s，实际为%s)", "string", type(path)), mps.util.ELID_FATAL) end
 
    local success, result = pcall(function(_path)
        local title = mw.title.new(_path) -- 获取要加载的页面的标题对象。
        if title == nil then
            error(mw.ustring.format("页面“%s”路径格式不正确。"), _path)
        elseif title.exists then -- 加载的页面存在。
            return require(_path)
        else
            mps.util.error(mw.ustring.format("页面“%s”不存在。", _path), mps.util.ELID_WARNING)
            return mps.NOVALUE
        end
    end, path)
    if result == mps.NOVALUE then return result
    elseif not success then
        mps.util.error(result, mps.util.ELID_ERROR)
        return mps.NOVALUE
    end
 
    local node = result
 
    if mps.validate(node, "sub") then -- 检测是否是节点对象。
        node = mps.derive(parent, node, path)
    else
        node = mps.parse(parent, node, path)
    end
 
    return node
end
 
--[[
    将一个节点设为本节点的继承节点。
    -----
    parent - 本节点。
    sub - 要被设为继承节点的节点。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：被设为继承节点的节点。
--]]
function mps.derive(parent, sub, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("在derive中参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(sub) ~= "table" then mps.util.error(mw.ustring.format("在derive中参数sub的值类型错误。(应为%s，实际为%s)", "table", type(sub)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    sub.base = sub.base or page or parent.base
 
    return sub
end
 
--[[
    将一个普通Lua表转换成为本节点的子节点。
    -----
    parent - 本节点。
    tab - 要被转换为本节点的子节点的普通Lua表。
    page - 定义这个节点的页面，应当是你在书写这个代码时所处的模块名页面全名。若为非空值，则将覆盖参数parent的继承。
    -----
    返回：转换后的节点。
--]]
function mps.parse(parent, tab, page)
    if type(parent) == "nil" then mps.util.error(mw.ustring.format("在parse中参数parent的值类型错误。(应为%s，实际为%s)", "table", type(parent)), mps.util.ELID_FATAL) end
    if type(tab) ~= "table" then mps.util.error(mw.ustring.format("在parse中参数tab的值类型错误。(应为%s，实际为%s)", "table", type(tab)), mps.util.ELID_FATAL) end
    if page ~= nil and type(page) ~= "string" then mps.util.error(mw.ustring.format("参数page的值类型错误。(应为%s，实际为%s)", "nil或string", type(page)), mps.util.ELID_FATAL) end
 
    local node = mps.create(page or parent.base)
    for _name, _node in pairs(tab) do
        if type(_node) == "table" then
            -- 递归转换Lua表中的节点
            mps.registerSubpage(node, _name, _node)
        elseif type(_node) == "string" then
            -- 默认转换为纯文本节点。
            mps.registerPlain(node, _name, _node)
        end
    end
 
    return node
end
 
return mps