蛙蛙推荐：蛙蛙教你发明一种新语言之二--代码生成

摘要

上一篇里我们构建了语法树，但他并不能执行，还要把它转换成可执行的代码。语法树是抽象的，可以把它转换到各种平台的执行文件，但我们现在只关注它是如何生成一个CLR的可执行文件。

 

IL指令介绍
书接上文，话说曹操来到了景阳岗。。。，汗，串频道了。。。
有人说，编译原理中语法分析是核心，有人却说语法分析没啥新花样，都是死的东西，代码生成才是最关键的，确实，你要到了那种水平，啥都觉得简单。我们要把语法树翻译成.NET中间语言，所以我们得学一些常用的IL指令，常识性的东西就不介绍了，比如CLR的大致运行原理呀，反射，Emit基础应用等都不细说了。把IL运行环境想象成一个堆栈，我们要把参数压入到堆栈里，然后执行各种执行，我们会用到的指令罗列如下

ldstr 加载一个字符串到栈上
stloc 把栈顶的对象保存到本地变量里
ldloc 把本地变量加载到栈顶上
newobj 创建一个对象，并入栈，后面跟一个构造函数
callvirt 调用实例方法，后面跟methodinfo
br    无条件跳转到某标签
castclass    强制类型转换，后面跟要转换成的类型
call    调用静态方法
ceq    比较是否相等，如果相当就把1压入栈，否则把0压入栈
brtrue    如果栈顶元素是true或者非0，就跳转到指定标签
ret 表示返回栈顶对象，方法结束

就这么几个，简单吧，可你不懂还不行，周日我没弄明白brtrue和brtrue_s的区别，折腾了我一下午，一晚上，整整六七个小时，if语句里多加一条语句就出错，去掉就可以了，等今天跟脑袋一说，脑袋一眼就看出是长指令，短指令的问题，我汗，就是说brtrue_s跳转的标签只能是一个字节长度，所以if的body里语句多了就跳不过去了，我把brtrue_s都换成brtrue后问题解决，服了，这就是基础差和基础好的差距。

辅助方法

IL里除了栈、指令，还有两个东西，一个是Lebel，一个是本地变量，就是临时变量，有了这些所有的东西，顺序，分支，循环都可以实现了，我是先写C#代码，然后反射看il代码，然后翻译成Emit的c#代码，这么一个过程来学的。代码生成分几个方法

private   void  GenStmt(Stmt stmt)
private   void  GenExpr(Expr expr, System.Type expectedType)
private   void  Store( string  name, System.Type type)
private  System.Type TypeOfExpr(Expr expr)

前两个方法顾名思义，一个用来生成语句，一个用来生成表达式，其中GenExpr第二个参数表示你预想的表达式返回的数据类型，Store是保存一个本地变量，TypeOfExpr方法用来获取一个表达式的类型，我们先把后两个简单的方法实现看下。

private  System.Type TypeOfExpr(Expr expr) {
     if  (expr  is  StringLiteral) {
         return   typeof ( string );
    }
     else   if  (expr  is  IntLiteral) {
         return   typeof ( int );
    }
     else   if  (expr  is  Match) {
         return   typeof (System.Collections.IEnumerator);
    }
     else   if  (expr  is  StrLen) {
         return   typeof ( int );
    }
     else   if  (expr  is  BinExpr  &&  ((BinExpr)expr).Op  ==  BinOp.Eq) {
         return   typeof ( bool );
    }
     else   if  (expr  is  Builder) {
         return   typeof (System.Text.StringBuilder);
    }
     else   if  (expr  is  Variable) {
        Variable var  =  (Variable)expr;
         if  ( this .symbolTable.ContainsKey(var.Ident)) {
            Emit.LocalBuilder locb  =   this .symbolTable[var.Ident];
             return  locb.LocalType;
        }
         else  {
             throw   new  System.Exception( " undeclared variable ' "   +  var.Ident  +   " ' " );
        }
    }
     else  {
         throw   new  System.Exception( " don't know how to calculate the type of  "   +  expr.GetType().Name);
    }
}

