自己动手开发编译器（十二）生成托管代码

private void EmitLoadLocal(int locIndex)
{
switch (locIndex)
{
case 0:
m_ilgen.Emit(OpCodes.Ldloc_0);
break;
case 1:
m_ilgen.Emit(OpCodes.Ldloc_1);
break;
case 2:
m_ilgen.Emit(OpCodes.Ldloc_2);
break;
case 3:
m_ilgen.Emit(OpCodes.Ldloc_3);
break;
default:
if (locIndex <= 255)
{
m_ilgen.Emit(OpCodes.Ldloc_S, (byte)locIndex);
}
else
{
m_ilgen.Emit(OpCodes.Ldloc, (short)locIndex);
}
break;
}
}

public override AstNode VisitProgram(Program ast)
{
List<ClassDecl> classesInHierarchyOrder = new List<ClassDecl>();

var topBaseClasses = from c in ast.Classes where c.BaseClass.Type == null select c;
classesInHierarchyOrder.AddRange(topBaseClasses);

while (classesInHierarchyOrder.Count < ast.Classes.Count)
{
foreach (var c in ast.Classes)
{
foreach (var b in classesInHierarchyOrder.ToArray())
{
if (c.BaseClass.Type == b.Type)
{
classesInHierarchyOrder.Add(c);
}
}
}
}

foreach (var c in classesInHierarchyOrder)
{
Visit(c);
}

Visit(ast.MainClass);

return ast;
}

public override AstNode VisitMainClass(MainClass ast)
{
m_currentType = m_module.DefineType(
ast.Type.Name, TypeAttributes.Class | TypeAttributes.Abstract | TypeAttributes.Sealed);
m_currentMethod = m_currentType.DefineMethod(
"Main", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new[] { typeof(string[]) });

m_ilgen = m_currentMethod.GetILGenerator();

foreach (var s in ast.Statements)
{
Visit(s);
}

m_ilgen.Emit(OpCodes.Ret);

m_currentType.CreateType();
m_mainMethod = m_currentMethod;
return ast;
}

public override AstNode VisitIfElse(IfElse ast)
{
var ifBlock = m_ilgen.DefineLabel();
var elseBlock = m_ilgen.DefineLabel();
var endif = m_ilgen.DefineLabel();

Visit(ast.Condition);
//the e-stack should have a bool value
m_ilgen.Emit(OpCodes.Brfalse, elseBlock);

//if block
m_ilgen.MarkLabel(ifBlock);
Visit(ast.TruePart);
m_ilgen.Emit(OpCodes.Br, endif);

//elseblock
m_ilgen.MarkLabel(elseBlock);
Visit(ast.FalsePart);

//after if
m_ilgen.MarkLabel(endif);

return ast;
}

public override AstNode VisitWhile(While ast)
{
var beforeWhile = m_ilgen.DefineLabel();
var afterWhile = m_ilgen.DefineLabel();

m_ilgen.MarkLabel(beforeWhile);

Visit(ast.Condition);
//the e-stack should have a bool value
m_ilgen.Emit(OpCodes.Brfalse, afterWhile);

Visit(ast.LoopBody);

m_ilgen.Emit(OpCodes.Br, beforeWhile);
m_ilgen.MarkLabel(afterWhile);

return ast;
}

public override AstNode VisitBinary(Binary ast)
{
//push operands
Visit(ast.Left);
Visit(ast.Right);

switch (ast.Operator)
{
case BinaryOperator.Add:
m_ilgen.Emit(OpCodes.Add);
break;
case BinaryOperator.Substract:
m_ilgen.Emit(OpCodes.Sub);
break;
case BinaryOperator.Multiply:
m_ilgen.Emit(OpCodes.Mul);
break;
case BinaryOperator.Divide:
m_ilgen.Emit(OpCodes.Div);
break;
case BinaryOperator.Less:
m_ilgen.Emit(OpCodes.Clt);
break;
case BinaryOperator.Greater:
m_ilgen.Emit(OpCodes.Cgt);
break;
case BinaryOperator.Equal:
m_ilgen.Emit(OpCodes.Ceq);
break;
case BinaryOperator.LogicalAnd:
m_ilgen.Emit(OpCodes.And);
break;
case BinaryOperator.LogicalOr:
m_ilgen.Emit(OpCodes.Or);
break;
default:
m_ilgen.Emit(OpCodes.Pop);
m_ilgen.Emit(OpCodes.Pop);
m_ilgen.Emit(OpCodes.Ldc_I4_0);
break;
}
return ast;
}

public override AstNode VisitCall(Call ast)
{
var methodRInfo = GetClrMethod(ast.Method.MethodInfo);

//push target object
Visit(ast.Target);

//push arguments
foreach (var arg in ast.Arguments)
{
Visit(arg);
}

m_ilgen.EmitCall(OpCodes.Call, methodRInfo, null);

return ast;
}

public void Create(Ast.AstNode ast, string url)
{
Visit(ast);

Debug.Assert(m_assembly != null);

m_assembly.SetEntryPoint(m_mainMethod, PEFileKinds.ConsoleApplication);
m_assembly.Save(url);
}

static class 程序入口
{
//中文注释
public static void Main(string[] args)
{
Fac o;
o = new Fac();
System.Console.WriteLine(o.ComputeFac(8));
}
}

class Fac
{
public int ComputeFac(int num)
{
int num_aux;
if (num < 1)
num_aux = 1;
else
num_aux = num * (this.ComputeFac(num - 1));

return num_aux;
}
}