C语言的符号表和类型系统1
阅读博客的朋友可以到我的网易云课堂中，通过视频的方式查看代码的调试和执行过程：
http://study.163.com/course/courseMain.htm?courseId=1002830012
绝大多数编程语言都可以分成三部分：声明(declaration)，表达式(expression)，语句模块(statement). 每部分都有专门的语法来定义，在上一节中，我们通过语法定义了C语言的变量声明，并通过解析器成功实现了变量声明的语法解析。
对于C语言中的一段函数代码，便可分割成对应于上面所说的三部分。函数声明中的函数名，返回值和输入参数例如：
int fun(int arg1, int arg2);
就可以对应于上面三部分中的声明部分。函数的主体则对应于表达式和语句模块部分。
在对代码的声明部分进行语法解析时，我们需要构建一种数据结构，以便于支持具体的代码生成，这种数据结构，就是我们接下来要研究的符号表。符号表本质上是一种数据库，用来存储代码中的变量，函数调用等相关信息。该表以key-value 的方式存储数据。变量和函数的名字就用来对应表中的key部分，value部分包含一系列信息，例如变量的类型，所占据的字节长度，或是函数的返回值。当我们的解析器读取源代码，遇到声明部分时，便给符号表添加一条记录，如果变量或函数脱离了它的作用范围时，便将他们对应的记录从表中删除。例如：
{
int variable = 0;
}
在上面代码中，进入大括号时，解析器遇到变量的声明，于是便把变量variable 的相关信息写入符号表。当解析器读取到右括号时，便把variable在符号表中的信息给删除，因为出了variable的作用范围只在括号之内。
符号表还可以用来存储类型定义(typedef)和常量声明，在词法解析的过程，词法解析器还需要和符号表交互，用于确定一个变量名是否属于一种类型定义，例如：
typedef char SingleByte
当词法解析器读取SingleByte这个字符串后，会在符号表中查询这个字符串所对应的记录，由于每个记录都有一个标志位，用来表明该字符串是否属于变量声明，于是词法解析器从记录中读取这个标志位，发现SingleByte对应的标志位被设置为1，因此词法解析器就不会把SingleByte当做普通的变量处理，而是当做关键字来处理。
符号表作为一种数据库，它必须具备以下特点：
- 速度。由于符号表会被编译器频繁写入和读取，因此记录的写入，查询速度必须足够快。为了保证速度，整个符号表会直接存储在内存中，由此符号表的设计必须仔细考虑内存消耗。
- 维护性。符号表几乎是编译器中，最复杂的数据结构。它的设计必须灵活可扩展，使得除了编译器外，其他应用程序或模块也能良好的访问符号表。
- 灵活性。C语言的变量声明系统很复杂，例如它允许类型关键字的相互组合等(long int, long doube *…), 因此符号表必须能支持各种不同的变量声明方式。
- 重复性支持。由于对大多数编程语言而言，在不同的间套下，重复的变量名是允许的：
int variable = 0;
{
int variable = 1;
}
例如上面例子中，两个变量虽然拥有相同的名字，但却是合法的。在大括号内的变量会覆盖(shadow) 外层同名变量。因此符号表必须支持同一个key, 但却可以映射到不同的value.
- 易删除。由于变量可能随时超出作用范围，因此一旦语法解析器发现变量失效后，必须能快速的将其从符号表中删除。
符号表的数据结构设计
为了应对上面的需求，我们可通过哈希表来实现符号表的设计。由于哈希表的插入和删除平均耗时是O(1), 因此它能满足快速的插入和删除这一要求，如果遇到作用域不同的同名变量，他们必然被哈希到同一个位置，那么我们可以用链表把哈希到同一个地方的记录串联起来，这样就解决了支持重复性的问题。举个具体例子：
int Godot;
void waiting(int vladmir, int estragon) {
int pozzo;
while (condition) {
int pozzo, lucky;
}
}
在上面的代码中，Godto 和 waiting是属于第一层的变量，函数waiting的参数vladmir, estragon ,和内部变量 pozzo 属于第二层的变量。while 体内的变量 pozzo, 和 lucky 属于第三层的变量，而且两个pozzo是同名变量。
于是通过链式哈希表来实现符号表的过程如下：
所有的变量都存储到哈希表中，同名变量pozzo被哈希到同一个位置，所有用队列连接起来，由于我们使用变量名做哈希，因此不同变量名也有可能哈希到同一个地方，假定vladmir哈希到与pozzo相同的地方，所以vladmir也在同一个队列中。
在头顶还有一个队列，用来存储不同层次的变量起始指针，例如Godot, waiting 属于第一层次的变量，因此头部队列的第一个元素存储指针，指向第一个变量Godot, 然后Godot自己又引出一个指针，指向同一层的另一个变量wait, 由此，同一层的变量实际上是通过一个队列连接起来，这个队列的头指针就存储在Cross link 列表中。
第二层三个变量vladmir, estragon, pozzo , 也组成一个队列：vladmir->estragon->pozzo, 这个队列的头指针就存放在cross link列表的第二个元素。第三层以此类推。
符号表中的一个记录，我们可以用如下java代码表示（symbol.java)：
public class Symbol {
String name;
String rname;
int level; //变量的层次
boolean implicit; //是否是匿名变量
boolean duplicate; //是否是同名变量
Symbol args; //如果该符号对应的是函数名,那么args指向函数的输入参数符号列表
Symbol next; //指向下一个同层次的变量符号
}哈希表中的记录，我们用SymbolEntry来表示，代码如下：
public class SymbolEntry {
private Symbol symbol;
private SymbolEntry prev, next;
public SymbolEntry(Symbol sym) {
this.symbol = sym;
}
public void setPrev(SymbolEntry prev) {
this.prev = prev;
}
public void setNext(SymbolEntry next) {
this.next = next;
}
public SymbolEntry getPrev() {
return prev;
}
public SymbolEntry getNext() {
return next;
}
}
用于解决哈希冲突的链表是双向链表，所以SymbolEntry中有两个对象指针，prev 和 next, 分别指向当前符号的前缀和后缀，这种双向链表的设计有利于在队列中对元素进行删除。
类型系统
接下来的问题是，如何表示变量的类型，如果语言足够简单，那么类型可以用一些整形数组来表示，例如0表示整数，1表示浮点数。指针类型，例如int* 可以用数值3来表示。这种类型系统，称之为限制行类型系统，因为这种方法只能表示有限中类型。
像C语言这种拥有复杂类型表示方式的语言，上面的方法就捉襟见肘了。因此要表示C语言的类型系统，必须设计足够灵活的数据结构。C语言的变量声明包括两部分，一部分叫说明符(specifier),这部分对应各种数据类型关键字，int long, extern, struct等。另一部分叫修饰符，由变量名以及星号，中括号组成，例如 *a, a[10] 等。
说明符部分是有限的，毕竟关键字的数量有限，因此关键字的组合方式也有限，但是，修饰符部分就相当灵活，例如星号*就可以有多个，*和[]又可以相互组合，因此C语言的类型必须由两部分组成，一部分表示说明符部分，另一部分表示修饰符部分。整个类型系统就由包含这两种结构的链表构成。例如声明语句：
short in Quasimodo;
long *Gringoire;
他们的类型系统如下：
类型系统中，说明符部分只有一个，而修饰符部分可以有多个，当然也可以没有，同时，说明符始终放在链表的末尾。通过把链表顺序念下来，就可以读出变量声明语句，例如对于第二个队列，顺序读下来就是：Gringoire is a pointer to long.
如果是一个长整形数组，例如 long Coppenole[10],类型系统的表示如下：
一个指向10个长整形元素的数组指针，long (*Frollo)[10],类型系统表示如下：
这种类型系统有个显著特点是，容易促进代码生成。后面我们可以看到这个效果。
类型系统的实现
修饰符的实现比较简单，代码如下：
public class Declarator {
public static int POINTER = 0;
public static int ARRAY = 1;
public static int FUNCTION = 2;
private int declareType = POINTER;
private int numberOfElements = 0;
public Declarator(int type) {
if (type < POINTER) {
declareType = POINTER;
}
if (type > FUNCTION) {
declareType = FUNCTION;
}
}
public void setElementNum(int num) {
if (num < 0) {
numberOfElements = 0;
} else {
numberOfElements = num;
}
}
public int getType() {
return declareType ;
}
public int getElementNum() {
return numberOfElements;
}
}
上面代码中，declareType 用来表示要修饰的变量是一个指针，数组，还是函数，如果是数组的话，numberOfElements 这个成员用来表示数组含有多少个元素。
说明符的实现稍微麻烦些，代码如下：
public class Specifier {
//type
public static int INT = 0;
public static int CHAR = 1;
public static int VOID = 2;
public static int STRUCTURE = 3;
public static int LABEL = 4;
//storage
public static int FIXED = 0;
public static int REGISTER = 1;
public static int AUTO = 2;
public static int TYPEDEF = 3;
public static int CONSTANT = 4;
public static int NO_OCLASS = 0; //如果内存类型是auto, 那么存储类型就是NO_OCLASS
public static int PUBLIC = 1;
public static int PRIVATE = 2;
public static int EXTERN = 3;
public static int COMMON = 4;
private int basicType;
public void setType(int type) {
basicType = type;
}
public int getType() {
return basicType;
}
private int storageClass;
public void setStorageClass(int s) {
storageClass = s;
}
public int getStorageClass() {
return storageClass;
}
private int outputClass;
public void setOutputClass(int c) {
outputClass = c;
}
public int getOutputClass() {
return outputClass;
}
private boolean isLong = false;
public void setLong(boolean l) {
isLong = l;
}
public boolean getLong() {
return isLong;
}
private boolean isSigned = false;
public void setSign(boolean signed) {
isSigned = signed;
}
public boolean isSign() {
return isSigned;
}
private boolean isStatic = false;
public void setStatic(boolean s) {
isStatic = s;
}
public boolean isStatic() {
return isStatic;
}
private boolean isExternal = false;
public void setExternal(boolean e) {
isExternal = e;
}
public boolean isExternal() {
return isExternal;
}
private int constantValue = 0;
public void setConstantVal(int v) {
constantValue = v;
}
public int getConstantVal() {
return constantValue;
}
private StructDefine vStruct;
}
basicType用来表明变量属于什么类型，当前要做的编译器暂时只支持4种类型，int , char, void , struct, label. storageClass 表示变量的存储方式，FIXED表示变量只能存放在固定的内存地址，AUTO表示当前变量是局部变量，可以存放在堆栈上。如果当前变量是经过typedef修饰的，那么他的值也会设置成TYPEDEF, 例如：
typedef char single;那么变量single对应的说明符中，storageClass的值等于TYPEDEF。
CONSTANT 用来标识常量类型，加入你声明了一个枚举类型：
enum days {
MON, TUE, WED, TUR, FRI, SAU, SUN
};
编译器会将MON,TUE等当做int类型的常值变量加入符号表：
constant int MON = 0;
于是MON, TUE, 等对应的Specifier类中，storageClass的值就是CONSTANT. 同时constantValue也会做相应的设置，例如MON对应的Specifier类，constantValue 等于0， TUE对应的specifier类的constantValue 等于1.
对于字符串常量，编译器会把它转换成一个初始化了的char数组，例如
“contents of string”;
会转换成：
char s1[] = “contents of string”;
这样，编译器就可以建立一个类型列表来描述字符串常量。
Specifier最后还有一个StructDefine类型的成员，如果当前的变量是一个结构体的话，vStruct就不是null, StructDefine的具体定义，我们后面再给出。
isLong用来表示当前变量占据多大字节，默认下int类型占据2字节，long int 占据4字节，因此：
long int x;
变量x对应的Specifier类，isLong就会设置为true.由于编译器默认没有long修饰的变量都占据2字节，所以short关键字会被自动忽略。
isSigned, isStatic, isExternal 用来表明变量是否被对应的关键字所修饰，例如：
external unsigned long int y;
那么变量y对应的Specifier 中，isExternal 等于true, isSigned 等于false, isLong等于true.
类型系统是一个复杂而且繁琐的技术要点，一节不可能讲清楚，本节我们先探讨一部分，在后面的章节中，我们继续就类型系统的理论和代码实现进行深入的了解。