大致意思就是写死的，固定的表达式类型返回固定的类型，如果是一个变量名的话，就返回这个变量名指向的本地变量的类型。

private   void  Store( string  name, System.Type type) {
     if  ( this .symbolTable.ContainsKey(name)) {
        Emit.LocalBuilder locb  =   this .symbolTable[name];

         if  (locb.LocalType  ==  type) {
             this .il.Emit(Emit.OpCodes.Stloc,  this .symbolTable[name]);
        }
         else  {
             throw   new  System.Exception( " ' "   +  name  +   " ' is of type  "   +  locb.LocalType.Name  +
  "  but attempted to store value of type  "   +  type.Name);
        }
    }
     else  {
         throw   new  System.Exception( " undeclared variable ' "   +  name  +   " ' " );
    }
}

这个方法是用Stloc指令来吧栈顶的对象保存成一个命名的本地变量，没别的，就是查看了下符号表里有没有声明过这个变量以及抛出了一些异常。

生成表达式

再看一个稍微简单的，生成表达式的部分，比如Match表达式，它有两个参数，两个参数都是string类型，第一个input，第二个是Pattern，c#代码的写法是new Regex(pattern).Matches(input).GetEnumerator();
而要转换成il的话，就要先把pattern用ldstr指令加载到栈上，然后用newobj创建一个Regex对象，然后用ldstr把input压入栈，然后用callvrit来调用Regex的Matches方法，把一个IEnumerable对象呀入栈，最后来掉一次IEnumerable的GetEnumerator()方法

大致应该如下

L_0006:   ldstr   " //d+| "   // pattern
L_000b:   newobj   instance   void  [System]System.Text.RegularExpressions.Regex::.ctor( string )
L_0010:   ldloc.0   // input
L_0011:   callvirt   instance   class  [System]System.Text.RegularExpressions.MatchCollection
    [System]System.Text.RegularExpressions.Regex::Matches( string )  // call Matches
L_0016:   callvirt   instance   class  [mscorlib]System.Collections.IEnumerator
    [System]System.Text.RegularExpressions.MatchCollection::GetEnumerator()  // call GetEnumerator

而我们根据AST生成IL的代码应该如下

if  (expr  is  Match) {
    Match m  =  (Match)expr;
    GenExpr(m.Pattern,  typeof ( string ));
    il.Emit(OpCodes.Newobj,  typeof (Regex).GetConstructor( new [] {  typeof ( string ) }));
    GenExpr(m.Input,  typeof ( string ));
    il.Emit(OpCodes.Callvirt,  typeof (Regex).GetMethod( " Matches " ,  new [] {  typeof ( string ) }));
    il.Emit(OpCodes.Callvirt,  typeof (MatchCollection).GetMethod( " GetEnumerator " ));
    deliveredType  =   typeof (System.Collections.IEnumerator);
}

再看一个StrLen的代码生成        

if  (expr  is  StrLen) {
      StrLen len  =  (StrLen)expr;
      GenExpr(len.Input,  typeof ( string ));
      il.Emit(OpCodes.Callvirt,  typeof ( string ).GetMethod( " get_Length " ));
      deliveredType  =   typeof ( int );

}

生成语句

表达式的生成大概就是这样了，没有比这再复杂的了，再复杂也不会了，有了上面的基础，我们看一个生成foreach语句的吧。
逻辑上应该是这样，foreach语句应该翻译成一个while语句如下的WawaSharp语句

for  item  in  arr  do
    print item;
end;

对应的c#语句是

foeach( object  item in arr)
{
    Console.Write(item);
}

 

我们先转换成如下

while(arr.MoveNext())
{
     object  o = arr.Current;
    Console.Write(o);
}

 

