LCC编译器的源程序分析(16)函数的声明
在第一节介绍的例子里，就需要使用到函数声明。比如下面的语句：
printf(nTest3 = %d\r\n,nTest3);
如果没有预先的声明，编译器是找不到它的类型定义，所以编译不通过。因此就需要了解什么是函数的声明，在LCC里又是怎么样处理函数的声明的。在hello.i文件里，有下面一句的函数声明：
int printf(const char *, ...);
要分析上面的声明，就需要先识别类型int，然后再识别ID字符串printf，最后处理括号和参数列表。在LCC的源程序里，先在函数specifier函数里就已经可以把类型和ID识别出来，并判断语法的合法性，主要还剩下括号和参数列表的分析。下面的代码就是处理它们的，如下：
#001 static Type dclr1(char **id, Symbol **params, int abstract)
#002 {
#003 Type ty = NULL;
#004
#005 switch (t)
…
#067 while (t == '(' || t == '[')
#068 {
#069 switch (t)
#070 {
#071 case '(': //函数声明。
#072 t = gettok();
#073 {
#074 Symbol *args;
#075 ty = tnode(FUNCTION, ty);
#076
#077 enterscope();
#078 if (level > PARAM)
#079 enterscope();
#080
#081 //分析参数列表。
#082 args = parameters(ty);
#083
#084 if (params && *params == NULL)
#085 *params = args;
#086 else
#087 exitparams(args);
#088 }
#089 break;
在函数decl里调用函数dclr1来处理函数的括号和参数列表，在第67行那里，就判断是否这个ID是否函数的声明开始，如果是左括号的话，就肯定是函数的声明开始了。接着就跳到第71行处理，获取下一个记号，就是函数的类型。在第75行那里创建一个类型节点，它是函数声明的类型。在第77行里增加作用域的计算，也就是参数列表的作用域是只限于参数内部。第78行是判断是否在函数声明里再声明一个函数，如是就需要再增加它的作用域。
第82行开始调用函数parameters来分析参数的列表，比如上面const char*等等参数。
在第84行是保存分析后的参数列表返回，以便后面构造函数声明的类型。
这样就可以分析完成一个函数的声明，在编写C程序过程中需要把函数的声明放到使用函数之前，这样就可以让编译器提前计算好它的类型大小，以及参数的传送过程。
接着下来，就是分析参数列表，看看LCC是怎么样来分析参数列表的。
#001 //函数参数列表分析。
#002 static Symbol *parameters(Type fty)
#003 {
#004 List list = NULL;
#005 Symbol *params;
#006
#007 if (kind[t] == STATIC || istypename(t, tsym))
#008 {
#009 int n = 0;
#010 Type ty1 = NULL;
第7行是判断参数类型是否合法，主要是存储类型或者类型声明。
下面的for循环就是一个一个地分析逗号分隔的参数。
#011 for (;;)
#012 {
#013 Type ty;
#014 int sclass = 0;
#015 char *id = NULL;
#016 if (ty1 && t == ELLIPSIS)
#017 {
#018 static struct symbol sentinel;
#019 if (sentinel.type == NULL)
#020 {
#021 sentinel.type = voidtype;
#022 sentinel.defined = 1;
#023 }
#024
#025 if (ty1 == voidtype)
#026 error(illegal formal parameter types\n);
#027
#028 list = append(&sentinel, list);
#029 t = gettok();
#030 break;
#031 }
#032
在第16行到第31行就是处理参数里可变参数（…），C编译器为了处理可变参数需要从右向左地压参数入栈，以便计算有多少个参数。ty1的判断是表示在可变参数之前，一定需要有一个参数，如果只有一个可变参数是非法的。处理可变参数很简单，就是把它类型sentinel添加到参数列表list。
#033 if (!istypename(t, tsym) && t != REGISTER)
#034 error(missing parameter type\n);
#035
#036 n++;
#037
第33行里是判断参数是否有声明类型，如果没有就出错。
第36行是增加参数的计算，也可以说参数的名称，由于LCC里把所有没有写名称的参数都变成数字化编名，比如第一个参数就叫1，第二个参数就叫2，依次类推。由于C语言里可以声明这样的函数：
int printf(int *,int *,…);
像上面的函数就没有明确指名参数的名称，这样就需要自动地添加参数的名称。
#038 //分析参数类型声明。
#039 ty = dclr(specifier(&sclass), &id, NULL, 1);
#040
在第39行里就是递归调用类型声明函数dclr来分析这个参数定义是否合法，而在函数dclr调用之前，就需要先递归调用说明符处理函数specifier来处理。
#041 if ( ty == voidtype && (ty1 || id) ||
#042 ty1 == voidtype)
#043 error(illegal formal parameter types\n);
#044
#045 if (id == NULL)
#046 id = stringd(n);
#047
#048 if (ty != voidtype)
#049 list = append(dclparam(sclass, id, ty, &src), list);
#050
第41行和第42行是处理声明为void类型语法错误处理。
第45行是处理声明参数变量是空时处理，采用自定义的数据作为名称。
第48行是判断声明的类型不为空类型的话，就说明已经定义了一个参数变量，需要检查这个参数变量是否已经在前面的局部变量或者全局变量里声明了吗？要解决定这个疑问就需要调用参数变量声明函数dclparam来处理。
#051 if (Aflag >= 1 && !hasproto(ty))
#052 warning(missing prototype\n);
#053
#054 if (ty1 == NULL)
#055 ty1 = ty;
#056
#057 if (t != ',')
#058 break;
#059
#060 t = gettok();
#061 }
#062
在第57行是判断是否还有参数变量声明，如果没有就跳出for循环，处理参数完毕。
#063 fty->u.f.proto = newarray(length(list) + 1,
#064 sizeof (Type *), PERM);
#065 params = ltov(&list, FUNC);
#066 for (n = 0; params[n]; n++)
#067 fty->u.f.proto[n] = params[n]->type;
#068 fty->u.f.proto[n] = NULL;
#069 fty->u.f.oldstyle = 0;
#070 }
第63行是创建参数类型原型列表，然后在第66行到第67行里保存所有参数变量的类型，在第69行里指定这个函数声明是新类型的函数声明。
#071 else
#072 {
#073 if (t == ID)
#074 for (;;)
#075 {
#076 Symbol p;
#077 if (t != ID)
#078 {
#079 error(expecting an identifier\n);
#080 break;
#081 }
#082
#083 p = dclparam(0, token, inttype, &src);
#084 p->defined = 0;
#085 list = append(p, list);
#086 t = gettok();
#087 if (t != ',')
#088 break;
#089 t = gettok();
#090 }
#091 params = ltov(&list, FUNC);
#092 fty->u.f.proto = NULL;
#093 fty->u.f.oldstyle = 1;
#094 }
#095
上面这段是处理旧参数列表的声明。比如像下面的声明：
int max(x,y)
int x,int y;
{
return x>y ? x:y;
}
这种方式的声明，现在越来越少了，就不再去分析这种函数的处理代码。
#096 if (t != ')')
#097 {
#098 static char stop[] = { CHAR, STATIC, IF, ')', 0 };
#099 expect(')');
#100 skipto('{', stop);
#101 }
#102
#103 if (t == ')')
#104 t = gettok();
#105 return params;
#106 }
#107
在第96行里就是判断是否函数声明结束，如果不是行就进入错误恢复的处理，直找到上面定义的类型字符为止。
通过上面的分析已经了解函数声明的处理过程，已经可以把声明语法分析完成。不过其中还有一个参数变量声明函数dclparam没有分析，下一次再分析它的实现。 LCC编译器的源程序分析(17)参数变量的声明
函数里的参数变量个数不固定，因此也需要检查这些参数的名称是否相同，还需要检查类型的合法性。现在就来分析上次提到的函数dclparam，它的代码如下：
#001 //参数类型声明处理
#002 static Symbol dclparam(int sclass, char *id, Type ty, Coordinate *pos)
#003 {
#004 Symbol p;
#005
#006 if (isfunc(ty))
#007 ty = ptr(ty);
#008 else if (isarray(ty))
#009 ty = atop(ty);
#010
第6行判断这个参数变量是否声明为函数类型，如果是就需要创建新类型。
第8行判断这个参数变量是否声明为数据类型。
#011 if (sclass == 0)
#012 sclass = AUTO;
#013 else if (sclass != REGISTER)
#014 {
#015 error(invalid storage class `%k' for `%t%s\n,
#016 sclass, ty, stringf(id ? %s' : ' parameter, id));
#017 sclass = AUTO;
#018 }
#019 else if (isvolatile(ty) || isstruct(ty))
#020 {
#021 warning(register declaration ignored for `%t%s\n,
#022 ty, stringf(id ? %s' : ' parameter, id));
#023 sclass = AUTO;
#024 }
#025
第11行到第24行都是判断存储类型。如果没有声明存储类型，缺省为AUTO类型。其它几个识别为寄存器类型REGISTER、不可删除属性、结构类型。
#026 p = lookup(id, identifiers);
#027 if (p && p->scope == level)
#028 error(duplicate declaration for `%s' previously declared at %w\n, id, &p->src);
#029 else
#030 p = install(id, &identifiers, level, FUNC);
#031
第26行是查找这个参数变量是否已经在其它地方声明过，如果声明过就从lookup返回给p，如果作用域一样的声明肯定就是重复声明，这是出错的，在第28行里提示出错信息。如果没有这个参数变量是合法的，就把它保存到声明表格identifiers里。
#032 p->sclass = sclass;
#033 p->src = *pos;
#034 p->type = ty;
#035 p->defined = 1;
#036
上面几行是保存参数的属性到p符号里。
#037 if (t == '=')
#038 {
#039 error(illegal initialization for parameter `%s'\n, id);
#040 t = gettok();
#041 (void)expr1(0);
#042 }
#043
由于在标准C里是不允许参数变量初始化的，所以在第37行就处理这样的出错，如果在C＋＋里应是允许的。
#044 return p;
#045 }
在第44行里就是返回分析出来的一个参数变量返回添加到参数列表里。
设备寿命周期费用（Life Cycle Cost，缩写LCC）
生命周期成本（LCC―Life Cycle Cost）
低成本国家采购