现代编译原理－－第六章（中间树 IR Tree 含源码）

/*
 * tree.h - Definitions for intermediate representation (IR) trees.
 *
 */
#ifndef TREE_H_
#define TREE_H_

typedef struct T_stm_ *T_stm;
typedef struct T_exp_ *T_exp;
typedef struct T_expList_ *T_expList;
struct T_expList_ {T_exp head; T_expList tail;};
typedef struct T_stmList_ *T_stmList;
struct T_stmList_ {T_stm head; T_stmList tail;};

typedef enum {T_plus, T_minus, T_mul, T_div,
    T_and, T_or, T_lshift, T_rshift, T_arshift, T_xor} T_binOp ;

typedef enum  {T_eq, T_ne, T_lt, T_gt, T_le, T_ge,
    T_ult, T_ule, T_ugt, T_uge} T_relOp;

struct T_stm_ {enum {T_SEQ, T_LABEL, T_JUMP, T_CJUMP, T_MOVE,
    T_EXP} kind;
union {struct {T_stm left, right;} SEQ;
Temp_label LABEL;
struct {T_exp exp; Temp_labelList jumps;} JUMP;
struct {T_relOp op; T_exp left, right;
Temp_label trues, falses;} CJUMP;
struct {T_exp dst, src;} MOVE;
T_exp EXP;
} u;
};

struct T_exp_ {enum {T_BINOP, T_MEM, T_TEMP, T_ESEQ, T_NAME,
    T_CONST, T_CALL} kind;
union {struct {T_binOp op; T_exp left, right;} BINOP;
T_exp MEM;
Temp_temp TEMP;
struct {T_stm stm; T_exp exp;} ESEQ;
Temp_label NAME;
int CONST;
struct {T_exp fun; T_expList args;} CALL;
} u;
};

T_expList T_ExpList (T_exp head, T_expList tail);
T_stmList T_StmList (T_stm head, T_stmList tail);

T_stm T_Seq(T_stm left, T_stm right);
T_stm T_Label(Temp_label);
T_stm T_Jump(T_exp exp, Temp_labelList labels);
T_stm T_Cjump(T_relOp op, T_exp left, T_exp right, 
              Temp_label trues, Temp_label falses);
T_stm T_Move(T_exp, T_exp);
T_stm T_Exp(T_exp);

T_exp T_Binop(T_binOp, T_exp, T_exp);
T_exp T_Mem(T_exp);
T_exp T_Temp(Temp_temp);
T_exp T_Eseq(T_stm, T_exp);
T_exp T_Name(Temp_label);
T_exp T_Const(int);
T_exp T_Call(T_exp, T_expList);

T_relOp T_notRel(T_relOp);  /* a op b    ==     not(a notRel(op) b)  */
T_relOp T_commute(T_relOp); /* a op b    ==    b commute(op) a       */



#endif

#include <stdio.h>
#include "util.h"
#include "symbol.h"
#include "temp.h"
#include "tree.h"

T_expList T_ExpList(T_exp head, T_expList tail)
{T_expList p = (T_expList) checked_malloc (sizeof *p);
 p->head=head; p->tail=tail;
 return p;
}

T_stmList T_StmList(T_stm head, T_stmList tail)
{T_stmList p = (T_stmList) checked_malloc (sizeof *p);
 p->head=head; p->tail=tail;
 return p;
}
 
T_stm T_Seq(T_stm left, T_stm right)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
  p->kind= T_stm_::T_SEQ;
 p->u.SEQ.left=left;
 p->u.SEQ.right=right;
 return p;
}

T_stm T_Label(Temp_label label)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
 p->kind= T_stm_::T_LABEL;
 p->u.LABEL=label;
 return p;
}
 
T_stm T_Jump(T_exp exp, Temp_labelList labels)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
 p->kind= T_stm_::T_JUMP;
 p->u.JUMP.exp=exp;
 p->u.JUMP.jumps=labels;
 return p;
}

T_stm T_Cjump(T_relOp op, T_exp left, T_exp right, 
          Temp_label trues, Temp_label falses)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
 p->kind= T_stm_::T_CJUMP;
 p->u.CJUMP.op=op; p->u.CJUMP.left=left; p->u.CJUMP.right=right;
 p->u.CJUMP.trues=trues;
 p->u.CJUMP.falses=falses;
 return p;
}
 
T_stm T_Move(T_exp dst, T_exp src)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
 p->kind= T_stm_::T_MOVE;
 p->u.MOVE.dst=dst;
 p->u.MOVE.src=src;
 return p;
}
 
T_stm T_Exp(T_exp exp)
{T_stm p = (T_stm) checked_malloc(sizeof *p);
 p->kind= T_stm_::T_EXP;
 p->u.EXP=exp;
 return p;
}
 
T_exp T_Binop(T_binOp op, T_exp left, T_exp right)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_BINOP;
 p->u.BINOP.op=op;
 p->u.BINOP.left=left;
 p->u.BINOP.right=right;
 return p;
}
 
T_exp T_Mem(T_exp exp)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_MEM;
 p->u.MEM=exp;
 return p;
}
 
T_exp T_Temp(Temp_temp temp)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_TEMP;
 p->u.TEMP=temp;
 return p;
}
 
T_exp T_Eseq(T_stm stm, T_exp exp)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_ESEQ;
 p->u.ESEQ.stm=stm;
 p->u.ESEQ.exp=exp;
 return p;
}
 
T_exp T_Name(Temp_label name)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_NAME;
 p->u.NAME=name;
 return p;
}
 
T_exp T_Const(int consti)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_CONST;
 p->u.CONST=consti;
 return p;
}
 
T_exp T_Call(T_exp fun, T_expList args)
{T_exp p = (T_exp) checked_malloc(sizeof *p);
 p->kind= T_exp_::T_CALL;
 p->u.CALL.fun=fun;
 p->u.CALL.args=args;
 return p;
}

