source: dev/trunk/abdev/BasicCompiler_Common/Variable.h@ 165

#pragma once

#include "Type.h"
#include <Symbol.h>

class Variable : public Type
{
    const NamespaceScopes namespaceScopes;
    string name;
    bool isConst;
    bool isRef;
    bool isArray;
    int subScripts[MAX_ARRAYDIM];

    bool isParameter;

public:
    Variable( const string &name, const Type &type, bool isConst = false, bool isRef = false )
        : Type( type )
        , name( name )
        , isConst( isConst )
        , isRef( isRef )
        , isArray( false )
        , isParameter( false)
    {
        subScripts[0] = -1;
    }
    Variable( const NamespaceScopes &namespaceScopes, const string &name, const Type &type, bool isConst = false, bool isRef = false )
        : namespaceScopes( namespaceScopes )
        , Type( type )
        , name( name )
        , isConst( isConst )
        , isRef( isRef )
        , isArray( false )
        , isParameter( false)
    {
        subScripts[0] = -1;
    }
    Variable( const Variable &var )
        : Type( var )
        , name( var.name )
        , isConst( var.isConst )
        , isRef( var.isRef )
        , isArray( false )
        , isParameter( false )
    {
        subScripts[0] = -1;
        if( var.isArray ){
            SetArray( var.subScripts );
        }
    }
    ~Variable(){}

    void SetArray( const int *pSubScripts ){
        isArray = true;
        memcpy( this->subScripts, pSubScripts, sizeof(int) * MAX_ARRAYDIM );
    }

    const string &GetName() const
    {
        return name;
    }

    bool IsEqualSymbol( const Symbol &symbol, bool isSupportStaticMember = true ) const;

    void ConstOff(){
        isConst = false;
    }
    void ConstOn(){
        isConst = true;
    }
    bool IsConst() const
    {
        return isConst;
    }
    bool IsRef() const
    {
        return isRef;
    }
    bool IsArray()const
    {
        return isArray;
    }
    const int *GetSubScriptsPtr() const
    {
        return subScripts;
    }

    void ThisIsParameter(){
        isParameter = true;
    }
    bool IsParameter() const
    {
        return isParameter;
    }


    int GetMemorySize() const
    {
        if( isRef || isParameter ){
            return PTR_SIZE;
        }

        int size = Type::GetSize();

        if( isArray ){
            int num = 1;
            for( int i=0; i<MAX_ARRAYDIM; i++){
                if(subScripts[i]==-1) break;
                num *= subScripts[i]+1;
            }
            size *= num;
        }

        if( size % PTR_SIZE ){
            size += PTR_SIZE-(size%PTR_SIZE);
        }

        return size;
    }


    /* --- オフセット ---

        ※グローバル変数で初期バッファがない場合は最上位ビットに1がセットされ、
        初期バッファの有無が識別される。
        （その後、スケジュール実行により、実際の配置に並び替えられる）*/
    int offset;

    //コンストラクタ用パラメータ
    string paramStrForConstructor;

    //レキシカルスコープ用
    int ScopeStartAddress;
    int ScopeEndAddress;
    int ScopeLevel;
    BOOL bLiving;


    int source_code_address;
};

class Variables : public vector<Variable *>
{
public:
    Variables(){}
    ~Variables(){
        clear();
    }

    void clear(){
        for( int i=0; i<(int)this->size(); i++ ){
            delete (*this)[i];
        }

        vector<Variable *>::clear();
    }

    bool DuplicateCheck( const Symbol &symbol ) const
    {
        //レキシカルスコープを考慮して重複判定
        for( int i=(int)this->size()-1; i>=0 ; i-- ){
            Variable &var = *(*this)[i];
            if( var.bLiving                                         //現在のスコープで有効なもの
                && var.ScopeLevel == obj_LexScopes.GetNowLevel()    //現在のスコープと同一レベル
                ){
                    if( var.IsEqualSymbol( symbol ) ){
                        return true;
                    }
            }
        }
        return false;
    }

    const Variable *BackSearch( const Symbol &symbol ) const
    {
        //レキシカルスコープを考慮してバックサーチ
        for( int i=(int)this->size()-1; i>=0 ; i-- ){
            Variable &var = *(*this)[i];
            if( var.bLiving                                         //現在のスコープで有効なもの
                && var.ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
                ){
                    if( var.IsEqualSymbol( symbol ) ){
                        return &var;
                    }
            }
        }
        return NULL;
    }

    const Variable *Find( const Symbol &symbol )const
    {
        int max = (int)this->size();
        for( int i=0; i<max; i++ ){
            Variable *pVar = (*this)[i];
            if( pVar->IsEqualSymbol( symbol ) ){
                return pVar;
            }
        }
        return NULL;
    }
};

extern Variables globalVars;