（接上篇）
Byterun
现在我们有足够的 Python 解释器的知识背景去考察 Byterun。
Byterun 中有四种对象。
  • VirtualMachine类，它管理高层结构，尤其是帧调用栈，并包含了指令到操作的映射。这是一个比前面Inteprter对象更复杂的版本。
  • Frame类，每个Frame类都有一个代码对象，并且管理着其他一些必要的状态位，尤其是全局和局部命名空间、指向调用它的整的指针和最后执行的字节码指令。
  • Function类，它被用来代替真正的 Python 函数。回想一下，调用函数时会创建一个新的帧。我们自己实现了Function，以便我们控制新的Frame的创建。
  • Block类，它只是包装了块的 3 个属性。（块的细节不是解释器的核心，我们不会花时间在它身上，把它列在这里，是因为 Byterun 需要它。）
VirtualMachine 类
每次程序运行时只会创建一个VirtualMachine实例，因为我们只有一个 Python 解释器。VirtualMachine 保存调用栈、异常状态、在帧之间传递的返回值。它的入口点是run_code方法，它以编译后的代码对象为参数，以创建一个帧为开始，然后运行这个帧。这个帧可能再创建出新的帧；调用栈随着程序的运行而增长和缩短。当第一个帧返回时，执行结束。
  1. classVirtualMachineError(Exception):
  2. pass
  3. classVirtualMachine(object):
  4. def __init__(self):
  5. self.frames =[]#The call stack of frames.
  6. self.frame =None#The current frame.
  7. self.return_value =None
  8. self.last_exception =None
  9. def run_code(self, code, global_names=None, local_names=None):
  10. """ An entry point to execute code using the virtual machine."""
  11.        frame =self.make_frame(code, global_names=global_names,
  12.                                local_names=local_names)
  13. self.run_frame(frame)
Frame 类
接下来，我们来写Frame对象。帧是一个属性的集合，它没有任何方法。前面提到过，这些属性包括由编译器生成的代码对象；局部、全局和内置命名空间；前一个帧的引用；一个数据栈；一个块栈；最后执行的指令指针。（对于内置命名空间我们需要多做一点工作，Python 在不同模块中对这个命名空间有不同的处理；但这个细节对我们的虚拟机不重要。）
  1. classFrame(object):
  2. def __init__(self, code_obj, global_names, local_names, prev_frame):
  3. self.code_obj = code_obj
  4. self.global_names = global_names
  5. self.local_names = local_names
  6. self.prev_frame = prev_frame
  7. self.stack =[]
  8. if prev_frame:
  9. self.builtin_names = prev_frame.builtin_names
  10. else:
  11. self.builtin_names = local_names['__builtins__']
  12. if hasattr(self.builtin_names,'__dict__'):
  13. self.builtin_names =self.builtin_names.__dict__
  14. self.last_instruction =0
  15. self.block_stack =[]
接着，我们在虚拟机中增加对帧的操作。这有 3 个帮助函数：一个创建新的帧的方法（它负责为新的帧找到名字空间），和压栈和出栈的方法。第四个函数，run_frame，完成执行帧的主要工作，待会我们再讨论这个方法。
  1. classVirtualMachine(object):
  2. [...删节...]
  3. #Frame manipulation
  4. def make_frame(self, code, callargs={}, global_names=None, local_names=None):
  5. if global_names isnotNoneand local_names isnotNone:
  6.            local_names = global_names
  7. elifself.frames:
  8.            global_names =self.frame.global_names
  9.            local_names ={}
  10. else:
  11.            global_names = local_names ={
  12. '__builtins__': __builtins__,
  13. '__name__':'__main__',
  14. '__doc__':None,
  15. '__package__':None,
  16. }
  17.        local_names.update(callargs)
  18.        frame =Frame(code, global_names, local_names,self.frame)
  19. return frame
  20. def push_frame(self, frame):
  21. self.frames.append(frame)
  22. self.frame = frame
  23. def pop_frame(self):
  24. self.frames.pop()
  25. ifself.frames:
  26. self.frame =self.frames[-1]
  27. else:
  28. self.frame =None
  29. def run_frame(self):
  30. pass
  31. # we'll come back to this shortly
