深入探究Lua中的解析表达式

 使用一个模式

这个例子显示了一个建立和使用模式的程序,它非常简单但很完整:

代码如下:

local lpeg = require "lpeg"

-- matches a word followed by end-of-string
p = lpeg.R"az"^1 * -1

print(p:match("hello"))        --> 6
print(lpeg.match(p, "hello"))  --> 6
print(p:match("1 hello"))      --> nil

模式是简单的一个或多个小写字符并在尾端以(-1)结束的序列。该程序调用match来当作一个方法和函数。在以上成功案例,匹配函数返回成功 匹配的第一个字符的索引,为其字符串长度加1。

代码如下:

Name-value lists

这个例子解析一个名称 - 值配对的列表,并返回那些配对的表:

代码如下:

lpeg.locale(lpeg)   -- adds locale entries into 'lpeg' table

local space = lpeg.space^0
local name = lpeg.C(lpeg.alpha^1) * space
local sep = lpeg.S(",;") * space
local pair = lpeg.Cg(name * "=" * space * name) * sep^-1
local list = lpeg.Cf(lpeg.Ct("") * pair^0, rawset)
t = list:match("a=b, c = hi; next = pi")  --> { a = "b", c = "hi", next = "pi" }

每一配对都有  formatname =namefollowed 的一个可选的分离器(用逗号或分号)。  配对模式(Thepairpattern)在一个组模式里形成闭包,那么那些名称就可以成为单个捕获的值。 列表模式 (Thelistpattern)然后折叠这些捕获。 它以空列表开始,通过创建列表捕获匹配一个空字符串,然后为每个捕获(一名称对)appliesrawsetover累加器(表)和捕捉值(对名称)。rawsetreturns((未初始化的集合)返回表本身,所以累加器总是表中执行。

以下代码创建了一个模式,该模式使用给定的分隔模式sep作为分隔器来来拆分字符串:

代码如下:

function split (s, sep)
  sep = lpeg.P(sep)
  local elem = lpeg.C((1 - sep)^0)
  local p = elem * (sep * elem)^0
  return lpeg.match(p, s)
end

首先,该函数确保sep一个合适的模式。只要没有匹配分隔器,该模式的elem 是重复的零个或多个任意字符。它还捕捉其匹配值。模式p匹配由sep拆分的一组元素.

如果拆分产生的结果值太多,可能会溢出由一个Lua函数返回的最大数目的值。在这种情况下,我们可以将这些值放到一个表中:

代码如下:

function split (s, sep)
  sep = lpeg.P(sep)
  local elem = lpeg.C((1 - sep)^0)
  local p = lpeg.Ct(elem * (sep * elem)^0)   -- make a table capture
  return lpeg.match(p, s)
end

模式搜索

基本的匹配仅仅工作在锚定模式下。如果我们打算查找匹配字符串中任何地方的模式,那么我们必须写一个匹配任何地方的模式。

因为模式是可以编写的,所以我们可以编写一个函数,它给定一个任意的模式p,返回一个搜索p的新模式,以匹配字符串的任何位置。执行这种搜索有几种方法。一种方法如下:

代码如下:

function anywhere (p)
  return lpeg.P{ p + 1 * lpeg.V(1) }
end

这个语法的直接解读:匹配p或者跳过一个字符,然后试图再次匹配。

如果我们想知道这个模式在字符串的所有匹配位置(而不仅仅知道它在字符串的某个位置),那么我们可以给这个模式添加位置捕捉:

代码如下:

local I = lpeg.Cp()
function anywhere (p)
  return lpeg.P{ I * p * I + 1 * lpeg.V(1) }
end

print(anywhere("world"):match("hello world!"))   -> 7   12

这种搜索的另一个方法如下:

代码如下:

local I = lpeg.Cp()
function anywhere (p)
  return (1 - lpeg.P(p))^0 * I * p * I
end

再次说明,这个模式的直接解读:当不匹配p时,它跳过尽可能多的字符,然后对p进行匹配(外加正确的位置捕捉)。

如果我们打算查找仅仅匹配单词边界的模式的话,那么我们可以使用以下转换:

代码如下:

local t = lpeg.locale()

function atwordboundary (p)
  return lpeg.P{
    [1] = p + t.alpha^0 * (1 - t.alpha)^1 * lpeg.V(1)
  }
end

平衡的括号

以下模式只匹配带有平衡括号的字符串::

代码如下:

b = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }

