Lua Xml

wiki

• 工具包；
• 仅限 Lua 的 XML 解析器；
• 包含 C 代码和绑定的 XML 解析器；
• 用于处理基于 XML 的协议（如 XML-RPC 和 SOAP）的模块。

在适当的地方会提到作者的贡献。

工具包

LazyKit 是一个 XML 处理工具集合。它的主要目的是引发关于 Lua 中 XML 工具的讨论。

PenlightLibraries 提供了一个 XML 模块 [参见文档]，它使用 LuaExpat? 定义的 LOM，并提供漂亮打印、模板匹配和 Orbit 风格的“html 化”。如果可用，它将使用 LuaExpat?，否则将回退到基于 Roberto 的纯 Lua 解析器（见下文）。

仅限 Lua 的 XML 解析器

LuaBasicTagParser?

xml2lua

[xml2lua] 是一个更新的版本，适用于 Lua 5.0 到 5.3。它基于 Paul Chakravarti 的 [LuaXML for Lua 4]。

该模块实现了一个非验证的 XML 流解析器，它具有基于处理程序的事件 API（在概念上类似于 SAX），可用于根据需要对事件数据进行后处理（例如，将其转换为树）。

当前功能包括 -

• 对格式良好的 XML 进行标记化（相对健壮）
• 灵活的基于处理程序的事件 API（
• 解析/生成所有 XML 元素的事件 - 即
  • 标签
  • 文本
  • 注释
  • CDATA
  • XML 声明
  • 处理指令
  • DOCTYPE 声明
• 提供有限的格式良好性检查（仅检查基本语法和平衡的标签）
• 灵活的空白处理（可选）
• 实体处理（可选）

限制包括 -

• 非验证
• 没有字符集处理
• 不支持命名空间
• 仅进行浅层格式良好性检查（无法检测大多数语义错误）

该发行版还包括用于将 SAX 事件流转换为 Lua 表的示例事件处理程序 -

• domHandler 生成类似 DOM 的节点树结构，并且能够表示任何有效的 XML 文档
• simpleTreeHandler 尝试生成一个更“自然”的基于表格的结构，该结构支持许多常见的 XML 格式，并且通常更有用（但是，在处理混合内容时有一些限制）。

SLAXML

另一个纯 Lua 非验证 SAX 式流处理器。它还包含一个简单的 DOM 解析器实现（解析为表格层次结构）。

https://github.com/Phrogz/SLAXML

特性

• 单个文件中的纯 Lua（如果您使用 DOM 解析器，则为两个文件）。
• 流解析器对输入进行单次传递，并报告它所看到的內容。
• 支持元素、属性、注释、文本、CDATA 和处理指令。（不支持 DTD 或 XML 声明作为非处理指令）。
• 支持命名空间
• 支持语法有效的 XML，例如 cond="7 > 5"（但也错误地“支持”某些无效的 XML，例如 <foo></bar> 或 <a>5 < 7）
• 在属性和文本节点中取消转义命名 XML 实体（< > & " '）和数字实体（例如 
）（但在注释或 CDATA 中不正确地取消转义）。正确处理边缘情况，例如 &&。
• 可以选择忽略仅包含空格的文本节点（如缩进 XML 标记时出现的那样）。
• 包含一个 DOM 解析器，它既是方便地提取 XML 以供使用的便捷方法，也是使用流解析器的良好示例。
• 不会向全局命名空间添加任何键。使用模式 local SLAXML = require 'slaxml' 来使用它。

经典的纯 Lua 版本

来自：Roberto Ierusalimschy

我有一个基本的骨架，它解析 XML 字符串的“主要”部分（它不处理元数据，如“<?”和“<!”...）。-- Roberto

[!] 版本说明：以下代码与旧版本的 Lua 版本 Lua 4 相关。它不能在 Lua 5 下按原样运行。

[!] 此实现显然无法正确解析冒号 (:)，如用于 XML 命名空间。有关建议的修复方法，请参见下文。

