Treetop 入门

Treetop 是一个出奇简单的Ruby 写的解析器。我知道Treetop 是因为看到Nathan Sobo在RubyConf 2007上做的一个报告 。

第一步：安装Treetop

gem install treetop

第二步：新建一个叫arithmetic 的.treetop 文件

grammar Arithmetic rule additive multitive '+' additive / multitive end rule multitive primary '*' multitive / primary end rule primary '(' additive ')' / number end rule number [1-9] [0-9]* end end

第三步：测试一下

require 'treetop' Treetop.load "arithmetic" parser = ArithmeticParser.new if parser.parse('1+1') puts 'success' else puts 'failure' end

done!

语法结构：

grammar GrammarName rule rule_name ... end rule rule_name ... end ... end 

关键字grammar 定义一个新的语法。rule 定义这个语法的一条解析规则，rule 后面跟的名字可以被其他rule 引用。

每条rule 名都对应了一条解析规则。解析规则由终结符(Terminal Symbols)、非终结符(Nonterminal Symbols)和一些类似 正则表达式的特殊操作组成。终结符有：单引号或双引号括起来的字串、字符集、通配符(the anything symbol ".")。非终结符就是其他rules 的名字。前面提到的特殊操作包括：有序选择(Ordered Choice "/")、序列(Sequences)、出现次数("*+?")、前向断言(Lookahead Assertions "&!")。

其中有序选择是最不同于正则表达式的地方。有序选择可以看作一系列并列的rules （就像正则表达式中的"|"），不过匹配的时候是按从左至右的顺序，一旦匹配上就不再试探后面的规则。比如：

"foobar" / "foo" / "bar"

如果"foo" 在前，则"foobar" 永远不可能匹配上。

这是项很有用的技术，用它可以产生优先级。

光有语法还不足以解析表达式，还有配上语义解释。语义解释就是在识别语法单元的时候执行某些操作（比如：求值）。有两种方式为rule 添加动作。一种是在定义的时候嵌入方法。比如：