T_relOp T_notRel(T_relOp r)
{
 switch(r)
   {case T_eq: return T_ne;
    case T_ne: return T_eq;
    case T_lt: return T_ge;
    case T_ge: return T_lt;
    case T_gt: return T_le;
    case T_le: return T_gt;
    case T_ult: return T_uge;
    case T_uge: return T_ult;
    case T_ule: return T_ugt ;
    case T_ugt: return T_ule;
  }
 assert(0); 
}

T_relOp T_commute(T_relOp r)
{switch(r) {
    case T_eq: return T_eq;
    case T_ne: return T_ne;
    case T_lt: return T_gt;
    case T_ge: return T_le;
    case T_gt: return T_lt ;
    case T_le: return T_ge;
    case T_ult: return T_ugt;
    case T_uge: return T_ule;
    case T_ule: return T_uge ;
    case T_ugt: return T_ult;
   }
 assert(0); 
}

#ifndef TRANSLATE_H_
#define TRANSLATE_H_

#include "frame.h"
#include "absyn.h"
//frame œ‡πÿ

typedef struct Tr_level_      * Tr_level ;    
typedef struct Tr_accesslist_ * Tr_accesslist ;
typedef struct Tr_access_     * Tr_access ;  
struct  Tr_accesslist_  { Tr_access  head ;  Tr_accesslist tial ; };
struct  Tr_level_       { Tr_level parent ;  F_frame frame; };  //≤„µƒ◊˜”√ «Œ™¡À±£¥Êæ≤è¡¥
struct  Tr_access_      { Tr_level level  ;  F_access access ; };//º«¬º¡À“ª∏ˆ≤„∫Õ≤„÷–µƒŒª÷√ ’‚—? ∑Ω±„“ª∏ˆ«∂Ã◊≤„»•≤È—Ø“?”√µƒÕ‚≤ø±‰¡ø À¸ «E_varEntry÷–µƒ“ª∏ˆ±‰¡ø


//frame œ‡πÿ
Tr_accesslist Tr_Accesslist(Tr_access head , Tr_accesslist tial) ;
Tr_access Tr_Access(Tr_level level , F_access access ) ;
Tr_level Tr_outermorst() ;
Tr_level Tr_newLevel(Tr_level parent , Temp_label name , U_boolList formals ) ;
Tr_accesslist Tr_formals(Tr_level level) ;
Tr_access Tr_allocLocal(Tr_level level , bool escape ) ;
void     Tr_ClearAcces(Tr_accesslist list) ; //Ω´list Õ∑≈ µ´ « ≤ª Õ∑≈?‰÷–µƒhead



// IR Tree œ‡πÿ
#define  GetExpEx  Tr_exp_::Tr_ex
#define  GetExpNx  Tr_exp_::Tr_nx 
#define  GetExpCx  Tr_exp_::Tr_cx 

typedef struct Tr_exp_* Tr_exp ;
typedef struct Tr_expList_ * Tr_expList ;
typedef struct patchList_ * patchList ;

struct Cx { patchList trues ; patchList falses ; T_stm stm ; };
struct patchList_ { Temp_label *head ; patchList tail ; };

struct Tr_exp_
{
    enum{Tr_ex , Tr_nx , Tr_cx } kind;
    union
    {
        T_exp ex ;
        T_stm nx ;
        Cx    cx ;
    }u;
};

struct Tr_expList_
{
    Tr_exp head ;
    Tr_expList tail ;
};

//IR Treeœ‡πÿ 
Tr_exp Tr_Ex(T_exp exp ) ;
Tr_exp Tr_Nx(T_stm stm ) ;
Tr_exp Tr_Cx(patchList trues , patchList falses , T_stm stm ) ;

T_exp  Tr_unEx(Tr_exp exp) ;
T_stm  Tr_unNx(Tr_exp exp) ;
Cx     Tr_unCx(Tr_exp exp) ;

patchList PatchList(Temp_label *head , patchList patchlist ) ;
void doPatch(patchList patchlist , Temp_label label) ;
Tr_expList Tr_ExpList(Tr_exp head , Tr_expList tail) ;

Tr_exp  Tr_nilExp() ;
Tr_exp  Tr_intExp(int i) ;
Tr_exp  Tr_stringExp(string str) ;

Tr_exp  Tr_simpleVar(Tr_access acc , Tr_level level );
Tr_exp  Tr_subscriptVar(Tr_exp base, Tr_exp index);
Tr_exp  Tr_fieldVar(Tr_exp base, int offset);

Tr_exp  Tr_binopExp(Tr_exp left , Tr_exp right ,A_oper oper );
Tr_exp  Tr_relopExp(Tr_exp left , Tr_exp right , A_oper oper) ;

Tr_exp Tr_ifExp( Tr_exp test , Tr_exp then , Tr_exp elses ) ;
Tr_exp Tr_recordExp( Tr_expList explist , int num) ;
Tr_exp Tr_arryExp(Tr_exp index , Tr_exp init) ;
Tr_exp Tr_seqExp(Tr_expList explist) ;
Tr_exp Tr_assignExp(Tr_exp exp1 , Tr_exp exp2) ;

Tr_exp Tr_whileExp(  Tr_exp test , Tr_exp body , bool isbreak) ;
Tr_exp Tr_forExp(Tr_access acc , Tr_exp hi , Tr_exp low , Tr_exp body) ;
Tr_exp Tr_breakExp() ;
Tr_exp Tr_letExp(Tr_expList declist , Tr_exp exp ) ;

Tr_exp Tr_callExp(Temp_label label ,Tr_level funleve , Tr_level  level ,Tr_expList explist ) ;
Tr_exp Tr_StaticLink(Tr_level now, Tr_level def);


