lua工具库penlight--06数据（二）

词法扫描

虽然 Lua 的字符串模式匹配是非常强大，但需要更强大的东西。pl.lexer.scan可以提供标记字符串，按标记机分类数字、字符串等。

> lua -lpl

Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio

> tok = lexer.scan 'alpha = sin(1.5)'

> = tok()

iden    alpha

> = tok()

=       =

> = tok()

iden    sin

> = tok()

(       (

> = tok()

number  1.5

> = tok()

)       )

> = tok()

(nil)

scanner是一个函数，它会反复被调用并返回标记的类型和值。基本类型有'iden'、 'string'、 'number' 和 'space' ，一切都由基本类型识别。请注意默认情况下扫描程序将跳过任何’space’（空白）标记。

'comment'（注释） 和 'keyword' （关键字）并不是适用于简单的scanner，对所有语言一样，但了解 Lua 的scanner可以。它承认了 Lua 的关键字，并了解短和长注释和字符串。

> for t,v in lexer.lua 'for i=1,n do' do print(t,v) end

keyword for

iden    i

=       =

number  1

,       ,

iden    n

keyword do

词法扫描器会很有用，当没有高度结构化的数据。例如，这里是我维护一个内部文件格式的片段：

points

(818344.1,-20389.7,-0.1),(818337.9,-20389.3,-0.1),(818332.5,-20387.8,-0.1)

,(818327.4,–20388,–0.1),(818322,–20387.7,–0.1),(818316.3,–20388.6,–0.1)

,(818309.7,–20389.4,–0.1),(818303.5,–20390.6,–0.1),(818295.8,–20388.3,–0.1)

,(818290.5,–20386.9,–0.1),(818285.2,–20386.1,–0.1),(818279.3,–20383.6,–0.1)

,(818274,–20381.2,–0.1),(818274,–20380.7,–0.1);

这是用pl.lexer提取点 :

-- assume 's' contains the text above...

local lexer = require 'pl.lexer'

local expecting = lexer.expecting

local append = table.insert

local tok = lexer.scan(s)

local points = {}

local t,v = tok() -- should be 'iden','points'

while t ~= ';' do

c = {}

expecting(tok,'(')

c.x = expecting(tok,'number')

expecting(tok,',')

c.y = expecting(tok,'number')

expecting(tok,',')

c.z = expecting(tok,'number')

expecting(tok,')')

t,v = tok()  -- either ',' or ';'

append(points,c)

end

expecting函数抓取下一个标记，如果类型不匹配，则会引发一个错误。（pl.lexer ，不同于其他 PL库，如果出了什么差错将引发错误，所以你应该代码中用pcall优雅地捕获错误。)

所有scanner都有第二个可选参数，这是一个表，控制是否您想要排除空白和评论。Lexer.lua的默认值是{space=true,comments=true}。有第三个可选的参数如何处理字符串和数字标记。

高度结构化的数据当然是程序源代码。 ' text-lexer.lua'的一点片段：

require 'pl'

lines = [[

for k,v in pairs(t) do

if type(k) == 'number' then

print(v) -- array-like case

else

print(k,v)

end

end

]]

ls = List()

for tp,val in lexer.lua(lines,{space=true,comments=true}) do

assert(tp ~= 'space' and tp ~= 'comment')

if tp == 'keyword' then ls:append(val) end

end

test.asserteq(ls,List{'for','in','do','if','then','else','end','end'})

这里是一个有用的小工具，用于标识在 lua 模块 （暂时忽略那些局部声明） 中找到的所有常见全局变量：

-- testglobal.lua

require 'pl'

local txt,err = utils.readfile(arg[1])

if not txt then return print(err) end

local globals = List()

for t,v in lexer.lua(txt) do

if t == 'iden' and _G[v] then

globals:append(v)

end

end

pretty.dump(seq.count_map(globals))

与其dump整个列表，我们把它传入seq.count_map转换为键值对，并且关联的值的表示这些值会出现在序列中的次数。典型输出如下所示：

{

type = 2,

pairs = 2,

table = 2,

print = 3,

tostring = 2,

require = 1,

ipairs = 4

}

您可以进一步通过这tablex.keys以获取唯一的符号列表。当编写 '严格'的 Lua 模块时，所有全局符号都必须在文件的顶部定义为local。