阅读第一个(也是唯一的)所给语法规则,所谓平衡字符串,就是一个开括号,后跟零个或多个非括号字符或者平衡字符串(LPFG.V(1)),最后跟着与开括号能够闭合的结束括号。
全局替换

下面的例子和tostring.gsub所做工作类似。它接收一个母串和一个模式以及一个替换值,然后替代所传入的母串中所有与指定模式匹配的子串为指定的替换值::

代码如下:

function gsub (s, patt, repl)
  patt = lpeg.P(patt)
  patt = lpeg.Cs((patt / repl + 1)^0)
  return lpeg.match(patt, s)
end

作为instring.gsub,替换值可以是一个字串、函数,或者一个表.

逗号分隔值(CSV)

下面的例子将字符串转换成逗号分隔的值,并返回所有的字段:

代码如下:

local field = '"' * lpeg.Cs(((lpeg.P(1) - '"') + lpeg.P'""' / '"')^0) * '"' +
                    lpeg.C((1 - lpeg.S',\n"')^0)

local record = field * (',' * field)^0 * (lpeg.P'\n' + -1)

function csv (s)
  return lpeg.match(record, s)
end

一个字段或是一个引用的字段(一族可能包含任何字符除单引号,或双引号)或是一个未被引用的字段(不包含逗号,换行符或引号)。一个记录就是一个用逗号分隔的字段列表(以换行符或以字符串结尾)。

就像这样,前面的匹配返回的每个字段都是独立返回的。若我们添加一个列表截取定义的记录。返回的将不再是一个独立的包含所有字段的列表。

代码如下:

local record = lpeg.Ct(field * (',' * field)^0) * (lpeg.P'\n' + -1)

UTF-8 和 Latin 1

使用LPeg来将一字符串从UTF-8编码转换成Latin 1(ISO 88590-1),这并不困难:

代码如下:

-- convert a two-byte UTF-8 sequence to a Latin 1 character
local function f2 (s)
  local c1, c2 = string.byte(s, 1, 2)
  return string.char(c1 * 64 + c2 - 12416)
end

local utf8 = lpeg.R("\0\127")
           + lpeg.R("\194\195") * lpeg.R("\128\191") / f2

local decode_pattern = lpeg.Cs(utf8^0) * -1

这些代码中,UTF-8定义已经为Latin 1的编码范围(从0到255)。所有不在该范围内的编码(以及任何无效的编码)将不匹配该模式。

正如decode_pattern所要求的,这个模式匹配所有的输入(因为-1在它的结尾处),任何无效字符串会匹配失败,而无任何关于此问题的有用信息。我们可以通过重定义如下decode_pattern来改善这种情况:

代码如下:

local function er (_, i) error("invalid encoding at position " .. i) end

local decode_pattern = lpeg.Cs(utf8^0) * (-1 + lpeg.P(er))

现在,如果模式utf8^0  在字符串尾部之前停止,会调用一个适用的出错函数。

UTF-8 和 Unicode

我们可以扩展以前的模式来处理所有的Unicdoe代码片段,当然, 我们不能把它们翻译阿拉伯数字1或其他任何一个字节编码。相反,我们的翻译序列结果中的数字表示的代码片段。这里完整的代码:

代码如下:

-- decode a two-byte UTF-8 sequence
local function f2 (s)
  local c1, c2 = string.byte(s, 1, 2)
  return c1 * 64 + c2 - 12416
end
 
-- decode a three-byte UTF-8 sequence
local function f3 (s)
  local c1, c2, c3 = string.byte(s, 1, 3)
  return (c1 * 64 + c2) * 64 + c3 - 925824
end
 
-- decode a four-byte UTF-8 sequence
local function f4 (s)
  local c1, c2, c3, c4 = string.byte(s, 1, 4)
  return ((c1 * 64 + c2) * 64 + c3) * 64 + c4 - 63447168