Tr_exp Tr_varDec(Tr_access acc , Tr_exp init) ;
Tr_exp Tr_typeDec();
Tr_exp Tr_funDec(Tr_expList bodylist) ;

void Tr_procEntryExit(Tr_level level , Tr_exp body , Tr_accesslist formals) ;

F_fragList Tr_getResult() ;

#endif

#include "translate.h"
#include "util.h"
#include "env.h"
#include <stdio.h>
#include <stdlib.h>
Tr_access Tr_allocLocal(Tr_level level , bool escape )
{
  F_access acc ;
  acc = F_allocLoacl(level->frame  , escape) ;
  return Tr_Access(level , acc) ;
}

Tr_access Tr_Access(Tr_level level , F_access access )
{
    Tr_access acc = (Tr_access)checked_malloc(sizeof(*acc));
    acc->level = level;
    acc->access = access;
    return acc;
}

Tr_accesslist Tr_Accesslist(Tr_access head , Tr_accesslist tial)
{
    Tr_accesslist tmp = (Tr_accesslist)checked_malloc(sizeof(*tmp));
    tmp->head = head ;
    tmp->tial = tial ;
    return tmp ;
}
Tr_level Tr_newLevel(Tr_level parent , Temp_label name , U_boolList formals )
{
    Tr_level level = (Tr_level)checked_malloc(sizeof(*level));
    level->parent = parent ;
    level->frame = F_newframe(name , U_BoolList(true , formals) ) ; // ’‚¿Ôº”µƒtrue¥˙±Ì¡Àæ≤è¡¥
    return level ;
}


Tr_accesslist Tr_formals(Tr_level level)
{
    F_accesslist f_acc = level->frame->formals ;
    f_acc = f_acc->tail ;//µ⁄“ª∏ˆ¥˙±Ì¡Àæ≤è¡¥ À?“‘“™ÃÙ≥ˆ¿¥
    Tr_accesslist tmp = NULL ;
    while(f_acc)
    {
         tmp = Tr_Accesslist(Tr_Access(level , f_acc->head), tmp) ;
         f_acc = f_acc->tail ;
    }
    return tmp ;
}

Tr_level Tr_outermorst()
{
    static Tr_level tmp = NULL ;
    if (!tmp)
    {
        tmp = (Tr_level)checked_malloc(sizeof(*tmp));
        U_boolList b = U_BoolList(true , NULL) ;
        tmp->frame = F_newframe(Temp_newlabel() , b)  ;
        tmp->parent = NULL ;
    }
    return tmp ;

}

void Tr_ClearAcces(Tr_accesslist list)
{
    Tr_accesslist tmp ;
    tmp = list ;
    while(list)
    {
        list = list->tial ;
        tmp->head =  NULL ;
        tmp->tial =  NULL ;
        free(tmp) ;
        tmp = list ;
    }
}

Tr_exp Tr_Ex(T_exp exp )
{
    Tr_exp tmp = (Tr_exp)checked_malloc(sizeof(*tmp));
    tmp->kind = GetExpEx ;
    tmp->u.ex = exp ;
    return tmp ;
}

Tr_exp Tr_Nx(T_stm stm )
{
    Tr_exp tmp = (Tr_exp)checked_malloc(sizeof(*tmp));
    tmp->kind = GetExpNx ;
    tmp->u.nx = stm ;
    return tmp ;
}

Tr_exp Tr_Cx(patchList trues , patchList falses , T_stm stm )
{
    Tr_exp tmp = (Tr_exp)checked_malloc(sizeof(*tmp));
    tmp->kind = GetExpCx ;
    tmp->u.cx.falses = falses ;
    tmp->u.cx.trues = trues ;
    tmp->u.cx.stm = stm ;
    return tmp ;
}
T_stm  Tr_unNx(Tr_exp exp)
{
    switch (exp->kind)
    {
    case  GetExpEx:
        return T_Exp(exp->u.ex);
    case  GetExpCx:
        return T_Exp(Tr_unEx(exp));
    case  GetExpNx:
        return exp->u.nx;
    }
    assert(0);
}
Cx  Tr_unCx(Tr_exp exp)
{
    switch (exp->kind)
    {
    case GetExpCx :
        return exp->u.cx;
    case GetExpEx:
        {
            T_stm stm = T_Cjump(T_ne, exp->u.ex, T_Const(0), NULL ,  NULL);
            Cx cx; 
            cx.stm = stm;
            cx.falses = PatchList(&stm->u.CJUMP.falses, NULL);
            cx.trues = PatchList(&stm->u.CJUMP.trues, NULL);
            return cx;
        }
    }
    assert(0);
}
T_exp  Tr_unEx(Tr_exp exp)
{
    switch(exp->kind)
    {
    case GetExpEx :
     return exp->u.ex ;
    case GetExpCx :
        {
          Temp_temp tmp = Temp_newtemp() ;
          Temp_label t = Temp_newlabel() , f = Temp_newlabel() ;
          doPatch(exp->u.cx.falses , f) ;
          doPatch(exp->u.cx.trues , t) ;
          return T_Eseq(T_Move(T_Temp(tmp) , T_Const(1)),
                  T_Eseq( exp->u.cx.stm ,
                   T_Eseq( T_Label(f) ,
                    T_Eseq(T_Move(T_Temp(tmp) , T_Const(0)) ,
                     T_Eseq(T_Label(t) ,
                      T_Temp(tmp)))))) ;

        }
    case GetExpNx :
        {
          return T_Eseq(exp->u.nx, T_Const(0));// Œ™ ≤√¥“™∑µªÿ0 ’‚∏ˆnx≤ª «Œ?÷µ”Ôæ‰√¥
        }
    }
    assert(0);
}

void doPatch(  patchList patchlist , Temp_label lable)
{
    for ( ;  patchlist ; patchlist = patchlist->tail)
    {
        (*patchlist->head) = lable ;
    }
}

