现代编译原理——第四章：语义分析以及源码

　　转自： 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] = '' ;
    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 ;
}