|
How To Build a Yacc(1)
Yacc 是什么？
编译器的编译器。
简单来说，Yacc读入一套语法定义规格(syntax rules), 然后分析一段代码(source code), 判断代码是否符合定义好的syntax rules。
语法定义规格是由形式化的BNF表达式来定义；目前大多数语言都可以用它来定义。
一个BNF表达式由一个NONTERMINAL（非终结符）和它的产生式组成，产生式可以是终结符（TERMINAL）和非终结符组成的序列。比如，我们定义一个函数声明:
function_decl := function func_name ( argment_list );
func_name := id
argument_list := argument_list , id
argument_list := id
斜体字表示非终结符，而粗体的是终结符。
一套完整的BNF文法意味着每一个NONTERMINAL最终都可以推导为一系列的TERMINAL。
一套文法定义了什么样的语言？如上面的function_decl, 非形式化的来说，一个function_decl
开头是一个function关键字,然后紧接着一个func_name，也就是一个id,表示函数名字，然后是一个'(',
加上一个参数列表，再加上一个')'
参数列表是由','分隔的id列表。
例如：function foo (kick, so, by);
BNF或是扩展EBNF(扩展BNF)表达式有几下几种表达方式:
S := A B C (S 推导出A B C 三个部分)
S := A | B | C (S推导出A 或 B 或 C三个符号)
S := { A } (S推导出一个或多个A}
How To Build a Yacc(2)
如何识别一段代码是否符合定义的文法？
如上面的例子：
function foo(kick, so, by);
首先，技术上来说，代码文本是一段字符流，f, u, n, c....，而我们文法识别的最小级别是符号(token), 所以需要将其转化为符号流，这个功能可以很容易的用lex实现，这个步骤不是讲述重点，不加详细叙述。
最直接的识别方法，以function_decl文法为例,我们从符号流中取一个当前符号，然后判断这个符号是否属于开始符号
(function_decl)的某个产生式的第一个符号,
如果找到了这样一个产生式，那么认为应该按照这个产生式进行展开，匹配并丢弃当前这个符号，并期望符号流中余下的符号能匹配该产生式剩余的符号；那么继续
从符号流中取去下一个符号，继续上面的步骤。
如果要用一个算法来描述它，那么看起来，象这个样子。
// 匹配一个符号token...
void match(token)
{
if (current_token == token) current_token = get_next_token();
else error("expect {token}, but give {current_token}")
}
// function_decl 用来匹配一个函数声明语句；
// function_decl 的产生式为:
// function_decl := function func_name ( argment_list );
void function_decl( )
{
current_token = get_next_token(); // 取出一个符号
match(function); // 匹配function
func_name(); // 如果已经匹配，那么接下来应该匹配函数名字了
match('('); // 匹配'('
argument_list(); // 接下来应该参数列表
match(')'); // 匹配')'
}
void func_name()
{
match(id);
}
void argument_list()
{
while (current_token == id) {
match(",");
}
}
如此简单？是不是？
以上的分析技术被称为递归下降分析技术，它对大多数简单的语法规则非常有效。
这种分析方法可以很容易的被归纳成一些简单的规则，根据这些规则，我们可以方便的编制分析程序。
在阐述这些规则之前，有必要介绍一个概念：fisrt集合。
什么是fisrt集合？
一个产生式的first项目就是这个产生式(production)的匹配第一个非终结符号。一套文法的所有产生式的first项目组成了first集合。求解first集合的方法：对于production: S = ABC
first(ABC)
， 如果A是一个terminal, 那么first(ABC)= A, 如果A是一个NONTERMINAL, 那么first(ABC) =
first(A), 如果A最终被推出一个空的符号，那么first(ABC) = first(BC), 依次类推。
这个概念之所以重要，是因为在递归下降算法中，在匹配一个非终结符的过程中，需要检测当前符号流中的符号是否属于该非终结符的所有产生式的first集合；如果属于，则用该产生式来扩展这个非终结符。
如何编写递归下降解析程序？
是时候总结一下规律了，对于每个产生式a来说，我们定义T(a) 是匹配a的程序代码：
when: a = A (A是terminal)
T(a):
if (t == A) t = get_next_token();
else error (t 是当前符号，get_next_token取得下一个符号)
when: a = X (X是nonterminal)
T(a): X(); 定义一个X的函数，实现由X的产生式定义。
when: a = a1 | a2 | a3 | ... | aN
T(a):
if (t <- First(a1) ) T(a1)
else if (t <- First(a2)) T(a2)
...
else if (t <- First(aN)) T(aN)
else error
when: a = a1 a2 ... aN
T(a): T(a1) T(a2) ... T(aN)
when: a = {a1}
T(a): while (t <- First(a1)) T(a1)
How To Build a Yacc(3)
在(2)中，我们阐述了一个简单高效的分析方法，最终产生一个文法的最左推导(即每次优先扩展左边的NONTERMINAL)
但是递归下降算法有些许局限性，比如：对于两个不同的NONTERMINAL，如果他们的FIRST集合有交集的话，就会产生歧义，很显然，当目前的符号分别属于两个不同的NONTERMINAL的FIRST集合时，就无法决定采用哪个产生式了。
我们来考虑另外一种分析方法，与递归下降相反，它最终产生一个文法的最右推导。我们称这种方法为LR分析。
LR分析基于一种有穷确定性自动机（DFA）原理，根据语法规则来创建一个DFA， 然后判断输入的符号流是否最后落入这个DFA的ACCEPT状态。
如何根据语法规则建立DFA？
DFA是一个状态集合，这些状态由某些确定的有向边连接；DFA由一个初始状态开始，接受一个符号，进入下一个状态。那么LR分析中的DFA状态是
什么？想象一个当前推导状态这个概念，即对于一个文法来说，当它识别了一些符号流以后，进入到一个什么样的状态。这个状态要么还剩下一些符号有待识别，要
么已经完成。
以前面的文法为例：
初始时候：
一个符号都没有识别，DFA需要识别整个文法的初始符号。我们标记为：
S = # function_decl (I1)
将'#'定义为“当前识别位置”，S是一个虚拟符号，我们将这个表达式定义为一个项目(item) ,这个项目认为，没有识别一个符号，DFA需要识别的是整个function_decl代表的符号串。
由
于我们每次只从符号流中取出一个符号，因此将DFA一步就将整个function_decl全部识别是不可能的，只能将function_decl展开，
看看function_decl下一个要识别的TERMINAL是什么，这就引出了闭包(closure)的概念:
一个状态的closure集合这样定义的，遍历这个状态中的所有item,如果#后面紧接的是一个NONTERMINAL，那么将这个
NONTERMINAL的所有产生式的初始化项目加入到这个集合中。
比如I1的closure集合S1为：
S := # function_decl (I1)
function_decl := # function func_name ( argment_list ); (I2)
这就是初始状态(S1)
继续推导(S1)以后的状态，我们要求解后续状态，主要方法是看当前位置(#)后面紧接的符号,如果符号流中下一个符号与之相同，那么当前位置后移一位，DFA进入了下一个状态(S2), 而由状态(S1)到(S2)的边的输入符号，就是#后面的符号。
那么如果下一个符号是 function , 那么（S1）进入下一个状态(S2):
function_decl := function # func_name ( argment_list ); (I3)
对S2求closure:得出：
function_decl := function # func_name ( argment_list ); (I3)
func_name := # id (I4)
目前，DFA成为如下的状况：
S1 (function) --> S2 (意思是：状态S1当输入符号function后变迁到S2)
新的问题产生了：S1中还有一个I1 中#后面是NONTERMINAL function_decl,
每次只取一个符号，如何才能从 S := # function_decl 直接输入一个 function_decl而直接进入到 S := function_decl # ? （DFA的终止状态）
也就是说，当我们处于状态S1(S := # function_decl)时，什么时候才能认为已经输入了 function_decl这个NONTERMINAL了呢。这涉及到另外一个概念：规约(reduction):
当DFA运行到一个状态(SX)，SX中含有一个Item已经到达末尾，诸如：
function_decl := function func_name ( argment_list ); # 那么我们认为DFA已经识别/输入了一个等同的NONTERMINAL：function_decl。
先不考虑reduction在什么时候进行，一会在讨论分析算法的时候再讨论它。
那么由S1，我们还能推导出另一个状态S3：
S := function_decl # (I5)
这是DFA的终止接受状态。
根据上面的规则，我们由S2可以一直往下推导DFA中所有的状态，一直到新的状态中每个ITEM都是终止状态(#在末尾)。
How To Build a Yacc(4)
有了DFA,接下来的事情好办多了，只要写一个DFA识别算法就完了，通常我们把这个算法称为移进-规约算法(shift-reduction)。
借助一个stack来描述shift-reduction：
1) 初始时，stack存放初始状态S1
2) 取符号流中下一个符号(token)，在DFA中查找是否有边S1(token) --> SX，如果有，将符号(token)移进stack, 并将状态(SX)也移进stack。
3)
如果当前stack顶部的状态(SX)中的所有Item都是非终止状态，那么继续步骤2), 反之，如果含有一个Item(N :=
ABC#)到达了终止状态 (#在末尾)，那么查看当前符号, 如果当前符号属于follow(S),
那么进行reduction,将stack中顶部的符号和状态弹出(一个2* length of (ABC)个符号), 执行文法N :=
ABC的附加动作，并将NONTERMINAL (N) 移进stack, 然后在DFA中查找是否有边SP(N) --> SX
，其中SP是当前stack顶部的状态，即stack[-1]。如果DFA中存在这条边，那么把SX移进stack.继续进行步骤2)
4) 如果当前stack顶部到达接受状态SE，算法结束。
5) 算法在运行中如果发现DFA中没有可以匹配的边，则算法失败。
How To Build a Yacc(5)
现在是时候来讨论How To Build a Yacc?(1)中的最初提出的问题了。。
如何判断一段代码是否符合预定义的syntax rules，毫无疑问：用你的眼睛和大脑配合也能完成这个任务，或许你还需要一张白纸，以计算syntax rules生成的DFA和stack。但是在有计算机的情况下，谁还会用人脑去代替计算机呢？
用计算机来实现这个功能，有了上面的讨论后，一切似乎很明了：读入syntax rules，生成DFA, 然后读入源代码，运用shift-reduction算法进行识别。
首先要花些时间来考虑用哪种语言来完成这个工作；因为生成DFA需要进行很多集合运算，我选择使用ruby, 如果你不想被那些糟糕的细节拖入地狱，最好用比较高级一点的工具。
在兴奋的往键盘上胡乱敲击代码之前，先转换一下身份，想象自己是这个程序的使用者，该如何调用它？
或许我们会写下如下的代码：
compiler = Compiler.new("syntax.rule", "src")
assert ( compiler.run() == true )
Compiler类ctor有两个参数：语法规则文件syntax.rule, 源代码src。Compiler类还有一个run方法，它用来决定src是否符合syntax.rule定义的规则。true表示符合，false表示不符合。
运行它，不奇怪，它失败了；好象还没写Compiler类呢！
为了使这个test case通过，仅仅为了使它编译通过，写一个Compiler类：
class Compiler
def initialize(rule_file, src_file)
end
def run
return true
end
end
run方法实际上什么也没做，但是足够了，test case已经通过了。一切看起来都很棒，我们迈出相当不错的第一步。
毕竟，现在还没有任何有意义的代码，我们想要点漂亮的东西，就得实实在在的干点活，不是吗？不过我们已经掌握了一个办法：在编写代码前先编写它的测试代码。看起来有点本末倒置，但是一旦你习惯了它，就会觉得这是个非常cool的想法。
测试优先 ---- 来自敏捷方法。
How To Build a Yacc(6)
显然，Compiler至少分为两个明显的部分：一部分是读入源代码，将其转换成符号流，一部分是读入语法规则文件，生成DFA。
先来讨论字符流转换成符号流的部分，由于这部分不是讨论的重点，就利用了目前已经相当通用的技术lex。
如果要想在ruby环境中利用lex工具生成的c代码，只有把c代码封装成ruby的扩展库。
lex怎么工作的？
首先编写一个lex的输入文件：
// prog.l
%{
#include <string.h>
#include "prog.h"
char token_string[MAX_ID_LENGTH];
%}
whitespace [ /t]+
newline /n
digit [0-9]
number [+-]?{digit}+(/.{digit}+)?
bool true|false
lbrace "("
rbrace ")"
semicolon ";"
comma ","
assignment "="
string /"[^"]*/"
comment ////.*{newline}
letter [a-zA-Z]
identifier {letter}(/_|{letter}|{digit})*
constant {bool}|{number}|{string}
%%
{lbrace} { return LBRACE; }
{rbrace} { return RBRACE; }
function { return FUNCTION; }
{semicolon} { return SEMICOLON; }
{comma} { return COMMA; }
{assignment} { return ASSIGNMENT; }
{identifier} { return IDENTIFIER; }
{constant} { return CONSTANT; }
{whitespace} { }
{comment} { }
{newline} { }
. { return ERR; }
%%
int yywrap(void)
{
return 1;
}
int get_next_token()
{
int t_id = yylex();
strcpy(token_string, yytext);
return t_id;
}
输入文件分三部分，第1部分是%{
%}之间的代码，纯粹的C代码，将被copy到目标C文件中，接下来是正则表达式定义；第2部分是模式，表示匹配表达式需要执行什么操作。第3部分是几个
C函数，最终也是被copy到目标C文件中，其中最核心的就是get_next_token()了，这个是提供给外部的函数。
关于lex的更多信息，需要参考更多的参考书，满大街都是。
好了，基础的知道了解这么多就够了，不要忘了我们的游戏规则：测试优先。那么，假若有了这样一个lex的封装如何使用它？
lex = Lex.new(src)
while (true)
token = lex.get_next_token
ts = lex.get_token_string
assert(token == current_token && ts == current_token_string)
if (token == EOF) break
end
那么我们的Lex类需要至少提供两个方法：
get_next_token取得下一个符号
get_token_string取得当前识别符号的字符串
Lex类是一个ruby的扩展类，创建这个扩展类的方法如下：
1) 按prog.l的规则生成prog.c
flex -t prog.l >prog.c
2) prog.h定义一些constant和外部接口
#ifndef PROG_H_
#define PROG_H_
#define MAX_ID_LENGTH 256
enum {LBRACE = 1, RBRACE = 2, FUNCTION=3, SEMICOLON=4,
COMMA=5, ASSIGNMENT= 6, IDENTIFIER=7, CONSTANT=8, ERR=9};
extern char token_string[];
int get_next_token(void);
#endif /*PROG_H_*/
3) 编写ruby扩展程序lex.c
// lex.c
#include <ruby.h>
#include <string.h>
#include "prog.h"
extern FILE* yyin;
static VALUE lex_init(VALUE self, VALUE file)
{
long length = 0 ;
char* name = rb_str2cstr(file, &length);
yyin = fopen(name, "r");
rb_iv_set(self, "@file", file);
return self;
}
static VALUE lex_get_next_token(VALUE self)
{
VALUE t = INT2NUM(get_next_token());
return t;
}
static VALUE lex_get_token_string(VALUE self)
{
VALUE ts = rb_str_new2(token_string);
return ts;
}
static VALUE cTest;
void __declspec(dllexport)
Init_lex() {
cTest = rb_define_class("Lex", rb_cObject);
rb_define_method(cTest, "initialize", lex_init, 1);
rb_define_method(cTest, "get_next_token", lex_get_next_token, 0);
rb_define_method(cTest, "get_token_string", lex_get_token_string, 0);
}
4) 编写extconf.rb
require 'mkmf'
dir_config('lex')
create_makefile("lex")
5) 生成makefile
ruby extconf.rb --with-lex-dir=[include path]
6) 运行nmake ,生成lex.so
这些步骤顺利进行以后，只需要require 'lex.so', 就拥有了一个好用的Lex类。
关于如何编写ruby扩展的更多信息，请参考更多的资料:) 很快，他们就会满大街都是了。
How To Build a Yacc(7)
代码，还是代码！
要完成一个这样相对复杂的功能，是需要写一些代码，不过我保证，他最终将比你想象的少的多。
我对Lex类还有些不尽满意，实际上，我更希望lex.get_token_string能取得当前符号流中的任何一个符号，而不仅仅是当前的一个符号。。
lex = Lex.new(src)
lex.get_next_token
assert ( lex.get_token_string(0) == current_token_string && lex.get_token_string(-1) == prev_token_string )
设计一个类ExtendLex, 在初始化时将source code文件全部分解成符号流读入，保存在成员里。然后建立一个内部迭代变量。
class ExtendLex
ERROR = 9
EOF = 0
def read_file
while true
t_id = @lex.get_next_token
if ERROR == t_id
raise "lex error: '#{super.get_token_string}' is unknown character"
end
@token_ids.push(t_id)
@token_defs.push(@@token_match[t_id])
@token_strs.push(@lex.get_token_string)
break if t_id == EOF
end
end
def initialize(file)
@lex = Lex.new(file)
@token_ids = Array.new
@token_defs = Array.new
@token_strs = Array.new
@current_pos = -1
read_file
end
@@token_match = {
1 => "(",
2 => ")",
3 => "function",
4 => ";",
5 => ",",
6 => "=",
7 => "id",
8 => "constant",
9 => "error",
0 => "$"
}
def get_next_token
@current_pos = @current_pos + 1
return @token_ids[@current_pos]
end
def get_next_token2
@current_pos = @current_pos + 1
return @token_defs[@current_pos]
end
def get_token_string(index)
return @token_strs[@current_pos+index]
end
attr_reader :token_ids, :token_defs, :token_strs
end
如上面的代码：read_file调用lex的get_next_token方法分析整个文件，将所有识别的符号存储在一个数组:
token_ids里面，而将所有的符号字符串存储在一个数组: token_strs里面。
get_token_string方法带了一个参数，如果对象拥有文件中所有的符号，那么可以根据index来取得任何一个位置的符号，符号字符串。
How To Build a Yacc(8)
搞定lex后，很显然，我们要将它加入到Compiler中。
class Compiler
def initialize(rule_file, src_file)
@lex = ExtendLex.new(src_file)
end
def run
return true
end
end
要想在run里面真正的干点事，就需要一个shift-reduction算法来识别src_file中的符号流是否能符合rule_file
中所定义的规则。
我们目前只有@lex, 从它那儿我们只能得到符号流，要进行shift-reduction分析，我们需要从rule_file生成DFA,这一点才是关键。为了达到这个目的，得重新写一个类来完成这个功能。
根据这个类的功能，一个紧迫的工作是定义规则文件的格式，以function_decl文法为例：
##### File: ican.y ###############
%%
%token function id
%token ; , = ( )
%%
nil := function_decl :
function_decl := function function_name ( argument_list ) ; :
function_name := id : p @lex.get_token_string(-1)
argument_list := argument_list , id : p @lex.get_token_string(-1)
argument_list := id : p @lex.get_token_string(-1)
以'%%'为分割符，第1个'%%'后面是terminal定义，第2个‘%%’后面定义的是rule,
rule的写法就是普通的BNF表达式，后面跟着一个:引出的action表达式，目前我们只执行ruby表达式。这里有几个特定约束：每个
NONTERMINAL最终总能推出TERMINAL序列。开始符号由nil := Start_Symbol来定义。
好了，假设我们已经有了一个Yacc类，它所完成的工作就是读入rule_file生成DFA，我们该如何使用(测试)它？
#### test.rb
require 'rubyunit'
class TestCompiler < Test::Unit::TestCase
def create_rule_file
File.open("rulefile","w") do |file|
file.puts "%%/n%token function id/n%token ; , = ( )/n"
file.puts "%%/nnil := function_decl : /n"
file.puts "function_decl := function function_name ( argument_list ) ; : /n"
file.puts "function_name := id : /n"
file.puts "argument_list := argument_list , id : /n"
file.puts "argument_list := id :"
end
end
def test_yacc
create_rule_file
yacc = Yacc.new("rulefile")
yacc.generate
assert(yacc.state[0].size == 2)
end
end
在我们上面所定义的rulefile中，DFA的state[0]（开始状态）应该是2个item：
item1:[nil = # function_decl]
item2:[function_decl = # function function_name ( argument_list ) ;]
当然我们可以编写更多的assert, 不过对于一个想象中的类，还是不要对它要求过多。
How To Build a Yacc(9)
考虑该怎么样设计Yacc类。
显然，Yacc面临的第1个问题就是分析rule_file的内容。Yacc类本身不应该实现这个功能，因为还有一个功能是生成DFA，这是两个没有多大关系的功能，按照SRP（单一职责原则），不应该在一个类里实现。
按照这个设计原则，很容易做出的决定，需要一个类Vocab识别rule_file定义的所有符号(TERMINAL,NONTERMINAL,EOF,START_SYMBOL)。另外需要一个类识别每一个Rule定义。
这两个类的功能很单一，接口也不会太复杂。
class TestCompiler < Test::Unit::TestCase
def test_vocab
vocab = Vocab.new
assert( vocab.identify("nil") == Vocab::NULL )
assert( vocab.identify("$") == Vocab::EOF )
assert( vocab.identify("function") == Vocab::UNKNOWN )
vocab.add_terminal("%token )")
assert( vocab.identify(")") == Vocab::TERMINAL )
vocab.add_terminal("%token function id")
assert( vocab.identify("function") == Vocab::TERMINAL )
assert( vocab.identify("id") == Vocab::TERMINAL )
assert( vocab.identify("ids") == Vocab::UNKNOWN )
vocab.add_nonterminal("proc")
assert( vocab.identify("proc") == Vocab::NONTERMINAL )
vocab.add_nonterminals(%w{kick sanf})
assert( vocab.identify("kick") == Vocab::NONTERMINAL )
assert( vocab.identify("sanf") == Vocab::NONTERMINAL )
end
def test_rule
rule = Rule.parse("function_decl := /
function function_name ( argument_list ) ; : decl")
assert(rule, "parse rule failed")
assert(rule.vocabs.include?("function_decl"))
assert(rule.vocabs.include?("function"))
assert(rule.vocabs.include?("function_name"))
assert(rule.vocabs.include?("argument_list"))
assert(rule.lt == "function_decl")
assert(rule.rt == %w{function function_name ( argument_list ) ;})
assert(rule.action == "decl")
end
end
同样，实现他们也很简单。
###### File : algo.rb #############
##############################
# Vocab
# 该类会存储一个syntax define中的
# 所有符号，包括terminal, nonterminal
# nil(空), $(结束)
##############################
class Vocab
### @types
TERMINAL = 1
NONTERMINAL = 2
NULL = 3
EOF = 4
UNKNOWN = 5
### @vocabs list
@@nulls = ["nil"]
@@eofs = ["$"]
###
@@terminal_match = /^%token/s+(.*)$/
# @terminals 终结符的集合
# @nonterminals 非终结符的集合
def initialize
@terminals = Array.new
@nonterminals = Array.new
end
# @identify
# 判断一个符号名字属于哪一种符号
def identify(name)
return TERMINAL if @terminals.include?(name)
return NULL if @@nulls.include?(name)
return EOF if @@eofs.include?(name)
return NONTERMINAL if @nonterminals.include?(name)
return UNKNOWN
end
def Vocab.type_name(type)
Vocab.constants.each do |x|
return x if eval(x) == type
end
return "error type"
end
def Vocab.nulls
@@nulls
end
def Vocab.eofs
@@eofs
end
# 分析一个token定义语句并将其定义的所有符号加入集合
# 如果定义语句有错误,返回nil
def add_terminal(term_def_text)
# %token term1, term2, term3 ...
matches = @@terminal_match.match(term_def_text.strip())
return nil if !matches
# then tokens--matches[1] be (term1, term2, term3 ...)
tokens = matches[1].strip()
# erase all whitespaces in tokens
#tokens.gsub!(//s+/, "")
# split to singleton token
@terminals.concat(tokens.split(//s+/))
@terminals.uniq!
@terminals
end
# 加入非终结符集合
def add_nonterminal(name)
@nonterminals.push(name) if identify(name) == UNKNOWN &&
!@nonterminals.include?(name)
@nonterminals.uniq!
@nonterminals
end
def add_nonterminals(tokens)
tokens.each {|x| add_nonterminal(x)}
end
def tokens
return @terminals + @nonterminals + @@nulls + @@eofs
end
## traverse vocabs methods.
def each_terminal(&block)
@terminals.each(&block)
end
def each_nonterminal(&block)
@nonterminals.each(&block)
end
def each_token(&block)
tokens().each(&block)
end
end # end Vocab
将"%token id , ( )"这一行内容识别为四个TERMINAL是由函数add_terminal完成的，它使用了正则表达式。容易推测，Rule也使用了这种方法：
###### File : algo.rb #############
##################################
# 一个Rule对象即代表一个语法规则(生成式)
##################################
class Rule
# lt : Nonterminal & NULL
# rt : sequence of Vocab
@@match_rule = /(/w+)/s*:=/s*(.*):(.*)/
def initialize(lt, rt, action)
@lt, @rt, @action = lt, rt, action
end
def Rule.parse(rule_plain_text)
matches = @@match_rule.match(rule_plain_text)
return nil if !matches
begin
lts = matches[1]
rts = matches[2].strip()
action = matches[3].strip()
rta = rts.split(//s+/)
return Rule.new(lts, rta, action)
rescue
return nil
end
end
def vocabs
tokens = Array.new
tokens.push(@lt)
tokens.concat(@rt)
tokens.uniq!
return tokens
end
def to_s
"#{@lt} = #{@rt.join(" ")} : #{@action}"
end
def eql?(other)
return @lt.eql?(other.lt) && @rt.eql?(other.rt)
end
alias :== eql?
attr_reader :lt, :rt, :action
end
How To Build a Yacc(10)
将Vocab和Rule功能组合起来作为一个RuleParser类来提供分析rule_file的功能是个不错的主意，因为对这两个类而言并没有太大的重用的意义，只不过是为了将错误的出现尽可能的控制在局部。
class TestCompiler < Test::Unit::TestCase
def test_rule_parser
create_rule_file
p = RuleParser.new("rulefile")
assert(p.rules[0].lt == "nil")
assert(p.rules[0].rt == ["function_decl"])
assert(p.vocabs.identify("function") == Vocab::TERMINAL)
end
end
有了Vocab和Rule，实现RuleParser只是举手之劳。
class RuleParser
def initialize(file_name)
@vocabs = Vocab.new
@rules = Array.new
compile(file_name)
end
@@directive = 0
DIRECTIVE = "%%"
####################################################
# 对于 yacc的输入规则文件进行解析
# 将文件中定义的token和rule分别存入@vocabs, @rules
# 定义文件分两段:
# %%
# {第一段：token definition}
# %%
# {第二段：rule definition}
# %%
####################################################
def compile(file_name)
file = File.open(file_name, "r")
no = 0
begin
file.each do |line|
no = no+1
if line.strip().chomp() == DIRECTIVE
@@directive = @@directive + 1
next
end
# @@directive == 0 not started, continue
# @@directive == 1 start parse terminals
# @@directive == 2 start parse rules
# @@directive == 3 end parse
case @@directive
when 0
next
when 1
if !add_terminal(line)
error(no, line, "parse terminal error")
end
when 2
rule = parse_rule(line)
if !rule
error(no, line, "parse nonterminal error")
end
add_nonterminal(rule)
when 3
break
end # end when
end # end for each
rescue
raise
ensure
file.close()
end # end begin...
end
def add_terminal(line)
@vocabs.add_terminal(line)
end
def add_nonterminal(rule)
@vocabs.add_nonterminals(rule.vocabs())
end
def parse_rule(line)
rule = Rule.parse(line)
@rules.push(rule)
return rule
end
def error(no, line, msg)
raise "Error #{msg} in Line #{no}, #{line}."
end
private :error
attr_reader :rules, :vocabs
end
实际上，对RuleParser的test
case的设计，无意中凸显了一个事实，那就是应该将RuleParser设计为一个interface,
对外提供至少两个方法：get_rules（分析rule_file得到的rule集合）；get_vocabs（分析rule_file得到的
vocab集合）。这样，Yacc类就不必依赖于RuleParser的实现，意味着Yacc不必知晓rule_file的特定格式，这些细节只应该由
RuleParser的实现类来关心。
在ruby这种动态语言里。。只要你设计出一个类提供rules,vocabs两个属性就好。。
How To Build a Yacc(11)
分析完rule_file, 最后一个关键的步骤是生成DFA。
这是一个比较复杂的过程，首先我们要建立一个Item结构，这样才能构造状态(states)
item 应该是一个rule和一个相关的position(当前识别位置)组成。
class TestCompiler < Test::Unit::TestCase
def test_item
rule = Rule.parse("function_decl := /
function function_name ( argument_list ) ; : decl")
assert(rule)
item = Item.new(rule, 0)
assert(item.current_token == "function_decl")
assert(item.next_token == "function")
item = item.step
assert(item.current_token == "function")
assert(item.next_token == "function_name")
assert(item.is_end? == false)
item.step!(5)
assert(item.is_end? == true)
end
end
##################################
# 一个Item即NFA中一个状态集合中的成员
##################################
class Item
def initialize(rule, pos)
@rule, @pos = rule, pos
end
def current_token
return token(@pos)
end
def next_token
return token(@pos + 1)
end
def step(distance = 1)
return Item.new(@rule, @pos + distance)
end
def step!(distance = 1)
@pos = @pos + distance
end
def is_end?
return @pos >= @rule.rt.length
end
def token(pos)
return nil if pos < 0 || pos > @rule.rt.length
return @rule.lt if 0 == pos
return @rule.rt.at(pos-1)
end
def to_s
rta = rule.rt.dup
#shift_pos = @pos-1 < 0 ? 0 : @pos - 1
rta.insert(@pos, "#")
"[#{rule.lt} = #{rta.join(" ")}]"
end
def eql?(other)
#p "#{self.to_s} eql? #{other.to_s}, #{@rule.eql?(other.rule) && @pos.eql?(other.pos)}"
return @rule.eql?(other.rule) && @pos.eql?(other.pos)
end
alias :== eql?
attr_reader :rule, :pos
end
How To Build a Yacc(12)
生成DFA的第1步，计算first集合和follow集合。
first_set和follow_set都是一个hast set结构，这个hash的key是一个 vocab,而
value是一个集合，用一个array表示，这与普通的hash不同，因此写了一个HashDup的
module,其中重写了hash的store方法，用来满足上述要求：
###### hashdup.rb ###########
module HashDup
def store(key, value)
return if !value
if self.has_key?(key)
self[key].push(value)
else
self[key] = [value]
end
self[key].flatten!
self[key].uniq!
end
def eql?(other)
self.each_pair do |key, value|
if !other[key].eql?(value)
return false
end
end
return true
end
end
其中eql?方法十分有用，在计算first和follow集合时，每遍循环都要检查集合是否有
变化以决定集合是否计算终止。
class DFA
def initialize()
@first_set = Hash.new
@follow_set = Hash.new
@first_set.extend(HashDup)
@follow_set.extend(HashDup)
end
########################################################
# 计算token的first集合
# 对于terminal, first(terminal) = [terminal]
# 对于nonterminal S, 如果有S = aBC, first(S) = first(aBC)
# if a -> nil , first(aBC) = first(BC), 依次类推
# if a not-> nil, first(aBC) = first(a).
########################################################
def calc_first_set(parser)
parser.vocabs.each_terminal do |terminal|
@first_set.store(terminal, terminal)
end
begin
old_first_set = @first_set.dup
parser.vocabs.each_nonterminal do |nonterminal|
parser.rules.each do |rule|
if rule.lt == nonterminal
if !rule.rt.empty? && @first_set[rule.rt[0]]
@first_set.store(nonterminal, @first_set[rule.rt[0]])
end
end
end
end
end while @first_set.eql?(old_first_set)
return @first_set
end
########################################################
# 计算token的follow集合
# 对每个rule(产生式进行遍历)
# S = aBC, 每个rule右边的产生序列(rule.rt=aBC)的每一个非结尾符号
# 比如a,B; follow集合对于紧邻符号的first集合;follow(a) = fisrt(B).
# 而每一个结尾符号，其follow集合等于左边非终结符的follow集合
# follow(C) = follow(S)
########################################################
def calc_follow_set(parser)
begin
old_follow_set = @follow_set.dup
parser.rules.each do |rule|
if token_type(rule.lt, parser) == Vocab::NULL
@follow_set.store(rule.lt, Vocab.eofs)
end
for i in 0...rule.rt.length
if i < rule.rt.length-1
@follow_set.store(rule.rt[i], @first_set[rule.rt[i+1]])
else
@follow_set.store(rule.rt[i], @follow_set[rule.lt])
end
end #end for
end #end parser.rules.each
end while !@follow_set.eql?(old_follow_set)
return @follow_set
end
end
How To Build a Yacc(13)
实际上，有了上面的准备后，计算DFA的算法很清楚：
class DFA
SHIFT = 1
REDUCE = 2
ERROR = 3
ACCEPT = 4
def initialize()
@state_set = Array.new
@current_state = 0
@max_state = 0
@action_table = Hash.new
@first_set = Hash.new
@follow_set = Hash.new
@first_set.extend(HashDup)
@follow_set.extend(HashDup)
end
def token_type(token, parser)
parser.vocabs.identify(token)
end
def action(state, token)
key = "#{state},#{token}"
return @action_table[key]
end
########################################################
# 生成DFA
# 首先计算first, follow集合, 产生第一个状态,然后依次产生每一个后继
########################################################
def generate(parser)
calc_first_set(parser)
calc_follow_set(parser)
#@state_set.push(generate_first_state(parser))
#dump_first_follow
@state_set[@current_state] = generate_first_state(parser)
#p "fisrt state: #{@state_set[@current_state].to_s}"
while @current_state <= @max_state
successors(@current_state, parser)
@current_state = @current_state + 1
end
@action_table.store("0,nil", [ACCEPT, 0])
@action_table.store("0,$", [ACCEPT, 0])
end
########################################################
# 求DFA的第一个状态
# 我们把nil = #S的item闭包作为第一个状态，其中S是开始符号
########################################################
def generate_first_state(parser)
itemset = Array.new
parser.rules.each do |rule|
#p "DFA::#{rule}"
if token_type(rule.lt, parser) == Vocab::NULL
#p "DFA::match nil rule #{rule}"
itemset.push(Item.new(rule, 0))
end
end
first_state = closure(itemset, parser)
end
########################################################
# 求一个状态的闭包
# 对于状态集合中的任意一个item: S = av#BC, 如果B是nonterminal
# 那么把所有rule中rule.lt = B的rule加入到这个闭包中
########################################################
def closure(itemset, parser)
oldset = nil
begin
itemset.each do |item|
oldset = itemset.dup
nt = item.next_token
if !item.is_end? && token_type(nt, parser) == Vocab::NONTERMINAL
additem = Array.new
parser.rules.each do |rule|
if rule.lt == nt
expand = Item.new(rule, 0)
additem.push(expand) if (!itemset.include?(expand))
end
end
itemset.concat(additem)
end
end
end while !oldset.eql?(itemset) # end begin...end while
return itemset
end
########################################################
# 由item: S = a#vBC前进到 S = av#BC
########################################################
def advance(itemset)
newitemset = Array.new
itemset.each do |item|
newitemset.push(item.step)
end
return newitemset
end
########################################################
# 求每一个状态的所有后继
# 对于状态s中任意一个item:
# 1. 如果存在item: S = a#vBC, 那么当下一个 token是v时，意味着
# 将v进行shift操作，并将状态转移到下一个状态closure(S = av#BC);
# 2. 如果存在item: S = avBC#, 那么当下一个token在follow(S)中
# 意味着需要救星reduce操作，将stack里的avBC序列替换为S, 并移动到
# 下一个状态 goto(stack.last, S)
########################################################
def successors(state, parser)
itemset = @state_set[state]
parser.vocabs.each_token do |token|
key = "#{state},#{token}"
# 找到所有 s = a.vc中v=token的item
next_items = itemset.find_all { |item| item.next_token == token }
if !next_items.empty?
next_items_c = closure(advance(next_items), parser)
# 检查next_items_s是否已经在状态表中
next_state_no = @state_set.index(next_items_c)
if !next_state_no
next_state_no = @max_state + 1
@max_state = next_state_no
@state_set[next_state_no] = next_items_c
end
@action_table.store(key, [SHIFT, next_state_no])
end
# 找到所有 s= av. 的rule, 并将@follow_set(rule.rt.last)
end_items = itemset.find_all { |item| item.is_end? == true }
if !end_items.empty?
end_items.each do |item|
if @follow_set[item.rule.lt].include?(token)
@action_table.store(key, [REDUCE, end_items])
end
end
end
# 如果没有任何可用的项目
#@action_table.store(key, [ERROR, nil]) until @action_table[key]
end
end
########################################################
# 计算token的first集合
# 对于terminal, first(terminal) = [terminal]
# 对于nonterminal S, 如果有S = aBC, first(S) = first(aBC)
# if a -> nil , first(aBC) = first(BC), 依次类推
# if a not-> nil, first(aBC) = first(a).
########################################################
def calc_first_set(parser)
parser.vocabs.each_terminal do |terminal|
@first_set.store(terminal, terminal)
end
begin
old_first_set = @first_set.dup
parser.vocabs.each_nonterminal do |nonterminal|
parser.rules.each do |rule|
if rule.lt == nonterminal
if !rule.rt.empty? && @first_set[rule.rt[0]]
@first_set.store(nonterminal, @first_set[rule.rt[0]])
end
end
end
end
end while @first_set.eql?(old_first_set)
return @first_set
end
########################################################
# 计算token的follow集合
# 对每个rule(产生式进行遍历)
# S = aBC, 每个rule右边的产生序列(rule.rt=aBC)的每一个非结尾符号
# 比如a,B; follow集合对于紧邻符号的first集合;follow(a) = fisrt(B).
# 而每一个结尾符号，其follow集合等于左边非终结符的follow集合
# follow(C) = follow(S)
########################################################
def calc_follow_set(parser)
begin
old_follow_set = @follow_set.dup
parser.rules.each do |rule|
if token_type(rule.lt, parser) == Vocab::NULL
@follow_set.store(rule.lt, Vocab.eofs)
end
for i in 0...rule.rt.length
if i < rule.rt.length-1
@follow_set.store(rule.rt[i], @first_set[rule.rt[i+1]])
else
@follow_set.store(rule.rt[i], @follow_set[rule.lt])
end
end #end for
end #end parser.rules.each
end while !@follow_set.eql?(old_follow_set)
return @follow_set
end
#### debug util function################
def dump_state_set
index = 0
@state_set.each do |state|
p "state:#{index}, item:#{state.to_s}"
index = index + 1
end
end
def dump_action_table
p "[action table]:"
@action_table.each_pair do |key, value|
cond = key.gsub(/,(.*)/, '(/1)')
p "#{cond} --> [#{DFA.action_name(value[0])}], #{value[1]}"
end
end
def dump_first_follow
p "first: #{@first_set.inspect}"
p "follow: #{@follow_set.inspect}"
end
def DFA.action_name(action)
DFA.constants.each do |x|
return x if eval(x) == action
end
return "unknown action"
end
#attr_reader :state_set, :action_table, :goto_table
end
而Yacc这时的实现也仅仅是转调一下DFA的方法而已:
class Yacc
def initialize(file_name)
@parser = RuleParser.new(file_name)
@dfa = DFA.new
end
def rule_parser
@parser
end
def dfa
@dfa
end
def generate
@dfa.generate(@parser)
end
end
回头运行一下我们的test_yacc，看看有什么结果?
How To Build a Yacc(14)
既然已经生成了DFA，按照之前的描述写出shift_reduction算法就不是什么了不起的工作了。
class Compiler
def initialize(rule_file, src_file)
@yacc = Yacc.new(rule_file)
@lex = ExtendLex.new(src_file)
@parse_stack = Array.new
end
def run
@yacc.generate
shift_reduction
end
def shift_reduction
@parse_stack.push(0)
token = @lex.get_next_token2
while true
action = @yacc.dfa.action(@parse_stack.last, token)
return false until action
action_id = action[0]
new_state = action[1]
case action_id
when DFA::SHIFT
@parse_stack.push(token)
@parse_stack.push(new_state)
token = @lex.get_next_token2
when DFA::REDUCE
rule = new_state[0].rule
eval(rule.action)
# pop 2 * rt.length
rindex = 0 - 2 * rule.rt.length
@parse_stack[rindex..-1] = nil
goto = @yacc.dfa.action(@parse_stack.last, rule.lt)
if goto
if goto[0] == DFA::SHIFT
@parse_stack.push(rule.lt)
@parse_stack.push(goto[1])
elsif goto[0] == DFA::ACCEPT
return true
end
else
return false
end
when DFA::ACCEPT
return true
end
end
end
end
|