patchList PatchList(Temp_label *head , patchList patchlist ) 
{
    patchList tmp = (patchList)checked_malloc(sizeof(*tmp));
    tmp->head = head ;
    tmp->tail = patchlist ;
    return tmp ;
}

Tr_expList Tr_ExpList(Tr_exp head , Tr_expList tail)
{
    Tr_expList tmp = (Tr_expList)checked_malloc(sizeof(*tmp)) ;
    tmp->head = head ;
    tmp->tail = tail ;
    return tmp ;
}

Tr_exp Tr_nilExp()
{
    static Temp_temp temp =  NULL  ;
        if ( !temp )
        {
           temp = Temp_newtemp() ;
           T_stm alloc = T_Move(T_Temp(temp),
               T_Call(T_Name(Temp_namedlabel("initRecord")), T_ExpList(T_Const(0), NULL)));
           return Tr_Ex(T_Eseq(alloc, T_Temp(temp)));
        }

     return Tr_Ex(T_Temp(temp)) ;
}

Tr_exp Tr_intExp(int i)
{
    return  Tr_Ex(T_Const(i)) ;
}

static F_fragList stringFragList = NULL;
Tr_exp Tr_stringExp(string s) 
{ 
    Temp_label slabel = Temp_newlabel();
    F_frag fragment = F_StringFrag(slabel, s);
    stringFragList = F_FragList(fragment, stringFragList);
    return Tr_Ex(T_Name(slabel));
}

Tr_exp Tr_simpleVar(Tr_access acc, Tr_level level)
{
    T_exp tmp = T_Temp(F_FP());
    while ( level && level != acc->level->parent )
    {
        tmp = T_Mem(T_Binop(T_plus, T_Const(level->frame->formals->head->u.offset), tmp));
        level = level->parent;
    }
    
    return  Tr_Ex(F_Exp(acc->access, tmp));
}

Tr_exp Tr_subscriptVar(Tr_exp base, Tr_exp index )
{
    return Tr_Ex(T_Mem(T_Binop(T_plus, Tr_unEx(base), T_Binop(T_mul, Tr_unEx(index), T_Const(F_wordSize)))));
}

Tr_exp Tr_fieldVar(Tr_exp base, int offset)
{
    return Tr_Ex(T_Mem(T_Binop(T_plus, Tr_unEx(base), T_Const(offset * F_wordSize))));
}

Tr_exp Tr_binopExp(Tr_exp left , Tr_exp right ,A_oper oper )
{
    T_binOp op ;
    switch(oper)
    {
    case A_plusOp   :
        {
            op = T_binOp::T_plus ;
            break ;
        }
    case A_minusOp  :
        {
            op = T_binOp::T_minus ;
            break ;
        }
    case A_timesOp  :
        {
            op = T_binOp::T_mul ;
            break ;
        }
    case A_divideOp :
        {
            op = T_binOp::T_div ;
            break ;
        }
    default :
        {
            return NULL ;
        }
    }
   return Tr_Ex(T_Binop(op , Tr_unEx(left) , Tr_unEx(right))) ;
}
Tr_exp  Tr_relopExp(Tr_exp left , Tr_exp right , A_oper oper) 
{
    T_relOp op ;
    switch(oper)
    {
     case A_ltOp :
         {
             op = T_relOp::T_lt ;
             break ;
         }
     case A_leOp :
         {
             op = T_relOp::T_le ;
             break ;
         }
     case A_gtOp :
         {
             op = T_relOp::T_gt ;
             break ;
         }
     case A_geOp :
         {
              op = T_relOp::T_ge ;
             break ;
         }
     case A_eqOp :
         {
             op = T_relOp::T_eq ;
             break ;
         }
     case A_neqOp :
         {
             op = T_relOp::T_ne ;
             break ;
         }
     default :
         return NULL ;
    }
    T_stm stm = T_Cjump(op ,Tr_unEx(left) , Tr_unEx(right) , NULL , NULL );
    patchList trues =  PatchList(&stm->u.CJUMP.trues , NULL) ;
    patchList falses =  PatchList(&stm->u.CJUMP.falses , NULL) ;
    return  Tr_Cx(trues , falses , stm) ;
}

Tr_exp Tr_ifExp( Tr_exp test , Tr_exp then , Tr_exp elses ) 
{

   Cx ctest  = Tr_unCx(test) ;
   T_stm reslutstm , thenstm , elsestm  ;
   reslutstm = thenstm = elsestm = NULL ;
   Temp_label t = Temp_newlabel() ;
   Temp_label f = Temp_newlabel() ;
   Temp_temp v = Temp_newtemp() ; 
    doPatch(ctest.falses , f) ;
    doPatch(ctest.trues , t ) ; 
        switch(then->kind)
        {
        case GetExpEx :
            {
                thenstm = T_Seq(ctest.stm , T_Seq(T_Label(t) , T_Move(T_Temp(v) , Tr_unEx(then)))) ;
                break ;
            }
        case GetExpNx :
            {
                thenstm = T_Seq(ctest.stm ,T_Seq(T_Label(t) , then->u.nx)) ;
                break ;
            }
        case GetExpCx :
            {
                
                thenstm = T_Seq(ctest.stm , T_Seq(T_Label(t) , Tr_unNx(then))) ;
                break ;
            }
        }

   if (elses)
   {
       switch(elses->kind)
       {
       case GetExpEx:
           {
               elsestm = T_Move(T_Temp(v), Tr_unEx(elses)) ;
               break ;
           }
       case GetExpNx :
           {
               elsestm = elses->u.nx ;
               break ;
           }
       case GetExpCx :
           {
              elsestm = Tr_unNx(elses) ;
              break ;
           }
       }
   }
   if (elsestm)
   {
       Temp_label jump = Temp_newlabel() ;
       
       return Tr_Nx(T_Seq(
           T_Seq( thenstm , T_Seq(T_Jump( T_Name(jump) , Temp_LabelList(jump , NULL)) ,T_Seq(T_Label(f) ,elsestm))) ,
           T_Label(jump))) ;
   }
        return Tr_Nx( T_Seq(thenstm , T_Label(f))) ; 
}