Function 类
Function的实现有点曲折，但是大部分的细节对理解解释器不重要。重要的是当调用函数时 —— 即调用 __call__方法 —— 它创建一个新的Frame并运行它。
  1. classFunction(object):
  2. """
  3.    Create a realistic function object, defining the things the interpreter expects.
  4.    """
  5.    __slots__ =[
  6. 'func_code','func_name','func_defaults','func_globals',
  7. 'func_locals','func_dict','func_closure',
  8. '__name__','__dict__','__doc__',
  9. '_vm','_func',
  10. ]
  11. def __init__(self, name, code, globs, defaults, closure, vm):
  12. """You don't need to follow this closely to understand the interpreter."""
  13. self._vm = vm
  14. self.func_code = code
  15. self.func_name =self.__name__ = name or code.co_name
  16. self.func_defaults = tuple(defaults)
  17. self.func_globals = globs
  18. self.func_locals =self._vm.frame.f_locals
  19. self.__dict__ ={}
  20. self.func_closure = closure
  21. self.__doc__ = code.co_consts[0]if code.co_consts elseNone
  22. #Sometimes, we need a real Pythonfunction.Thisisfor that.
  23.        kw ={
  24. 'argdefs':self.func_defaults,
  25. }
  26. if closure:
  27.            kw['closure']= tuple(make_cell(0)for _ in closure)
  28. self._func = types.FunctionType(code, globs,**kw)
  29. def __call__(self,*args,**kwargs):
  30. """When calling a Function, make a new frame and run it."""
  31.        callargs = inspect.getcallargs(self._func,*args,**kwargs)
  32. #Use callargs to provide a mapping of arguments: values to pass into the new
  33. # frame.
  34.        frame =self._vm.make_frame(
  35. self.func_code, callargs,self.func_globals,{}
  36. )
  37. returnself._vm.run_frame(frame)
  38. def make_cell(value):
  39. """Create a real Python closure and grab a cell."""
  40. #Thanks to AlexGaynorfor help withthis bit of twistiness.
  41.    fn =(lambda x:lambda: x)(value)
  42. return fn.__closure__[0]
接着，回到VirtualMachine对象，我们对数据栈的操作也增加一些帮助方法。字节码操作的栈总是在当前帧的数据栈。这些帮助函数让我们的POP_TOP、LOAD_FAST以及其他操作栈的指令的实现可读性更高。
  1. classVirtualMachine(object):
  2. [...删节...]
  3. #Data stack manipulation
  4. deftop(self):
  5. returnself.frame.stack[-1]
  6. def pop(self):
  7. returnself.frame.stack.pop()
  8. def push(self,*vals):
  9. self.frame.stack.extend(vals)
  10. def popn(self, n):
  11. """Pop a number of values from the value stack.
  12.        A list of `n` values is returned, the deepest value first.
  13.        """
  14. if n:
  15.            ret =self.frame.stack[-n:]
  16. self.frame.stack[-n:]=[]
  17. return ret
  18. else:
  19. return[]