end
 
local cont = lpeg.R("\128\191")   -- continuation byte
 
local utf8 = lpeg.R("\0\127") / string.byte
           + lpeg.R("\194\223") * cont / f2

-- decode a two-byte UTF-8 sequence
local function f2 (s)
  local c1, c2 = string.byte(s, 1, 2)
  return c1 * 64 + c2 - 12416
end
 
-- decode a three-byte UTF-8 sequence
local function f3 (s)
  local c1, c2, c3 = string.byte(s, 1, 3)
  return (c1 * 64 + c2) * 64 + c3 - 925824
end
 
-- decode a four-byte UTF-8 sequence
local function f4 (s)
  local c1, c2, c3, c4 = string.byte(s, 1, 4)
  return ((c1 * 64 + c2) * 64 + c3) * 64 + c4 - 63447168
end
 
local cont = lpeg.R("\128\191")   -- continuation byte
 
local utf8 = lpeg.R("\0\127") / string.byte
           + lpeg.R("\194\223") * cont / f2

Lua的长字符串

Lua中的长字符串由模式 [= *[ 开始,到第一次出现的带有完全相同数量的等号的 ] =*] 结束。如果开括号后跟一个换行符,换行符将被丢弃(即,不会把它当作字符串的一部分)。

在Lua中想要匹配一个长字符串,模式必须捕捉第一次重复的等号,然后,只需找到有关闭字符串的候选项,检查其是否具有相同数量的等号。

代码如下:

equals = lpeg.P"="^0
open = "[" * lpeg.Cg(equals, "init") * "[" * lpeg.P"\n"^-1
close = "]" * lpeg.C(equals) * "]"
closeeq = lpeg.Cmt(close * lpeg.Cb("init"), function (s, i, a, b) return a == b end)
string = open * lpeg.C((lpeg.P(1) - closeeq)^0) * close / 1

open 模式匹配 [=*[,在一个名为 init 的组中捕获重复的等号;它也会丢弃一个可选的换行符(如果它存在的话)。close 模式匹配 ]= *],也是捕捉重复的等号。closeeq模式首先匹配 close,然后它采用逆向捕捉来恢复先前由 open 捕捉并命名为 init 的内容,最后,用 match-time 捕捉来检查两个捕获是否相同。字符串模式从 open 开始之后,它会一直包含到匹配了 closeeq 为止,然后匹配最终的 close。最后的数字捕获简单地丢弃由 close 产生的捕获。

算术表达式

本例对简单的算术表达式进行完整的解析和求值。而且我们用两种风格来书写。

第一种途径首先建立一个语法树,然后遍历这棵树来计算表达式的值:

代码如下:

-- 词典元素
[code]local Space = lpeg.S(" \n\t")^0
local Number = lpeg.C(lpeg.P"-"^-1 * lpeg.R("09")^1) * Space
local TermOp = lpeg.C(lpeg.S("+-")) * Space
local FactorOp = lpeg.C(lpeg.S("*/")) * Space
local Open = "(" * Space
local Close = ")" * Space

-- 语法
local Exp, Term, Factor = lpeg.V"Exp", lpeg.V"Term", lpeg.V"Factor"
G = lpeg.P{ Exp,
  Exp = lpeg.Ct(Term * (TermOp * Term)^0);
  Term = lpeg.Ct(Factor * (FactorOp * Factor)^0);
  Factor = Number + Open * Exp * Close;
}

G = Space * G * -1

-- 求值器
function eval (x)
  if type(x) == "string" then
    return tonumber(x)
  else
    local op1 = eval(x[1])
    for i = 2, #x, 2 do
      local op = x[i]
      local op2 = eval(x[i + 1])
      if (op == "+") then op1 = op1 + op2
      elseif (op == "-") then op1 = op1 - op2
      elseif (op == "*") then op1 = op1 * op2
      elseif (op == "/") then op1 = op1 / op2
      end
    end
    return op1
  end
end

