当使用通用编程语言1进行编写代码时,我们一定要认识到代码首先是写给人看的,只是恰好可以被机器编译和执行,而很难被人理解和维护的代码是非常糟糕。代码其实是按照约定格式编写的字符串,经过训练的软件工程师能对本来无意义的字符串进行分组和分析,按照约定的语法来理解源代码,并在脑内编译并运行程序。
既然工程师能够按照一定的方式理解和编译 Go 语言的源代码,那么我们如何模拟人理解源代码的方式构建一个能够分析编程语言代码的程序呢。我们在这一节中将介绍词法分析和语法分析这两个重要的编译过程,这两个过程能将原本机器看来无序意义的源文件转换成更容易理解、分析并且结构化的抽象语法树,接下来我们就看一看解析器眼中的 Go 语言是什么样的。
2.2.1 词法分析
源代码在计算机『眼中』其实是一团乱麻,一个由字符组成的、无法被理解的字符串,所有的字符在计算器看来并没有什么区别,为了理解这些字符我们需要做的第一件事情就是将字符串分组,这能够降低理解字符串的成本,简化源代码的分析过程。
make(chan int)
哪怕是不懂编程的人看到上述文本的第一反应也应该会将上述字符串分成几个部分 - make、chan、int 和括号,这个凭直觉分解文本的过程就是词法分析,词法分析是将字符序列转换为标记(token)序列的过程2。
lex
lex3 是用于生成词法分析器的工具,lex 生成的代码能够将一个文件中的字符分解成 Token 序列,很多语言在设计早期都会使用它快速设计出原型。词法分析作为具有固定模式的任务,出现这种更抽象的工具必然的,lex 作为一个代码生成器,使用了类似 C 语言的语法,我们将 lex 理解为正则匹配的生成器,它会使用正则匹配扫描输入的字符流,下面是一个 lex 文件的示例:
% {#
include < stdio.h >
%
}
% %
package printf("PACKAGE ");
import printf("IMPORT ");\.printf("DOT ");\ {
printf("LBRACE ");\
}
printf("RBRACE ");\
(printf("LPAREN ");\) printf("RPAREN ");\
" printf("
QUOTE ");\
n printf("\n");
[0 - 9] + printf("NUMBER ");
[a - zA - Z_] + printf("IDENT "); % %
这个定义好的文件能够解析 package 和 import 关键字、常见的特殊字符、数字以及标识符,虽然这里的规则可能有一些简陋和不完善,但是用来解析下面的这一段代码还是比较轻松的:
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello")
}
.l 结尾的 lex 代码并不能直接运行,我们首先需要通过 lex 命令将上面的 simplego.l 展开成 C 语言代码,这里可以直接执行如下所示的命令编译并打印文件中的内容:
$ lex simplego.l
$ cat lex.yy.c
...
int yylex(void) {
...
while(1) {
...
yy_match:
do {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI( * yy_cp)];
if (yy_accept[yy_current_state]) {
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
yy_current_state = (int) yy_def[yy_current_state];
if (yy_current_state >= 30)
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
} while (yy_base[yy_current_state] != 37);
...
do_action:
switch (yy_act)
case 0:
...
case 1:
YY_RULE_SETUP
printf("PACKAGE ");
YY_BREAK
...
}
lex.yy.c4 的前 600 行基本都是宏和函数的声明和定义,后面生成的代码大都是为 yylex 这个函数服务的,这个函数使用有限自动机(Deterministic Finite Automaton、DFA)5的程序结构来分析输入的字符流,上述代码中 while 循环就是这个有限自动机的主体,你如果仔细看这个文件生成的代码会发现当前的文件中并不存在 main 函数,main 函数是在 liblex 库中定义的,所以在编译时其实需要添加额外的 -ll 选项:
$ cc lex.yy.c -o simplego -ll
$ cat main.go | ./simplego
当我们将 C 语言代码通过 gcc 编译成二进制代码之后,就可以使用管道将上面提到的 Go 语言代码作为输入传递到生成的词法分析器中,这个词法分析器会打印出如下的内容:
PACKAGE IDENT
IMPORT LPAREN
QUOTE IDENT QUOTE
RPAREN
IDENT IDENT LPAREN RPAREN LBRACE
IDENT DOT IDENT LPAREN QUOTE IDENT QUOTE RPAREN
RBRACE
从上面的输出我们能够看到 Go 源代码的影子,lex 生成的词法分析器 lexer 通过正则匹配的方式将机器原本很难理解的字符串进行分解成很多的 Token,有利于后面的处理。
![](data:image/png;base64,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)
图 2-7 从 .l 文件到二进制
到这里我们已经为各位读者展示了从定义 .l 文件、使用 lex 将 .l 文件编译成 C 语言代码以及二进制的全过程,而最后生成的词法分析器也能够将简单的 Go 语言代码进行转换成 Token 序列。lex 的使用还是比较简单的,我们可以使用它快速实现词法分析器,相信各位读者对它也有了一定的了解。
Go
Go 语言的词法解析是通过 src/cmd/compile/internal/syntax/scanner.go6 文件中的 cmd/compile/internal/syntax.scanner 结构体实现的,这个结构体会持有当前扫描的数据源文件、启用的模式和当前被扫描到的 Token:
type scanner struct {
source
mode uint
nlsemi bool
// current token, valid after calling next()
line, col uint
blank bool // line is blank up to col
tok token
lit string // valid if tok is _Name, _Literal, or _Semi ("semicolon", "newline", or "EOF"); may be malformed if bad is true
bad bool // valid if tok is _Literal, true if a syntax error occurred, lit may be malformed
kind LitKind // valid if tok is _Literal
op Operator // valid if tok is _Operator, _AssignOp, or _IncOp
prec int // valid if tok is _Operator, _AssignOp, or _IncOp
}
src/cmd/compile/internal/syntax/tokens.go7 文件中定义了 Go 语言中支持的全部 Token 类型,所有的 token 类型都是正整数,你可以在这个文件中找到一些常见 Token 的定义,例如:操作符、括号和关键字等:
const (
_ token = iota _EOF // EOF
// operators and operations
_Operator // op
...
// delimiters
_Lparen // (
_Lbrack // [
...
// keywords
_Break // break
..._Type // type
_Var // var
tokenCount //
)
从 Go 语言中定义的 Token 类型,我们可以将语言中的元素分成几个不同的类别,分别是名称和字面量、操作符、分隔符和关键字。词法分析主要是由 cmd/compile/internal/syntax.scanner 这个结构体中的 cmd/compile/internal/syntax.scanner.next 方法驱动,这个 250 行函数的主体是一个 switch/case 结构:
cmd/compile/internal/syntax.scanner 每次都会通过 cmd/compile/internal/syntax.source.nextch 函数获取文件中最近的未被解析的字符,然后根据当前字符的不同执行不同的 case,如果遇到了空格和换行符这些空白字符会直接跳过,如果当前字符是 0 就会执行 cmd/compile/internal/syntax.scanner.number 方法尝试匹配一个数字。
func(s * scanner) number(seenPoint bool) {
kind: = IntLit
base: = 10 // number base
digsep: = 0
invalid: = -1 // index of invalid digit in literal, or < 0
s.kind = IntLit
if !seenPoint {
digsep |= s.digits(base, & invalid)
}
s.setLit(kind, ok)
}
func(s * scanner) digits(base int, invalid * int)(digsep int) {
max: = rune('0' + base)
for isDecimal(s.ch) || s.ch == '_' {
ds: = 1
if s.ch == '_' {
ds = 2
} else if s.ch >= max && * invalid < 0 {
_, col: = s.pos() * invalid = int(col - s.col) // record invalid rune index
}
digsep |= ds
s.nextch()
}
return
}
上述的 cmd/compile/internal/syntax.scanner.number 方法省略了很多的代码,包括如何匹配浮点数、指数和复数,我们只是简单看一下词法分析匹配整数的逻辑:在 for 循环中不断获取最新的字符,将字符通过 cmd/compile/internal/syntax.source.nextch 方法追加到 cmd/compile/internal/syntax.scanner 持有的缓冲区中;
当前包中的词法分析器 cmd/compile/internal/syntax.scanner 也只是为上层提供了 cmd/compile/internal/syntax.scanner.next 方法,词法解析的过程都是惰性的,只有在上层的解析器需要时才会调用 cmd/compile/internal/syntax.scanner.next 获取最新的 Token。
Go 语言的词法元素相对来说还是比较简单,使用这种巨大的 switch/case 进行词法解析也比较方便和顺手,早期的 Go 语言虽然使用 lex 这种工具来生成词法解析器,但是最后还是使用 Go 来实现词法分析器,用自己写的词法分析器来解析自己8。
2.2.2 语法分析
语法分析是根据某种特定的形式文法(Grammar)对 Token 序列构成的输入文本进行分析并确定其语法结构的过程9。从上面的定义来看,词法分析器输出的结果 — Token 序列是语法分析器的输入。
语法分析的过程会使用自顶向下或者自底向上的方式进行推导,在介绍 Go 语言语法分析之前,我们会先来介绍语法分析中的文法和分析方法。
文法
上下文无关文法是用来形式化、精确描述某种编程语言的工具,我们能够通过文法定义一种语言的语法,它主要包含一系列用于转换字符串的生产规则(Production rule)10。上下文无关文法中的每一个生产规则都会将规则左侧的非终结符转换成右侧的字符串,文法都由以下的四个部分组成:
终结符是文法中无法再被展开的符号,而非终结符与之相反,还可以通过生产规则进行展开,例如 “id”、“123” 等标识或者字面量11。
N 有限个非终结符的集合;
Σ 有限个终结符的集合;
P 有限个生产规则12的集合;
S 非终结符集合中唯一的开始符号;
文法被定义成一个四元组 (N,Σ,P,S),这个元组中的几部分是上面提到的四个符号,其中最为重要的就是生产规则,每个生产规则都会包含非终结符、终结符或者开始符号,我们在这里可以举个简单的例子:
S→aSb
S→ab
S→ϵ
上述规则构成的文法就能够表示 ab、aabb 以及 aaa..bbb 等字符串,编程语言的文法就是由这一系列的生产规则表示的,在这里我们可以从 src/cmd/compile/internal/syntax/parser.go13 文件中摘抄一些 Go 语言文法的生产规则:
SourceFile = PackageClause ";" {
ImportDecl ";"
} {
TopLevelDecl ";"
}.
PackageClause = "package"
PackageName.
PackageName = identifier.
ImportDecl = "import" (ImportSpec | "(" {
ImportSpec ";"
}
")").
ImportSpec = ["." | PackageName] ImportPath.
ImportPath = string_lit.
TopLevelDecl = Declaration | FunctionDecl | MethodDecl.
Declaration = ConstDecl | TypeDecl | VarDecl.
Go 语言更详细的文法可以从 Language Specification14 中找到,这里不仅包含语言的文法,还包含词法元素、内置函数等信息。
因为每个 Go 源代码文件最终都会被解析成一个独立的抽象语法树,所以语法树最顶层的结构或者开始符号都是 SourceFile:
SourceFile = PackageClause ";" { ImportDecl ";" } { TopLevelDecl ";" } .
从 SourceFile 相关的生产规则我们可以看出,每一个文件都包含一个 package 的定义以及可选的 import 声明和其他的顶层声明(TopLevelDecl),每一个 SourceFile 在编译器中都对应一个 cmd/compile/internal/syntax.File 结构体,你能从它们的定义中轻松找到两者的联系:
type File struct {
Pragma Pragma
PkgName * Name
DeclList[] Decl
Lines uint
node
}
顶层声明有五大类型,分别是常量、类型、变量、函数和方法,你可以在文件 src/cmd/compile/internal/syntax/parser.go 中找到这五大类型的定义。
ConstDecl = "const" (ConstSpec | "(" {
ConstSpec ";"
}
")").
ConstSpec = IdentifierList[[Type]
"="
ExpressionList].
TypeDecl = "type" (TypeSpec | "(" {
TypeSpec ";"
}
")").
TypeSpec = AliasDecl | TypeDef.
AliasDecl = identifier "="
Type.
TypeDef = identifier Type.
VarDecl = "var" (VarSpec | "(" {
VarSpec ";"
}
")").
VarSpec = IdentifierList(Type["="
ExpressionList] | "="
ExpressionList).
上述的文法分别定义了 Go 语言中常量、类型和变量三种常见的结构,从文法中可以看到语言中的很多关键字 const、type 和 var,稍微回想一下我们日常接触的 Go 语言代码就能验证这里文法的正确性。
除了三种简单的语法结构之外,函数和方法的定义就更加复杂,从下面的文法我们可以看到 Statement 总共可以转换成 15 种不同的语法结构,这些语法结构就包括我们经常使用的 switch/case、if/else、for 循环以及 select 等语句:
FunctionDecl = "func"
FunctionName Signature[FunctionBody].
FunctionName = identifier.
FunctionBody = Block.
MethodDecl = "func"
Receiver MethodName Signature[FunctionBody].
Receiver = Parameters.
Block = "{"
StatementList "}".
StatementList = {
Statement ";"
}.
Statement =
Declaration | LabeledStmt | SimpleStmt |
GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
DeferStmt.
SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl.
这些不同的语法结构共同定义了 Go 语言中能够使用的语法结构和表达式,对于 Statement 展开的更多内容这篇文章就不会详细介绍了,感兴趣的读者可以直接查看 Go 语言说明书或者直接从 src/cmd/compile/internal/syntax/parser.go 文件中找到想要的答案。
分析方法
语法分析的分析方法一般分为自顶向下和自底向上两种,这两种方式会使用不同的方式对输入的 Token 序列进行推导:
自顶向下分析:可以被看作找到当前输入流最左推导的过程,对于任意一个输入流,根据当前的输入符号,确定一个生产规则,使用生产规则右侧的符号替代相应的非终结符向下推导15;
自底向上分析:语法分析器从输入流开始,每次都尝试重写最右侧的多个符号,这其实是说解析器会从最简单的符号进行推导,在解析的最后合并成开始符号16;
如果读者无法理解上述的定义也没有关系,我们会在这一节的剩余部分介绍两种不同的分析方法以及它们的具体分析过程。
自顶向下
LL 文法17是一种使用自顶向下分析方法的文法,下面给出了一个常见的 LL 文法:
S→aS1
S1→bS1
S1→ϵ
假设我们存在以上的生产规则和输入流 abb,如果这里使用自顶向下的方式进行语法分析,我们可以理解为每次解析器会通过新加入的字符判断应该使用什么方式展开当前的输入流:
S (开始符号)
aS1(规则 1)
abS1(规则 2)
abbS1(规则 2)
abb(规则 3)
这种分析方法一定会从开始符号分析,通过下一个即将入栈的符号判断应该如何对当前堆栈中最右侧的非终结符(S 或 S1)进行展开,直到整个字符串中不存在任何的非终结符,整个解析过程才会结束。
自底向上
但是如果我们使用自底向上的方式对输入流进行分析时,处理过程就会完全不同了,常见的四种文法 LR(0)、SLR、LR(1) 和 LALR(1) 使用了自底向上的处理方式18,我们可以简单写一个与上一节中效果相同的 LR(0) 文法:
S→S1
S1→S1b
S1→a
使用上述等效的文法处理同样地输入流 abb 会使用完全不同的过程对输入流进行展开:
a(入栈)
S1(规则 3)
S1b(入栈)
S1(规则 2)
S1b(入栈)
S1(规则 2)
S(规则 1)
自底向上的分析过程会维护一个栈用于存储未被归约的符号,在整个过程中会执行两种不同的操作,一种叫做入栈(Shift),也就是将下一个符号入栈,另一种叫做归约(Reduce),也就是对最右侧的字符串按照生产规则进行合并。
上述的分析过程和自顶向下的分析方法完全不同,这两种不同的分析方法其实也代表了计算机科学中两种不同的思想 — 从抽象到具体和从具体到抽象。
Lookahead
在语法分析中除了 LL 和 LR 这两种不同类型的语法分析方法之外,还存在另一个非常重要的概念,就是向前查看(Lookahead),在不同生产规则发生冲突时,当前解析器需要通过预读一些 Token 判断当前应该用什么生产规则对输入流进行展开或者归约19,例如在 LALR(1) 文法中,需要预读一个 Token 保证出现冲突的生产规则能够被正确处理。
Go
Go 语言的解析器使用了 LALR(1) 的文法来解析词法分析过程中输出的 Token 序列20,最右推导加向前查看构成了 Go 语言解析器的最基本原理,也是大多数编程语言的选择。
我们在概述中已经介绍了编译器的主函数,该函数调用的 cmd/compile/internal/gc.parseFiles 会使用多个 Goroutine 来解析源文件,解析的过程会调用 cmd/compile/internal/syntax.Parse,该函数初始化了一个新的 cmd/compile/internal/syntax.parser 结构体并通过 cmd/compile/internal/syntax.parser.fileOrNil 方法开启对当前文件的词法和语法解析:
func Parse(base * PosBase, src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode)(_ * File, first error) {
var p parser
p.init(base, src, errh, pragh, mode)
p.next()
return p.fileOrNil(), p.first
}
cmd/compile/internal/syntax.parser.fileOrNil 方法其实是对上面介绍的 Go 语言文法的实现,该方法首先会解析文件开头的 package 定义:
// SourceFile = PackageClause ";" { ImportDecl ";" } { TopLevelDecl ";" } .
func(p * parser) fileOrNil() * File {
f: = new(File)
f.pos = p.pos()
if !p.got(_Package) {
p.syntaxError("package statement must be first")
return nil
}
f.PkgName = p.name()
p.want(_Semi)
从上面的这一段方法中我们可以看出,当前方法会通过 cmd/compile/internal/syntax.parser.got 来判断下一个 Token 是不是 package 关键字,如果是 package 关键字,就会执行 cmd/compile/internal/syntax.parser.name 来匹配一个包名并将结果保存到返回的文件结构体中。
for p.got(_Import) {
f.DeclList = p.appendGroup(f.DeclList, p.importDecl)
p.want(_Semi)
}
确定了当前文件的包名之后,就开始解析可选的 import 声明,每一个 import 在解析器看来都是一个声明语句,这些声明语句都会被加入到文件的 DeclList 中。
在这之后会根据编译器获取的关键字进入 switch 的不同分支,这些分支调用 cmd/compile/internal/syntax.parser.appendGroup 方法并在方法中传入用于处理对应类型语句的 cmd/compile/internal/syntax.parser.constDecl、cmd/compile/internal/syntax.parser.typeDecl 函数。
for p.tok != _EOF {
switch p.tok {
case _Const:
p.next()
f.DeclList = p.appendGroup(f.DeclList, p.constDecl)
case _Type:
p.next()
f.DeclList = p.appendGroup(f.DeclList, p.typeDecl)
case _Var:
p.next()
f.DeclList = p.appendGroup(f.DeclList, p.varDecl)
case _Func:
p.next()
if d: = p.funcDeclOrNil();
d != nil {
f.DeclList = append(f.DeclList, d)
}
default:
...
}
}
f.Lines = p.source.line
return f
}
cmd/compile/internal/syntax.parser.fileOrNil 使用了非常多的子方法对输入的文件进行语法分析,并在最后会返回文件开始创建的 cmd/compile/internal/syntax.File 结构体。
读到这里的人可能会有一些疑惑,为什么没有看到词法分析的代码,这是因为词法分析器 cmd/compile/internal/syntax.scanner 作为结构体被嵌入到了 cmd/compile/internal/syntax.parser 中,所以这个方法中的 p.next() 实际上调用的是 cmd/compile/internal/syntax.scanner.next 方法,它会直接获取文件中的下一个 Token,所以词法和语法分析一起进行的。
cmd/compile/internal/syntax.parser.fileOrNil 与在这个方法中执行的其他子方法共同构成了一棵树,这棵树根节点是 cmd/compile/internal/syntax.parser.fileOrNil,子节点是 cmd/compile/internal/syntax.parser.importDecl、cmd/compile/internal/syntax.parser.constDecl 等方法,它们与 Go 语言文法中的生产规则一一对应。
![](data:image/png;base64,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)
图 2-8 Go 语言解析器的方法
cmd/compile/internal/syntax.parser.fileOrNil、cmd/compile/internal/syntax.parser.constDecl 等方法对应了 Go 语言中的生产规则,例如 cmd/compile/internal/syntax.parser.fileOrNil 实现的是:
SourceFile = PackageClause ";" { ImportDecl ";" } { TopLevelDecl ";" } .
我们根据这个规则能很好地理解语法分析器的实现原理 - 将编程语言的所有生产规则映射到对应的方法上,这些方法构成的树形结构最终会返回一个抽象语法树。
因为大多数方法的实现都非常相似,所以这里就仅介绍 cmd/compile/internal/syntax.parser.fileOrNil 方法的实现了,想要了解其他方法的实现原理,读者可以自行查看 src/cmd/compile/internal/syntax/parser.go 文件,该文件包含了语法分析阶段的全部方法。
辅助方法
虽然这里不会展开介绍其他类似方法的实现,但是解析器运行过程中有几个辅助方法我们还是要简单说明一下,首先就是 cmd/compile/internal/syntax.parser.got 和 cmd/compile/internal/syntax.parser.want 这两个常见的方法:
func(p * parser) got(tok token) bool {
if p.tok == tok {
p.next()
return true
}
return false
}
func(p * parser) want(tok token) {
if !p.got(tok) {
p.syntaxError("expecting " + tokstring(tok))
p.advance()
}
}
cmd/compile/internal/syntax.parser.got 只是用于快速判断一些语句中的关键字,如果当前解析器中的 Token 是传入的 Token 就会直接跳过该 Token 并返回 true;而 cmd/compile/internal/syntax.parser.want 就是对 cmd/compile/internal/syntax.parser.got 的简单封装了,如果当前 Token 不是我们期望的,就会立刻返回语法错误并结束这次编译。
这两个方法的引入能够帮助工程师在上层减少判断关键字的大量重复逻辑,让上层语法分析过程的实现更加清晰。
另一个方法 cmd/compile/internal/synctax.parser.appendGroup 的实现就稍微复杂了一点,它的主要作用就是找出批量的定义,我们可以简单举一个例子:
var (
a int
b int
)
这两个变量其实属于同一个组(Group),各种顶层定义的结构体 cmd/compile/internal/syntax.parser.constDecl、cmd/compile/internal/syntax.parser.varDecl 在进行语法分析时有一个额外的参数 cmd/compile/internal/syntax.Group,这个参数是通过 cmd/compile/internal/syntax.parser.appendGroup 方法传递进去的:
func(p * parser) appendGroup(list[] Decl, f func( * Group) Decl)[] Decl {
if p.tok == _Lparen {
g: = new(Group)
p.list(_Lparen, _Semi, _Rparen, func() bool {
list = append(list, f(g))
return false
})
} else {
list = append(list, f(nil))
}
return list
}
cmd/compile/internal/syntax.parser.appendGroup 方法会调用传入的 f 方法对输入流进行匹配并将匹配的结果追加到另一个参数 cmd/compile/internal/syntax.File 结构体中的 DeclList 数组中,import、const、var、type 和 func 声明语句都是调用 cmd/compile/internal/syntax.parser.appendGroup 方法解析的。
节点
语法分析器最终会使用不同的结构体来构建抽象语法树中的节点,其中根节点 cmd/compile/internal/syntax.File 我们已经在上面介绍过了,其中包含了当前文件的包名、所有声明结构的列表和文件的行数:
type File struct {
Pragma Pragma
PkgName * Name
DeclList[] Decl
Lines uint
node
}
src/cmd/compile/internal/syntax/nodes.go 文件中也定义了其他节点的结构体,其中包含全部声明类型的,这里简单看一下函数声明的结构:
type(
Decl interface {
Node
aDecl()
}
FuncDecl struct {
Attr map[string] bool
Recv * Field
Name * Name
Type * FuncType
Body * BlockStmt
Pragma Pragma
decl
}
}
从函数定义中我们可以看出,函数在语法结构上主要由接受者、函数名、函数类型和函数体几个部分组成,函数体 cmd/compile/internal/syntax.BlockStmt 是由一系列的表达式组成的,这些表达式共同组成了函数的主体:
![](data:image/png;base64,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)
图 2-9 Go 语言函数定义的结构体
函数的主体其实是一个 cmd/compile/internal/syntax.Stmt 数组,cmd/compile/internal/syntax.Stmt 是一个接口,实现该接口的类型其实也非常多,总共有 14 种不同类型的 cmd/compile/internal/syntax.Stmt 实现:
![](data:image/png;base64,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)
图 2-9 Go 语言的 14 种声明
这些不同类型的 cmd/compile/internal/syntax.Stmt 构成了全部命令式的 Go 语言代码,从中我们可以看到很多熟悉的控制结构,例如 if、for、switch 和 select,这些命令式的结构在其他的编程语言中也非常常见。
2.2.3 小结
这一节介绍了 Go 语言的词法分析和语法分析过程,我们不仅从理论的层面介绍了词法和语法分析的原理,还从源代码出发详细分析 Go 语言的编译器是如何在底层实现词法和语法解析功能的。
了解 Go 语言的词法分析器 cmd/compile/internal/syntax.scanner 和语法分析器 cmd/compile/internal/syntax.parser 让我们对解析器处理源代码的过程有着比较清楚的认识,同时我们也在 Go 语言的文法和语法分析器中找到了熟悉的关键字和语法结构,加深了对 Go 语言的理解。