在我们运行帧之前，我们还需两个方法。
第一个方法，parse_byte_and_args 以一个字节码为输入，先检查它是否有参数，如果有，就解析它的参数。这个方法同时也更新帧的last_instruction属性，它指向最后执行的指令。一条没有参数的指令只有一个字节长度，而有参数的字节有3个字节长。参数的意义依赖于指令是什么。比如，前面说过，指令POP_JUMP_IF_FALSE，它的参数指的是跳转目标。BUILD_LIST，它的参数是列表的个数。LOAD_CONST，它的参数是常量的索引。
一些指令用简单的数字作为参数。对于另一些，虚拟机需要一点努力去发现它含意。标准库中的dis模块中有一个备忘单，它解释什么参数有什么意思，这让我们的代码更加简洁。比如，列表dis.hasname告诉我们LOAD_NAME、IMPORT_NAME、LOAD_GLOBAL，以及另外的 9 个指令的参数都有同样的意义：对于这些指令，它们的参数代表了代码对象中的名字列表的索引。
  1. classVirtualMachine(object):
  2. [...删节...]
  3. def parse_byte_and_args(self):
  4.        f =self.frame
  5.        opoffset = f.last_instruction
  6.        byteCode = f.code_obj.co_code[opoffset]
  7.        f.last_instruction +=1
  8.        byte_name = dis.opname[byteCode]
  9. if byteCode >= dis.HAVE_ARGUMENT:
  10. # index into the bytecode
  11.            arg = f.code_obj.co_code[f.last_instruction:f.last_instruction+2]
  12.            f.last_instruction +=2# advance the instruction pointer
  13.            arg_val = arg[0]+(arg[1]*256)
  14. if byteCode in dis.hasconst:#Look up a constant
  15.                arg = f.code_obj.co_consts[arg_val]
  16. elif byteCode in dis.hasname:#Look up a name
  17.                arg = f.code_obj.co_names[arg_val]
  18. elif byteCode in dis.haslocal:#Look up a local name
  19.                arg = f.code_obj.co_varnames[arg_val]
  20. elif byteCode in dis.hasjrel:#Calculate a relative jump
  21.                arg = f.last_instruction + arg_val
  22. else:
  23.                arg = arg_val
  24.            argument =[arg]
  25. else:
  26.            argument =[]
  27. return byte_name, argument
下一个方法是dispatch，它查找给定的指令并执行相应的操作。在 CPython 中，这个分派函数用一个巨大的 switch 语句实现，有超过 1500 行的代码。幸运的是，我们用的是 Python，我们的代码会简洁的多。我们会为每一个字节码名字定义一个方法，然后用getattr来查找。就像我们前面的小解释器一样，如果一条指令叫做FOO_BAR，那么它对应的方法就是byte_FOO_BAR。现在，我们先把这些方法当做一个黑盒子。每个指令方法都会返回None或者一个字符串why,有些情况下虚拟机需要这个额外why信息。这些指令方法的返回值，仅作为解释器状态的内部指示，千万不要和执行帧的返回值相混淆。
  1. classVirtualMachine(object):
  2. [...删节...]
  3. def dispatch(self, byte_name, argument):
  4. """ Dispatch by bytename to the corresponding methods.
  5.        Exceptions are caught and set on the virtual machine."""
  6. #When later unwinding the block stack,
  7. # we need to keep track of why we are doing it.
  8.        why =None
  9. try:
  10.            bytecode_fn = getattr(self,'byte_%s'% byte_name,None)
  11. if bytecode_fn isNone:
  12. if byte_name.startswith('UNARY_'):
  13. self.unaryOperator(byte_name[6:])
  14. elif byte_name.startswith('BINARY_'):
  15. self.binaryOperator(byte_name[7:])
  16. else:
  17. raiseVirtualMachineError(
  18. "unsupported bytecode type: %s"% byte_name
  19. )
  20. else:
  21.                why = bytecode_fn(*argument)
  22. except:
  23. # deal with exceptions encountered while executing the op.
  24. self.last_exception = sys.exc_info()[:2]+(None,)
  25.            why ='exception'
  26. return why
  27. def run_frame(self, frame):
  28. """Run a frame until it returns (somehow).
  29.        Exceptions are raised, the return value is returned.
  30.        """
  31. self.push_frame(frame)
  32. whileTrue:
  33.            byte_name, arguments =self.parse_byte_and_args()
  34.            why =self.dispatch(byte_name, arguments)
  35. #Dealwith any block management we need to do
  36. while why and frame.block_stack:
  37.                why =self.manage_block_stack(why)
  38. if why:
  39. break
  40. self.pop_frame()
  41. if why =='exception':
  42.            exc, val, tb =self.last_exception
  43.            e = exc(val)
  44.            e.__traceback__ = tb
  45. raise e
  46. returnself.return_value
