Lua Xml

wiki

• 工具組
• 僅限 Lua 的 XML 解析器
• 包含 C 程式碼和繫結的 XML 解析器
• 處理 XML-based 協定的模組，例如 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 所寫的 [Lua 4 的 LuaXML]。

此模組實作不驗證的 XML 串流解析器，具有基於事件 API 的處理常式 (概念上類似於 SAX)，可依需要用來後處理事件資料 (例如轉換成樹狀結構)。

現有的功能如下 -

• 將格式良好的 XML 標記化 (相當穩健)
• 基於事件處理常式的處理常式 (
• 解析/產生所有 XML 元素的事件，例如
  • 標籤
  • 文字
  • 註解
  • CDATA
  • XML 宣告
  • 處理指令
  • DOCTYPE 宣告
• 提供有限的格式良好性檢查 (僅檢查基本語法和平衡標籤)
• 彈性 whitespace 處理 (可選擇)
• 實體處理 (可選擇)

限制如下 -

• 不驗證
• 不處理字元集
• 不支援命名空間
• 僅進行淺層的格式良好性檢查 (偵測不到大多數語意錯誤)

此發行版本還包含範例事件處理常式，用於將 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 的傳統版本

來自：羅伯托‧伊魯撒林斯基

我有這個解析 XML 字串「主要」部分的基本架構（它不處理像「<?」和「<!」的元資料）。——羅伯托

[!] 版本須知：下列程式碼屬於較舊的 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

來自：Eckhart Koeppen

嗯，我編寫了一些程式對你有幫助，稱為 Kino XML 處理器。它透過 SWIG 為 Tcl 和 Lua 提供了封裝程式。它還提供了用於顯示具有 CSS 的 XML 的 Qt 和一個實驗性的 Gtk 小工具。在這裡查看一下：[2]（連結已失效）

它處於持續開發中，但會盡量遵循 DOM，因此我希望介面變動會很小。

libxml

[luagnome]（連結已失效，請使用 [3]）包含 libxml-1.8.x 的封裝程式，因為它被視為 Gnome 的一部分。它允許使用簡單的 api（物件導向）剖析和產生 XML 檔案。

[lua-xmlreader] 使用 libxml2 來實作 XmlReaderAPI。

Expat

對於 Lua 5.0/5.1，請使用功能齊全的 [LuaExpat]。

對於 Lua 4.0

來自：Jay Carlson

我已建立 expat 的一個簡單連結，James Clark 的 C 串流式 XML 剖析器在 [4]。不，並非一切都已連結，但如何將更多內容連結到它應該是顯而易見的。

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

來自：Robert Noll

使用 [TinyXML] (2.4.3) lib. 只是一個純文字「將檔案剖析成 lua 陣列」的 c++ 函式。

// 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-based protocols

XML-RPC

對於 Lua 5.0/5.1，請使用由 [The Kepler Project] 開發的 [LuaXMLRPC] 函式庫。

對於 Lua 4.0

來自：Jay Carlson

我已經在 [7] 為 XML-RPC 的 Lua 建立一個用戶端/伺服器連結的初始版本。它包含我的 lxp expat 連結，並使用 LuaSocket 作為用戶端傳輸。

有關 XML-RPC 的更多資訊，請參閱 [8]。

雖然包裝和文件很少，但此套件已成功通過 [9] 的驗證測試。

SOAP

[LuaSOAP] 是 Lua 函式庫，用於簡化 SOAP 的使用。

僅限 Lua XmlParser

適用於 Lua 5.1

作者：Alexander Makeev

此 XmlParser 可使用 XmlNodes? 產生類似 C# XmlDocument? 的物件。有關詳細資訊，請參閱範例。

-----------------------------------------------------------------------------------------
-- 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>	}