source: dev/trunk/abdev/BasicCompiler_Common/Const.cpp@ 193

#include <Compiler.h>

#include "common.h"
#include OPCODE_H_PATH  //opcode.h


//シングルトンオブジェクト
CDBConst CDBConst::obj;


bool ConstBase::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
{
    if( GetName() != name ){
        return false;
    }
    return compiler.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
}
bool ConstBase::IsEqualSymbol( const string &fullName ) const
{
    char AreaName[VN_SIZE] = "";        //オブジェクト変数
    char NestName[VN_SIZE] = "";        //入れ子メンバ
    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );

    return IsEqualSymbol( NamespaceScopes( AreaName ), NestName );
}




CConst::CConst( const NamespaceScopes &namespaceScopes, const string &name, const Type &newType, _int64 i64data)
    : ConstBase( namespaceScopes, name )
    , type( newType )
    , i64data( i64data )
    , pNext( NULL )
{
}
CConst::CConst( const NamespaceScopes &namespaceScopes, const string &name, int value)
    : ConstBase( namespaceScopes, name )
    , type( Type(DEF_LONG) )
    , i64data( value )
    , pNext( NULL )
{
}
CConst::~CConst(){
    //連結先のオブジェクトを破棄
    if(pNext){
        delete pNext;
        pNext = 0;
    }
}

Type CConst::GetType(){
    return type;
}
_int64 CConst::GetWholeData(){
    return i64data;
}
double CConst::GetDoubleData(){
    double dbl;
    memcpy(&dbl,&i64data,sizeof(_int64));
    return dbl;
}



CConstMacro::CConstMacro( const NamespaceScopes &namespaceScopes, const string &name, char *Expression)
    : ConstBase( namespaceScopes, name )
{
}
CConstMacro::~CConstMacro(){
}





CDBConst::CDBConst(){
    memset(this,0,sizeof(CDBConst));

    ppHash = (CConst **)calloc(MAX_HASH*sizeof(CConst *),1);
    Init();
}
CDBConst::~CDBConst(){
    Free();

    free(ppHash);
}

//解放
void CDBConst::Free(){
    int i;
    for(i=0; i<MAX_HASH; i++){
        if(ppHash[i]){
            delete ppHash[i];
            ppHash[i] = 0;
        }
    }
}

//初期化
void CDBConst::Init(){
    Free();
}

void AddConstData(char *Command);
void CDBConst::Add( const NamespaceScopes &namespaceScopes, char *buffer ){
    int i;

    //名前を取得
    char Name[VN_SIZE];
    for(i=0;;i++){
        if(buffer[i]=='\0'){
            SetError(10,"Const",cp);
            return;
        }
        if(buffer[i]=='='||buffer[i]=='('){
            Name[i]=0;
            break;
        }
        Name[i]=buffer[i];
    }

    //重複チェック
    if(GetBasicType(Name)){
        SetError(15,Name,cp);
        return;
    }

    if(buffer[i] == '('){
        //定数マクロ

        //未完成
        AddConstData(buffer);
    }
    else{
        //一般の定数
        char *Expression = buffer + i + 1;

        AddConst( namespaceScopes, Name,Expression);
    }
}

void CDBConst::AddConst( const string &name, CConst *newconst){
    int key = hash_default(name.c_str());

    //ハッシュリストに追加
    if(ppHash[key]){
        CConst *pConst = ppHash[key];
        while(pConst->pNext){
            pConst = pConst->pNext;
        }

        pConst->pNext = newconst;
    }
    else{
        ppHash[key] = newconst;
    }
}
void CDBConst::AddConst( const NamespaceScopes &namespaceScopes, const string &name , char *Expression){
    _int64 i64data;
    Type resultType;
    if( !StaticCalculation(false, Expression, 0, &i64data, resultType) ){
        //変数の場合
        //何もしない（実行領域コンパイル時にdim宣言として扱う）
        return;
    }

    //リテラル値の場合
    //登録を行う

    CConst *newconst = new CConst(namespaceScopes, name, resultType, i64data);

    AddConst( name, newconst);
}
void CDBConst::AddConst(const NamespaceScopes &namespaceScopes, const string &name, int value){
    CConst *newconst = new CConst( namespaceScopes, name, value);

    AddConst(name, newconst);
}

CConst *CDBConst::GetObjectPtr( const string &name ){
    char ObjName[VN_SIZE];      //オブジェクト変数
    char NestMember[VN_SIZE];   //入れ子メンバ
    bool isObjectMember = CClass::SplitName( name.c_str(), ObjName, NestMember );

    //ハッシュ値を取得
    int key;
    key=hash_default( NestMember );

    //格納位置を取得
    CConst *pConst;
    pConst=ppHash[key];
    while(pConst){
        if( pConst->IsEqualSymbol( name ) ) break;

        pConst=pConst->pNext;
    }

    return pConst;
}


int CDBConst::GetBasicType(char *Name){
    CConst *pConst = GetObjectPtr(Name);

    if(!pConst) return 0;

    return pConst->GetType().GetBasicType();
}
_int64 CDBConst::GetWholeData(char *Name){
    CConst *pConst = GetObjectPtr(Name);

    if(!pConst) return 0;

    return pConst->GetWholeData();
}
double CDBConst::GetDoubleData(char *Name){
    CConst *pConst = GetObjectPtr(Name);

    if(!pConst) return 0;

    return pConst->GetDoubleData();
}
bool CDBConst::IsStringPtr( char *Name ){
    CConst *pConst = GetObjectPtr(Name);

    if(!pConst) return false;

    const Type &type = pConst->GetType();

    return ( type.GetBasicType() == typeOfPtrChar && type.GetIndex() == LITERAL_STRING );
}