2.3.1 读取文件和输入#

一旦CPython有了运行时配置和命令行参数，它就可以加载它所需要执行的代码，这个任务由Modules/main.c文件中的pymain_main()函数来完成。 命令行输入字符串 CPython 可以通过指定-c选项，从而通过命令行模式来执行一个小的Python应用，比如:

1
$ ./python -c "print(2 ** 2)"
2
4

首先，pymain_run_command()函数在Modules/main.c文件中被执行，其将命令行中通过-c传入的命令行作为一个wchar_t*类型的参数。完成此操作后，pymain_run_command()将会把Python字节对象传递给 PyRun_SimpleStringFlags()用于执行,它将一个字符串转换成Python模块，然后把它送去执行。

2.3.2 本地模块输入#

执行 Python 命令的另一种方式是通过-m选项与模块名一起使用. CPython导入一个标准库模块runpy并通过PyObject_Call()来执行它，导入的过程由一个名为PyImport_ImportModule()的C API函数完成。 为了运行目标模块，runpy 做了以下三件事：

• 为你指定的模块名调用import()方法；
• 将 name（模块名称）设置到名为main的命名空间；
• 在main命名空间中执行模块。

2.3.3 来自脚本文件或标准输入的输入#

如果python执行时的第一个参数是一个文件名，例如python test.py，CPython将会打开一个文件句柄并将句柄传递给PyRun_SimpleFileExFlags()，这个方法可以处理三种类型的文件路径：

1. 如果文件是.pyc文件，那么它将会调用run_pyc_file()；
2. 如果文件是脚本文件.py，那么它将会调用PyRun_FileExFlags()；
3. 如果文件是stdin，如：用户执行了<command> | python，那么它会将stdin作为一个文件句柄并调用PyRun_FileExFlags()。

2.4.1 CST#

parser-tokenizer接收文本输入并循环执行分词器和解析器，直到光标到达文本末尾才结束（或者出现了一个语法错误）。 在执行前，parser-tokenizer会先创建出一个tok_state实例，分词器会将所有的状态存放到这个临时的数据结构中。分词器状态包括当前光标位置、行等信息。 parser-tokenizer通过调用tok_get()获取到下一个token。tokenizer将token ID传递给parser，parser使用parser-tokenizer生成的 DFA 在具象语法树上创建节点。 举个例子，比如：将算术表达式 “a + 1” 转换成具象语法树，如下图所示：

2.4.2 AST#

下一个阶段是将parser-tokenizer生成的具象语法树转换为能被执行且抽象层次更高的东西。 具象语法树是代码文件中文本的字面表示方式。Python的基本语法结构已经被解释过了，但你无法使用具象语法树来建立函数、作用域或者任何Python语言核心特性。 在代码被编译前，具象语法树需要转换为能表示 Python 实际结构的更高层次的结构。这个能表示具象语法树的结构被称为：抽象语法树（AST）。 比如：在AST中的二元运算操作被称为BinOp并被定义为一种表达式类型。其由三部分构成：

1. left：运算的左侧部分；
2. op：运算符，如：+、-、*；
3. right：运算的右侧部分。

a+1的AST可以这样表示： 与AST相关的文件有：

1. Python/ast.c抽象语法树的实现
2. Parser/Python.asdl在领域特定语言ASDL 5中的抽象语法树节点类型和属性列表集合
3. Include/Python-ast.h抽象语法树节点类型声明，由Parser/asdl_c.py文件生成

最终，Parser的输出类型是一个能表示Python模块的mod_ty。 同样的，在这部分我们关心的是执行流程，关于其中的实现细节会放在第三部分中。

指令#

指令instr具有如下字段:

基础帧块#

Python/flowgraph.c 基础帧块basicblock包含以下字段:

编译单元#

每个代码块为一个编译单元，当前在操作哪一个unit由compiler_enter_scope()和compiler_exit_scope()进行管理。

1
/* The following items change on entry and exit of code blocks.
2
   They must be saved and restored when returning to a block.
3
*/
4
struct compiler_unit {···};

2.5.1 创建符号表#

在编译代码之前，complier会创建出一个符号表(symbol table)。 符号表的目的是提供命名空间、全局和局部变量的列表，供编译器用于引用和解析作用域。 与上一章所讲到的 AST 编译类似，PySymtable_BuildObject()在 mod_ty（也就是AST）的可能类型(Module、Interactive、Expression 和 FunctionType)之间切换并访问其中的每个语句，然后递归地探索 AST的节点和分支，并将条目添加到symtable中。 准备好符号表之后，就开始了正式的编译过程。

