source: dev/trunk/abdev/BasicCompiler_Common/src/Const.cpp@ 253

#include "stdafx.h"

#include <Compiler.h>


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

void AddConst( 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( compiler.GetMeta().GetGlobalConstMacros().IsExist( name )
        || compiler.GetMeta().GetGlobalConsts().IsExist( name ) )
    {
        SetError(15,name,cp);
        return;
    }

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

        compiler.GetMeta().GetGlobalConstMacros().Add( namespaceScopes, name, buffer + i );
    }
    else{
        //一般の定数
        char *expression = buffer + i + 1;

        compiler.GetMeta().GetGlobalConsts().Add( namespaceScopes, name, expression );
    }
}

void Consts::Add( 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);

    //ハッシュリストに追加
    Put( newconst );
}
void Consts::Add(const NamespaceScopes &namespaceScopes, const string &name, int value){
    CConst *newconst = new CConst( namespaceScopes, name, value);

    //ハッシュリストに追加
    Put( newconst );
}

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

    CConst *pConst = GetHashArrayElement( NestMember );
    while( pConst )
    {
        if( pConst->IsEqualSymbol( name ) )
        {
            break;
        }
        pConst = pConst->GetChainNext();
    }

    return pConst;
}


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

    if(!pConst) return 0;

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

    if(!pConst) return 0;

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

    if(!pConst) return 0;

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

    if(!pConst) return false;

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

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


bool ConstMacro::GetCalcBuffer( const char *parameterStr, char *dest ) const
{
    extern HANDLE hHeap;
    int i2,i3,i4,num;
    char temporary[VN_SIZE];
    char *pParms[MAX_PARMS];
    num=0;
    i2=0;
    while(1){
        i2=GetOneParameter(parameterStr,i2,temporary);

        pParms[num]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
        lstrcpy(pParms[num],temporary);

        num++;
        if(parameterStr[i2]=='\0') break;
    }
    if( num != this->GetParameters().size() ){
        extern int cp;
        for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
        SetError(10,GetName().c_str(),cp);
        lstrcpy(dest,"0");
        return 1;
    }

    i2=0;
    i4=0;
    while(1){

        //数式内の項を取得
        for(i3=0;;i2++,i3++){
            if(!IsVariableChar( this->GetExpression()[i2] )){
                temporary[i3]=0;
                break;
            }
            temporary[i3] = this->GetExpression()[i2];
        }

        //パラメータと照合する
        for( i3=0; i3<(int)this->GetParameters().size(); i3++ ){
            if( this->GetParameters()[i3] == temporary ) break;
        }

        if( i3 == (int)this->GetParameters().size() ){
            //パラメータでないとき
            lstrcpy(dest+i4,temporary);
            i4+=lstrlen(temporary);
        }
        else{
            //パラメータのとき
            lstrcpy(dest+i4,pParms[i3]);
            i4+=lstrlen(pParms[i3]);
        }

        //演算子をコピー
        for(;;i2++,i4++){
            if( this->GetExpression()[i2] == 1 ){
                dest[i4++] = this->GetExpression()[i2++];
                dest[i4] = this->GetExpression()[i2];
                continue;
            }
            if(IsVariableTopChar( this->GetExpression()[i2] )) break;
            dest[i4] = this->GetExpression()[i2];
            if( this->GetExpression()[i2] == '\0' ) break;
        }

        if( this->GetExpression()[i2] == '\0' ) break;
    }

    for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);

    return 1;
}

// マクロ定数を追加するための関数
void ConstMacros::Add( const NamespaceScopes &namespaceScopes, const std::string &name, const char *parameterStr )
{
    std::vector<std::string> parameters;

    int i = 0;
    if(parameterStr[i]!='(')
    {
        SetError();
        return;
    }

    char temporary[VN_SIZE];
    int i2;
    for(i++,i2=0;;i++,i2++){
        if(parameterStr[i]=='\0'){
            SetError(1,NULL,cp);
            return;
        }
        if(parameterStr[i]==','||parameterStr[i]==')'){
            temporary[i2]=0;

            parameters.push_back( temporary );

            if(parameterStr[i]==')'){
                i++;
                if(parameterStr[i]!='='){
                    extern int cp;
                    SetError(1,NULL,cp);
                    return;
                }
                break;
            }

            i2=-1;
            continue;
        }
        temporary[i2]=parameterStr[i];
    }

    //データ
    lstrcpy(temporary,parameterStr+i+1);

    Put( new ConstMacro( namespaceScopes, name, parameters, temporary ) );
}
ConstMacro *ConstMacros::Find( const std::string &name ){
    char ObjName[VN_SIZE];      //オブジェクト変数
    char NestMember[VN_SIZE];   //入れ子メンバ
    bool isObjectMember = SplitMemberName( name.c_str(), ObjName, NestMember );

    ConstMacro *pConstMacro = GetHashArrayElement( NestMember );
    while( pConstMacro )
    {
        if( pConstMacro->IsEqualSymbol( name ) )
        {
            break;
        }
        pConstMacro = pConstMacro->GetChainNext();
    }

    return pConstMacro;
}