ucc编译器分析与总结(1) 语法分析
编译器、操作系统、数据库是计算机领域中的三大基础软件，基本上所有应用软件都是建立在这三个基础软件之上，这些领域经过前辈们不断打磨现在已经变得非常成熟，很多涉及到的代码技术都是精华中的精华，所以把上面3个软件搞清楚对代码水平的提高会有很多帮助，而且能够对现代计算机的软件架构有更清晰的了解。
我现在要研究一个逻辑推理系统，这个推理系统以C语言为基础，这里必然涉及到C语言的解析问题，所以C语言编译器是必须要先学习的，C语言编译器是把C语言转换成汇编语言，我打算在编译器的基础上生成一些关于逻辑的断言，然后以这些逻辑断言为基础再做一个推理系统。
目前C语言编译器比较成熟的是gcc、clang加llvm，但是这些都太庞大了，这里面有各种技术优化上的考量，个人是没有精力也没有时间掌握的。我需要学习的是编译器的一些基本思想，所以只要看一些小型的开源C语言编译器就可以了，其实还是挺多的，有lcc、ucc、tcc、8cc等等。
我现在打算从ucc入手学编译器，这是国人写的，可读性方面做的比较好，还有大佬对ucc做了非常详细的解析，见
https://blog.csdn.net/sheisc/article/category/2813001
而且还写了一本书叫《c编译器剖析》，对于我来说要以最快的速度学完编译器的一些基本知识，ucc相对来说是一个比较好的选择。
1.基本架构
其实ucc编译器并不是一个完整的编译器，完整的编译器包括预处理器、C编译器、汇编器和连接器，ucc只有把C语言编译成汇编语言的这一部分，如下图所示：
打开ucc的源码，可以看到包含ucc和ucl两部分工程，因为ucc编译器中只做了.i文件生成.s文件的工作，在ucl的代码中完成，所以为了从.c文件生成可执行文件还要在ucc中调用gcc的预处理器、汇编器和连接器的命令来完成整个编译的过程。
现在假如要编译一个test.c文件，可以先运行命令ucc -E -v test.c来生成预处理后的文件test.i,然后再运行ucl -ext:.s test.i来调试分析整个编译的过程。
2.词法分析
现在从ucl.c文件中的main函数来分析整个编译的流程，代码如下
i = ParseCommandLine(argc, argv);
SetupRegisters();
SetupLexer();
SetupTypeSystem();
for (; i < argc; ++i)
{
Compile(argv[i]);
}
首先是寄存器和词法分析器的相关初始化，然后通过for循环由Compile编译每一个.c文件。
之后由ParseTranslationUnit()来完成词法分析和语法分析工作，首先读取整个文件，放在Input的全局变量里，这是一个struct input结构体类型的变量，定义如下：
struct input
{
//文件名，预处理后会把所有.h文件展开到.i文件
//例如 # 667 "/usr/include/stdio.h" 3 4
//会记录头文件名和对应行数
char *filename;
unsigned char *base;//整个文件
//当前解析到的单词的下一个地址
//例如 int aa[4];
//如果现在解析了aa，那么cursor指向[4];
unsigned char *cursor;
unsigned char *lineHead;//每一条语句以;为单位
int line;// 当前在.i文件中的行数
void* file;//文件描述符
void* fileMapping;
unsigned long size;//文件大小
};
另外还一个TokenCoord全局变量是Input的补充，增加了头文件中的行数。在C语言中是以单词为单位的，上面代码的注释中用int aa[4];举了一个例子，这条语句的单词分别为int、aa、[、]、4、; 。ucc会用NEXT_TOKEN取得一个单词放在CurrentToken里，然后再进行语法分析：
#define NEXT_TOKEN CurrentToken = GetNextToken();
CurrentToken是一个枚举型变量，代表一个单词的属性，并不是每个单词字符串本身，每个关键字都会有一个对应的枚举变量，下面是所有token的定义：
enum token
{
TK_BEGIN,
#define TOKEN(k, s) k,
#include "token.h"
#undef TOKEN
};
//keywords
TOKEN(TK_AUTO, "auto")
TOKEN(TK_EXTERN, "extern")
TOKEN(TK_REGISTER, "register")
TOKEN(TK_STATIC, "static")
TOKEN(TK_TYPEDEF, "typedef")
... ...
C语言中定义的标识符Token统一用TK_ID来表示，在取得一个单词的Token后会添加到语法树的结点里。
3.语法分析
词法分析从C源文件中取得单词的token，而语法分析则把这些单词添加到语法树里面。AstNode是语法树结点最基本的结构体：
#define AST_NODE_COMMON \ int kind; \ struct astNode *next; \ struct coord coord;
typedef struct astNode
{
AST_NODE_COMMON
} *AstNode;
其中kind代表结点的类型。next用来把同类的表达式关联在一起，例如用;和，隔开的语句。coord则标记所在文件和与其对应的行数。其他类型的结点由于kind不同所需要的信息不同，结构体会有所差异，但都是在AstNode的基础上扩充而来的。
在语法分析的过程中，首先会先建立一个NK_TranslationUnit类型的根结点，该结点定义如下
struct astTranslationUnit
{
AST_NODE_COMMON
AstNode extDecls;
};
这个根结点把一个.c文件中每一条全局声明语句和函数串联在一起，如下图所示可以直观感受到语法树的特点
代码如下：
AstTranslationUnit ParseTranslationUnit(char *filename)
{
AstTranslationUnit transUnit;
AstNode *tail;
//...
while (CurrentToken != TK_END)
{
*tail = ParseExternalDeclaration();
tail = &(*tail)->next;
SkipTo(FIRST_ExternalDeclaration,
"the beginning of external declaration");
}
}
每个结点可以分为声明语句和表达式两种类型，表达式又由赋值和运算语句组成。以下面的代码举例说明
extern int c；
int test(int a)
{
int b = 1;
a = b+sizeof(int);
if(a>0){
c++;
}
return 0;
}
其中声明语句有
extern int c；
int test(int a){}
int b = 1；
表达式语句有
a = b+sizeof(int);
if(a>0){
c++;
}
return 0;
根据这2种类型的结点会再建立子语法树，层层递归直到语法树结点中的元素为单词为此。
3.1 声明语句
声明语句的解析会在ParseCommonHeader()函数中完成，ParseDeclarationSpecifiers()函数会解析声明关键字如int、static、typedef等，声明中的标识符由ParseInitDeclarator()来解析，碰到逗号通过next指针连接在一起。
while (CurrentToken == TK_COMMA)
{
NEXT_TOKEN;
*tail = (AstNode)ParseInitDeclarator();
tail = &(*tail)->next;
}
声明的语句中可能会初始化如int a = 3；在解析完后再把=后面的语句加入到语法树中
static AstInitDeclarator ParseInitDeclarator(void)
{
AstInitDeclarator initDec;
CREATE_AST_NODE(initDec, InitDeclarator);
initDec->dec = ParseDeclarator(DEC_CONCRETE);
if (CurrentToken == TK_ASSIGN)//遇到=说明要初始化
{
NEXT_TOKEN;
initDec->init = ParseInitializer();
}
return initDec;
}
ParseDeclarator解析具体的声明标识符，后面的参数DEC_CONCRETE说明标识符不可省略，有些地方的声明语句不能有标识符，如sizeof（int）,这时候用DEC_ABSTRACT，还有些地方可有可无，如声明函数的时候int f(int,int); ,这时候调用ParseDeclarator(DEC_CONCRETE|DEC_ABSTRACT);
声明符中可能会碰到指针的情况，*会作为一个单独的语法树结点解析
static AstDeclarator ParseDeclarator(int kind)
{
if (CurrentToken == TK_MUL) //指针声明符*
{
AstPointerDeclarator ptrDec;
CREATE_AST_NODE(ptrDec, PointerDeclarator);
//...
//递归调用继续解析
ptrDec->dec = ParseDeclarator(kind);
return (AstDeclarator) ptrDec;
}
//继续解析非指针情形下的声明标识符
return ParsePostfixDeclarator(kind);
}
在ParsePostfixDeclarator()函数中会调用ParseDirectDeclarator()解析最后的标识符单词，标识符后面跟着[]是数组，跟着()是函数形参，还需要继续解析。
当声明语句中碰到typedef时，会通过CheckTypedefName()函数将声明的标识符加入到TDName列表中记录下来。然后遇到TK_ID的标识符时，会通过IsTypedefName()确认之前有没有通过typedef声明过。在C语言中每个{}代表一个作用域，ucc中用Level标记当前的作用域，作用域每加深一层Level 加1。有时碰到内部作用域定义的变量和外部typedef声明的标识符重名了，需要加到OverloadNames列表中重载。
最后通过一张图来直观感受一下声明语句的解析过程，图片取自《C编译器剖析》
3.2 表达式语句
表达式语句只存在于函数中，在ParseCommonHeader()解析完声明语句后，会检查声明的标识符是否是函数，如果是函数则进一步解析由{}扩起来的符合语句，在ParseCompoundStatement()中完成，函数内部也分为声明语句和表达式语句，分别由ParseDeclaration()和ParseStatement()这两个函数完成。
表达式语句的组成有很多，如赋值语句，if语句，while语句等等，根据当前不同的token来对应解析：
static AstStatement ParseStatement(void)
{
switch (CurrentToken)
{
case TK_ID:
return ParseLabelStatement();
case TK_IF:
return ParseIfStatement();
case TK_SWITCH:
return ParseSwitchStatement();
case TK_WHILE:
return ParseWhileStatement();
case TK_DO:
return ParseDoStatement();
case TK_FOR:
return ParseForStatement();
case TK_GOTO:
return ParseGotoStatement();
//...
default:
return ParseExpressionStatement();
}
}
表达式的结点由struct astExpression结构体定义
struct astExpression
{
AST_NODE_COMMON
Type ty;
int op :16;//表达式对应的操作符
int isarray :1;
int isfunc :1;
int lvalue :1;
int bitfld :1;
int inreg :1;
int unused :11;
//记录2元表达式的前后2个子表达式
struct astExpression *kids[2];
union value val;
};
在碰到非关键字的标识符后会先通过ParseLabelStatement()查看是否是标签语句（例如error：），如果不是那么通过ParseExpressionStatement()来继续解析。首先解析赋值语句，碰到逗号继续递归调用，把下一个表达式连接在comaExpr->kids[1]里
AstExpression ParseExpression(void)
{
AstExpression expr, comaExpr;
expr = ParseAssignmentExpression();
while (CurrentToken == TK_COMMA)
{
CREATE_AST_NODE(comaExpr, Expression);
comaExpr->op = OP_COMMA;
comaExpr->kids[0] = expr;
NEXT_TOKEN;
comaExpr->kids[1] = ParseAssignmentExpression();
expr = comaExpr;
}
return expr;
}
ucc会认为所有的表示式语句都是赋值表达式，如果有赋值符号= *= /= %= += -= <<= >>= &= ^= |=则当成赋值表达式处理，或者没有赋值号当成条件表达式处理。
AstExpression ParseAssignmentExpression(void)
{
AstExpression expr;
expr = ParseConditionalExpression();
if (CurrentToken >= TK_ASSIGN && CurrentToken <= TK_MOD_ASSIGN)
{
//...
}
return expr;
}
赋值号左边的表达式都会当成条件表达式，条件表达式由2元表达式和？组成，没有？则当成2元表达式处理
static AstExpression ParseConditionalExpression(void)
{
AstExpression expr;
expr = ParseBinaryExpression(Prec[OP_OR]);
if (CurrentToken == TK_QUESTION)
{
//...
}
return expr;
}
依次类推，2元表达式由一元表达式和2元运算符组成，一元表达式由ParseUnaryExpression()来解析，1元表达式由前置一元运算符（++ – & * + - ! ~）和没有前置运算符的一元表达式组成，后者由ParsePostfixExpression()来解析,此时没有后缀的表达式由ParsePrimaryExpression()来解析，如果还有后缀.、->、–、++等还要再新建一个结点把前面解析的表示符合后缀连起来。碰到括号等情况会继续递归解析，就不再详细分析了。还要注意的是++运算符在前置和后置时的表示是不同的，前者用OP_PREINC表示后者用OP_POSTINC表示。
在解析2元表达式时，还要注意优先级问题，例如a<<5+3,在解析到5+3时，由于+的优先级比<<高，所以5+3要作为一个整体，而在表达式a*b+3中，+优先级没有*高，b要先作为*的右端开始解析然后再解析+号。
static AstExpression ParseBinaryExpression(int prec)
{
AstExpression binExpr;
AstExpression expr;
int newPrec;
expr = ParseUnaryExpression();
/// while the following binary operater's precedence is higher than current
/// binary operator's precedence, parses a higer precedence expression
while (IsBinaryOP(CurrentToken) && (newPrec = Prec[BINARY_OP]) >= prec)
{
CREATE_AST_NODE(binExpr, Expression);
binExpr->op = BINARY_OP;
binExpr->kids[0] = expr;
NEXT_TOKEN;
binExpr->kids[1] = ParseBinaryExpression(newPrec + 1);
expr = binExpr;
}
return expr;
}
最后仍然根据语法树的图片来直观感受下解析的过程，图片取自《C编译器剖析》
内存分配
最后讲一下内存分配，在ucc编译器中会把内存的分配放在自建的一个堆里进行管理。程序里总共有3个堆，分别为：
- ProgramHeap
用来初始化寄存器的管理和基本的类型系统。 - FileHeap
为每个C文件构建语法树和符号表用。 - StringHeap
存放C文件中字符串和标志符的名称。
每个堆是由一个头部节点和内存节点组成的链表，头部节点不分配内存，并分别指向下一个节点和链表最后一个节点，整体结构如下图所示：
分配内存时由HeapAllocate函数来完成，每一次申请内存时都会新建一个节点并分配相应的空间，在解析完一个文件后，FileHeap堆会重新初始化，堆里的内存并不会释放，而由FreeBlocks指向第2个结点，再次申请内存时会先从FreeBlocks查找有没有足够空间的结点。这里似乎有问题，如果一开始申请一块比较大的空间，让FreeBlocks移到了后面，然后FreeBlocks并没有跳回到前面，导致前面的空间都浪费了。