2.5.2 核心编译过程#

现在的PyAST_CompileObject()具有编译器状态、symtable 和 AST 形式的模块，实际的编译过程可以开始了。核心编译器有两个目的：

• 将状态、symtable和AST转换成控制流图(CFG)；
• 通过捕获逻辑或代码错误来保护执行阶段免受运行时异常的影响。

AST 模块编译的入口点是compiler_mod()函数，此函数根据模块类型切换到不同的编译器函数，然后循环遍历访问模块中的每个语句。 语句类型是通过调用asdl_seq_GET()确定的， 它会查看AST节点类型，然后调用VISIT宏为每个语句类型调用相应的函数： 小插曲：在这里，编译器用宏做了一个防止表达式作为左值的检查

1
#define asdl_seq_GET(S, I) _Py_RVALUE((S)->typed_elements[(I)])
2
// Prevent using an expression as a l-value.
3
// For example, "int x; _Py_RVALUE(x) = 1;" fails with a compiler error.
4
#define _Py_RVALUE(EXPR) ((void)0, (EXPR))
5
#define VISIT(C, TYPE, V) \
6
    RETURN_IF_ERROR(compiler_visit_ ## TYPE((C), (V)));

比如说，如果当前处理的是一个语句，而语句是for类型，那么compiler_visit_stmt()会调用compile_for()。所有语句和表达式类型都有一个等效的compiler_*()函数。更直接的类型会创建内联字节码指令，而一些更复杂的语句类型会调用其他函数。 简单的说，这里发生了什么呢？compiler_mod()将AST中的节点转换为指令序列，填充到各自的基础帧块中，并将这些基础帧块连接起来，形成CFG（并进行优化）。

2.5.3 汇编过程#

一旦这些编译阶段完成，编译器就会拥有帧块列表，每个帧块都包含指令列表和指向下一个块的指针。汇编器（assembler）对基础帧块执行深度优先搜索（DFS），并将指令合并为单字节码序列。 汇编器 API 有一个入口点：assemble()，它具有以下职责：

• 计算内存分配的块数；
• 确保每个边界情况的块都会返回 None；
• 解析任何被标记为相对的跳转语句偏移；
• 调用dfs()对块执行深度优先搜索；
• 向编译器发送所有指令；
• 把编译器状态作为入参调用makecode()以生成PyCodeObject。

2.5.4 创建Code Object#

makecode()的任务是检查编译器状态和汇编器的一些属性，并通过调用PyCode_New()将这些属性放入PyCodeObject中。变量名和常量会作为属性放到Code Object中。 字节码被送到PyCode_NewWithPosOnlyArgs()之前会被送到PyCode_Optimize()。此函数是Python/peephole.c中字节码优化过程的一部分。 窥孔（peephole）优化器检查字节码指令，并在某些情况下用其他指令替换它们。例如，有一个优化器，它可以删除return语句之后的任何无法访问的指令。

2.6.1 构建线程状态#

需要先将帧（Frame）绑定到一个线程上，它才能够被执行。CPython可以在单个解释器中同时运行多个线程。解释器拥有解释器状态（Interpreter State），其中保存了由这些线程状态组成的链表。 CPython需要至少包含一个线程，而每个线程都有它自己的线程状态。 线程状态（PyThreadState）包含了30多个属性，主要包括：

• 线程的唯一标识符；
• 指向其他线程状态的链表；
• 该线程状态由哪一个解释器状态生成；
• 当前正在执行的帧；
• 当前递归的深度；
• 可选的追踪函数；
• 当前正在处理的异常；
• 当前正在处理的任意异步异常；
• 产生多个异常时抛出的异常栈（例如在 except 代码块中触发的异常）;
• GIL 计数器；
• 异步生成器计数器。

2.6.2 构建帧对象#

编译后的Code Object会被添加到Frame Object中。由于Frame Object是一种Python类型，因此它可以被C或Python引用。执行Code Object中的指令时还需要其他运行时数据，这些数据也包含在Frame Object中，例如局部变量、全局变量和内置模块。 Frame Object的类型是PyObject，它包含了以下属性:

2.6.3 帧的执行#

如前面的编译器和AST部分所述，Code Object除了包含要执行的字节码的二进制编码，还包含了变量列表和符号表。Python中局部和全局变量的值在运行时才会确定，这些值由运行时函数、模块及代码块的调用方式决定。通过函数_PyEval_EvalCode()可以将这些变量的值添加到Frame Object中。除此之外，Frame Object还有一些其他的应用方式，例如协程装饰器会动态的生成一个以目标对象为变量的Frame Object。 PyEval_EvalFrameEx()是一个公共的API，它会调用解释器在eval_frame属性中配置的帧计算函数。基于PEP 523，在Python 3.7实现了帧计算的可插拔性(提供了C API，允许使用第三方代码自定义帧的计算函数)。 _PyEval_EvalFrameDefault()是CPython唯一自带的帧计算默认函数。这个函数是执行帧的关键，它将所有的东西组合到一起，让代码可以运行起来。同时这个函数经历了数十年的持续优化，因为即便是修改一行代码也会对CPython的性能产生巨大的影响。在CPython中，执行任何代码最终都要经过这个帧的求值函数。

2.6.4 值栈#

求值循环将从值栈获取输入从而真正的工作起来。 在核心的求值循环中会创建一个值栈。这个栈包含了一系列指向PyObject实例的指针，这些实例可以是变量、函数的引用（在Pythons中也是对象）或其他类型的Python对象。 求值循环中的字节码指令将从值栈中获取输入。 Python/generated_cases.c.h下:

1
TARGET(BINARY_OP_ADD_INT) {
2
            frame->instr_ptr = next_instr;
3
            next_instr += 2;
4
            INSTRUCTION_STATS(BINARY_OP_ADD_INT);
5
            static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 1, "incorrect cache size");
6
            PyObject *right;
7
            PyObject *left;
8
            PyObject *res;
9
            // _GUARD_BOTH_INT
10
            right = stack_pointer[-1];
11
            left = stack_pointer[-2];
12
            {
13
                DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
14
                DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
15
            }
16
            /* Skip 1 cache entry */
17
            // _BINARY_OP_ADD_INT
18
            {
19
                STAT_INC(BINARY_OP, hit);
20
                res = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);
21
                _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
22
                _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
23
                if (res == NULL) goto pop_2_error;
24
            }