function parseargs (s)
  local arg = {}
  gsub(s, "(%w+)=([\"'])(.-)%2", function (w, _, a)
    %arg[w] = a
  end)
  return arg
end

function collect (s)
  local stack = {n=0}
  local top = {n=0}
  tinsert(stack, top)
  local ni,c,label,args, empty
  local i, j = 1, 1
  while 1 do
    ni,j,c,label,args, empty = strfind(s, "<(%/?)([%w:]+)(.-)(%/?)>", i)
    if not ni then break end
    local text = strsub(s, i, ni-1)
    if not strfind(text, "^%s*$") then
      tinsert(top, text)
    end
    if empty == "/" then  -- empty element tag
      tinsert(top, {n=0, label=label, args=parseargs(args), empty=1})
    elseif c == "" then   -- start tag
      top = {n=0, label=label, args=parseargs(args)}
      tinsert(stack, top)   -- new level
    else  -- end tag
      local toclose = tremove(stack)  -- remove top
      top = stack[stack.n]
      if stack.n < 1 then
        error("nothing to close with "..label)
      end
      if toclose.label ~= label then
        error("trying to close "..toclose.label.." with "..label)
      end
      tinsert(top, toclose)
    end 
    i = j+1
  end
  local text = strsub(s, i)
  if not strfind(text, "^%s*$") then
    tinsert(stack[stack.n], text)
  end
  if stack.n > 1 then
    error("unclosed "..stack[stack.n].label)
  end
  return stack[1]
end


-- example

x = collect[[
     <methodCall kind="xuxu">
      <methodName>examples.getStateName</methodName>
      <params>
         <param>
            <value><i4>41</i4></value>
            </param>
         </params>
      </methodCall>
]]

function parseargs(s)
  local arg = {}
  string.gsub(s, "([%-%w]+)=([\"'])(.-)%2", function (w, _, a)
    arg[w] = a
  end)
  return arg
end
    