lexer.scan的更多详细使用，请看示例目录中testxml.lua。

XML

新的 0.9.7 版本是 支持一些 XML的。这是一个大的话题，和Penlight不提供一个完整的 XML 堆栈，这是更专门库的任务。

解析和好的打印

Lua 中的半标准 XML 分析器是lua-expat。尤其是，它有lxp.lom.parse函数可以解析 XML成 Lua 对象模型 （LOM）。然而，它不提供将此数据转换回为 XML 文本的方法。如果 lua-expat可用xml.parse将使用这个函数，否则为切换回原来 Roberto Ierusalimschy 写的纯 Lua 分析器。

生成的文档对象知道如何以字符串呈现，这对于调试非常有用：

> d = xml.parse "<nodes><node id='1'>alice</node></nodes>"

> = d

<nodes><node id='1'>alice</node></nodes>

> pretty.dump (d)

{

{

"alice",

attr = {

"id",

id = "1"

},

tag = "node"

},

attr = {

},

tag = "nodes"

}

数据的实际形状揭示了 LOM 的结构：

每个元素都具有其名称的tag字段

attr字段包含属性字段，并是数组。

元素的子级在元素数组里，所以d[1]是d的第一个孩子。

可以认为，具有属性作为数组的attr部分不是必不可少的 （你不能依赖 XML 中的属性顺序），但这与标准一致。

lua-expat是Penlight 的另一个软依赖项；一般来说，回退分析器对于简单 XML配置文件是是好足够的。doc.basic_parse不打算成为强大的符合分析器 （它只有六十行），但它可以处理简单没有的注释或 DTD 的指令的文档。它有足够的智力，忽略<?xml指令，仅此而已。

你可以得到好的打印效果，通过显式调用xml.tostring并传递给它的初始缩进和每个元素缩进：

> = xml.tostring(d,'','  ')

<nodes>

<node id='1'>alice</node>

</nodes>

第四个参数是属性缩进:

> a = xml.parse "<frodo name='baggins' age='50' type='hobbit'/>"

> = xml.tostring(a,'','  ','  ')

<frodo

type='hobbit'

name='baggins'

age='50'

/>

分析和使用配置文件

现在用XML作配置很常见。处理LOM数据和按你的想要的格式提取数据，非常简单 ：

require 'pl'

local config = [[

<config>

<alpha>1.3</alpha>

<beta>10</beta>

<name>bozo</name>

</config>

]]

local d,err = xml.parse(config)

local t = {}

for item in d:childtags() do

t[item.tag] = item[1]

end

pretty.dump(t)

--->

{

beta = "10",

alpha = "1.3",

name = "bozo"

}

唯一的地方是，在这里我们必须使用的Doc:childtags方法，它可以跳过任何文本元素。

本文摘录自serviceproviders.xml，它通常被发现位于Debian/Ubuntu Linux 系统/usr/share/mobile-broadband-provider-info/serviceproviders.xml。

d = xml.parse [[

<serviceproviders format="2.0">

...

<country code="za">

<provider>

<name>Cell-c</name>

<gsm>

<network-id mcc="655" mnc="07"/>

<apn value="internet">

<username>Cellcis</username>

<dns>196.7.0.138</dns>

<dns>196.7.142.132</dns>

</apn>

</gsm>

</provider>

<provider>

<name>MTN</name>

<gsm>

<network-id mcc="655" mnc="10"/>

<apn value="internet">

<dns>196.11.240.241</dns>

<dns>209.212.97.1</dns>

</apn>

</gsm>

</provider>

<provider>

<name>Vodacom</name>

<gsm>

<network-id mcc="655" mnc="01"/>

<apn value="internet">

<dns>196.207.40.165</dns>

<dns>196.43.46.190</dns>

</apn>

<apn value="unrestricted">

<name>Unrestricted</name>

<dns>196.207.32.69</dns>

<dns>196.43.45.190</dns>

</apn>

</gsm>

</provider>

<provider>

<name>Virgin Mobile</name>

<gsm>

<apn value="vdata">

<dns>196.7.0.138</dns>

<dns>196.7.142.132</dns>

</apn>

</gsm>

</provider>

</country>

....

</serviceproviders>

]]