25
            stack_pointer[-2] = res;
26
            stack_pointer += -1;
27
            DISPATCH();
28
        }

比如说:

1
if left or right:
2
    pass

编译器会把操作符or编译成BINARY_OR指令:

1
static int
2
binop(struct compiler *c, operator_ty op)
3
{
4
    switch (op) {
5
        case Add:
6
            return BINARY_ADD;
7
        ...
8
        case BitOr:
9
            return BINARY_OR;
10
        ...

在求值循环中，BINARY_OR将从值栈中获取两个值作为左右操作数（left 和 right），随后以这两个对象作为参数调用函数PyNumber_Or():

1
    ...
2
    case TARGET(BINARY_OR): {
3
          PyObject *right = POP();
4
          PyObject *left = TOP();
5
          PyObject *res = PyNumber_Or(left, right);
6
          Py_DECREF(left);
7
          Py_DECREF(right);
8
          SET_TOP(res);
9
          if (res == NULL)
10
                goto error;
11
          DISPATCH();
12
    }

最后，将求得的结果res放在栈的顶部，覆写了当前栈顶的值。 每一个操作码都有预定义的栈操作，可以由Python/compile.c中的函数 stack_effect()计算得到。这个函数会返回操作码执行后的值栈中元素数目的增量。 这个增量可能是正值、负值或 0。在执行操作码时，若stack_effect()返回值（例如 +1）与值栈中的增量不匹配，就会抛出一个异常。 举个字节码中使用值栈例子:

1
import dis
2

3
g = 11111
4

5
def outer():
6
    c = 22222
7
    def inner():
8
        l = 33333
9
        print(g, c, l)
10
    dis.dis(inner)
11

12
outer()

输出:

1
              0 COPY_FREE_VARS           1
2

3
  7           2 RESUME                   0
4

5
  8           4 LOAD_CONST               1 (33333)
6
              6 STORE_FAST               0 (l)
7

8
  9           8 LOAD_GLOBAL              1 (NULL + print)
9
             18 LOAD_GLOBAL              2 (g)
10
             28 LOAD_DEREF               1 (c)
11
             30 LOAD_FAST                0 (l)
12
             32 CALL                     3
13
             40 POP_TOP
14
             42 RETURN_CONST             0 (None)

18,28,30部分就是将变量加载到值栈当中。

2.6.5 总结#

求值循环是编译后的Python代码和底层 C 的扩展模块、标准库及系统调用之间的接口。虽然CPython解释器有一个核心求值循环，但其实你可以同时执行多个循环，不管它们是并发的还是并行的。CPython可以有多个求值循环去同时执行系统上的多个帧。使用帧栈系统让CPython运行在多核或多个 CPU 上。除此之外，CPython的Frame Object API允许帧以异步编程的方式暂停或恢复执行。