Tr_exp Tr_recordExp( Tr_expList explist , int num)  //’‚¿Ô¥´Ω¯¿¥µƒexplist ∫Õ’Ê «µƒexplist «œ‡∑¥µƒ
{
   T_stm stm ;
   Temp_temp t = Temp_newtemp();
   T_exp callfun = T_Call(T_Name(Temp_namedlabel("initRecord")) ,T_ExpList(T_Const(num*F_wordSize) , NULL)) ;

   stm = T_Move(T_Mem(T_Binop(T_plus , T_Temp(t) , T_Const((num - 1)*F_wordSize))), Tr_unEx(explist->head)) ;
   num-- ;
   explist = explist->tail ;
   while(explist)
   {
     stm = T_Seq(T_Move(T_Mem(T_Binop(T_plus, T_Temp(t) , T_Const((num -1 ) * F_wordSize))), Tr_unEx(explist->head)),stm) ;
     explist = explist->tail ;
     num-- ;
   }
   stm = T_Seq(T_Move(T_Temp(t) , callfun) , stm) ;
   return Tr_Ex( T_Eseq( stm , T_Temp(t))) ;
}


Tr_exp Tr_arryExp(Tr_exp index , Tr_exp init)
{
    Temp_temp t = Temp_newtemp() ;
    T_exp callfun = T_Call(T_Name(Temp_namedlabel("initArray")) ,T_ExpList( Tr_unEx(index),T_ExpList(Tr_unEx(init) ,NULL))) ;
    return  Tr_Nx( T_Move( T_Temp(t) , callfun) );
}
 
Tr_exp Tr_seqExp(Tr_expList explist)
{
    if (!explist)
    {
        return NULL ;
    }
    T_stm stm = Tr_unNx(explist->head) ;
    explist = explist->tail ;
    while(explist)
    {
        stm = T_Seq( Tr_unNx(explist->head) , stm) ;
        explist = explist->tail ;
    }
    return Tr_Nx(stm) ;
}

Tr_exp Tr_assignExp(Tr_exp exp1 , Tr_exp exp2)
{
    return Tr_Nx(T_Move(T_Mem( Tr_unEx(exp1)) , T_Mem(Tr_unEx(exp2))))  ;
}

Tr_exp Tr_letExp(Tr_expList declist , Tr_exp exp )
{
    if (!declist)
    {
        return NULL ;
    }
    T_stm stm = Tr_unNx(declist->head) ;
    declist = declist->tail ;
    while(declist)
    {
        stm = T_Seq(Tr_unNx(declist->head) , stm) ;
        declist = declist->tail ;
    }
    if (exp)
    {
        stm = T_Seq(stm , Tr_unNx(exp)) ;
    }
    return Tr_Nx(stm);
}

Tr_exp Tr_whileExp(Tr_exp test , Tr_exp body , bool isbreak)
{
  
    Cx ctest = Tr_unCx(test) ;
    Temp_label t = Temp_newlabel() ;
    Temp_label done = Temp_namedlabel("done") ;
    doPatch(ctest.falses , done) ;
    doPatch(ctest.trues , t) ;
    T_stm  stm ;
    Temp_label testlabel = Temp_newlabel();
    
    stm = T_Seq(T_Label(t) , T_Seq(Tr_unNx(body) ,T_Jump(T_Name(testlabel),Temp_LabelList(testlabel,NULL)))) ;
    stm = T_Seq( T_Label(testlabel) , T_Seq(ctest.stm ,T_Seq(stm , T_Label(done)))) ;
    return Tr_Nx(stm);
}

Tr_exp Tr_breakExp()
{
    Temp_label done = Temp_namedlabel("done") ;
    return Tr_Nx(T_Jump(T_Name(done) , Temp_LabelList(done , NULL))) ;
}

Tr_exp Tr_forExp(Tr_access acc , Tr_exp hi , Tr_exp low , Tr_exp body)
{
    T_exp tmp = T_Temp(F_FP());
     //tmp = T_Mem(T_Binop(T_plus ,tmp , T_Const(acc->level->frame->formals->head->u.offset))) ;
      T_exp memt =  F_Exp(acc->access , tmp) ;
    T_stm stm = T_Move(memt , Tr_unEx(low)) ;
    Temp_temp h = Temp_newtemp() ;
    T_stm limit = T_Move(T_Temp(h) , Tr_unEx(hi)) ;
    Cx cx ;
    cx.stm =  T_Cjump(T_lt ,memt ,T_Temp(h) , NULL , NULL) ;
    cx.falses = PatchList(&cx.stm->u.CJUMP.falses , NULL) ;
    cx.trues = PatchList(&cx.stm->u.CJUMP.trues , NULL) ;
    T_stm finalbody = T_Seq(T_Move(memt , T_Binop(T_plus , memt , T_Const(1))) , Tr_unNx(body)) ;
    
    Tr_exp tmpwhile = Tr_whileExp(Tr_Cx(cx.trues , cx.falses , cx.stm) , Tr_Nx(finalbody) , false) ;
    return  Tr_Nx(T_Seq( stm , T_Seq( limit , Tr_unNx(tmpwhile)))) ;
}
 Tr_exp Tr_StaticLink(Tr_level now, Tr_level def)
 {
    T_exp addr = T_Temp(F_FP());
    while(now && (now != def->parent)) 
    { 
        F_access sl = F_formals(now->frame)->head;
        addr = F_Exp(sl, addr);
        now = now->parent;
    }
    return Tr_Ex(addr);
}
Tr_exp Tr_callExp(Temp_label label ,Tr_level funleve , Tr_level  level ,Tr_expList explist ) 
{
    T_expList tmplist = NULL;
    while(explist)
    {
        tmplist = T_ExpList( Tr_unEx(explist->head) , tmplist) ;
        explist = explist->tail ;
    }
    tmplist = T_ExpList(Tr_unEx(Tr_StaticLink(funleve , level)) , tmplist) ;
    T_exp callfun = T_Call(T_Name(label) ,tmplist) ;
    return Tr_Ex(callfun) ;
}
Tr_exp Tr_callExp(E_enventry entry , Tr_level level , Tr_expList explist  ) 
{
    
     T_expList tmplist = NULL;
     while(explist)
     {
         tmplist = T_ExpList( Tr_unEx(explist->head) , tmplist) ;
         explist = explist->tail ;
     }
     tmplist = T_ExpList(Tr_unEx(Tr_StaticLink(entry->u.fun.level , level)) , tmplist) ;
    T_exp callfun = T_Call(T_Name(entry->u.fun.label) ,tmplist) ;
    return Tr_Ex(callfun) ;
}

