前面讲过语法的解析之后，代码生成方面就简单很多了。虽然myc是一个简单的示例编译器，但是它还是在解析的过程中生成了一个小的语法树，这个语法树将会用在生成exe可执行文件和il源码的过程中。

编译器在解析时，使用emit类来产生中间的语法树，语法树的数据结构和操作方法在iasm这个类型里完成，源程序的语法解析完毕后，Exe和Asm两个类分别遍历生成的语法树产生最终的代码。

我们来看几个代码的例子，下表的函数 Parser.program 里，在函数开始和结束的地方分别调用了 prolog 和 epilog 两个函数，这两个函数的目的就是在语法解析的前后执行一些准备和扫尾工作。如在编译过程的开始阶段，根据.net assembly的要求创建好模块（module）和类（class），虽然c语言是一个面向过程的语言，但是在.net是一个面向对象的环境，所有的代码都应该保存在一个类里。

public void program()
  {
  prolog();
  while (tok.NotEOF())
    {
    outerDecl();
    }
  if (Io.genexe && !mainseen)
    io.Abort("Generating executable with no main entrypoint");
  epilog();
  }

void prolog()
  {
  emit = new Emit(io);
  emit.BeginModule();       // need assembly module
  emit.BeginClass();
  }

而在emit里，BeginModule和BeginClass这两个函数的代码如下：

public void BeginModule()
  {
  // 委托给Exe类来创建这个module，虽然在.net里，一个assembly可以由
  // 多个module组成，但是在C程序里，只要一个module就足够了，因此
  // 下面的代码并没有在生成IL源码的时候产生module。
  exe.BeginModule(io.GetInputFilename());
  }

public void BeginClass()
  {
  // 委托给Exe类来创建class，再进一步跟踪代码的时候，会发现它其实
  // 是根据反射技术来创建类型的。
  exe.BeginClass(Io.GetClassname(), TypeAttributes.Public);
  // 如果在执行程序的命令行里，启用了生成源码的开关，那么
  // 将会输出IL class的源码定义。
  if (Io.genlist)
    io.Out(".class " + Io.GetClassname() + "{\r\n");
  }

.NET里，可以使用反射技术来生成assembly、类型和函数，下表就是Exe类的BeginModule函数的源码：

public void BeginModule(string ifile)
  {
  // .net的动态assembly创建功能，要求跟appdomain绑定
  appdomain = System.Threading.Thread.GetDomain();
  appname = getAssemblyName(filename);
  // 调用AppDomain.DefineDynamiceAssembly创建一个Assembly，以这个为
  // 起点，可以创建类型，创建函数并执行。实际上，.net上的IronPython等
  // 动态语言的实现就非常依赖这个技术。
  appbuild = appdomain.DefineDynamicAssembly(appname,
                         AssemblyBuilderAccess.Save,
                         Io.genpath);
  // 在.net里，所有的代码实际上都应该保存在一个module里。
  emodule = appbuild.DefineDynamicModule(
        filename+"_module",
        Io.GetOutputFilename(),
        Io.gendebug);
  Guid g = System.Guid.Empty;
  if (Io.gendebug)
    srcdoc = emodule.DefineDocument(ifile, g, g, g);
  }

准备工作做好了以后，就可以生成语法树了，编译器在解析语法的过程当中，不停的往语法树里添加元素，如在编译函数的过程中，以处理while循环为例（其中一个调用路径是：program -> outerDecl -> declFunc -> blockOuter -> fcWhile）

void fcWhile()
  {
  // 在一般的il或者汇编语言里，循环和判断语句一般都是在不同路径的入口
  // 出定义好标签（label），再通过判断条件的方式跳转到指定的label实现的
  String label1 = newLabel();
  String label2 = newLabel();
 
  // 记录当前源码的位置，以便生成IL源码的时候可以把源代码和IL代码对照生成
  CommentHolder();  /* mark the position in insn stream */
  // 一般来说，循环语句至少有两个分支代码块，一个是继续循环的代码块，
  // 一个是跳出循环的代码块，看后面的代码，这个label是循环中执行的代码块
  // 开始的地方，以便满足条件的时候跳到开头继续执行
  emit.Label(label1);
  tok.scan();
  // 做一些错误判断
  if (tok.getFirstChar() != '(')
    io.Abort("Expected '('");

  // 处理循环条件的判断语句相关代码
  boolExpr();
  CommentFillPreTok();
  // 跳出循环的label
  emit.Branch("brfalse", label2);

  // 循环内部的代码块，进入blockInner进行循环里面的编译
  blockInner(label2, label1);   /* outer label, top of loop */
  // 如果满足循环条件，跳转到代码块开头继续执行
  emit.Branch("br", label1);
  
  // 循环结束，跳出循环的地方
  emit.Label(label2);
  }

