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

来源：互联网发布：excel数据分析插件编辑：程序博客网时间：2024/04/28 15:47

在语法分析里，最主要的组成部份是声明分析，并且这是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;

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里的声明分析出来，如果不合法的声明就会出错。如果合法的声明，就返回相应的类型属性。只要有了声明的类型属性，那么一个变量的定义就完全了解了，也就是说它的语义已经确定下来。只剩下了一个问题没有解决？这个问题是什么呢？下一次再告诉你吧，这一次分析的代码够长的了。