source: dev/trunk/jenga/src/smoothie/Namespace.cpp@ 192

#include <jenga/include/smoothie/BasicFixed.h>
#include <jenga/include/smoothie/Smoothie.h>
#include <jenga/include/smoothie/Namespace.h>
#include <jenga/include/smoothie/SmoothieException.h>


NamespaceScopes::NamespaceScopes( const string &namespaceStr ){
    if( namespaceStr.size() == 0 ){
        return;
    }

    string::size_type i = 0;
    while( true ){
        string::size_type i2 = namespaceStr.find( '.', i );

        string tempName = namespaceStr.substr( i, i2-i );

        push_back( tempName );

        if( i2 == string::npos ){
            break;
        }

        i = i2 + 1;
    }
}

bool NamespaceScopes::IsLiving() const
{
    if( IsBelong( *this, Smoothie::Temp::liveingNamespaceScopes ) ){
        return true;
    }
    return false;
}

// 包括しているかをチェック
// 例:
// this =   "Discoversoft.ActiveBasic"
// living = "Discoversoft.ActiveBasic"
// name =   "ActiveBasic"
// この場合、living は name を包括している。
bool NamespaceScopes::IsCoverd( const string &name ) const
{
    if( IsEqual( name ) ){
        return true;
    }

    string thisStr = ToString();

    NamespaceScopes tempLivingNamespaceScopes = Smoothie::Temp::liveingNamespaceScopes;

    while( tempLivingNamespaceScopes.size() ){
        NamespaceScopes tempNamespaceScopes = tempLivingNamespaceScopes;

        string tempStr = tempNamespaceScopes.ToString() + "." + name;
        if( thisStr == tempStr ){
            return true;
        }

        tempLivingNamespaceScopes.pop_back();
    }
    return false;
}
bool NamespaceScopes::IsCoverd( const NamespaceScopes &namespaceScopes ) const
{
    return IsCoverd( namespaceScopes.ToString() );
}


void NamespaceScopesCollection::SplitNamespace( const char *fullName, char *namespaceStr, char *simpleName ) const
{
    NamespaceScopes namespaceScopes( fullName );
    bool hasSimpleName = false;
    while( namespaceScopes.size() > 0 ){
        if( IsExist( namespaceScopes ) ){
            break;
        }
        namespaceScopes.pop_back();

        hasSimpleName = true;
    }

    lstrcpy( namespaceStr, namespaceScopes.ToString().c_str() );

    bool hasNamespace = false;
    if( namespaceStr[0] ){
        hasNamespace = true;
    }

    int dotLength = 0;
    if( hasSimpleName && hasNamespace ){
        dotLength = 1;
    }

    lstrcpy( simpleName, fullName + lstrlen( namespaceStr ) + dotLength );
}
bool NamespaceScopesCollection::CollectNamespaces( const char *source, NamespaceScopesCollection &namespaceScopesCollection )
{
    int i, i2;
    char temporary[1024];

    bool isSuccessful = true;

    // 名前空間管理
    NamespaceScopes namespaceScopes;

    for(i=0;;i++){
        if(source[i]=='\0') break;

        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            namespaceScopes.push_back( temporary );

            if( !namespaceScopesCollection.IsExist( namespaceScopes ) ){
                namespaceScopesCollection.push_back( namespaceScopes );
            }

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                SmoothieException::Throw( 12, "End Namespace", i );
                isSuccessful = false;
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }
    }

    if( namespaceScopes.size() > 0 ){
        SmoothieException::Throw( 63 );
        isSuccessful = false;
    }

    return isSuccessful;
}