而在emit类型里，各个方法只是将解析出来的语法元素添加到语法树里，语法树的节点、数据结构和操作方法都在IAsm这个类里定义，如下表是 Branch 的源码：

public void Branch(String s, String lname)
  {             // this is the branch source
  NextInsn(1);
  // 往语法树里添加一个类别为 Branch 的元素
  icur.setIType(IAsm.I_BRANCH);
  // 指令名称
  icur.setInsn(s);
  // 指令参数
  icur.setLabel(lname);
  }

当程序编译完成后，Exe类和Asm类则分别遍历语法树生成最终的结果，在myc编译器的源码里，Parser.declFunc函数通过调用Emit.IL函数来完成程序的生成：

// 因为C程序大部分都是由函数组成的，而且函数使用到的变量或者其他函数，
// 都必须在函数之前定义，所以只需要在解析函数的时候实时生成代码即可
void declFunc(Var e)
  {
#if DEBUG
  Console.WriteLine("declFunc token=["+tok+"]\n");
#endif
  CommentHolder();  // start new comment
  // 记录解析出来的函数名
  e.setName(tok.getValue()); /* value is the function name */
  // 如果函数名是main，则设置一个标识位 - mainseen为true
  // 在外层的函数里，会通过判断这个标志来确定程序是否有语义错误
  if (e.getName().Equals("main"))
    {
    if (Io.gendll)
      io.Abort("Using main entrypoint when generating a DLL");
    mainseen = true;
    }
  // 函数名也是一个全局变量，放到全局变量表里，以便做语义分析
  // 例如要调用的函数之前没有定义，则应该报错，在后文我们将
  // 看到语义方面的处理
  staticvar.add(e);     /* add function name to static VarList */
  paramvar = paramList();   // track current param list
  e.setParams(paramvar);    // and set it in func var
  // 记录函数里面定义的局部变量
  localvar = new VarList(); // track new local parameters
  CommentFillPreTok();

  // 开始生成函数的prolog，例如参数传递，this对象等
  emit.FuncBegin(e);
  if (tok.getFirstChar() != '{')
    io.Abort("Expected ‘{'");
  // 递归分析函数里面的源码
  blockOuter(null, null);
  emit.FuncEnd();
  
  // 解析完整个函数后，执行代码生成操作
  emit.IL();
  // 如果需要生成IL源码，则调用LIST函数生成IL源码
  if (Io.genlist)
    emit.LIST();
  emit.Finish();
  }

而emit.IL函数就是用Exe类型遍历整个语法树，生成结果程序：

public void IL()
  {
  IAsm a = iroot;
  IAsm p;

  // 循环遍历整个语法树
  while (a != null)
    {
    // 根据语法树里各个节点的类型来执行对应的操作
    switch (a.getIType())
      {
      case IAsm.I_INSN:
    exe.Insn(a);
    break;
      case IAsm.I_LABEL:
    exe.Label(a);
    break;
      case IAsm.I_BRANCH:
    exe.Branch(a);
    break;
      // 省略一些代码
      default:
    io.Abort("Unhandled instruction type " + a.getIType());
    break;
      }
    p = a;
    a = a.getNext();
    }
  }

而Exe类型执行真正的代码生成，如前面IL函数，在碰到I_BRANCH类型的节点时，调用Exe.Branch函数在动态Assembly (DynamicAssemby) 里生成代码：

public void Branch(IAsm a)
  {
  Object o = opcodehash[a.getInsn()];
  if (o == null)
    Io.ICE("Instruction branch opcode (" + a.getInsn() + ") not found in hash”);
  // 使用 ILGenerator 类生成跳转IL指令。
  il.Emit((OpCode) o, (Label) getILLabel(a));
  }

而Asm类也采用类似的方法生成IL源码。

最后，myc编译器里也有一些语义方面的处理，如前面讲到的函数调用时，如果被调用的函数没有定义的话，应该抛出异常的情况，在Parser.statement（即编译实际的C语句的函数）中就有所体现

void statement()
  {
  Var e;
  String vname = tok.getValue();

  CommentHolder();  /* mark the position in insn stream */
  switch (io.getNextChar())
    {
    case '(':           /* this is a function call */
      // 省略一些语法处理方面的代码
     tok.scan();        /* move to next token */
     // 下面这一行即在生成函数调用代码之前，在全局变量列表里
   // 查找要调用的函数是否已经定义了，如果没有定义，则应该报告此错误
      e = staticvar.FindByName(vname); /* find the symbol (e cannot be null) */
      emit.Call(e);
     
      // 省略后面的代码
   }
  if (tok.getFirstChar() != ';')
    io.Abort("Expected ';'");
  tok.scan();
  }