Block 类
在我们完成每个字节码方法前，我们简单的讨论一下块。一个块被用于某种控制流，特别是异常处理和循环。它负责保证当操作完成后数据栈处于正确的状态。比如，在一个循环中，一个特殊的迭代器会存在栈中，当循环完成时它从栈中弹出。解释器需要检查循环仍在继续还是已经停止。
为了跟踪这些额外的信息，解释器设置了一个标志来指示它的状态。我们用一个变量why实现这个标志，它可以是None或者是下面几个字符串之一："continue"、"break"、"excption"、return。它们指示对块栈和数据栈进行什么操作。回到我们迭代器的例子，如果块栈的栈顶是一个loop块，why的代码是continue，迭代器就应该保存在数据栈上，而如果why是break，迭代器就会被弹出。
块操作的细节比这个还要繁琐，我们不会花时间在这上面，但是有兴趣的读者值得仔细的看看。
  1. Block= collections.namedtuple("Block","type, handler, stack_height")
  2. classVirtualMachine(object):
  3. [...删节...]
  4. #Block stack manipulation
  5. def push_block(self, b_type, handler=None):
  6.        level = len(self.frame.stack)
  7. self.frame.block_stack.append(Block(b_type, handler, stack_height))
  8. def pop_block(self):
  9. returnself.frame.block_stack.pop()
  10. def unwind_block(self, block):
  11. """Unwind the values on the data stack corresponding to a given block."""
  12. if block.type =='except-handler':
  13. #Theexception itself is on the stack as type, value,and traceback.
  14.            offset =3
  15. else:
  16.            offset =0
  17. while len(self.frame.stack)> block.level + offset:
  18. self.pop()
  19. if block.type =='except-handler':
  20.            traceback, value, exctype =self.popn(3)
  21. self.last_exception = exctype, value, traceback
  22. def manage_block_stack(self, why):
  23. """ """
  24.        frame =self.frame
  25.        block = frame.block_stack[-1]
  26. if block.type =='loop'and why =='continue':
  27. self.jump(self.return_value)
  28.            why =None
  29. return why
  30. self.pop_block()
  31. self.unwind_block(block)
  32. if block.type =='loop'and why =='break':
  33.            why =None
  34. self.jump(block.handler)
  35. return why
  36. if(block.type in['setup-except','finally']and why =='exception'):
  37. self.push_block('except-handler')
  38.            exctype, value, tb =self.last_exception
  39. self.push(tb, value, exctype)
  40. self.push(tb, value, exctype)#yes, twice
  41.            why =None
  42. self.jump(block.handler)
  43. return why
  44. elif block.type =='finally':
  45. if why in('return','continue'):
  46. self.push(self.return_value)
  47. self.push(why)
  48.            why =None
  49. self.jump(block.handler)
  50. return why
  51. return why
指令
剩下了的就是完成那些指令方法了：byte_LOAD_FAST、byte_BINARY_MODULO等等。而这些指令的实现并不是很有趣，完整的实现在 GitHub 上[2]。（这里包括的指令足够执行我们前面所述的所有代码了。）
动态类型：编译器不知道它是什么
你可能听过 Python 是一种动态语言 —— 它是动态类型的。在我们建造解释器的过程中，已经透露出这样的信息。
动态的一个意思是很多工作是在运行时完成的。前面我们看到 Python 的编译器没有很多关于代码真正做什么的信息。举个例子，考虑下面这个简单的函数mod。它取两个参数，返回它们的模运算值。从它的字节码中，我们看到变量a和b首先被加载，然后字节码BINAY_MODULO完成这个模运算。
  1. >>>def mod(a, b):
  2. ...return a % b
  3. >>> dis.dis(mod)
  4. 20 LOAD_FAST                0(a)
  5. 3 LOAD_FAST                1(b)
  6. 6 BINARY_MODULO
  7. 7 RETURN_VALUE
  8. >>> mod(19,5)
  9. 4
