从这一部分起，我们将逐步地去实现一个简易C语言编译器。所谓简易，就是会依照C语言的标准，忽略部分的语法，适当降低难度，实现包含基本功能的C语言编译器。我们将把主要的精力放在编译过程这个环节，汇编和链接过程将会使用已有编译器完成。
按照难易程度，我们先跳过前处理过程，直接进入编译阶段的词法分析。我们先从下面这段简单的C语言代码入手：
int main()
{
return (2 + 2) * 2 - 8;
}
我并没有用经典的Hello World!那段代码，因为那几行简单的代码，涉及了非常多的知识。现在，我们需要由浅入深，逐步地去理解编译器的实现方法。到时候再回过头来分析那段经典代码。
上面这段代码非常简单：没有头文件，只有一个主函数，函数内部进行一个简单的四则运算，然后返回结果。结果很容易计算。但别忘了，我们的目的是实现一个编译器，最终让计算机CPU芯片的运算单元来求解这个结果。因此，需要从系统层面思考，去解决一类问题，从而处理更多的类似于这样的计算过程。
前面提到，词法分析是将源代码分解成一个个的token，比如这里可以将源代码分解为下面的一些token：
| int | main | ( | ) | { | return | ( | 2 | + |
|---|---|---|---|---|---|---|---|---|
| 2 | ) | * | 2 | - | 8 | ; | } |
相信大家也看明白了，词法分析就是将这段代码一个一个拆开。对于连续的字符，我们将它们组成为一个token，直到遇到空格为止，当然也包括换行符。因此，如果将int main不小心写成了intmain，它也就成为了一个token，而不会被拆分为int和main。因为这可能就是定义的变量或者函数名，当然也可能只是程序员不小心没有用空格将它们分开。
是不是很容易？下面，我们用Python来实现这部分功能。当然，喝水不忘挖井人，我将沿用这个博客文章（Let's Build A Simple Interpreter）里面所使用的方法和思路。
先定义一直提到的token类。
class Token(object):
def __init__(self, type, value, pos=None):
self.type = type
self.value = value
可以简单地将token理解为一个键值对应的Map。其中，上面的C语言代码会用到的token名字，包括：
# algebra
PLUS = 'PLUS'
MINUS = 'MINUS'
MUL = 'MUL'
# scope
LPAREN = 'LPAREN'
RPAREN = 'RPAREN'
BEGIN = 'BEGIN'
END = 'END'
# symbol
ID = 'ID'
SEMI = 'SEMI'
EOF = 'EOF'
# reserved keywords
INT = 'INT'
RETURN = 'RETURN'
用大写字母表示，是为了区别python中的关键字。有了这些准备，我们就可以定义词法分析的专用类：Lexer。
class Lexer(object):
def __init__(self, text):
self.text = text
self.pos = 0
self.current_char = self.text[self.pos]
def next(self):
"""obtain the next the `pos` pointer ."""
self.pos += 1
if self.pos > len(self.text) - 1:
self.current_char = None # Indicates end of input
else:
self.current_char = self.text[self.pos]
def get_next_token(self):
"""Lexical analyzer. One token at a time."""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char.isalpha():
return self.identifier()
if self.current_char.isdigit():
return self.number()
if self.current_char == '+':
self.next()
return Token(PLUS, '+')
if self.current_char == '-':
self.next()
return Token(MINUS, '-')
if self.current_char == '*':
self.next()
return Token(MUL, '*')
if self.current_char == '(':
self.next()
return Token(LPAREN, '(')
if self.current_char == ')':
self.next()
return Token(RPAREN, ')')
if self.current_char == '{':
self.next()
return Token(BEGIN, '{')
if self.current_char == '}':
self.next()
return Token(END, '}')
if self.current_char == ';':
self.next()
return Token(SEMI, ';')
return Token(EOF, None)
这段代码中的EOF(同eof)代表文件结束符，表明一段源代码已经全部读取完毕。值得注意的是，Lexer类中还缺少三个函数，分别处理空格，数字和标识符。一旦定义了这些函数，我们就可以实例化一个Lexer对象来处理开头的那段C语言代码了。通过循环调用get_next_token()，从而得到拆分出来的一个个token。类似的，处理更加复杂的源代码时，只需要按照C语言语法的定义，增加token的名字，通过判断当前字符是否匹配，就可以依样画葫芦地处理得到对应的token了。
将那三个成员函数单独提出来的原因，是因为实现方法决定了我们是假设每一个字符都可能为一个token。但对于空格、数字或者标志符等，可能需要将多个字符组成为一个token，而不能像其它代数符号那样只去判断一个字符。因此，需要单独的函数进行处理。例如，对于数字的处理如下：
def number(self):
result = ''
while self.current_char is not None \
and self.current_char.isdigit():
result += self.current_char
self.next()
return Token(INT, int(result), self.line)
值得注意的是，我们的编译器不支持浮点运算。在后面进行汇编语言生成的过程中，浮点运算可以说是完整的一大块。从理解编译器的角度出发，掌握理解了整数型运算，就已经差不多了。后续如果大家有兴趣，完全可以扩充方法让编译器支持浮点型，原理都是差不多的。
同理，处理空白字符也是一样的：
def skip_whitespace(self):
# isspace contains '', '\n', '\t', etc.
while self.current_char is not None \
and self.current_char.isspace():
self.next()
然后是标志符的处理：
def identifier(self):
"""Handle identifiers and reserved keywords, and macro definition replace"""
result = ''
while self.current_char is not None and (self.current_char.isalnum() or self.current_char == '_'):
result += self.current_char
self.next()
token = RESERVED_KEYWORDS.get(result.upper(), Token(ID, result))
return token
这里用到了RESERVED_KEYWORDS。顾名思义，RESERVED_KEYWORDS就是预先定义好的保留关键字字典：
RESERVED_KEYWORDS = {
'INT': Token('INT', 'int'),
'RETURN': Token('RETURN', 'return'),
}
至此，词法分析的内容就分析完毕。
实现简易的C语言编译器（part 0）
实现简易的C语言编译器（part 2）
实现简易的C语言编译器（part 3）
实现简易的C语言编译器（part 4）
实现简易的C语言编译器（part 5）
实现简易的C语言编译器（part 6）
实现简易的C语言编译器（part 7）
实现简易的C语言编译器（part 8）
实现简易的C语言编译器（part 9）
实现简易的C语言编译器（part 10）
实现简易的C语言编译器（part 11）