教你使用swift写编译器玩具（1）

前言

本章对应官方教程第1章，介绍了Kaleidoscope以及实现词法分析器(Lexer)。

教程如下:

教你使用swift写编译器玩具（0）

教你使用swift写编译器玩具（1）

教你使用swift写编译器玩具（2）

教你使用swift写编译器玩具（3）

教你使用swift写编译器玩具（4）

教你使用swift写编译器玩具（5）

教你使用swift写编译器玩具（6）

教你使用swift写编译器玩具（7）

教你使用swift写编译器玩具（8）

仓库在这

Kaleidoscope大概长这样

1
2
3
4
5
6
7
def fib(x)
  if x < 3 then
    1
  else
    fib(x-1)+fib(x-2);
    
fib(40);

本项目参考官方文档编写，为了图方便与官方文档一样写了不少全局变量，这在实际工程中不是一个好的处理方式。

注意：教程中使用extern调用标准库本文并未实现，仅实现了extern的解析。由于本工程一开始把全部变量解析为int64类型而不是Double类型，所以后续章节可能会出现与官方教程生成的中间代码IR不相同的情况，还请各位具体问题具体分析。

开始

我们在实现语言时，首先需要能识别代码内容。通常情况下我们使用词法分析器(Lexer)，将输入分解为Token。首先我们需要定义Token以及CurrentToken结构体。

1
2
3
4
5
6
7
8
9
10
11
12
enum Token {
    case def
    case extern
    case identifier
    case number
    case other
}

struct CurrentToken {
    var token: Token
    var val: String
}

identifier是用来记录变量，而其他的几个Token的枚举一目了然。CurrentToken用来表示当前正在解析的内容。

定义Lexer

在编写详细的token处理之前，我们需要先定义一下Lexer类。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Lexer {
    
    /// 当前的token
    public var currentToken: CurrentToken?
    
    private var lastChar: Character = " "
    
    private var index = 0
    
    /// 代码内容
    private var source: [Character] = []
    
}

本工程解析代码通过index的增加从而依次从source中读取每一个字符进行处理。

获取下一个token

获取当前index对应的字符

1
2
3
4
5
private func getChar() -> Character {
    let char = source[index]
    index += 1
    return char
}

解析当前字符获取下一个currentToken

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/// 获取下一个currentToken
    public func nextToken() {
        var identifierStr = ""
      	//如果是空白则继续往下读取
        while lastChar.isWhitespace {
            lastChar = getChar()
        }
        
        //如果开头是字母的话说明是identifier类型或者是其他关键字
        if lastChar.isLetter {
            identifierStr = String(lastChar)
            lastChar = getChar()
            while lastChar.isNumber || lastChar.isLetter {
                identifierStr.append(lastChar)
                lastChar = getChar()
            }
            
            if identifierStr == "def" {
                currentToken = CurrentToken(token: .def, val: "def")
            } else if identifierStr == "extern" {
                currentToken = CurrentToken(token: .extern, val: "extern")
            } else {
                currentToken = CurrentToken(token: .identifier, val: identifierStr)
            }
            return
        }
        
        //是数字开头的话说明这个是一个数值
        if lastChar.isNumber || lastChar == "." {
            var numStr = ""
            repeat {
                numStr.append(lastChar)
                lastChar = getChar()
            } while lastChar.isNumber || lastChar == "."
            currentToken = CurrentToken(token: .number, val: numStr)
            return
        }
        
        //遇到";"说明这一个函数块结束了
        let thisChar = lastChar
        if thisChar != ";" {
            lastChar = getChar()
        }
        
        //返回其他类型仅作为占位使用
        currentToken = CurrentToken(token: .other, val: String(thisChar))
    }

代码详细的解释都体现在了注释中，现在我们已经完成了一个可以解析token的Lexer了。