source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/TypeDef.cpp @ 523

#include "stdafx.h"

#include <TypeDef.h>
#include <Compiler.h>

TypeDef::TypeDef( const NamespaceScopes &namespaceScopes, const std::string &name, const std::string &baseName, int nowLine )
    : Symbol( namespaceScopes, name )
    , baseName( baseName )
{
    if( !compiler.StringToType( baseName, baseType ) ){
        compiler.errorMessenger.Output(3, baseName, nowLine );
        return;
    }
}
/*
bool TypeDef::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const std::string &name ) const
{
    if( GetName() != name ){
        return false;
    }
    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
}
bool TypeDef::IsEqualSymbol( const std::string &fullName ) const
{
    char AreaName[VN_SIZE] = "";        //オブジェクト変数
    char NestName[VN_SIZE] = "";        //入れ子メンバ
    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );

    if( IsEqualSymbol( NamespaceScopes( AreaName ), NestName ) ){
        return true;
    }

    if( isNest ){
        // 静的メンバを考慮

        char AreaName2[VN_SIZE] = "";       //オブジェクト変数
        char NestName2[VN_SIZE] = "";       //入れ子メンバ
        bool isNest = SplitMemberName( AreaName, AreaName2, NestName2 );
        lstrcat( NestName2, "." );
        lstrcat( NestName2, NestName );

        return IsEqualSymbol( NamespaceScopes( AreaName2 ), NestName2 );
    }

    return false;
}*/



TypeDefCollection::TypeDefCollection(){
}
TypeDefCollection::~TypeDefCollection(){
}
void TypeDefCollection::Add( const NamespaceScopes &namespaceScopes, const std::string &name, const std::string &baseName, int nowLine ){
    TypeDef typeDef( namespaceScopes, name, baseName, nowLine );
    this->push_back( typeDef );
}
int TypeDefCollection::GetIndex( const NamespaceScopes &namespaceScopes, const std::string &name ) const{
    int max = (int)(*this).size();
    for( int i=0; i<max; i++ ){
        if( (*this)[i].IsEqualSymbol( namespaceScopes, name ) ){
            return i;
        }
    }
    return -1;
}
int TypeDefCollection::GetIndex( const std::string &fullName ) const{
    char AreaName[VN_SIZE] = "";        //オブジェクト変数
    char NestName[VN_SIZE] = "";        //入れ子メンバ
    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );

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

void TypeDefCollection::Add( const NamespaceScopes &namespaceScopes, const std::string &expression, int nowLine ){
    int i;
    char temporary[VN_SIZE];

    for(i=0;;i++){
        if(expression[i]=='='||expression[i]=='\0'){
            temporary[i]=0;
            break;
        }
        temporary[i]=expression[i];
    }

    if(expression[i]!='='){
        compiler.errorMessenger.Output(10,"TypeDef",nowLine);
        return;
    }

    const char *pTemp=expression.c_str()+i+1;

    //識別文字のエラーチェック（新しい型）
    i=0;
    for(;;i++){
        if(temporary[i]=='\0') break;
        if( !( IsVariableChar( temporary[i], true) ) ){
            compiler.errorMessenger.Output(10,"TypeDef",nowLine);
            return;
        }
    }

    //識別文字のエラーチェック（コピー元の型）
    if(pTemp[0]=='*'&&pTemp[1]==1&&(pTemp[2]==ESC_FUNCTION||pTemp[2]==ESC_SUB)){
        //関数ポインタ
        if(pTemp[3]!='('){
            compiler.errorMessenger.Output(10,"TypeDef",nowLine);
            return;
        }
    }
    else{
        i=0;
        while(pTemp[i]=='*') i++;
        for(;;i++){
            if(pTemp[i]=='\0') break;
            if( !( IsVariableChar( pTemp[i], true) ) )
            {
                compiler.errorMessenger.Output(10,"TypeDef",nowLine);
                return;
            }
        }
    }

    //識別子が重複している場合はエラーにする
    if(lstrcmp(temporary,pTemp)==0){
        compiler.errorMessenger.Output(1,NULL,nowLine);
        return;
    }



    //////////////////////////
    // TypeDef情報を追加
    //////////////////////////

    Add( namespaceScopes, temporary, pTemp, nowLine );
}

void TypeDefCollection::CollectTypeDefs(){

    // 名前空間管理
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    // Importsされた名前空間の管理
    NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
    importedNamespaces.clear();

    int i=-1, i2;
    char temporary[VN_SIZE];
    while(1){
        extern char *basbuf;

        i++;

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

            continue;
        }
        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                compiler.errorMessenger.Output(12, "End Namespace", i );
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }
        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPORTS ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( basbuf[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=basbuf[i];
            }
            if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
            {
                compiler.errorMessenger.Output(64,temporary,i );
            }

            continue;
        }
        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
            importedNamespaces.clear();
            continue;
        }

        if( basbuf[i]==1 ){
            char temporary[VN_SIZE];
            if(basbuf[i+1]==ESC_TYPEDEF){
                int i2 = 0;
                for(i+=2;;i2++,i++){
                    if(basbuf[i]=='\n'){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                    if(basbuf[i]=='\0') break;
                }
                Add( namespaceScopes, temporary, i );

                continue;
            }
            else if( basbuf[i+1] == ESC_CONST && basbuf[i+2] == 1 && basbuf[i+3] == ESC_ENUM ){
                int i2 = 0;
                for(i+=4;;i2++,i++){
                    if(!IsVariableChar(basbuf[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                    if(basbuf[i]=='\0') break;
                }
                Add( namespaceScopes, temporary, "Long", i );
            }
        }

        //次の行
        for(;;i++){
            if(IsCommandDelimitation(basbuf[i])) break;
        }
        if(basbuf[i]=='\0') break;
    }
}