symbols.cpp

基于ANTLR的简单编译器源码version0.1

// symbols.cpp : 函数实现文件

#include "symbols.h"

/*#######################################################*/
/*
            ----class TypeAttr----
*/
void   TypeAttr::SetType(MY_TYPE t){
   m_type=t;
   switch(t){     
	 case UCHAR_T:  length.ulen=1;isInt=true;m_signed=ISUNSIGNED;return;
     case INT16_T:  length.len=2;isInt=true;m_signed=ISSINGED;return;
     case UINT16_T:	length.ulen=2;isInt=true;m_signed=ISUNSIGNED;return; 
	 case INT_T:    length.len=4;isInt=true;m_signed=ISSINGED;return;
	 case UINT_T:   length.ulen=4;isInt=true;m_signed=ISUNSIGNED;return;
	 case FLOOT_T:  length.len=4;isDouble=true;return;
	 case DOUBLE_T: length.len=4;isDouble=true;return;
	 default:return;
   }
}
void   TypeAttr::SetValue(string str){
   value=str;
}
bool   TypeAttr::IsConvertable(TypeAttr t){
   MISDEEM(t.m_type==NULL_T);
   if(m_type!=NULL_T){      
     MISDEEM(t.m_type!=m_type);
	 return true;
	} 
   else{
     switch(t.m_type){
	    case UCHAR_T:   MISDEEM(!(isInt&&length.ulen==1));return true;
		case INT16_T:   MISDEEM(!(isInt&&length.len<3)); return true;
		case UINT16_T:  MISDEEM(!(isInt&&length.ulen<3));return true;
		case INT_T:     MISDEEM(!(isInt&&length.len<5));return true;
		case UINT_T:    MISDEEM(!(isInt&&length.ulen<5));return true;
		case FLOOT_T:   MISDEEM(!(isDouble&&length.len<5));return true;
		case DOUBLE_T:  MISDEEM(!(isDouble&&length.len<9));return true;
		default: return true;
	 }
   }     
}
void   TypeAttr::BitToStr(){
   char temp=value[2];
   value=temp;
}
bool   TypeAttr::BitsToStr(){
  size_t len=value.length();
  value=value.substr(2,len-2);
  if(value.length()>32)
    return false;
  else
    return true;
}
void   TypeAttr::IsInt(){
   isInt=true;
}
void   TypeAttr::IsDouble(){
   isDouble=true;
}
void   TypeAttr::HexToStr(){    
   int val=0;
   size_t i=2;
   size_t len=value.length();
   while(i<len){
      if(value[i]>='A'&&value[i]<'G')
	    val=(value[i]-55)*pow(16,(len-i-1));
	  else if(value[i]>'a'&&value[i]<'g')	 
        val=(value[i]-87)*pow(16,(len-i-1));	
      else
        val=(value[i]-48)*pow(16,(len-i-1));	 
	  i++;
   }
   value=lexical_cast<std::string>(val);
   length.ulen=(len-2)/2;
   length.len=len-2;
}
void   TypeAttr::CharToStr(){
   char temp=value[1];
   value=temp;
}
void   TypeAttr::StrToStr(){
   size_t len=value.length();
   value=value.substr(1,len-2);
}
void   TypeAttr::CalcLen(){
  if(isInt){
    double  temp=lexical_cast<double>(value);
	if(temp<pow(2,7)){
	  length.ulen=1;length.ulen=1;
	}
    else if(temp<pow(2,8)){
	  length.ulen=1;length.len=2;	  
    }	
	else if(temp<pow(2,15)){
	  length.ulen=2;length.len=2;
	}
	else if(temp<pow(2,16)){
	  length.ulen=2;length.len=3;
	}
	else if(temp<pow(2,31)){
	  length.ulen=4;length.len=4;
	}
	else if(temp<pow(2,32)){
	  length.ulen=4;length.len=5;
	}	
  }
  else if(isDouble){
    length.len=4;
  }
  
}

/*#######################################################*/
/*
            ----class CSymTable----
*/
int CSymbol::ID=0;//静态成员函数初始化
CSymTable::~CSymTable(){
    SymbolMap::iterator itor;
    for(itor=m_table.begin();itor!=m_table.end();itor++){
        delete itor->second;
    }
}
/*
bool CSymTable::AddSymb(string id,CSymbol* value){
    SymbolMap::iterator itr = m_table.find(name);
    if (itr != m_table.end()) {
		return false;	// 同名变量已存在
	}
	size+=get_size(value->GetType());
	m_table[id]=value;
	return true;
} 
bool CSymTable::AddSymb(string id,MY_TYPE type,string value=""){
    SymbolMap::iterator itr = m_table.find(name);
    if (itr != m_table.end()) {
		return false;	// 同名变量已存在
	}
	size+=get_size(value->GetType());
	CSymbol* sym=new CSymbol(type,value)
	m_table[id]=sym;
	return true;
}*/
void  CSymTable::AddSymb(TypeAttr t,string id,string value){
   	size+=get_size(t.m_type);
	t.value=value;
	CSymbol* sym=new CSymbol(t);
	m_table[id]=sym;
}
void CSymTable::SetSymValue(string id,string value){    
	m_table[id]->SetSymValue(value);	
}
CSymbol*  CSymTable::GetSymb(string name){
    SymbolMap::iterator itr = m_table.find(name);
    if (itr != m_table.end()) {
		return itr->second;	
	}
	else
	  return NULL;
}
void CSymTable::SaveData(string file_name){
	ofstream fout(file_name.c_str());
	fout<<"<config>"<<'\n';
	fout<<"<data>"<<'\n';
	fout<<size<<'\n';	
	int i=0;
	for(SymbolMap::iterator itor=m_table.begin();itor!=m_table.end();itor++,i++){
		MY_TYPE m_type=itor->second->GetAttr().m_type;
	   if(m_type!=BITS_T)
		   fout<<itor->second->GetId()<<'\t'<<m_type<<'\t'<<itor->second->GetAttr().value<<'\n';
	   else{
	      int len=itor->second->GetAttr().value.length();
		  int value;
		  strtobits(itor->second->GetAttr().value,value);
	      fout<<itor->second->GetId()<<'\t'<<m_type<<'\t'<<len<<'\t'<<value<<'\n';		  
	   }          	   
    }
    fout<<-1<<'\n';	
	fout<<"</data>"<<'\n';
}
bool CSymTable::CheckEmpty(string& warnings){
   warnings="";
   bool  temp=false;
   for(SymbolMap::iterator itor=m_table.begin();itor!=m_table.end();itor++){
	   if(itor->second->GetAttr().value==""){	  
	    warnings="warning:未使用的变量：";
		warnings+=itor->first;
		temp=true;
	  }	
   }
   return temp;
}