grammar Arithmetic rule number [1-9] [0-9]* { def eval text_value.to_i # text_value: The substring of the input represented by this node. end } end end 

当方法太长时，还可以像JSP 那样做个标签，在专门的.rb 文件中定义相应的动作。

grammar Arithmetic rule number [1-9] [0-9]* <NumberNode> end end # nodes.rb class NumberNode < Treetop::Runtime::SyntaxNode def eval() text_value.to_i end end 

介绍几个Treetop::Runtime::SyntaxNode 的方法：

• terminal?   当前结点是否由一个终结符产生？
• nonterminal?   当前结点是否由一个非终结符产生？
• text_value     返回一个String，当前结点所对应的输入子串。
• elements    只能用于非终结结点。返回一个Array，里面是已解析出来的SyntaxNode 对象。

Treetop 使用起来很方便 bla, bla, bla.

heist 的作者jcoglan 写了一个tini Scheme 解释器，还贡献了胶片和视频。

还记得Lisp 吗？Scheme 是Lisp 的一个变种。这已不是第一个Ruby 写的Lisp 解释器了。Phil Hagelberg 写过，James Coglan 写过，Jim Weirich 写过……

这么多人热衷于用Scheme 来练手就是因为它实在是太简单了。一对圆括号把一个操作符、一堆操作数括起来，像这样：(op arg1 arg2 ... argn) 这就是传说中的list。

请看下面Treetop 版的Lisp 语法。

lisp.treetop

grammar Lisp rule program cell* <Program> end rule cell space* (list / atom) space* <Cell> end rule list "(" cell* ")" <List> end rule atom datum / identifier end rule datum boolean / integer end rule boolean ("#t" / "#f") <Boolean> end rule integer ("0" / [1-9] [0-9]*) <Integer> end rule identifier (!delimiter .)+ <Identifier> end rule space [/s/n/r/t] end rule paren [/(/)/[/]] end rule delimiter paren / space end end 

你看懂了吗？我的理解是：Lisp 程序由若干cell 构成；cell 的前后有若干space，中间要么是list，要么是atom；list 是圆括号括起来的若干cell；atom 有两种，datum 和identifier；datum 要么是boolean，要么是整数；boolean 只有#t 和#f；identifier 是没有前导空格或前导括号的任意字串。

function.rb

class Function def initialize(scope, formals = [], body = nil, &block) @scope = scope @formals = formals.map { |f| f.to_s } @body = body || block end def call(scope, args) args = args.map { |a| a.eval(scope) } return @body.call(*args) if primitive? closure = Scope.new(@scope) @formals.each_with_index { |name, i| closure[name] = args[i] } @body.map { |expr| expr.eval(closure) }.last end def primitive? Proc === @body end end class Syntax < Function def call(scope, args) @body.call(scope, args) end end 

lisp.rb

module Lisp class Program < Treetop::Runtime::SyntaxNode def eval(scope) elements.map { |e| e.eval(scope) }.last end end class List < Treetop::Runtime::SyntaxNode def eval(scope) func = cells.first.eval(scope) args = cells[1..-1] func.call(scope, args) end def cells elements[1].elements.map { |c| c.data } end end class Cell < Treetop::Runtime::SyntaxNode def eval(scope); data.eval(scope); end def data; elements[1]; end end module Boolean def eval(scope); text_value == '#t'; end end module Integer def eval(scope); text_value.to_i; end end class Identifier < Treetop::Runtime::SyntaxNode def eval(scope); scope[text_value]; end end end 

scheme.rb

require 'rubygems' require 'treetop' Treetop.load File.dirname(__FILE__) + '/lisp.treetop' %w[lisp scope function].each { |path| require File.dirname(__FILE__) + '/' + path } module Scheme def self.run(path) tree = parse(File.read path) scope = TopLevel.new tree.eval(scope) end def self.parse(string) @parser ||= LispParser.new @parser.parse(string) end end 

scope.rb

class Scope def initialize(parent = nil) @parent = parent || {} @symbols = {} end def [](name) @symbols[name] || @parent[name] end def []=(name, value) @symbols[name] = value end def define(name, *args, &block) self[name] = Function.new(self, *args, &block) end def syntax(name, &block) self[name] = Syntax.new(self, &block) end end class TopLevel < Scope def initialize(*args) super syntax('define') do |scope, cells| first = cells.first case first when Lisp::List names = first.cells.map { |c| c.text_value } scope.define(names.first, names[1..-1], cells[1..-1]) when Lisp::Identifier scope[first.text_value] = cells[1].eval(scope) end end syntax('lambda') do |scope, cells| names = cells.first.cells.map { |c| c.text_value } Function.new(scope, names, cells[1..-1]) end syntax('if') do |scope, cells| which = cells.first.eval(scope) ? cells[1] : cells[2] which.eval(scope) end define('+') { |arg1, arg2| arg1 + arg2 } define('-') { |arg1, arg2| arg1 - arg2 } define('*') { |arg1, arg2| arg1 * arg2 } define('/') { |arg1, arg2| arg1 / arg2 } define('=') { |arg1, arg2| arg1 == arg2 } define('display') { |x| puts x } end end  

测试文件test.scm

(define (fact x) (if (= x 0) 1 (* x (fact (- x 1))))) (display (fact 6)) (define (add x) (lambda (y) (+ x y))) (define add4 (add 4)) (define add5 (add 5)) (display (add4 3)) (display (add5 3)) 

执行（说明一下：lisp.treetop, function.rb, lisp.rb, scheme.rb, scope.rb 在lib 目录下；test.scm 和lib 在同一目录下）

require './lib/scheme' require 'treetop' puts Scheme.run("./test.scm") #=> 720 #=> 7 #=> 8 #=> nil