Tr_exp Tr_varDec(Tr_access acc , Tr_exp init)
{
    T_exp tmp = T_Temp(F_FP());
    T_exp memt =  F_Exp(acc->access , tmp) ;
    return Tr_Nx(T_Move(memt , Tr_unEx(init)))  ;
}

Tr_exp Tr_typeDec()
{
     return Tr_Ex(T_Const(0)) ;
}

Tr_exp Tr_funDec(Tr_expList bodylist)
{
    T_stm stm ;
    stm = T_Move(T_Temp(F_RV()) , Tr_unEx(bodylist->head)) ;
    bodylist = bodylist->tail ;
    while (bodylist)
    {
      stm = T_Seq(T_Move(T_Temp(F_RV()) , Tr_unEx(bodylist->head)) , stm);
    }
    return Tr_Nx(stm) ;
}

#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 , Tr_level level) ;
expty  transExp(S_table venv , S_table tenv , A_exp exp , Tr_level level  ) ; //∑µªÿ÷µ÷–µƒtyty“ª∂® «◊ÓµÕ≤„µƒ¿‡–Õ
Tr_exp   transDec(S_table venv , S_table tenv , A_dec dec , Tr_level level ) ;
Ty_ty  transTy( S_table tenv , A_ty ty) ;
//ƒ⁄÷√±Í æ∑?ºÏ≤‚ int string ÷ª”√‘⁄œÚ÷µª∑æ≥ ‰»Î÷µµƒ ±∫Ú≤≈ºÏ≤‚  ¿‡–Õª∑æ≥‘⁄ tranTy÷–“—æ≠ºÏ≤‚
bool  innerIdentifiers( S_symbol sym);
#endif