得到每个国家的供应商的名称非常简单：

local t = {}

for country in d:childtags() do

local providers = {}

t[country.attr.code] = providers

for provider in country:childtags() do

table.insert(providers,provider:child_with_name('name'):get_text())

end

end

pretty.dump(t)

-->

{

za = {

"Cell-c",

"MTN",

"Vodacom",

"Virgin Mobile"

}

....

}

使用'Xmlification' 生成 XML

此功能的灵感来自Oribt的htmlify简化 HTML 生成，只是没有环境函数 ；tags函数返回一组给定标记名称的元素构造器。

> nodes, node = xml.tags 'nodes, node'

> = node 'alice'

<node>alice</node>

> = nodes { node {id='1','alice'}}

<nodes><node id='1'>alice</node></nodes>

Lua 表的灵活性会非常有用，因此可以自然地编码的属性和元素的子级。这些标记的构造函数的参数是单个值 （如字符串） 或表，这个表的属性是命名的键和孩子们的数组值。

使用模板生成 XML

模板是一个小的XML 文档，其中包含”$”变量。subst方法可以产生包含这些变量值的数组。请。注意指定父标记名称的方式：

> templ = xml.parse "<node id='$id'>$name</node>"

> = templ:subst {tag='nodes', {id=1,name='alice'},{id=2,name='john'}}

<nodes><node id='1'>alice</node><node id='2'>john</node></nodes>

替代是和过滤文件相关。有关 XML 的令人讨厌的事情有，一是它是一种文档标记语言，二是它是数据语言。标准的解析器将假定你真的关心所有这些额外的文本元素。请考虑此片段，已经一个五岁孩子改变了：

T = [[

<weather>

boops!

<current_conditions>

<condition data='$condition'/>

<temp_c data='$temp'/>

<bo>whoops!</bo>

</current_conditions>

</weather>

]]

标准解析器会在<current_conditions>后文本元素，虽然它使处理数据更令人恼火。

local function parse (str)

return xml.parse(str,false,true)

end

第二个参数是指 字符串，而非文件，第三个参数表示使用 Lua 内置解析器 （而不是 LuaExpat ，如果可用），默认情况下保持字符串不感兴趣。

如何删除字符串boops!?  clone（作为一种方法调用时也称为filter） 可以复制LOM 的文档。它可以传入一个filter函数，作用到每个找到的字符串。这个函数的强大之处在于接收结构信息 — 父节点，无论是否是一个标记名称，一个文本元素或属性的名称：

d = parse (T)

c = d:filter(function(s,kind,parent)

print(stringx.strip(s),kind,parent and parent.tag or '?')

if kind == '*TEXT' and #parent > 1 then return nil end

return s

end)

--->

weather    *TAG    ?

boops!    *TEXT    weather

current_conditions    *TAG    weather

condition    *TAG    current_conditions

$condition    data    condition

temp_c    *TAG    current_conditions

$temp    data    temp_c

bo    *TAG    current_conditions

whoops!    *TEXT    bo

通过丢弃不是单一元素子元素的文本元素，我们可以把拉出来 'boops' 而不是 'whoops' 。

使用模板提取数据

匹配在相反的方向。我们有一份文件，并想使用模式从中提取值。

这样的一个常见用途是分析 API 查询的 XML 结果。谷歌天气 API是一个很好的例子。使用pretty-print打印抓取的结果http://www.google.com/ig/api?weather=Johannesburg,ZA"如下：

<xml_api_reply version='1'>

mobile_row = '0' >

<forecast_information>

<city data=‘Johannesburg, Gauteng’/>

<postal_code data=‘Johannesburg,ZA’/>

<latitude_e6 data=‘’/>

<longitude_e6 data=‘’/>

<forecast_date data=‘2010-10-02’/>

<current_date_time data=‘2010-10-02 18:30:00 +0000’/>

<unit_system data=‘US’/>

</forecast_information>

<current_conditions>

<condition data=‘Clear’/>

<temp_f data=‘75’/>

<temp_c data=‘24’/>

<humidity data=‘Humidity: 19%’/>

<icon data=‘/ig/images/weather/sunny.gif’/>

<wind_condition data=‘Wind: NW at 7 mph’/>

</current_conditions>

