lua 语法校验 lua语法检查工具

词法扫描
虽然 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，这不是你的工具 ！