function collect(s)
  local stack = {}
  local top = {}
  table.insert(stack, top)
  local ni,c,label,xarg, empty
  local i, j = 1, 1
  while true do
    ni,j,c,label,xarg, empty = string.find(s, "<(%/?)([%w:]+)(.-)(%/?)>", i)
    if not ni then break end
    local text = string.sub(s, i, ni-1)
    if not string.find(text, "^%s*$") then
      table.insert(top, text)
    end
    if empty == "/" then  -- empty element tag
      table.insert(top, {label=label, xarg=parseargs(xarg), empty=1})
    elseif c == "" then   -- start tag
      top = {label=label, xarg=parseargs(xarg)}
      table.insert(stack, top)   -- new level
    else  -- end tag
      local toclose = table.remove(stack)  -- remove top
      top = stack[#stack]
      if #stack < 1 then
        error("nothing to close with "..label)
      end
      if toclose.label ~= label then
        error("trying to close "..toclose.label.." with "..label)
      end
      table.insert(top, toclose)
    end
    i = j+1
  end
  local text = string.sub(s, i)
  if not string.find(text, "^%s*$") then
    table.insert(stack[#stack], text)
  end
  if #stack > 1 then
    error("unclosed "..stack[#stack].label)
  end
  return stack[1]
end

原始版本

来自：上野裕隆

这是我的测试程序，现在已经修改了 [1] （链接已失效） 但它只针对生物学中使用的几个 XML 文件进行了测试。罗伯托的代码可能比我的代码提供了更好的框架，但在 Lua 表中对 xml 标签的描述存在差异。

XML :           <methodCall kind="xuxu">
Lua by Roberto: { label="methodCall", args={kind="xuxu"} }
Lua by Ueno:    { xml="methodCall", kind="xuxu" }

因为属性名“xml”从未出现在 XML 中。这种方法对于生物学中提出的深度很深的 XML 标签来说更好一些。

C 绑定

Kino

来自：埃克哈特·科彭

好吧，我编写了一些可能会有帮助的东西，那就是 Kino XML 处理器。它通过 SWIG 为 Tcl 和 Lua 提供了包装器。还提供了用于使用 CSS 显示 XML 的 Xt 和实验性 Gtk 小部件。请查看：[2] （链接已失效）

它处于不断开发中，但试图坚持 DOM，因此我希望接口更改保持很小。

libxml

[luagnome] （链接已失效，请使用 [3]）包含 libxml-1.8.x 的包装，因为它被认为是 Gnome 的一部分。它允许使用简单的 API（面向对象）解析和生成 XML 文件。

[lua-xmlreader] 是使用 libxml2 实现的 XmlReader API。

Expat

对于 Lua 5.0/5.1，请使用 [LuaExpat]，它功能齐全。

对于 Lua 4.0

来自：杰伊·卡尔森

我在 [4] 中放置了一个简单的 expat 绑定，它是詹姆斯·克拉克的基于 C 流的 XML 解析器。并非所有内容都绑定了，但应该很明显如何将更多内容绑定到它。

LuaXML

[LuaXML] 是一个精简但完整的模块，用于 XML 数据和 Lua 表之间的直接映射。

XML-DOM 解析器

PugXML 是一个 C++ 小型、快速、非验证 DOM XML 解析器，包含在一个头文件中，除了标准 C 库和 <iostream>（带有 WIN32 的 KERNEL32.DLL）之外没有其他依赖项。此 XML 解析器会对给定字符串就地进行分段（类似于 strtok），在单次传递中执行扫描/标记化和解析。

以下是在 Lua 中使用解析器的示例

-- create xml_parser object
parser = pug.xml_parser( pug.xml_parser.parse_default, true, 4);

-- parse string
xml_string = '<xml><child>some data </child><child2 attr="value"/></xml>';
print('parsing string: ' .. xml_string );
parser:parse(xml_string, pug.xml_parser.parse_noset);
print( tostring(parser:document()) );

-- Testing xml_node
-- getting root
root=parser:document();

-- add a element child
child=root:append_child( pug.xml_node_type.element );
print( tostring(root) );

-- rename child to child
child:name('child');
print('child name is ' .. child:name() );
print( tostring(root) );

-- adding attributes
child:append_attribute('attribute','value');
child:append_attribute('attribute2','value2');

-- adding on children
child2=child:append_child( pug.xml_node_type.element );
child2:name('child2');
print( tostring(root) );

使用 [LuaBind] 为此解析器编写了一个包装器，可在 [5] （链接已失效） 中获得。有关 PugXML 的原始文章位于 [6]。

TinyXML

对于 Lua 5.0

来自：罗伯特·诺尔

在 c++ 中使用 [TinyXML] (2.4.3) 库，只需一个简单的“将文件解析为 lua 数组”函数。

// header

class lua_State;
	
/// register parser functions to lua
void	RegisterLuaXML (lua_State *L);


// sourcefile

#include "tinyxml.h"

extern "C" {
	#include "lua.h"
	#include "lauxlib.h"
	#include "lualib.h"
}

void LuaXML_ParseNode (lua_State *L,TiXmlNode* pNode) { PROFILE
	if (!pNode) return;
	// resize stack if neccessary
	luaL_checkstack(L, 5, "LuaXML_ParseNode : recursion too deep");
	
	TiXmlElement* pElem = pNode->ToElement();
	if (pElem) {
		// element name
		lua_pushstring(L,"name");
		lua_pushstring(L,pElem->Value());
		lua_settable(L,-3);
		
		// parse attributes
		TiXmlAttribute* pAttr = pElem->FirstAttribute();
		if (pAttr) {
			lua_pushstring(L,"attr");
			lua_newtable(L);
			for (;pAttr;pAttr = pAttr->Next()) {
				lua_pushstring(L,pAttr->Name());
				lua_pushstring(L,pAttr->Value());
				lua_settable(L,-3);
				
			}
			lua_settable(L,-3);
		}
	}
	
	// children
	TiXmlNode *pChild = pNode->FirstChild();
	if (pChild) {
		int iChildCount = 0;
		for(;pChild;pChild = pChild->NextSibling()) {
			switch (pChild->Type()) {
				case TiXmlNode::DOCUMENT: break;
				case TiXmlNode::ELEMENT: 
					// normal element, parse recursive
					lua_newtable(L);
					LuaXML_ParseNode(L,pChild);
					lua_rawseti(L,-2,++iChildCount);
				break;
				case TiXmlNode::COMMENT: break;
				case TiXmlNode::TEXT: 
					// plaintext, push raw
					lua_pushstring(L,pChild->Value());
					lua_rawseti(L,-2,++iChildCount);
				break;
				case TiXmlNode::DECLARATION: break;
				case TiXmlNode::UNKNOWN: break;
			};
		}
		lua_pushstring(L,"n");
		lua_pushnumber(L,iChildCount);
		lua_settable(L,-3);
	}
}

static int LuaXML_ParseFile (lua_State *L) { PROFILE
	const char* sFileName = luaL_checkstring(L,1);
	TiXmlDocument doc(sFileName);
	doc.LoadFile();
	lua_newtable(L);
	LuaXML_ParseNode(L,&doc);
	return 1;
}

void	RegisterLuaXML (lua_State *L) {
	lua_register(L,"LuaXML_ParseFile",LuaXML_ParseFile);
}

pugilua

https://github.com/d-led/pugilua

示例

require 'pugilua'


---- reading ----
local doc=pugi.xml_document()
local res=doc:load_file [[..\..\scripts\pugilua\pugilua.vcxproj]]

print(res.description)

local node1=doc:root():child('Project')
local query1=doc:root():select_nodes('Project/PropertyGroup')

local n=query1.size
for i=0,n-1 do
	local node=query1:get(i):node()
	local attribute=query1:get(i):attribute()
	print(node.valid,node.path)
	local a=node:first_attribute()
	while a.valid do
		print(a.name)
		a=a:next_attribute()
	end
end

---- creating ----
doc:reset()
--- from the tutorial
-- add node with some name
local node = doc:root():append_child("node")

-- add description node with text child
local descr = node:append_child("description")
descr:append(pugi.node_pcdata):set_value("Simple node")

-- add param node before the description
local param = node:insert_child_before("param", descr)

-- add attributes to param node
param:append_attribute("name"):set_value("version")
param:append_attribute("value"):set_value(1.1)
param:insert_attribute_after("type", param:attribute("name")):set_value("float")

doc:save_file("tutorial.xml")

xerceslua

作为 pugilua 的补充，我们努力提供一个对 [xerces.apache.org/xerces-c/ Xerces-C++] 的最小绑定，以便能够验证 xml 文档。

https://github.com/d-led/xerceslua

assert(require 'xerceslua')

示例

local parser=xerces.XercesDOMParser()
parser:loadGrammar("Employee.dtd",xerces.GrammarType.DTDGrammarType)
parser:setValidationScheme(xerces.ValSchemes.Val_Auto)
local log=parser:parse("Employeexy.xml")
print(log.Ok)
if not log.Ok then
    print(log.Count)
    for i=0,log.Count-1 do
        local err=log:GetLogEntry(i)
        print(err.SystemId..', l:'..err.LineNumber..', c:'..err.ColumnNumber..', e:'..err.Message,err.LogType)
    end
end

基于 XML 的协议

XML-RPC

对于 Lua 5.0/5.1，请使用由 [The Kepler Project] 开发的 [LuaXMLRPC] 库。

对于 Lua 4.0

来自：杰伊·卡尔森

我在 [7] 中发布了 Lua 的 XML-RPC 客户端/服务器绑定的初始版本。它包含我的 lxp expat 绑定，并使用 LuaSocket 进行客户端传输。

有关 XML-RPC 的更多信息，请参见 [8]。

虽然打包和文档很少，但此包成功通过了 [9] 的验证测试。

SOAP

[LuaSOAP] 是一个 Lua 库，用于简化 SOAP 的使用。

仅 Lua XmlParser

对于 Lua 5.1

来自：Alexander Makeev

此 XmlParser 允许构建类似于 C# XmlDocument? 的对象，其中包含 XmlNodes?。有关详细信息，请参见示例。

-----------------------------------------------------------------------------------------
-- LUA only XmlParser from Alexander Makeev
-----------------------------------------------------------------------------------------
XmlParser = {};

function XmlParser:ToXmlString(value)
	value = string.gsub (value, "&", "&");		-- '&' -> "&"
	value = string.gsub (value, "<", "&lt;");		-- '<' -> "&lt;"
	value = string.gsub (value, ">", "&gt;");		-- '>' -> "&gt;"
	--value = string.gsub (value, "'", "&apos;");	-- '\'' -> "&apos;"
	value = string.gsub (value, "\"", "&quot;");	-- '"' -> "&quot;"
	-- replace non printable char -> "&#xD;"
   	value = string.gsub(value, "([^%w%&%;%p%\t% ])",
       	function (c) 
       		return string.format("&#x%X;", string.byte(c)) 
       		--return string.format("&#x%02X;", string.byte(c)) 
       		--return string.format("&#%02d;", string.byte(c)) 
       	end);
	return value;
end

function XmlParser:FromXmlString(value)
  	value = string.gsub(value, "&#x([%x]+)%;",
      	function(h) 
      		return string.char(tonumber(h,16)) 
      	end);
  	value = string.gsub(value, "&#([0-9]+)%;",
      	function(h) 
      		return string.char(tonumber(h,10)) 
      	end);
	value = string.gsub (value, "&quot;", "\"");
	value = string.gsub (value, "&apos;", "'");
	value = string.gsub (value, "&gt;", ">");
	value = string.gsub (value, "&lt;", "<");
	value = string.gsub (value, "&amp;", "&");
	return value;
end
   
function XmlParser:ParseArgs(s)
  local arg = {}
  string.gsub(s, "(%w+)=([\"'])(.-)%2", function (w, _, a)
    	arg[w] = self:FromXmlString(a);
  	end)
  return arg
end

function XmlParser:ParseXmlText(xmlText)
  local stack = {}
  local top = {Name=nil,Value=nil,Attributes={},ChildNodes={}}
  table.insert(stack, top)
  local ni,c,label,xarg, empty
  local i, j = 1, 1
  while true do
    ni,j,c,label,xarg, empty = string.find(xmlText, "<(%/?)([%w:]+)(.-)(%/?)>", i)
    if not ni then break end
    local text = string.sub(xmlText, i, ni-1);
    if not string.find(text, "^%s*$") then
      top.Value=(top.Value or "")..self:FromXmlString(text);
    end
    if empty == "/" then  -- empty element tag
      table.insert(top.ChildNodes, {Name=label,Value=nil,Attributes=self:ParseArgs(xarg),ChildNodes={}})
    elseif c == "" then   -- start tag
      top = {Name=label, Value=nil, Attributes=self:ParseArgs(xarg), ChildNodes={}}
      table.insert(stack, top)   -- new level
      --log("openTag ="..top.Name);
    else  -- end tag
      local toclose = table.remove(stack)  -- remove top
      --log("closeTag="..toclose.Name);
      top = stack[#stack]
      if #stack < 1 then
        error("XmlParser: nothing to close with "..label)
      end
      if toclose.Name ~= label then
        error("XmlParser: trying to close "..toclose.Name.." with "..label)
      end
      table.insert(top.ChildNodes, toclose)
    end
    i = j+1
  end
  local text = string.sub(xmlText, i);
  if not string.find(text, "^%s*$") then
      stack[#stack].Value=(stack[#stack].Value or "")..self:FromXmlString(text);
  end
  if #stack > 1 then
    error("XmlParser: unclosed "..stack[stack.n].Name)
  end
  return stack[1].ChildNodes[1];
end

function XmlParser:ParseXmlFile(xmlFileName)
	local hFile,err = io.open(xmlFileName,"r");
	if (not err) then
		local xmlText=hFile:read("*a"); -- read file content
		io.close(hFile);
        return self:ParseXmlText(xmlText),nil;
	else
		return nil,err;
	end
end
------------------------------------------------------------------------------------------

示例

function dump(_class, no_func, depth)
	if(not _class) then 
		log("nil");
		return;
	end
	
	if(depth==nil) then depth=0; end
	local str="";
	for n=0,depth,1 do
		str=str.."\t";
	end
    
	log(str.."["..type(_class).."]");
	log(str.."{");
    
	for i,field in pairs(_class) do
		if(type(field)=="table") then
			log(str.."\t"..tostring(i).." =");
			dump(field, no_func, depth+1);
		else 
			if(type(field)=="number") then
				log(str.."\t"..tostring(i).."="..field);
			elseif(type(field) == "string") then
				log(str.."\t"..tostring(i).."=".."\""..field.."\"");
			elseif(type(field) == "boolean") then
				log(str.."\t"..tostring(i).."=".."\""..tostring(field).."\"");
			else
				if(not no_func)then
					if(type(field)=="function")then
						log(str.."\t"..tostring(i).."()");
					else
						log(str.."\t"..tostring(i).."<userdata=["..type(field).."]>");
					end
				end
			end
		end
	end
	log(str.."}");
end

--local obj,err = XmlParser:ParseXmlFile("test.xml");
--if(not err) then
--	dump(obj);
--else
--	log("ERROR: "..err);		
--end

local xmlTree=XmlParser:ParseXmlText([[<?xml version="1.0" encoding="utf-8"?>
<Config>
	<EntityList>
		<Entity value="1&quot;2&quot;3">innerText</Entity>	
		<Entity value="456"/>
	</EntityList>
</Config>
]])
for i,xmlNode in pairs(xmlTree.ChildNodes) do
	if(xmlNode.Name=="EntityList") then
		for i,subXmlNode in pairs(xmlNode.ChildNodes) do
			if(subXmlNode.Name=="Entity") then
				log("Entity value=\""..subXmlNode.Attributes.value.."\"");
				if(subXmlNode.Value) then
					log("   Content=\""..subXmlNode.Value.."\"");
				end
			end
		end
	end
end
dump(xmlTree)

结果

<log>Entity value="1"2"3"
<log>   Content="innerText"
<log>Entity value="456"
<log>	[table]
<log>	{
<log>		Attributes =
<log>		[table]
<log>		{
<log>		}
<log>		Name="Config"
<log>		ChildNodes =
<log>		[table]
<log>		{
<log>			1 =
<log>			[table]
<log>			{
<log>				Attributes =
<log>				[table]
<log>				{
<log>				}
<log>				Name="EntityList"
<log>				ChildNodes =
<log>				[table]
<log>				{
<log>					1 =
<log>					[table]
<log>					{
<log>						Value="innerText"
<log>						Attributes =
<log>						[table]
<log>						{
<log>							value="1"2"3"
<log>						}
<log>						Name="Entity"
<log>						ChildNodes =
<log>						[table]
<log>						{
<log>						}
<log>					}
<log>					2 =
<log>					[table]
<log>					{
<log>						Attributes =
<log>						[table]
<log>						{
<log>							value="456"
<log>						}
<log>						Name="Entity"
<log>						ChildNodes =
<log>						[table]
<log>						{
<log>						}
<log>					}
<log>				}
<log>			}
<log>		}
<log>	}