LCC编译器的源程序分析(9)声明分析

在语法分析里,最主要的组成部份是声明分析,并且这是C语言编译器最复杂的组成部分。由于任何变量都需要声明,那么怎么样知道这个变量声明是合法的呢?现在带着这个问题去分下面的代码。
为了理解代码的工作,先来看前面的例子里的第一行有效代码:
typedef unsigned int size_t;
在这句语句里,使用类型定义关键字来声明了一个无符号整数的类型size_t,为了识别这句语句的语法,那么最开始的是类型关键字,它相当于存储类型。接着是无符号、整型,最后才是标识ID。其实上面这句语句也可能有这种形式,如下:
typedef int size_t;
那么上面这句就上面那句少了一个无符号的说明。
要分析这种声明,那么就需要一个函数来把这些属性整理出来,并断它的合法性。LCC里的声明分析是在函数decl里调用函数specifier来实现的:
#001 //说明
#002 static Type specifier(int *sclass)
#003 {
#004 int cls, cons, sign, size, type, vol;
#005 Type ty = NULL;
#006
#007 cls = vol = cons = sign = size = type = 0;
#008 if (sclass == NULL)
#009 {
#010 cls = AUTO;
#011 }
#012
第2行里输入了获取声明的存储类型参数sclass。
一个声明变量有可能出现的说明符就有以下几种:
存储类型、常量说明、符号说明、类型大小、类型、是否删除。
比如像这些语句:
auto int a;
register int iLoop;
auto unsigned int nRet;
static unsigned int g_nRet;
const unsigned int cnstRet;
第4行里就是定义上面几种说明的类型变量保存。
第5行里定义了返回类型保存变量。
第7行是把所有类型说明初始化为0值,表示没有出现这种说明。
第8行到第11行是把存储类型设置为自动类型。由于在C语言里,所有变量声明如果没有明确地指明存储类型时,缺省就是自动类型AUTO。

下面就通过循环来分析出6种说明:
#013 for (;;)
#014 {
#015 int *p, tt = t;
#016 switch (t)
#017 {
#018 case AUTO:
#019 case REGISTER:
#020 if (level <= GLOBAL && cls == 0)
#021 error("invalid use of ‘%k’\n", t);
#022
#023 p = &cls;
#024 t = gettok();
#025 break;
#026
第16行使用switch语句来处理不同的记号类型。
第18行和第19行就是分析存储类型AUTO和REGISTER。
第20行是当全局变量声明而又声明为寄存器类型,就出会提示出错。
第23行保存当前识别出来的类型说明。
第24行获取下一个记号。

#027 case STATIC:
#028 case EXTERN:
#029 case TYPEDEF:
#030 p = &cls;
#031 t = gettok();
#032 break;
#033
上面识别static,extern,typedef的存储类型说明。

#034 case CONST:
#035 p = &cons;
#036 t = gettok();
#037 break;
#038
上面识别常量说明。

#039 case VOLATILE:
#040 p = &vol;
#041 t = gettok();
#042 break;
上面识别优化限制说明,当指定这个属性时,表示这个变量不能优化掉的。

#043 case SIGNED:
#044 case UNSIGNED:
#045 p = &sign;
#046 t = gettok();
#047 break;
上面无符号和有符号的识别。

#048 case LONG:
#049 if (size == LONG)
#050 {
#051 size = 0;
#052 tt = LONG+LONG;
#053 }
#054 p = &size;
#055 t = gettok();
#056 break;
上面识别long类型和long long的64位的类型。

#057 case SHORT:
#058 p = &size;
#059 t = gettok();
#060 break;
#061 case VOID:
#062 case CHAR:
#063 case INT:
#064 case FLOAT:
#065 case DOUBLE:
#066 p = &type;
#067 ty = tsym->type;
#068 t = gettok();
#069 break;
上面这些都是简单类型的识别。

#070 case ENUM:
#071 p = &type;
#072 ty = enumdcl();
#073 break;
上面是枚举类型识别,调用函数enumdcl进行类型的分配。后面再仔细地讨论怎么样处理枚举类型的成品。