<forecast_conditions>

<day_of_week data=‘Sat’/>

<low data=‘60’/>

<high data=‘89’/>

<icon data=‘/ig/images/weather/sunny.gif’/>

<condition data=‘Clear’/>

</forecast_conditions>

….

</weather>

ml_api_reply>

假设上述 XML 已从google被读取。这个想法写一个模板，并使用它来提取一些感兴趣的值：

t = [[

<weather>

<current_conditions>

<condition data='$condition'/>

<temp_c data='$temp'/>

</current_conditions>

</weather>

]]

local res, ret = google:match(t)

pretty.dump(res)

的输出是：

{

condition = "Clear",

temp = "24"

}

match方法可以传入一个LOM文档或一些文本，可以进行文本分析。

但是如果我们需要从重复元素中提取值呢？匹配模板可能包含 '数组匹配' ，用'{{}.}' 括住：

<weather>

{{<forecast_conditions>

<day_of_week data='$day'/>

<low data='$low'/>

<high data='$high'/>

<condition data='$condition'/>

</forecast_conditions>}}

</weather>

匹配结果是：

{

{

low = "60",

high = "89",

day = "Sat",

condition = "Clear",

},

{

low = "53",

high = "86",

day = "Sun",

condition = "Clear",

},

{

low = "57",

high = "87",

day = "Mon",

condition = "Clear",

},

{

low = "60",

high = "84",

day = "Tue",

condition = "Clear",

}

}

这一系列的表，您可以使用tablex或List重新塑造成所需的格式。和读取 Unix 密码文件与配置类似，您可以进行数组到的天气图到使用条件：

tablex.pairmap ('|k,v| v,v.day',conditions)

（在这里使用替代字符串 lambda）

但是，xml 匹配可以塑造输出结构。通过替换模板的day_of_week行<day_of_week data=‘$’/> 我们得到同样的效果 ；$是一个特殊的符号，意味着它捕获的值 （或只是捕获） 成为key。

请注意$NUMBER是指一个数值索引，这样， $1是生成的数组，等等的第一个元素。您可以混合使用编号和命名捕获，但它已强烈建议使编号的捕获形成适当的数组序列 （从1到n包容一切)。$0有特殊的含义 ；如果它是唯一的捕获 ({[0]=‘foo’}） 表可以折叠为 foo。

<weather>

{{<forecast_conditions>

<day_of_week data='$_'/>

<low data='$1'/>

<high data='$2'/>

<condition data='$3'/>

</forecast_conditions>}}

</weather>

现在的结果是：

{

Tue = {

"60",

"84",

"Clear"

},

Sun = {

"53",

"86",

"Clear"

},

Sat = {

"60",

"89",

"Clear"

},

Mon = {

"57",

"87",

"Clear"

}

}

将匹配应用到此配置文件会带来另一个问题，因为实际标记匹配本身有意义。

<config>

<alpha>1.3</alpha>

<beta>10</beta>

<name>bozo</name>

</config>

标记 '通配符' 的元素名称用连字符结束。

<config>

{{<key->$value</key->}}

</config>

你就会找到{{alpha=‘1.3’},…}。将由这返回的最方便的格式 （请注意， –的行为就像$):

<config>

{{<_->$0</_->}}

</config>

这会返回{alpha=‘1.3’,beta=‘10’,name=‘bozo’}.

我们可以无止境地，玩这种游戏和编码方式的转换的捕获。但该模式足够复杂，不过很容易地进行转换。

local numbers = {alpha=true,beta=true}

for k,v in pairs(res) do

if numbers[v] then res[k] = tonumber(v) end

end

HTML 分析

HTML 是一种异常地退化形式的 XML，Dennis Schridde 贡献的一个功能，可以更轻松解析它。例如：

doc = xml.parsehtml [[

<BODY>

Hello dolly<br>

HTML is <b>slack</b><br>

</BODY>

]]

asserteq(xml.tostring(doc),[[

<body>

Hello dolly<br/>

HTML is <b>slack</b><br/></body>]])

也就是说，所有的标记都转换为小写字母，空的 HTML 元素如br已正确关闭 ；不需要被引用属性。

此外，DOCTYPE 指令和注释被跳过。对于真正格式不好的 HTML，这不是你的工具 ！