-- 解析/求值
function evalExp (s)
  local t = lpeg.match(G, s)
  if not t then error("syntax error", 2) end
  return eval(t)
end

-- 使用例子
print(evalExp"3 + 5*9 / (1+1) - 12")   --> 13.5

第二种风格不用建立语法树,直接求值。下面代码就按此种途径(假定和上面有相同的词典元素):

代码如下:

-- 辅助函数
function eval (v1, op, v2)
  if (op == "+") then return v1 + v2
  elseif (op == "-") then return v1 - v2
  elseif (op == "*") then return v1 * v2
  elseif (op == "/") then return v1 / v2
  end
end

-- 语法
local V = lpeg.V
G = lpeg.P{ "Exp",
  Exp = lpeg.Cf(V"Term" * lpeg.Cg(TermOp * V"Term")^0, eval);
  Term = lpeg.Cf(V"Factor" * lpeg.Cg(FactorOp * V"Factor")^0, eval);
  Factor = Number / tonumber + Open * V"Exp" * Close;
}

-- 使用例子
print(lpeg.match(G, "3 + 5*9 / (1+1) - 12"))   --> 13.5

注意 fold (收集器) 捕获的用法。 要计算一个表达式的值,收集器从第一个术语的值开始,为每个副本应用进化收集器,操作符,和新术语。

(0)