#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  , Tr_level level )  // done  «Œ™¡ÀºÏ≤‚break «∑Ò‘⁄’?»∑µƒŒª÷√
{
    static bool done  = false ;
  if (exp == NULL )
  {
      assert(0);
  }
   switch(exp->kind)
   {
   case  A_varExp :
           return transVar(venv , tenv , exp->u.var , level ) ;
   case  A_nilExp :
          return expTy( Tr_nilExp() ,Ty_Nil());
   case  A_intExp :  // ’‚¿Ôµƒint «Àµµƒ’?–Õ≥£¡ø ∂¯≤ª «int¿‡–Õ
          return expTy( Tr_intExp(exp->u.intt) , Ty_Int()) ;
   case  A_stringExp ://’‚¿Ôµƒstring  «Àµµƒ◊÷∑?¥Æ≥£¡ø ∂¯≤ª «string¿‡–Õ
          return expTy( Tr_stringExp(exp->u.stringg) , 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 ;
              Tr_expList trexplist = NULL ;
              while (tylist != NULL && explist != NULL)
              {
                  expty exptyp = transExp(venv , tenv , explist->head , level) ;
                 
                  if (exptyp.ty->kind == Ty_ty_::Ty_nil)
                  {
                      continue ;
                  }
                   if (!isTyequTy(tylist->head , exptyp.ty))
                   {
                       assert(0) ;
                   }
                    trexplist = Tr_ExpList(exptyp.exp , trexplist) ;
                  tylist = tylist->tail ;  explist = explist->tail ;
              }
              if (tylist != NULL || explist != NULL )
              {
                  assert(0);
              }

              return expTy(Tr_callExp(tmp->u.fun.label , tmp->u.fun.level , level , trexplist) , actrulyTy(tmp->u.fun.result)) ; 
          }
   case  A_opExp :
          {
              expty tmpleft = transExp(venv , tenv, exp->u.op.left , level ) ;
              expty tmpright = transExp(venv , tenv, exp->u.op.right , level ) ;
              switch(exp->u.op.oper)
              {
              case A_plusOp   : 
              case A_minusOp  : 
              case A_timesOp  : 
              case A_divideOp : 
                  {

                      if (tmpleft.ty->kind != Ty_ty_::Ty_int)
                          assert(0);
                      if (tmpright.ty->kind != Ty_ty_::Ty_int)
                          assert(0);   
                       return expTy(Tr_binopExp(tmpleft.exp , tmpright.exp ,exp->u.op.oper) , Ty_Int()) ; 
                  }
              case A_ltOp     : 
              case A_leOp     : 
              case A_gtOp     : 
              case A_geOp     : 
                     {
                         if (tmpleft.ty->kind != Ty_ty_::Ty_int)
                             assert(0);
                         if (tmpright.ty->kind != Ty_ty_::Ty_int)
                             assert(0);   
                         return expTy(Tr_relopExp(tmpleft.exp , tmpright.exp , exp->u.op.oper) , Ty_Int()) ;
                     }
              case A_eqOp :
              case A_neqOp: 
                     {
                         if (tmpleft.ty->kind == Ty_ty_::Ty_int
                             && tmpright.ty->kind == Ty_ty_::Ty_int)
                             return expTy(Tr_relopExp(tmpleft.exp , tmpright.exp , exp->u.op.oper)  , 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(Tr_relopExp(tmpleft.exp , tmpright.exp , exp->u.op.oper) , 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 ;
              Tr_expList trexplist = NULL ;
              int num = 0 ;
              while(tmpefield && tmpfieldlist)
              {    
                   expty tmp = transExp(venv , tenv , tmpefield->head->exp , level) ;
                  if (tmpefield->head->name != tmpfieldlist->head->name )
                  {
                      assert(0) ;
                  }
                  if (!isTyequTy(tmp.ty ,tmpfieldlist->head->ty))
                  {
                      assert(0) ;
                  }
                  trexplist = Tr_ExpList(tmp.exp , trexplist) ;
                  tmpefield = tmpefield->tail ; tmpfieldlist = tmpfieldlist->tail ; 
                  num ++;
              }
              if (tmpfieldlist!= NULL || tmpefield != NULL )
              {
                  assert(0) ;
              }
              expty tmp = expTy(Tr_recordExp(trexplist,num),tmpty));
               Tr_FreeExplist(trexplist) ; // 只释放链表结构 不释放内容（hand）
              return tmp ;
          }
   case  A_seqExp :
          {
              A_expList explist = exp->u.seq ;
              Tr_expList trexplist = NULL ;

              if (explist)
              {
                  while(explist->tail)
                  {
                      trexplist = Tr_ExpList(transExp( venv , tenv , explist->head , level).exp , trexplist) ;
                      explist = explist->tail ;
                  }
              }
              else
              {
                  return expTy( Tr_seqExp(trexplist) , Ty_Void());
              }
              expty tmp = transExp(venv , tenv , explist->head , level) ;
              trexplist = Tr_ExpList(tmp.exp , trexplist) ;
              Tr_FreeExplist(trexplist) ; //只释放链表结构 不是放内容(hand)
              return expTy(Tr_seqExp(trexplist) , tmp.ty);
          }
   case  A_assignExp :
          {
              expty tmpV = transVar(venv , tenv , exp->u.assign.var , level) ;
              expty tmpE = transExp(venv , tenv , exp->u.assign.exp , level);
              if (tmpE.ty->kind != tmpV.ty->kind)
              {
                  assert(0);
              }
              return expTy(Tr_assignExp(tmpV .exp , tmpE.exp) , Ty_Void());
          }
   case  A_ifExp :
          {
              expty tmptest = transExp(venv ,tenv , exp->u.iff.test , level) ; 
              if(tmptest.ty->kind != Ty_ty_::Ty_int)
              {
                  assert(0);
              }
              expty tmpthen = transExp(venv , tenv , exp->u.iff.then , level ) ;
              if (exp->u.iff.elsee != NULL)
              {
                  expty tmpelse = transExp(venv , tenv , exp->u.iff.elsee , level) ;
                  if ( tmpthen.ty != tmpelse.ty )
                  {
                      assert(0);
                  }
                  return expTy( Tr_ifExp(tmptest.exp , tmpthen.exp , tmpelse.exp) , tmpelse.ty);
              }
              if (tmpthen.ty->kind != Ty_ty_::Ty_void)
              {
                  assert(0);
              }
              return expTy(Tr_ifExp(tmptest.exp , tmpthen.exp , NULL) , Ty_Void());
          }
   case  A_whileExp : 
          {
              expty test = transExp(venv , tenv , exp->u.whilee.test , level );
              if (test.ty->kind != Ty_ty_::Ty_int)
              {
                  assert(0) ;
              }
              expty body = transExp(venv , tenv , exp->u.whilee.body , level );
              if ( done )
              {
                   // Àµ√˜’‚¿Ô√Ê”–break
                  done = false ;
              }
             /* if (body.ty->kind != Ty_ty_::Ty_void)
              {
                  assert(0);
              }*/
              return expTy(Tr_whileExp(test.exp , body.exp , false) , Ty_Void());
          }
   case  A_forExp :
          {
              expty tmplo = transExp(venv , tenv , exp->u.forr.lo , level );
              expty tmphi = transExp(venv , tenv ,  exp->u.forr.hi ,level );
              S_beginScope(venv);
              Tr_access acc;
              acc = Tr_allocLocal(level , exp->u.forr.escape); // forŒ™ ≤√¥“™”–Ô“›£ø£ø£ø£ø£ø
              S_enter(venv , exp->u.forr.var , E_VarEntry( acc ,Ty_Int()));
              expty tmpbody = transExp(venv , tenv, exp->u.forr.body , level);
              if (tmplo.ty->kind != Ty_ty_::Ty_int || tmphi.ty->kind != Ty_ty_::Ty_int )
              {
                  assert(0);
              }
              S_endScope(venv);
              return expTy(Tr_forExp(acc, tmphi.exp , tmplo.exp , tmpbody.exp) , Ty_Void());
          }
   case  A_breakExp :
       {
           done = true ;
           return expTy(Tr_breakExp() , Ty_Void());
       }
   case  A_letExp :
          {
              S_beginScope(venv);
              S_beginScope(tenv);
              A_decList declist = exp->u.let.decs ;
              Tr_expList trexplist = NULL ;
              while(declist != NULL)
              {
                  trexplist = Tr_ExpList(transDec(venv , tenv , declist->head , level) , trexplist) ;
                  declist = declist->tail;
              }
              expty tmp ;
              if (exp->u.let.body)
              {
                  tmp = transExp(venv , tenv , exp->u.let.body  , level);
                  tmp = expTy(Tr_letExp(trexplist , tmp.exp) , tmp.ty) ;
              }
              else
              {
                  tmp = expTy(Tr_letExp(trexplist , NULL) , Ty_Void()) ;
              }
             Tr_FreeExplist（trexplist） ；//只释放链表结构，不是放链表内容（hand）
              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 , level );
              if (tynum.ty->kind != Ty_ty_::Ty_int)
              {
                  assert(0);
              }
              expty tyinit = transExp(venv , tenv, exp->u.array.init , level ) ;
              if (tyinit.ty != ty->u.array )
              {
                  assert(0) ;
              }
              return expTy(Tr_arryExp(tynum.exp,  tyinit.exp) , ty);
          }    
   }
   assert(0);
}

expty transVar(S_table venv , S_table tenv , A_var var , Tr_level level)
{
     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(Tr_simpleVar(tmp->u.var.access , level), actrulyTy(tmp->u.var.ty)) ;
                }
                assert(0) ;
            }
     case  A_fieldVar :
            {
                expty tmpty = transVar(venv , tenv , var->u.field.var , level) ;
                if (tmpty.ty->kind != Ty_ty_::Ty_record)
                {
                    assert(0);
                }
                Ty_fieldList fieldList = tmpty.ty->u.record ;
                int num = 0; 
                while( fieldList )
                {
                 if ( fieldList->head->name == var->u.field.sym  )
                 {
                    return expTy(Tr_fieldVar(tmpty.exp ,num)  , actrulyTy(fieldList->head->ty)) ;
                 }
                 num ++ ;
                  fieldList = fieldList->tail ;
                }
                assert(0);
            }
     case  A_subscriptVar :
            {
                expty tmp = transVar(venv , tenv , var->u.subscript.var , level) ;
                if (tmp.ty->kind != Ty_ty_::Ty_array )
                {
                    assert(0) ;
                }
                expty tmpexp  = transExp(venv , tenv , var->u.subscript.exp , level ) ;
                if (tmpexp.ty->kind != Ty_ty_::Ty_int)
                {
                    assert(0) ;
                }
                return expTy(Tr_subscriptVar(tmp.exp ,tmpexp.exp) , tmp.ty) ;
            }    
     }
     assert(0) ;
}

