（转载请注明出处 http://www.cnblogs.com/BlackWalnut/p/4527845.html）
写完语义分析的代码后感觉语义分析只是为了进行类型检测（后来才发现，这只是语义分析的一部分）。词法分析注重的是每个单词是否合法，以及这个单词属于语言中的哪些部分。语法分析的上下文无关文法注重的是一个一个的推导式，是将词法分析中得到的单词按照语法规则进行组合。那么，语义分析就是要了解各个推导式之间的关系是否合法，主要体现在推导式中使用的终结符和非终结符之间的关系，也就是它们的类型。所以语义分析注重的一个方面是类型检测。
为了将上下文无关文法中各种终结符和非终结符联系起来，以及在想要使用它们的时候得到它们相应的类型，我们使用了一种叫做符号表的东西，又称为环境。环境可以理解为对每一个ID建立一个栈，栈中存放的和这个ID相关的一些信息，这些信息称为绑定。使用栈的好处是，可以解决作用域的问题。ID始终对应于栈顶的绑定，每次进入一个新的作用域就将一个作用域标示符压入栈中。这样，在一个新的作用域中定义了一个和老作用域ID相同的变量，类型或者函数时，将新的绑定压入栈中，那么老的绑定就会失效。当出作用域时，将作用域标示符以上的所有绑定都弹出，这样就完成了老绑定的恢复。
上面介绍的栈式环境，我们称为命令式风格。还有一种称为函数式风格，它的特点是每次都将原来的环境复制一份，将老的保存起来，对新的进行更改。当出作用域时，直接将新的抛弃，然后使用老的。
为什么只存放变量，类型以及函数的相关信息呢？我们可以看到，一种语言其实包含四个部分类型声明，函数声明，变量声明以及表达式， 前三个就利用内置类型来创造新的东西，而表达式则是使用这些东西所要遵守的规则，这些规则都是由上下文无关文法定义好的。声明和表达式就组成了一个语言的基本部分，我们只能使用这些规则来组织我们创造的东西，最终形成我们的程序。所以在语义分析阶段，我们只用注重各种类型的检测，看看在特定的规则下是否符合要求。
下面我们来看看tiger中语义分析时要注意的事项。
在tiger的语义分析过程中，我们使用了两个环境，值环境和类型环境。其中，值环境用来存放函数声明，变量声明的，类型环境是用来存放类型声明的。之所以使用两个符号表是因为在tiger中我们允许类型和变量，函数名使用相同的ID，但是不允许变量和函数使用相同的ID。并且，在tiger中，为了更快的找到ID所对应的绑定，我们使用了hash表来存储每个ID对应的栈。但是这里有个问题要解决，就是hash可能会造成冲突。例如ID1和ID2同时hash到同一个表项中，那么这个表项对应的栈是谁的？这个时候，我们要在绑定中存放这个绑定对应的ID。我们只要从栈顶开始比较，找到第一个和我们hash的ID相同的绑定，就是我们需要的绑定。
但是，这样的话，每次查找hash表都要进行字符串的比较，是十分低效的。所以，tiger中symbol.h文件给了另一个hash表，这个hash表的作用是将一个ID映射到一个指针（就是在语法分析中使用函数S_symbol）。那么我们只要将这个指针和绑定压入栈总，比较这个指针就可以确定这个绑定是不是我需要查找的绑定。这是一个十分精巧的设计。
知道了如何根据ID查找相应的绑定，那么我们来看看这些绑定究竟是什么。
首先，我们向栈中压入绑定时，绑定其实使用一个void＊类型的指针指向的，也就是说，我们不关心压入的绑定是什么，我们只关心压入绑定的地址以及压入到哪个表中（函数s_enter）。在读出（函数s_look）绑定的时候，我们只要把这个地址转换为我们需要的绑定（值绑定或者类型绑定）就可以了。
对于类型环境，每一个类型ID对应一个Ty_ty_结构体定义的绑定，这个Ty_ty_在Types.h中定义。可以看出这个结构体包含的类型（kind 枚举）是很多，其中要注意的是TY_name这个枚举，这个枚举是所有由 type id = id 这种语句定义的类型。根据不同的类型，我们使用联合中不同变量来解读。后面的几个函数都是根据不同kind来创建不同Ty_ty。但是要注意到，在新建一个类型环境的时候，我们要把int和string两个ID以及对应的绑定压入（S_enter）栈中，这两个是内置类型，必须先入栈。这里的int和string是类型，也就是终结符ID。和词法分析时的INT STRING的概念不同，这两个INT STRING是整型常量和字符型常量，它们的类型是int和string。
对于值环境，我们使用env.h中的E_enventry 结构体。这个就相对简单许多。
知道tiger中使用的绑定是什么样子的，就来说说这里面的一些坑。注意到我们使用到很多指针，大部分都是由指针引起的。
首先，我们在进行类型比较的时候，使用的指针。这里说说为什么，对于 type intary = array of int 以及 type strary = array of string ，如果只intary和strary所对应的绑定的kind来判断，两个都是Ty_array，但是两个的类型确实是不一样的，所以这种只使用kind判断的方式是失效的。所以这个时候我们要看看绑定中联合里的array（这是一个指针）是否一致。我们查看内置类型（int vaid nil sting），它们都是由函数（Ty_Int等）直接返回的指针，查看函数后发现，这些内置类型使用的都是相同的地址。但是其他类型的地址却有可能不同，这时就是下面这个注意事项。
另外一个需要注意的是，因为在tiger中存在这样的类型定义 type ID1 ＝ ID2 也就是说ID1 是 ID2 的别名，此时ID1中的绑定指向由 Ty_Name 函数返回的一个地址，该函数申请了一块新的内存。如果我们再定义type ID3 = ID2 ，此时使用指针比较ID1 和 ID3，这个时候判断两个类型是不一致的。这显然和tiger的要求的相违背。这个时候我们定义了一个新的函数actrulyTy，这个函数将返回绑定的“真实类型”，这些真是类型只可能是四个内置类型 ，数组类型或者记录类型，同时书中要求返回的任何expty中的Ty_ty必须是“真实类型”。那么，对一下代码进行类型检测就可以得到正确的结果。
type recd = { a : int , b : string }
type recd1 = recd
type recd2 = recd
//测试 recd1 和 recd2 是否相等
recd1 == recd2
这里提醒一下，我提供的代码实不支持一下类型检测的
type recd = { a : int , b : string }
type recd1 = recd
type recd2 = recd
type recd1ary = array of recd1
type recd2ary = array of recd2
//以下此时将返回false
recd1ary == recd2ary
其实就是将recd1和recd2 再次进行一次actrulyTy就可以了。总之，两类型比较时，一定要求时“真实类型”。
还有一个，可能是虎书的作者没有注意到的一个地方（或许是我的代码有问题？？）。在使用词法分析器向语法分析器传送ID以及相应的字符串时，我们使用一个变量（在我上一篇文章中讲述bison和flex传值）yylval.sval ，注意，这个sval是一个指针，指向一个字符串的开头，被指向的这个字符串是yytext。这个yytext字符串在进行词法分析时是会改变的。所以当你在语法分析器中将词法分析器传出的sval作为参数调用S_symbol时，这个sval指向的字符串yytext可能已经改变了（因为语法分析器存在移进以及规约，所以并不是和词法分析器同步工作的）。因此在使用s_symbol时要进行一些调整，如下：
S_symbol S_Symbol(string Id) { int i = 0 ; for ( ; (Id[i] >= '0' && Id[i] <= '9') || ( Id[i] >= 'a' && Id[i] <= 'z')||( Id[i] >= 'A' && Id[i] <= 'Z') ;++i) ; string name = (string)checked_malloc( sizeof(*name) * (i+1)) ; int b = sizeof(*name) * (i+1) ; memcpy(name , Id , sizeof(*name)*(i)) ; name[i] = '\0' ; int index= hash(name) % SIZE; S_symbol syms = hashtable[index], sym; for(sym=syms; sym; sym=sym->next) if (streq(sym->name,name)) return sym; sym = mksymbol(name,syms); hashtable[index]=sym; return sym; }
代码比较渣渣。。。。同样的调整还出现在处理字符串常量的函数中。
对于要处理的函数以及记录类型的递归，可以看成时c++中先处理头文件，在处理cpp。也不算太难，但是要注意，保持指针指向正确的位置。
以下就是这次的部分代码，没有实现当有错误时，显示错误位置的功能。有些代码比较简单，就没有贴出来。这份代码已经经过随书附带的前六个测试用例测试过，没有问题：
env.h
#ifndef ENV_H_ #define ENV_H_ #include "types.h" typedef struct E_enventry_ *E_enventry ; struct E_enventry_ { enum { E_varEntry , E_funEntry } kind; union { struct { Ty_ty ty ; } var; struct { Ty_tyList formals ; Ty_ty result ;} fun ; }u; }; E_enventry E_VarEntry(Ty_ty ty) ; E_enventry E_FunEntry(Ty_tyList formals , Ty_ty reslut) ; S_table E_base_tenv() ; S_table E_base_venv() ; Ty_ty actrulyTy(Ty_ty) ; bool isTyequTy( const Ty_ty ,const Ty_ty) ; void tyCpy(Ty_ty dec , const Ty_ty src ); #endif
env.cpp
#include "env.h" #include <stdio.h> #include <string.h> E_enventry E_VarEntry(Ty_ty ty) { E_enventry p = (E_enventry) checked_malloc(sizeof(*p)) ; p->kind = E_enventry_::E_varEntry ; p->u.var.ty = ty ; return p ; } E_enventry E_FunEntry(Ty_tyList formals , Ty_ty reslut) { E_enventry p = (E_enventry)checked_malloc(sizeof(*p)) ; p->kind = E_enventry_::E_funEntry ; p->u.fun.formals = formals ; p->u.fun.result = reslut ; return p ; } Ty_ty actrulyTy(Ty_ty ty) { if (ty == NULL ) { return NULL ; } while(ty->kind == Ty_ty_::Ty_name) { ty = ty->u.name.ty ; } return ty ; } bool isTyequTy(const Ty_ty s1 , const Ty_ty s2) { Ty_ty tmp1 = actrulyTy(s1) ; Ty_ty tmp2 = actrulyTy(s2) ; bool aryOrRec = (tmp1->kind == Ty_ty_::Ty_array || tmp2->kind == Ty_ty_::Ty_record) ; bool isnil = (tmp1->kind == Ty_ty_::Ty_nil || tmp2->kind == Ty_ty_::Ty_nil) ; if ( tmp1->kind != tmp2->kind) { if ( isnil && aryOrRec ) { return true ; } return false ; } if (aryOrRec) { if (tmp1 != tmp2 ) { return false ; } } return true ; } void tyCpy(Ty_ty dec , const Ty_ty src) { if (dec == NULL || src == NULL ) { assert(0) ; } memcpy(dec , src , sizeof(*src)) ; }
sement.h
#ifndef SENMANT_H_ #define SENMANT_H_ #include "types.h" #include "translate.h" #include "absyn.h" struct expty { Tr_exp exp ; Ty_ty ty; }; expty expTy(Tr_exp exp , Ty_ty ty) ; expty transVar(S_table venv , S_table tenv , A_var var) ; expty transExp(S_table venv , S_table tenv , A_exp exp) ; void transDec(S_table venv , S_table tenv , A_dec dec) ; Ty_ty transTy( S_table tenv , A_ty ty) ; bool innerIdentifiers( S_symbol sym); #endif
sement.cpp
#include "semant.h" #include <assert.h> #include "env.h" expty expTy(Tr_exp exp , Ty_ty ty) { expty e ; e.exp = exp ; e.ty = ty ; return e ; } expty transExp(S_table venv , S_table tenv , A_exp exp) { if (exp == NULL ) { assert(0); } switch(exp->kind) { case A_varExp : return transVar(venv , tenv , exp->u.var) ; case A_nilExp : return expTy(NULL ,Ty_Nil()); case A_intExp : return expTy(NULL , Ty_Int()) ; case A_stringExp : return expTy(NULL , Ty_String()) ; case A_callExp : { E_enventry tmp = (E_enventry)S_look(venv, exp->u.call.func) ; if (tmp == NULL) { assert(0) ; } Ty_tyList tylist = tmp->u.fun.formals ; A_expList explist = exp->u.call.args ; while (tylist != NULL && explist != NULL) { expty exptyp = transExp(venv , tenv , explist->head) ; if (exptyp.ty->kind == Ty_ty_::Ty_nil) { continue ; } if (!isTyequTy(tylist->head , exptyp.ty)) { assert(0) ; } tylist = tylist->tail ; explist = explist->tail ; } if (tylist != NULL || explist != NULL ) { assert(0); } return expTy(NULL , actrulyTy(tmp->u.fun.result)) ; } case A_opExp : { switch(exp->u.op.oper) { case A_plusOp : case A_minusOp : case A_timesOp : case A_divideOp : case A_ltOp : case A_leOp : case A_gtOp : case A_geOp : { if (transExp(venv , tenv, exp->u.op.left).ty->kind != Ty_ty_::Ty_int) assert(0); if (transExp(venv , tenv, exp->u.op.right).ty->kind != Ty_ty_::Ty_int) assert(0); return expTy(NULL , Ty_Int()) ; } case A_eqOp : case A_neqOp: { expty tmpleft = transExp(venv , tenv, exp->u.op.left) ; expty tmpright = transExp(venv , tenv, exp->u.op.right) ; if (tmpleft.ty->kind == Ty_ty_::Ty_int && tmpright.ty->kind == Ty_ty_::Ty_int) return expTy(NULL , Ty_Int()) ; if (tmpleft.ty->kind == tmpright.ty->kind) { if (tmpleft.ty->kind == Ty_ty_::Ty_record || tmpleft.ty->kind == Ty_ty_::Ty_array) { if ( tmpleft.ty == tmpright.ty ) { return expTy(NULL , Ty_Int()) ; } } } assert(0); } } assert(0); } case A_recordExp : { Ty_ty tmpty = (Ty_ty)S_look(tenv , exp->u.record.typ) ; tmpty = actrulyTy(tmpty) ; if (tmpty == NULL ) { assert(0) ; } if (tmpty->kind != Ty_ty_::Ty_record ) { assert(0) ; } A_efieldList tmpefield = exp->u.record.fields ; Ty_fieldList tmpfieldlist = tmpty->u.record ; while(tmpefield && tmpfieldlist) { if (tmpefield->head->name != tmpfieldlist->head->name ) { assert(0) ; } if (!isTyequTy(transExp(venv , tenv , tmpefield->head->exp).ty ,tmpfieldlist->head->ty)) { assert(0) ; } tmpefield = tmpefield->tail ; tmpfieldlist = tmpfieldlist->tail ; } if (tmpfieldlist!= NULL || tmpefield != NULL ) { assert(0) ; } return expTy(NULL ,tmpty); } case A_seqExp : { A_expList explist = exp->u.seq ; if (explist) { while(explist->tail) { transExp( venv , tenv , explist->head); explist = explist->tail ; } } else { return expTy(NULL , Ty_Void()); } return transExp(venv , tenv , explist->head); } case A_assignExp : { expty tmpV = transVar(venv , tenv , exp->u.assign.var) ; expty tmpE = transExp(venv , tenv , exp->u.assign.exp); if (tmpE.ty->kind != tmpV.ty->kind) { assert(0); } return expTy(NULL , Ty_Void()); } case A_ifExp : { expty tmptest = transExp(venv ,tenv , exp->u.iff.test) ; if(tmptest.ty->kind != Ty_ty_::Ty_int) { assert(0); } expty tmpthen = transExp(venv , tenv , exp->u.iff.then) ; if (exp->u.iff.elsee != NULL) { expty tmpelse = transExp(venv , tenv , exp->u.iff.elsee) ; if ( tmpthen.ty != tmpelse.ty ) { assert(0); } return expTy(NULL , tmpelse.ty); } if (tmpthen.ty->kind != Ty_ty_::Ty_void) { assert(0); } return expTy(NULL , Ty_Void()); } case A_whileExp : { expty test = transExp(venv , tenv , exp->u.whilee.test); if (test.ty->kind != Ty_ty_::Ty_int) { assert(0) ; } expty body = transExp(venv , tenv , exp->u.whilee.body); if (body.ty->kind != Ty_ty_::Ty_void) { assert(0); } return expTy(NULL , Ty_Void()); } case A_forExp : { expty tmplo = transExp(venv , tenv , exp->u.forr.lo); expty tmphi = transExp(venv , tenv , exp->u.forr.hi); S_beginScope(venv); S_enter(venv , exp->u.forr.var , E_VarEntry(Ty_Int())); expty tmpbody = transExp(venv , tenv, exp->u.forr.body); if (tmplo.ty->kind != Ty_ty_::Ty_int || tmphi.ty->kind != Ty_ty_::Ty_int || tmpbody.ty->kind != Ty_ty_::Ty_void) { assert(0); } S_endScope(venv); return expTy(NULL , Ty_Void()); } case A_breakExp : return expTy(NULL , Ty_Void()); case A_letExp : { S_beginScope(venv); S_beginScope(tenv); A_decList declist = exp->u.let.decs ; while(declist != NULL) { transDec(venv , tenv , declist->head); declist = declist->tail; } expty tmp ; if (exp->u.let.body) { tmp = transExp(venv , tenv , exp->u.let.body); } else { tmp = expTy(NULL , Ty_Void()) ; } S_endScope(venv); S_endScope(tenv); return tmp ; } case A_arrayExp : { Ty_ty ty = (Ty_ty)S_look(tenv , exp->u.array.typ); ty = actrulyTy(ty); if (ty == NULL || ty->kind != Ty_ty_::Ty_array) { assert(0); } expty tynum = transExp(venv , tenv , exp->u.array.size); if (tynum.ty->kind != Ty_ty_::Ty_int) { assert(0); } expty tyinit = transExp(venv , tenv, exp->u.array.init) ; if (tyinit.ty != ty->u.array ) { assert(0) ; } return expTy(NULL , ty); } } assert(0); } expty transVar(S_table venv , S_table tenv , A_var var) { switch(var->kind) { case A_simpleVar : { E_enventry tmp = (E_enventry) S_look(venv , var->u.simple) ; if (tmp != NULL && tmp->kind == E_enventry_::E_varEntry) { return expTy(NULL , actrulyTy(tmp->u.var.ty)) ; } assert(0) ; } case A_fieldVar : { expty tmpty = transVar(venv , tenv , var->u.field.var) ; if (tmpty.ty->kind != Ty_ty_::Ty_record) { assert(0); } Ty_fieldList fieldList = tmpty.ty->u.record ; while( fieldList ) { if ( fieldList->head->name == var->u.field.sym ) { return expTy(NULL , actrulyTy(fieldList->head->ty)) ; } fieldList = fieldList->tail ; } assert(0); } case A_subscriptVar : { expty tmp = transVar(venv , tenv , var->u.subscript.var) ; if (tmp.ty->kind != Ty_ty_::Ty_array ) { assert(0) ; } expty tmpexp = transExp(venv , tenv , var->u.subscript.exp) ; if (tmpexp.ty->kind != Ty_ty_::Ty_int) { assert(0) ; } return tmp ; } } assert(0) ; } void transDec(S_table venv , S_table tenv , A_dec dec) { switch(dec->kind) { case A_functionDec : { A_fundecList tmpfun = dec->u.function ; while(tmpfun) { A_fieldList tmpfeldList = tmpfun->head->params ; Ty_tyList tylist = NULL ; while(tmpfeldList) { Ty_ty ty = (Ty_ty)S_look(tenv,tmpfeldList->head->typ); tylist = Ty_TyList(ty , tylist) ; tmpfeldList = tmpfeldList->tail ; } if (innerIdentifiers(tmpfun->head->name)) { assert(0) ; } //¿‡À∆”⁄…˘√˜“ª∏ˆ∫Ø ˝ ªπ√ª”–∂®“ÂÀ¸ S_enter(venv , tmpfun->head->name , E_FunEntry(tylist , (Ty_ty)S_look(tenv ,tmpfun->head->result))) ; tmpfun = tmpfun->tail ; } tmpfun = dec->u.function ; while(tmpfun) { S_beginScope(venv) ; A_fieldList tmpfeldList = tmpfun->head->params ; while(tmpfeldList) { Ty_ty ty = (Ty_ty)S_look(tenv,tmpfeldList->head->typ); if (innerIdentifiers(tmpfeldList->head->name)) { assert(0); } S_enter(venv ,tmpfeldList->head->name, E_VarEntry(ty)) ; tmpfeldList = tmpfeldList->tail ; } transExp(venv , tenv , tmpfun->head->body) ; S_endScope(venv) ; tmpfun = tmpfun->tail ; } return ; } case A_typeDec : { A_nametyList namelist = dec->u.type ; while(namelist) { if (innerIdentifiers(namelist->head->name)) { assert(0) ; } // ¥¶¿Ìµ›πÈ ¿‡À∆”⁄ …˘√˜“ª∏ˆ¿‡–Õ µ´ «ªπ√ª”–∂®“ÂÀ¸ S_enter(tenv , namelist->head->name ,Ty_Name(namelist->head->name , NULL)) ; namelist = namelist->tail ; } namelist = dec->u.type ; while(namelist) { // ¥¶¿Ìµ›πÈ Ty_ty tmp1 = transTy(tenv , namelist->head->ty ) ; Ty_ty tmp2 = (Ty_ty)S_look(tenv , namelist->head->name) ; if ( tmp1->kind == Ty_ty_::Ty_int || tmp1->kind == Ty_ty_::Ty_string || tmp1->kind == Ty_ty_::Ty_nil || tmp1->kind == Ty_ty_::Ty_void) { //如果是内置类型 绑定指向的地方是一个固定的地方 所以 这个时候就不是替换内容那么简单了 tmp2 = (Ty_ty)S_changeBind(tenv , namelist->head->name , tmp1); tmp2 = (Ty_ty)freeTy(tmp2) ; } else { tyCpy(tmp2 , tmp1) ; tmp1 = (Ty_ty)freeTy(tmp1) ; } namelist = namelist->tail ; } namelist = dec->u.type; while(namelist) { // 避免出现 type a = b type b = a 这种没有真实类型的类型定义 Ty_ty tmp = (Ty_ty)S_look(tenv , namelist->head->name) ; if (!actrulyTy(tmp)) { assert(0) ; } namelist = namelist->tail ; } return; } case A_varDec : { if(dec->u.var.init == NULL) { assert(0) ; } expty tmp = transExp(venv , tenv , dec->u.var.init) ; if( (dec->u.var.typ != NULL) ) { if ( actrulyTy((Ty_ty)S_look(tenv ,dec->u.var.typ)) != tmp.ty) { assert(0) ; } } if (innerIdentifiers(dec->u.var.var)) { assert(0) ; } S_enter(venv , dec->u.var.var ,E_VarEntry(tmp.ty)) ; return; } } assert(0) ; } Ty_ty transTy(S_table tenv , A_ty ty) { switch(ty->kind) { case A_nameTy : { if (S_Symbol("int") == ty->u.name) { return Ty_Int(); } if (S_Symbol("string") == ty->u.name) { return Ty_String(); } Ty_ty tmp = (Ty_ty)S_look(tenv , ty->u.name) ; if ( tmp == NULL ) { assert(0) ; } return Ty_Name(ty->u.name , tmp) ; } case A_recordTy : { A_fieldList tmpfeldList = ty->u.record ; Ty_fieldList tyfdlist = NULL ; while(tmpfeldList) { Ty_ty tmp = (Ty_ty)S_look(tenv , tmpfeldList->head->typ) ; if ( tmp == NULL ) { assert(0) ; } if (innerIdentifiers(tmpfeldList->head->name)) { assert(0); } tyfdlist = Ty_FieldList(Ty_Field( tmpfeldList->head->name , tmp ) , tyfdlist) ; tmpfeldList = tmpfeldList->tail ; } return Ty_Record(tyfdlist); } case A_arrayTy : { Ty_ty tmp = (Ty_ty)S_look(tenv , ty->u.array); if ( tmp == NULL ) { assert(0); } return Ty_Array(tmp) ; } } assert(0) ; } bool innerIdentifiers( S_symbol sym) { if (sym == S_Symbol("int") || sym == S_Symbol("string") ) { return true ; } return false ; }
函数 S_changeBind 相关代码
S_symbol.cpp void* S_changeBind(S_table t , S_symbol sym , void *value) { return TAB_changeBind(t , sym , value) ; } S_table.cpp void* TAB_changeBind( TAB_table t , void * key , void *value ) { int index ; assert(t&&key) ; binder b ; void * tmp ; index = ((unsigned)key) % TABSIZE ; for ( b = t->table[index] ; b ; b = b->next) { if (b->key == key ) { tmp = b->value ; b->value = value ; return tmp ; } } return NULL ; }
391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