相关推荐

  • Lua学习笔记之运算符和表达式

    本篇博客学习一下Lua的运算符,比较简单,我将说明直接写到了代码中,代码如下. --算术运算符 --二元运算符:+ - * / ^ (加减乘除幂) --一元运算符:- (负值) --这些运算符的操作数都是实数,Lua中没有自增自减的运算符. --关系运算符 -- < > <= >= == ~= --这里需要注意的是不等于是用~=表示的 --这些操作符返回结果为false或者true:==和~=比较两个值,如果两个值类型不同,Lua认为两者不同: --nil只和自己相等.Lua通过引

  • 实现Lua中数据类型的源码分享

    概述 在Lua中有8种基础类型:nil.boolean.number.string.userdata.function.thread和table.可以使用函数type查看某个变量或值的类型,返回相应的类型名称.像其他动态语言一样,在语言中没有类型定义的语法,每个值都携带了它自身的类型信息.下面将通过Lua 5.2.1的源码来看类型的实现.    源码实现 Lua将值表示成带标志的联合结构,代码如下(lobject.h): 90 /* 91 ** Union of all Lua values 9

  • Lua基础教程之赋值语句、表达式、流程控制、函数学习笔记

    赋值语句 注释,单行用(--)来表示:多行用(--[[ ... ]])来标示: 定义,lua中没有定义(申明数据类型),它是通过赋值来确定其数据类型的. 赋值,是改变一个变量的值和改变表域的最基本的方法. a = "hello" .. "world" Lua可以对多个变量同时赋值,变量列表和值列表的各个元素用逗号分开,赋值语句右边的值会依次赋给左边的变量.a, b = 10, 2*x <--> a=10; b=2*x 遇到赋值语句Lua会先计算右边所有的

  • 详解Lua中的数据类型

    Lua是动态类型语言,所以变量没有类型,仅值有类型.值可以被存储在变量中,作为参数传递,并作为结果返回. 在Lua中虽然我们没有变量的数据类型,但我们有类型的值.用于数值数据类型的列表在下面给出.  函数类型 在Lua中有一个叫做函数类型,使我们能够知道变量的类型.如下一些例子给出了下面的代码. 复制代码 代码如下: print(type("What is my type"))   --> string t=10 print(type(5.8*t))              

  • Lua表达式和控制结构学习笔记

    算术操作符 Lua 的算术操作符有: "+"(加法): 复制代码 代码如下: print(1 + 2) "-"(减法): 复制代码 代码如下: print(2 - 1) "*"(乘法): 复制代码 代码如下: print(1 * 2) "/"(除法): 复制代码 代码如下: print(1 / 2) "^"(指数): 复制代码 代码如下: print(27^(-1/3)) "%"(取模)

  • Lua学习笔记之数据类型

    从本篇博客开始研究一下Lua,现在的Lua真得是很火,因为Cocos2d-x写游戏的时候会用到,所以就拿过来学学吧,先从基础的语法开始,然后慢慢的深入.本人也是刚刚学习,希望和学习Lua的大家交流,博客权当笔记,有错误之处还请赐教. 当然首先是开发环境了,我的学习背景是Cocos2d-x,所以下载了最近发布的Cocos Code IDE版本,我们可以在Cocos Code IDE上边新建工程,然后写Lua测试代码,关于Cocos Code IDE的使用官方有不少的教程,这里就不说了.当然你也可以

  • Lua中的操作符和表达式总结

    前言 这里总结的内容和其它语言的基本类似,所以这里就只是基本的进行总结.不做详细的讲解. 算术操作符 Lua支持常规的算术操作符有:"+"(加法),"-"(减法),"*"(乘法),"/"(除法),"^"(指数),"%"(取模),一元的"-"(负号).所有的这些操作符都用于实数.例如:x^0.5将计算x的平方根,x^3将计算x的3次方. 关系操作符 Lua提供的关系操作

  • Lua学习笔记之表达式

    前言 这里总结的内容和其它语言的基本类似,所以这里就只是基本的进行总结.不做详细的讲解. 算术操作符 Lua支持常规的算术操作符有:"+"(加法),"-"(减法),"*"(乘法),"/"(除法),"^"(指数),"%"(取模),一元的"-"(负号).所有的这些操作符都用于实数.例如:x^0.5将计算x的平方根,x^3将计算x的3次方. 关系操作符 Lua提供的关系操作

  • Lua数据类型介绍

    Lua 是一个功能强大.快速.轻量的可嵌入式脚本语言,由标准的 ANSI C 实现,由于拥有一组精简的强大特性,以及容易使用的 C API,这使得它可以很容易嵌入或扩展到其他语言中使用,并且有个非官方认领的中文名 -- "撸啊". 安装 Lua Lua 安装很简单,把源码下载下来后,直接 make 就行: 复制代码 代码如下: wget http://www.lua.org/ftp/lua-5.2.2.tar.gz tar -zxvf lua-5.2.2.tar.gz cd lua-5

  • Lua中基本的数据类型、表达式与流程控制语句讲解

    1. Lua类型 1.1 基本类型 Lua是一种动态类型语言,没有类型定义的语法.Lua一共有8种基础类型:nil(空).boolean(布尔).number(数字).string(字符串).userdata(自定义类型).function(函数).thread(线程).table(表). 函数type可根据一个值返回其类型名称(字符串),如print(type(print)),输出"function":print(type(type(X))) ,输出"string"

  • Lua教程(三):表达式和语句

    一.表达式: 1. 算术操作符:     Lua支持常规算术操作符有:二元的"+"."-"."*"."/"."^"(指数)."%"(取模),一元的"-"(负号).所有这些操作符都可用于实数.然而需要特别说明的是取模操作符(%),Lua中对该操作符的定义为:   复制代码 代码如下: a % b == a - floor(a / b) * b 由此可以推演出x % 1的

  • Lua中的基本数据类型详细介绍

    基础介绍 Lua是一种动态类型的语言.在语言中没有类型定义的语法,每个值都带有其自身的类型信息.在Lua中有8中基本类型,分别是: 1.nil(空)类型 2.boolean(布尔)类型 3.number(数字)类型 4.string(字符串)类型 5.userdata(自定义类型) 6.function(函数)类型 7.thread(线程)类型 8.table(表)类型 以上是Lua中的8中基本类型,我们可以使用type函数,判断一个值得类型,type函数返回一个对应类型的字符串描述.例如: 复

  • Lua判断数据类型的方法

    一.判断数据类型的方法 type(xxxx) 这个函数的返回值是string类型   也就是说: 复制代码 代码如下: a = type(X)   -- a="nil" b = type(a)   -- b="string" a = type(nil) -- a="nil" 二.Lua脚本语言的8种基本数据类型 1.数值(number):内部以double表示. 2.字符串(string):总是以零结尾,但可以包含任意字符(包括零),因此并不等价

随机推荐