source: dev/branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_TypeDef.cpp@ 812

#include "stdafx.h"
#include <abdev/ab_common/include/ab_common.h>
#include "LexicalAnalyzer.h"
#include "Compiler.h"
#include "StrOperation.h"

using namespace ActiveBasic::Compiler;

void LexicalAnalyzer::AddTypeDef( TypeDefCollection &typeDefs, 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情報を追加
    //////////////////////////

    Type baseType;
    if( !compiler.StringToType( pTemp, baseType ) )
    {
        compiler.errorMessenger.Output(3, pTemp, nowLine );
        return;
    }

    typeDefs.push_back(
        TypeDef(
            Symbol( namespaceScopes, temporary ),
            pTemp,
            baseType
        )
    );
}
void LexicalAnalyzer::CollectTypeDefs( const char *source, TypeDefCollection &typeDefs )
{
    // 名前空間管理
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    // Imports情報のクリア
    compiler.GetNamespaceSupporter().ClearImportedNamespaces();

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

        i++;

        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 );

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

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

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED )
        {
            // Imports情報のクリア
            compiler.GetNamespaceSupporter().ClearImportedNamespaces();
            continue;
        }

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

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

                Type baseType;
                if( !compiler.StringToType( "Long", baseType ) )
                {
                    throw;
                }

                typeDefs.push_back(
                    TypeDef(
                        Symbol( namespaceScopes, temporary ),
                        "Long",
                        baseType
                    )
                );
            }
        }

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