#074 case STRUCT:
#075 case UNION:
#076 p = &type;
#077 ty = structdcl(t);
#078 break;
上面结构定义和联合的识别,这也是比较复杂的类型,所以也调用structdcl来进一步处理结构体。

#079 case ID:
#080 if (istypename(t, tsym) && type == 0
#081 && sign == 0 && size == 0)
#082 {
#083 use(tsym, src);
#084 ty = tsym->type;
#085
#086 if (isqual(ty) && ty->size != ty->type->size)
#087 {
#088 ty = unqual(ty);
#089
#090 if (isconst(tsym->type))
#091 ty = qual(CONST, ty);
#092
#093 if (isvolatile(tsym->type))
#094 ty = qual(VOLATILE, ty);
#095
#096 tsym->type = ty;
#097 }
#098
#099 p = &type;
#100 t = gettok();
#101 }
#102 else
#103 {
#104 p = NULL;
#105 }
#106 break;
当把所有的说明符分析完成后,最后肯定是剩下一个ID,如果不是就有可能出错的。
在第80行到第101行里处理ID是自己定义的类型处理,比如用typedef定义的ID类型,就需要在那里识别出类型的属性。
如果这个ID是变量,就会在第104行设置为空,并且在后面的第111行到第114行里跳出来for循环。
#107 default:
#108 p = NULL;
#109 }
#110
#111 if (p == NULL)
#112 {
#113 break;
#114 }
#115
#116 if (*p)
#117 {
#118 error("invalid use of ‘%k’\n", tt);
#119 }
#120
#121 *p = tt;
#122 }
上面在第113行里跳出了for循环,意味着整声明已经分析完成,接着就是把所有分析出来的说明符组成属性结构,保存了到相应的符号表里。

#123
#124 if (sclass)
#125 *sclass = cls;
#126
#127 if (type == 0)
#128 {
#129 type = INT;
#130 ty = inttype;
#131 }
#132
第124行到第125行保存存储类型返回给调用函数。
第127行到第131行是设置类型为缺省值。

#133 if (size == SHORT && type != INT
#134 || size == LONG+LONG && type != INT
#135 || size == LONG && type != INT && type != DOUBLE
#136 || sign && type != INT && type != CHAR)
#137 {
#138 error("invalid type specification\n");
#139 }
#140
第133行到第136行里都判断声明组合是否合法,如果不合法的组合,就需要提示出错。

#141 if (type == CHAR && sign)
#142 {
#143 ty = sign == UNSIGNED ? unsignedchar : signedchar;
#144 }
#145 else if (size == SHORT)
#146 {
#147 ty = sign == UNSIGNED ? unsignedshort : shorttype;
#148 }
#149 else if (size == LONG && type == DOUBLE)
#150 {
#151 ty = longdouble;
#152 }
#153 else if (size == LONG+LONG)
#154 {
#155 ty = sign == UNSIGNED ? unsignedlonglong : longlong;
#156 if (Aflag >= 1)
#157 warning("‘%t’ is a non-ANSI type\n", ty);
#158 }
#159 else if (size == LONG)
#160 {
#161 ty = sign == UNSIGNED ? unsignedlong : longtype;
#162 }
#163 else if (sign == UNSIGNED && type == INT)
#164 {
#165 ty = unsignedtype;
#166 }
#167
第141行到第166行就是根据符号和类型来判断声明的类型,由于类型的大小不同,符号位不同,而组成不同的类型。这些类型都是C编译器预先定义好的。不知道你还记起最开始的类型初始化没有?如果不记起,就回过头去看看。

#168 if (cons == CONST)
#169 ty = qual(CONST, ty);
#170
#171 if (vol == VOLATILE)
#172 ty = qual(VOLATILE, ty);
#173
#174 return ty;
#175 }
第168行把类型添加常量属性。
第171行是类型添加不可删除属性。
第174行就把声明的类型返回给调用函数。
通过上面的代码,就可以把C里的声明分析出来,如果不合法的声明就会出错。如果合法的声明,就返回相应的类型属性。只要有了声明的类型属性,那么一个变量的定义就完全了解了,也就是说它的语义已经确定下来。只剩下了一个问题没有解决?这个问题是什么呢?下一次再告诉你吧,这一次分析的代码够长的了。

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License