计算 19 % 5 得4，—— 一点也不奇怪。如果我们用不同类的参数呢？
  1. >>> mod("by%sde","teco")
  2. 'bytecode'
刚才发生了什么？你可能在其它地方见过这样的语法，格式化字符串。
>>> print("by%sde" % "teco") bytecode
用符号%去格式化字符串会调用字节码BUNARY_MODULO。它取栈顶的两个值求模，不管这两个值是字符串、数字或是你自己定义的类的实例。字节码在函数编译时生成（或者说，函数定义时）相同的字节码会用于不同类的参数。
Python 的编译器关于字节码的功能知道的很少，而取决于解释器来决定BINAYR_MODULO应用于什么类型的对象并完成正确的操作。这就是为什么 Python 被描述为动态类型dynamically typed：直到运行前你不必知道这个函数参数的类型。相反，在一个静态类型语言中，程序员需要告诉编译器参数的类型是什么（或者编译器自己推断出参数的类型。）
编译器的无知是优化 Python 的一个挑战 —— 只看字节码，而不真正运行它，你就不知道每条字节码在干什么！你可以定义一个类，实现__mod__方法，当你对这个类的实例使用%时，Python 就会自动调用这个方法。所以，BINARY_MODULO其实可以运行任何代码。
看看下面的代码，第一个a % b看起来没有用。
  1. def mod(a,b):
  2.    a % b
  3. return a %b
不幸的是，对这段代码进行静态分析 —— 不运行它 —— 不能确定第一个a % b没有做任何事。用 %调用__mod__可能会写一个文件，或是和程序的其他部分交互，或者其他任何可以在 Python 中完成的事。很难优化一个你不知道它会做什么的函数。在 Russell Power 和 Alex Rubinsteyn 的优秀论文中写道，“我们可以用多快的速度解释 Python？”，他们说，“在普遍缺乏类型信息下，每条指令必须被看作一个INVOKE_ARBITRARY_METHOD。”
总结
Byterun 是一个比 CPython 容易理解的简洁的 Python 解释器。Byterun 复制了 CPython 的主要结构：一个基于栈的解释器对称之为字节码的指令集进行操作，它们顺序执行或在指令间跳转，向栈中压入和从中弹出数据。解释器随着函数和生成器的调用和返回，动态的创建、销毁帧，并在帧之间跳转。Byterun 也有着和真正解释器一样的限制：因为 Python 使用动态类型，解释器必须在运行时决定指令的正确行为。
我鼓励你去反汇编你的程序，然后用 Byterun 来运行。你很快会发现这个缩短版的 Byterun 所没有实现的指令。完整的实现在 https://github.com/nedbat/byterun，或者你可以仔细阅读真正的 CPython 解释器ceval.c，你也可以实现自己的解释器！
致谢
感谢 Ned Batchelder 发起这个项目并引导我的贡献，感谢 Michael Arntzenius 帮助调试代码和这篇文章的修订，感谢 Leta Montopoli 的修订，以及感谢整个 Recurse Center 社区的支持和鼓励。所有的不足全是我自己没搞好。
via: http://aosabook.org/en/500L/a-python-interpreter-written-in-python.html
作者： Allison Kaptur 译者：qingyunha[3] 校对：wxy[4]
本文由 LCTT[5] 原创翻译，Linux中国[6] 荣誉推出
[1]: http://akaptur.com

[2]: https://github.com/nedbat/byterun

[3]: https://github.com/qingyunha

[4]: https://github.com/wxy

[5]: https://github.com/LCTT/TranslateProject

[6]: http://linux.cn/

推荐文章
点击标题或输入文章 ID 直达该文章
4283 使用 Python 创建你自己的 Shell （上）
4301 使用 Python 创建你自己的 Shell（下）
4392 Mock 在 Python 单元测试中的使用
将文章分享给朋友是对我们最好的赞赏！
继续阅读
阅读原文