再想办法弄成IL指令序列，这里有两个label，一个是arr.MoveNext这里，这里测试返回值是否为true，一个是循环体，执行while里的实际执行语句，我们一个定义为test，一个定义为body，刚开始我先用Br指令无提交跳转到test标签，test标签里，生成IEnumerable表达式，用Callvirt调用MoveNext，当返回true时，用Brtrue指令跳转到body标签，body标签里先得到IEnumerable，这里又用了次GenExpr，这里不会重新调用GetEnumerator方法的，因为each.IEnumerable只是一个变量arr，执行GenExpr(each.IEnumerable, typeof(System.Collections.IEnumerator))只不过是ldloc arr而已，所以不用担心性能问题。然后调用get_Current,访问Current树形，再强转成System.Text.RegularExpressions.Match类型，并调用其父类Capture的Value属性，最后把item本地变量存起来，供body语句里ldloc起来使用。

if  (stmt  is  Foreach) {
        Foreach each  =  (Foreach)stmt;
        Label body  =  il.DefineLabel();
        Label test  =  il.DefineLabel();
        
        il.Emit(OpCodes.Br, test);
        
        il.MarkLabel(body);
        GenExpr(each.IEnumerable,  typeof (System.Collections.IEnumerator));
        il.Emit(OpCodes.Callvirt,  typeof (System.Collections.IEnumerator).GetMethod( " get_Current " ));
        il.Emit(OpCodes.Castclass,  typeof (System.Text.RegularExpressions.Match));
        il.Emit(OpCodes.Callvirt,  typeof (Capture).GetMethod( " get_Value " ));
        symbolTable[each.Ident]  =  il.DeclareLocal( typeof ( object ));
        Store(each.Ident,  typeof ( object ));
        
        GenStmt(each.Body);
        
        il.MarkLabel(test);
        GenExpr(each.IEnumerable,  typeof (System.Collections.IEnumerator));
        il.Emit(OpCodes.Callvirt,  typeof (System.Collections.IEnumerator).GetMethod( " MoveNext " ));
        il.Emit(OpCodes.Brtrue, body);
}

累了，就举这一个例子算了，if语句的生成就不说了，看代码吧。

检查结果

完了看下，我们示例代码中生成的IL代码吧

.entrypoint
.maxstack   6
.locals   init  (
    [ 0 ]  string  str,
    [ 1 ]  class  [mscorlib]System.Collections.IEnumerator enumerator,
    [ 2 ]  class  [mscorlib]System.Text.StringBuilder builder,
    [ 3 ]  object  obj2,
    [ 4 ]  int32  num,
    [ 5 ]  class  [mscorlib]System.Collections.IEnumerator enumerator2,
    [ 6 ]  object  obj3)
L_0000:   ldstr   " 11|222|33|44|55 "
L_0005:   stloc.0
L_0006:   ldstr   " //d+| "
L_000b:   newobj   instance   void  [System]System.Text.RegularExpressions.Regex::.ctor( string )
L_0010:   ldloc.0
L_0011:   callvirt   instance   class  [System]System.Text.RegularExpressions.MatchCollection
[System]System.Text.RegularExpressions.Regex::Matches( string )
L_0016:   callvirt   instance   class  [mscorlib]System.Collections.IEnumerator
[System]System.Text.RegularExpressions.MatchCollection::GetEnumerator()
L_001b:   stloc.1
L_001c:   newobj   instance   void  [mscorlib]System.Text.StringBuilder::.ctor()
L_0021:   stloc.2
L_0022:  br L_00bb
L_0027:   ldloc.1
L_0028:   callvirt   instance   object  [mscorlib]System.Collections.IEnumerator::get_Current()
L_002d:   castclass  [System]System.Text.RegularExpressions.Match
L_0032:   callvirt   instance   string  [System]System.Text.RegularExpressions.Capture::get_Value()
L_0037:   stloc.3
L_0038:   ldloc.3
L_0039:   callvirt   instance   string  [mscorlib]System.Object::ToString()
L_003e:   call   void  [mscorlib]System.Console::WriteLine( object )
L_0043:   ldloc.3
L_0044:   callvirt   instance   string  [mscorlib]System.Object::ToString()
L_0049:   callvirt   instance   int32  [mscorlib]System.String::get_Length()
L_004e:   stloc.s  num
L_0050:   ldloc.s  num
L_0052:   ldc.i4   2
L_0057:  ceq
L_0059:   ldc.i4.0
L_005a:  ceq
L_005c:   brtrue  L_00bb
L_0061:   ldstr   " //d "
L_0066:   newobj   instance   void  [System]System.Text.RegularExpressions.Regex::.ctor( string )
L_006b:   ldloc.3
L_006c:   callvirt   instance   string  [mscorlib]System.Object::ToString()
L_0071:   callvirt   instance   class  [System]System.Text.RegularExpressions.MatchCollection
    [System]System.Text.RegularExpressions.Regex::Matches( string )