Tr_exp transDec(S_table venv , S_table tenv , A_dec dec , Tr_level level)
{
    switch(dec->kind)
    {
    case  A_functionDec :
           {
               A_fundecList tmpfun = dec->u.function ;
               Tr_level newlevel ;
               Tr_access acce ;
               U_boolList boollist = NULL ;
               Ty_ty reslut = NULL ;
               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);
                       if (ty == NULL )
                       {
                           assert(0) ;
                       }
                       tylist = Ty_TyList(ty , tylist) ;
                       tmpfeldList = tmpfeldList->tail ;
                        boollist = U_BoolList(true , boollist) ;
                   }
                   if (innerIdentifiers(tmpfun->head->name))
                   {
                       assert(0) ;
                   }
                   //¿‡À?”⁄…?√˜“ª∏ˆ∫Ø ? ªπ√ª”–∂®“ÂÀ¸
                   newlevel = Tr_newLevel(level ,Temp_newlabel() ,boollist); 
                   reslut = (Ty_ty)S_look(tenv ,tmpfun->head->result) ;
                   if (reslut == NULL )
                   {
                       reslut = Ty_Void() ;
                   }
                   S_enter(venv , tmpfun->head->name , E_FunEntry( newlevel, newlevel->frame->name , tylist , reslut)) ;
                   tmpfun = tmpfun->tail ;
                   U_ClearBoolList(boollist) ; // “ÚŒ™÷ª «”√¡Àbool ≤¢√ª”–±£¥ÊÀ¸ À?“‘ªπ“™ Õ∑≈“ªœ¬
                   boollist = NULL ;
               }
               tmpfun = dec->u.function ;
               E_enventry funEntry;
               Tr_accesslist tr_acceselist , tmpacclist ;
               Tr_expList trexplist = NULL ;
               while(tmpfun)
               {
                    S_beginScope(venv) ;
                     funEntry = (E_enventry) S_look(venv , tmpfun->head->name) ;
                   tmpacclist = tr_acceselist = Tr_formals(funEntry->u.fun.level) ;
                   A_fieldList tmpfeldList = tmpfun->head->params ; // ’‚¿Ô“™øº¬«µΩparamsµƒ…˙≥…∑Ω Ω »Áπ?∫Õtr_accesslist≤ª“ª÷¬“™∏ƒ“ªœ¬
                   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(tmpacclist->head,ty)) ;
                       tmpfeldList = tmpfeldList->tail ;
                       tmpacclist =  tmpacclist->tial ;
                   }
                  expty  tmp = transExp(venv , tenv , tmpfun->head->body , newlevel) ;
                  trexplist = Tr_ExpList(tmp.exp , trexplist) ;
                  if (tmp.ty != actrulyTy(funEntry->u.fun.result))
                  {
                      assert(0) ;
                  }
                   Tr_ClearAcces(tr_acceselist) ; //÷ª π”√¡Àhead tail≤ø∑÷«Â¿Ì∏…æª
                   S_endScope(venv) ;
                   tmpfun = tmpfun->tail ;
               }
               return Tr_funDec(trexplist) ;
           }
    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 Tr_typeDec();
           }
    case  A_varDec :
           {
               if(dec->u.var.init == NULL)
               {
                   assert(0) ;
               }
               expty tmp = transExp(venv , tenv , dec->u.var.init , level ) ;
               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) ;
               }
               Tr_access acc = Tr_allocLocal(level , dec->u.var.escape) ;
               S_enter(venv , dec->u.var.var ,E_VarEntry( acc ,tmp.ty)) ;
               return Tr_varDec(acc , tmp.exp);
           }    
    }
   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 ;
 }