L_0076:   callvirt   instance   class  [mscorlib]System.Collections.IEnumerator
    [System]System.Text.RegularExpressions.MatchCollection::GetEnumerator()
L_007b:   stloc.s  enumerator2
L_007d:  br L_00af
L_0082:   ldloc.s  enumerator2
L_0084:   callvirt   instance   object  [mscorlib]System.Collections.IEnumerator::get_Current()
L_0089:   castclass  [System]System.Text.RegularExpressions.Match
L_008e:   callvirt   instance   string  [System]System.Text.RegularExpressions.Capture::get_Value()
L_0093:   stloc.s  obj3
L_0095:   ldloc.2
L_0096:   ldstr   " /r/n "
L_009b:   callvirt   instance   class  [mscorlib]System.Text.StringBuilder
     [mscorlib]System.Text.StringBuilder::Append( string )
L_00a0:   pop
L_00a1:   ldloc.2
L_00a2:   ldloc.s  obj3
L_00a4:   callvirt   instance   string  [mscorlib]System.Object::ToString()
L_00a9:   callvirt   instance   class  [mscorlib]System.Text.StringBuilder
     [mscorlib]System.Text.StringBuilder::Append( string )
L_00ae:   pop
L_00af:   ldloc.s  enumerator2
L_00b1:   callvirt   instance   bool  [mscorlib]System.Collections.IEnumerator::MoveNext()
L_00b6:   brtrue  L_0082
L_00bb:   ldloc.1
L_00bc:   callvirt   instance   bool  [mscorlib]System.Collections.IEnumerator::MoveNext()
L_00c1:   brtrue  L_0027
L_00c6:   ldloc.2
L_00c7:   callvirt   instance   string  [mscorlib]System.Object::ToString()
L_00cc:   call   void  [mscorlib]System.Console::WriteLine( object )
L_00d1:   ret

用refleter转换成c#代码如下

string  input  =   " 11|222|33|44|55 " ;
IEnumerator enumerator  =   new  Regex( @" /d+| " ).Matches(input).GetEnumerator();
StringBuilder builder  =   new  StringBuilder();
while  (enumerator.MoveNext())
{
     object  obj2  =  ((Match) enumerator.Current).Value;
    Console.WriteLine(obj2.ToString());
     if  (obj2.ToString().Length  ==   2 )
    {
        IEnumerator enumerator2  =   new  Regex( @" /d " ).Matches(obj2.ToString()).GetEnumerator();
         while  (enumerator2.MoveNext())
        {
             object  obj3  =  ((Match) enumerator2.Current).Value;
            builder.Append( " /r/n " );
            builder.Append(obj3.ToString());
        }
    }
}
Console.WriteLine(builder.ToString());

执行输出如下

E:/CompilerWriting/bin/Debug > TEST
11

222

33

44

55


1
1
3
3
4
4
5
5

总结

一个小型的语言系统WawaSharp已经实现了，它可以做简单的字符串处理，你可以在此基础上扩展更全的字符串处理函数，甚至xml处理函数，这样做一些简单的XML和字符串处理小工具，用这种语言就足以应付了，否则还得打开vs.net写c#。据说.net 4.0里的表达式树才只是循环和分支等结构，咱现在都提前实现了。

代码下载地址如下

wawasharp.zip