source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp@ 797

#include "stdafx.h"

#ifdef _AMD64_
#include "../compiler_x64/opcode.h"
#else
#include "../compiler_x86/opcode.h"
#endif

using namespace ActiveBasic::Compiler;

BOOL IsPtrType(int type){
    if(type==-1) return 0;

    if(PTR_LEVEL(type)||type==DEF_PTR_VOID||type==DEF_PTR_PROC||
        (type&FLAG_PTR) ) return 1;

    return 0;
}
BOOL IsSignedType(int type){
    switch(type){
        case DEF_SBYTE:
        case DEF_INTEGER:
        case DEF_LONG:
        case DEF_INT64:
        case DEF_SINGLE:
        case DEF_DOUBLE:
        case DEF_CHAR:
            return 1;
        default:
            break;
    }
    return 0;
}
BOOL IsNaturalWholeNumberType(int type){
    switch(type){
        case DEF_SBYTE:
        case DEF_BYTE:
        case DEF_INTEGER:
        case DEF_WORD:
        case DEF_LONG:
        case DEF_DWORD:
        case DEF_INT64:
        case DEF_QWORD:
        case DEF_CHAR:
            return 1;
        default:
            break;
    }
    return 0;
}
BOOL IsWholeNumberType(int type){
    return (
        IsNaturalWholeNumberType(type)
        || IsPtrType(type)
        || type == DEF_BOOLEAN
        );
}
BOOL IsRealNumberType(int type){
    switch(type){
        case DEF_DOUBLE:
        case DEF_SINGLE:
            return 1;
        default:
            break;
    }
    return 0;
}
BOOL Is64Type(int type){
    switch(type){
        case DEF_INT64:
        case DEF_QWORD:
            return 1;
        default:
            break;
    }
#ifdef _AMD64_
    return IsPtrType(type);
#else
    return 0;
#endif
}
int GetSignedType(int type){
    switch(type){
        case DEF_BYTE:
            return DEF_SBYTE;
        case DEF_WORD:
            return DEF_INTEGER;
        case DEF_DWORD:
            return DEF_LONG;
        case DEF_QWORD:
            return DEF_INT64;
        default:
            break;
    }
#ifdef _AMD64_
    if(IsPtrType(type)) return DEF_INT64;
#else
    if(IsPtrType(type)) return DEF_LONG;
#endif
    return type;
}
int GetUnsignedType(int type){
    switch(type){
        case DEF_SBYTE:
            return DEF_BYTE;
        case DEF_INTEGER:
            return DEF_WORD;
        case DEF_LONG:
            return DEF_DWORD;
        case DEF_INT64:
            return DEF_QWORD;
        case DEF_CHAR:
            if( compiler.IsUnicode() ) return DEF_WORD;
            return DEF_BYTE;
    }
    return type;
}
int GetPtrType(int type){
    return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
}
BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
    if(PTR_LEVEL(type)){
        //ポインタ型
        name[0]='*';
        return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
    }

    //整数型
    if(type==DEF_SBYTE)             lstrcpy(name,"SByte");
    else if(type==DEF_BYTE)         lstrcpy(name,"Byte");
    else if(type==DEF_INTEGER)      lstrcpy(name,"Integer");
    else if(type==DEF_WORD)         lstrcpy(name,"Word");
    else if(type==DEF_LONG)         lstrcpy(name,"Long");
    else if(type==DEF_DWORD)        lstrcpy(name,"DWord");
    else if(type==DEF_INT64)        lstrcpy(name,"Int64");
    else if(type==DEF_QWORD)        lstrcpy(name,"QWord");

    //実数型
    else if(type==DEF_SINGLE)       lstrcpy(name,"Single");
    else if(type==DEF_DOUBLE)       lstrcpy(name,"Double");

    //文字型
    //else if(type==DEF_CHAR)               lstrcpy(name,"Char");

    //bool型
    else if(type==DEF_BOOLEAN)      lstrcpy(name,"Boolean");

    //オブジェクト
    else if(type==DEF_OBJECT || type==DEF_STRUCT){
        if(lpIndex==0) lstrcpy(name,"non");
        else{
            lstrcpy(name,((CClass *)lpIndex)->GetName().c_str());
        }
    }

    //ポインタ型
    else if(type==DEF_PTR_VOID)     lstrcpy(name,"VoidPtr");

    else if(type==DEF_PTR_PROC){
        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
        else{
            if( compiler.GetObjectModule().meta.GetProcPointers()[lpIndex]->ReturnType().IsNull() )
                lstrcpy(name,"*Sub");
            else lstrcpy(name,"*Function");
        }
    }

    else{
        extern int cp;
        compiler.errorMessenger.Output(1,NULL,cp);
        return 0;
    }
    return 1;
}

Type GetStringTypeInfo(){
    Type type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
    return type;
}

void GetWithName(char *buffer){
    extern WithInfos withInfos;
    buffer[0]=0;
    foreach( const WithInfo &withInfo, withInfos )
    {
        lstrcat( buffer, withInfo.name.c_str() );
    }
}

void GetWithName(std::string& buffer){
    extern WithInfos withInfos;
    std::string tmp;
    tmp.reserve(1024);
    foreach( const WithInfo &withInfo, withInfos )
    {
        tmp+=withInfo.name;
    }
    tmp.swap(buffer);
}

void GetArrange(char *variable,char *variAnswer, Subscripts &subscripts ){
    extern int cp;
    int i,i2,i4;
    double dbl;
    _int64 i64data;
    BOOL bBracket;
    char temporary[VN_SIZE];

    for(i=0;;i++){
        if(variable[i]=='('||variable[i]=='['){
            if(variable[i]=='[') bBracket=1;
            else bBracket=0;

            variAnswer[i]=0;
            for(i++,i2=0;;i++,i2++){
                if(variable[i]==','){
                    temporary[i2]=0;

                    Type resultType;
                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
                        return;
                    }
                    if(resultType.IsReal()){
                        memcpy(&dbl,&i64data,sizeof(double));
                        i64data=(_int64)dbl;
                    }

                    if(i64data<0)
                    {
                        //error
                        subscripts.push_back( 0 );
                    }
                    else
                    {
                        subscripts.push_back( (int)i64data );
                    }
                    i2=-1;
                    continue;
                }
                if(variable[i]=='('){
                    i4=GetStringInPare(temporary+i2,variable+i);
                    i2+=i4-1;
                    i+=i4-1;
                    continue;
                }
                if(variable[i]=='['){
                    i4=GetStringInBracket(temporary+i2,variable+i);
                    i2+=i4-1;
                    i+=i4-1;
                    continue;
                }
                if(variable[i]==')'&&bBracket==0||
                    variable[i]==']'&&bBracket){
                    temporary[i2]=0;
                    if(i2==0){
                        subscripts.push_back( -2 );
                        break;
                    }

                    Type resultType;
                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
                        return;
                    }
                    if(resultType.IsReal()){
                        memcpy(&dbl,&i64data,sizeof(double));
                        i64data=(_int64)dbl;
                    }

                    if(i64data<0){
                        //error
                        subscripts.push_back( 0 );
                    }
                    else
                    {
                        subscripts.push_back( (int)i64data );
                    }
                    break;
                }
                if(variable[i]=='\"'){
                    compiler.errorMessenger.Output(1,NULL,cp);
                    return;
                }
                temporary[i2]=variable[i];
            }
            break;
        }
        variAnswer[i]=variable[i];
        if(variable[i]=='\0'){
            break;
        }
    }
}

//対応する閉じ括弧cPare_Closeが現れるまでbufからarrayへコピーする。
int CopyInsideBracket(char *array, const char *buf, char cPare_Open, char cPare_Close)
{
    bool inStr=false;
    for(int i2=0;;i2++){
        if(buf[i2]=='"'){
            inStr=!inStr;
        }
        if(!inStr){
            if(buf[i2]==cPare_Open){
                int i3;
                if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buf+i2);
                else i3=GetStringInPare(array+i2,buf+i2);
                i2+=i3-1;
                continue;
            }
            if(buf[i2]==cPare_Close){
                array[i2]=0;
                return i2;
            }
        }
        array[i2]=buf[i2];
    }
}

bool GetVarFormatString( char *buffer,char *array,char *array2,char *NestMember,ReferenceKind &refType, PareOrBracket *pPareOrBracket ){
    extern int cp;
    int i;
    char cPare_Open,cPare_Close;

    array[0]=0;
    array2[0]=0;
    NestMember[0]=0;
    for(i=0;;i++){
        if(buffer[i]=='\"'){
            for(i++;;i++){
                if(IsDBCSLeadByte(buffer[i])){
                    i++;
                    continue;
                }
                if(buffer[i]=='\"') break;
            }
        }
        if(buffer[i]=='['||buffer[i]=='('){
            if(buffer[i]=='['){
                cPare_Open='[';
                cPare_Close=']';
            }
            else{
                cPare_Open='(';
                cPare_Close=')';
            }

            if( pPareOrBracket )
            {
                // []なのか、()なのかを伝える
                if( cPare_Open == '[' )
                {
                    *pPareOrBracket = Bracket;
                }
                else
                {
                    *pPareOrBracket = Pare;
                }
            }

            buffer[i]=0;
            i++;
            i+=CopyInsideBracket(array,buffer+i,cPare_Open,cPare_Close);
            if(buffer[i+1]==cPare_Open){
                i+=2;
                for(int i2=0;;i++,i2++){
                    if(buffer[i]==cPare_Open){
                        int i3;
                        if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
                        else i3=GetStringInPare(array2+i2,buffer+i);
                        i+=i3-1;
                        i2+=i3-1;
                        continue;
                    }
                    if(buffer[i]==cPare_Close){
                        array2[i2]=0;
                        break;
                    }
                    array2[i2]=buffer[i];
                }
                if(buffer[i+1]==cPare_Open){
                    compiler.errorMessenger.Output(14,buffer,cp);
                    return false;
                }
            }
            continue;
        }
        if(buffer[i]=='.'){
            lstrcpy(NestMember,buffer+i+1);
            refType = RefDot;
            buffer[i]=0;
            break;
        }
        if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
            lstrcpy(NestMember,buffer+i+2);
            refType = RefPointer;
            buffer[i]=0;
            break;
        }
        if(buffer[i]=='\0') break;
    }
    return true;
}

void GetArrayElement( const char *buffer,char *variable,char *array_element){
    array_element[0]=0;

    if(buffer[lstrlen(buffer)-1]!=']'){
        lstrcpy(variable,buffer);
        return;
    }

    int i,i2;
    for(i=0;;i++){
        if(buffer[i]=='\0') break;
        if(buffer[i]=='['){
            i2=GetStringInBracket(array_element,buffer+i);
            i+=i2-1;
            continue;
        }
    }

    lstrcpy(variable,buffer);
    variable[lstrlen(variable)-lstrlen(array_element)]=0;

    RemoveStringBracket(array_element);
}

BOOL CheckVarNameError(char *name,int nowLine){
    int i2;

    if(!IsVariableTopChar(name[0])){
        compiler.errorMessenger.Output(1,NULL,nowLine);
        return 0;
    }
    for(i2=1;;i2++){
        if(name[i2]=='\0') break;
        if(!IsVariableChar(name[i2])){
            compiler.errorMessenger.Output(1,NULL,nowLine);
            return 0;
        }
    }
    return 1;
}

int JumpSubScripts( const Subscripts &subscripts ){
    //DIMで定義された並んだ配列の数だけアドレスを進める
    int i, i2;
    for( i=0,i2=1; i<(int)subscripts.size(); i++ ){
        i2 *= subscripts[i] + 1;
    }
    return i2;
}


bool GetMemberType( const Type &classType, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled)
{
    const CClass &objClass = classType.GetClass();

    extern int cp;

    //クラス、配列の構成要素を解析する
    char VarName[VN_SIZE];      //変数名
    char array[VN_SIZE];        //第1次配列
    char lpPtrOffset[VN_SIZE];      //第2次配列
    char NestMember[VN_SIZE];   //入れ子メンバ
    ReferenceKind refType = RefNon;
    lstrcpy(VarName,lpszMember);
    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;

    const Member *pMember = objClass.FindDynamicMember( VarName );
    if( !pMember ){
        if(isErrorEnabled) compiler.errorMessenger.Output(103,VarName,cp);
        return false;
    }

    //アクセシビリティをチェック
    if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
        if( pMember->IsNoneAccess() ){
            if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
            return false;
        }
    }
    else{
        if(( bPrivateAccess==0 && pMember->IsPrivate() )||
            pMember->IsNoneAccess() ){
            if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
            return false;
        }
        else if( bPrivateAccess==0 && pMember->IsProtected() ){
            if(isErrorEnabled) compiler.errorMessenger.Output(108,VarName,cp);
            return false;
        }
    }

    resultType = pMember->GetType();

    // 型パラメータを解決
    ResolveFormalGenericTypeParameter( resultType, classType );


    //ポインタ変数の場合
    if( resultType.IsPointer() ){
        if( pMember->GetSubscripts().size() == 0 ){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]){
            if(isErrorEnabled) compiler.errorMessenger.Output(16,lpszMember,cp);
            return false;
        }
    }

    if(array[0]){
        //配列オフセット
        if( pMember->GetSubscripts().size() <= 0 )
        {
            // 配列ではないメンバに配列指定をした
            return false;
        }
    }
    else if( pMember->GetSubscripts().size() > 0 ){
        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    }

    if( refType != RefNon ){
        //入れ子構造の場合

        return GetMemberType( pMember->GetType(),
            NestMember,
            resultType,
            0,
            isErrorEnabled);
    }

    if(lpPtrOffset[0]){
        if( resultType.PtrLevel() ){
            resultType.PtrLevelDown();
        }
        else{
            //エラー
            if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
            return false;
        }
    }

    return true;
}
bool GetVarType( const char *nameBuffer, Type &resultType, bool isErrorEnabled){
    char variable[VN_SIZE];

    if(nameBuffer[0]=='.'){
        GetWithName(variable);
        lstrcat(variable,nameBuffer);
    }
    else lstrcpy(variable,nameBuffer);

    // 名前空間を分離
    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );

    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
    ReferenceKind refType;
    char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);

    // 名前空間を分離していた場合は結合
    char VarName[VN_SIZE];
    if( namespaceStr[0] ){
        sprintf( VarName, "%s.%s", namespaceStr, simpleName );
    }
    else{
        lstrcpy( VarName, simpleName );
    }

    const Variable *pVar = NULL;

    if( compiler.IsLocalAreaCompiling() ){
        /////////////////
        // ローカル変数
        /////////////////

        pVar = compiler.GetCompilingUserProc().GetLocalVars().BackSearch(
            LexicalAnalyzer::FullNameToSymbol( VarName ),
            compiler.codeGenerator.lexicalScopes.GetNowLevel()
        );
        if( pVar ){
            goto ok;
        }
    }

    if( compiler.IsCompilingClass() ){
        ///////////////////////
        // クラスメンバの参照
        ///////////////////////

        if(lstrcmpi(variable,"This")==0){
            //Thisオブジェクト
            resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
            return true;
        }

        if(memicmp(variable,"This.",5)==0){
            //Thisオブジェクトのメンバを参照するとき
            SlideString(variable+5,-5);
            lstrcpy(VarName,variable);
        }
        else{
            //クラス内の動的メンバを参照するとき（通常）

            if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
            {
                goto NonClassMember;
            }
        }

        return GetMemberType(
            Type( DEF_OBJECT, compiler.GetCompilingClass() ),
            variable,
            resultType,
            1,
            isErrorEnabled
        );
    }

NonClassMember:

    //////////////////////////
    // 静的ローカル変数
    // ※"Static.Object.Method.Variable"
    //////////////////////////

    char temporary[VN_SIZE];
    if( compiler.IsLocalAreaCompiling() ){
        GetNowStaticVarFullName(VarName,temporary);

        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temporary ) );
        if( pVar ){
            goto ok;
        }
    }


    //////////////////////////
    // クラスの静的メンバ
    //////////////////////////

    if(member[0]){
        lstrcpy(temporary,member);
        char tempMember[VN_SIZE];
        char tempArray[VN_SIZE];
        {
            ReferenceKind refType;
            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
        }

        const TypeDef *pTypeDef = compiler.GetObjectModule().meta.GetTypeDefs().Find( LexicalAnalyzer::FullNameToSymbol( VarName ) );
        if( pTypeDef )
        {
            // TypeDef後の型名だったとき
            lstrcpy( VarName, pTypeDef->GetBaseName().c_str() );
        }

        char temp2[VN_SIZE];
        sprintf(temp2,"%s.%s",VarName,temporary);

        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
        if( pVar ){
            lstrcpy(member,tempMember);
            lstrcpy(array,tempArray);
            goto ok;
        }
    }

    if( compiler.IsCompilingClass() ){
        //自身のクラスから静的メンバを参照する場合
        char temp2[VN_SIZE];
        sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);

        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
        if( pVar ){
            goto ok;
        }
    }


    ////////////////////
    // グローバル変数
    ////////////////////

    pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch(
        LexicalAnalyzer::FullNameToSymbol( VarName ),
        compiler.codeGenerator.lexicalScopes.GetNowLevel()
    );
    if( pVar ){
        goto ok;
    }

    //変数として見つからなかったとき
    if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
    return false;

ok:

    //ポインタ変数の場合
    if( pVar->GetType().IsPointer() ){
        if( !pVar->IsArray() ){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]){
            if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
            return false;
        }
    }

    resultType = pVar->GetType();

    if(member[0]){
        if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
            || NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
        {
            return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
        }
    }

    if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
        //配列の先頭ポインタを示す場合
        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    }

    if(lpPtrOffset[0]){
        if( resultType.PtrLevel() ){
            resultType.PtrLevelDown();
        }
        else{
            //エラー
            if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
            return false;
        }
    }

    return true;
}

bool GetVarOffsetReadOnly(const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
{
    //読み取り専用で変数へアクセス
    return GetVarOffset(
        true,       //エラー表示有効
        false,      //書き込みアクセスは無し
        NameBuffer,
        pRelativeVar,
        resultType,
        pResultSubscripts
    );
}
bool GetVarOffsetReadWrite(const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
{
    //読み書き両用で変数へアクセス
    return GetVarOffset(
        true,       //エラー表示有効
        true,       //書き込みアクセス
        NameBuffer,
        pRelativeVar,
        resultType,
        pResultSubscripts
    );
}



bool GetDimentionFormat( const char *buffer,
                        char *VarName,
                        Subscripts &subscripts,
                        Type &type,
                        char *InitBuf,
                        char *ConstractParameter ){
    int i,i2,i3,IsStr;
    char variable[VN_SIZE],temporary[8192];

    for(i=0;;i++){
        if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
            buffer[i]=='='||
            buffer[i]=='\0'){
            variable[i]=0;
            break;
        }
        variable[i]=buffer[i];
    }

    if(buffer[i]=='='){
        ////////////////////////////////////
        // 初期化データが指定されいるとき
        ////////////////////////////////////
        i++;

        if( buffer[i]=='[' ){
            // 構造初期データの場合

            i3=GetStringInBracket(InitBuf,buffer+i);
            i+=i3;
        }
        else{
            // 代入初期データの場合

            for(i2=0,IsStr=0;;i++,i2++){
                if(buffer[i]=='\"') IsStr^=1;
                if(buffer[i]=='('&&IsStr==0){
                    i3=GetStringInPare(InitBuf+i2,buffer+i);
                    i+=i3-1;
                    i2+=i3-1;
                    continue;
                }
                if(buffer[i]=='['&&IsStr==0){
                    i3=GetStringInBracket(InitBuf+i2,buffer+i);
                    i+=i3-1;
                    i2+=i3-1;
                    continue;
                }
                if((buffer[i]==','&&IsStr==0)||
                    buffer[i]=='\0'){
                    InitBuf[i2]=0;
                    break;
                }
                InitBuf[i2]=buffer[i];
            }
        }
    }
    else{
        //初期化データなし
        InitBuf[0]=0;
    }

    ConstractParameter[0]=0;
    if(buffer[i]==1&&buffer[i+1]==ESC_AS){
        /////////////////////////////
        // "As ～" による型指定あり
        /////////////////////////////

        for(i+=2,i2=0;;i++,i2++){
            if(buffer[i]=='('||buffer[i]=='\0'){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
        if(temporary[0]=='*'&&
            temporary[1]==1&&
            (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
            if(buffer[i]!='('){
                compiler.errorMessenger.Output(10,temporary,cp);
                return false;
            }
            i3=GetStringInPare(temporary+3,buffer+i);
            i+=i3;
            i2+=i3;

            if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
                temporary[i2++]=buffer[i++];
                temporary[i2++]=buffer[i++];
                for(;;i++,i2++){
                    if(!IsVariableChar(buffer[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=buffer[i];
                }
            }
        }

        ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType result = compiler.StringToTypeEx( temporary, type, true );
        if( result != ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful )
        {
            if( result == ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType )
            {
                compiler.errorMessenger.Output(143,temporary,cp);
            }
            else
            {
                compiler.errorMessenger.Output(3,temporary,cp);
            }
            return false;
        }

        if(buffer[i]=='('){
            //コンストラクタに渡すパラメータを取得
            i2=GetStringInPare(ConstractParameter,buffer+i);
            i+=i2;
            RemoveStringPare(ConstractParameter);

            if( !type.IsObject() ){
                compiler.errorMessenger.Output(112,variable,cp);
                return false;
            }
        }
    }
    else{
        /////////////////
        // As指定なし
        /////////////////

        if( InitBuf[0] == '\0' ){
            //As指定も、初期値指定もない場合
            type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );

            i2=lstrlen(variable)-1;
            if(i2>=0){
                if(!(variable[i2]=='#'||variable[i2]=='!'||variable[i2]=='%'||variable[i2]=='$'))
                    compiler.errorMessenger.Output(-103,variable,cp);
            }
        }
        else{
            //初期値の型を判別して自動的に型情報を付加する
            if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
                // エラーの場合
                return false;
            }

            if( IS_LITERAL( type.GetIndex() ) ){
                type.SetIndex( -1 );
            }
        }

    }

    if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
        //初期値とコンストラクタパラメータが同時に呼び出されているとき
        compiler.errorMessenger.Output(132, NULL, cp);
    }

    GetArrange(variable,VarName,subscripts);
    return true;
}

BOOL GetNowStaticVarFullName(char *VarName,char *FullName){
    if( compiler.IsGlobalAreaCompiling() ){
        // グローバル領域をコンパイル中のとき
        return 0;
    }

    const UserProc &proc = compiler.GetCompilingUserProc();

    //Static識別
    lstrcpy(FullName,"Static%");

    //クラス名
    if( compiler.IsCompilingClass() ){
        lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
        lstrcat(FullName,"%");
    }

    //関数（またはメソッド）名
    lstrcat(FullName,proc.GetName().c_str());
    lstrcat(FullName,"%");

    //ID
    char temp[255];
    sprintf(temp,"%x",proc.GetId());
    lstrcat(FullName,temp);
    lstrcat(FullName,"%");

    //変数名
    lstrcat(FullName,VarName);

    return 1;
}


void AddGlobalVariable( const char *name, const Subscripts &subscripts, const Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlag){
    /////////////////////////
    // グローバル変数を追加
    /////////////////////////

    if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ), compiler.codeGenerator.lexicalScopes.GetNowLevel() ) ){
        //２重定義のエラー
        compiler.errorMessenger.Output(15,name,cp);
        return;
    }

    bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;

    Variable *pVar = new Variable(
        Symbol( compiler.GetNamespaceSupporter().GetLivingNamespaceScopes(), name ),
        type,
        isConst,
        false,
        ConstractParameter,
        ( InitBuf[0] != 0 || dwFlag == DIMFLAG_INITDEBUGVAR )
    );

    if( subscripts.size() > 0 ){
        //配列あり
        pVar->SetArray( subscripts );
    }

    //レキシカルスコープ
    pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
    pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
    pVar->isLiving = true;

    //エラー用
    pVar->source_code_address=cp;

    // 変数を追加
    compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );

    if(InitBuf[0]){
        int result = 0;
        if( !pVar->GetType().IsObject() ){
            result = SetInitGlobalData(pVar->GetOffsetAddress(),
                pVar->GetType(),
                pVar->GetSubscripts(),
                InitBuf);
        }

        if(!result){
            //動的な式だった場合は代入演算を行う

            //初期代入時のみ、書き込みアクセスを許可する
            if( isConst ){
                pVar->ConstOff();
            }

            //代入
            char temporary[8192];
            sprintf(temporary,"%s=%s",name,InitBuf);
            OpcodeCalc(temporary);

            //アクセス制限を元に戻す
            if( isConst ){
                pVar->ConstOn();
            }
        }
    }


    if( type.IsObject() ){
        //デストラクタの利用フラグをオンにする
        const CMethod *method = type.GetClass().GetDestructorMethod();
        if( method ){
            method->GetUserProc().Using();
        }
    }
}

void dim(char *Parameter,DWORD dwFlags){
    int i2;
    char VarName[VN_SIZE];

    i2 = 0;

    if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
        //参照型
        compiler.errorMessenger.OutputFatalError();
        Parameter += 2;
    }

    if(dwFlags & DIMFLAG_CONST){

        //////////////////////////////////
        // 定数変数の場合を考慮
        //////////////////////////////////
        for(;;i2++){
            if(Parameter[i2] == '=' ||
                Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
                Parameter[i2] =='('){
                    VarName[i2] = 0;
                    break;
            }
            VarName[i2] = Parameter[i2];
        }

        //定数と２重定義されていないる場合は抜け出す
        if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
            return;
        }

        //定数マクロとして定義されている場合は抜け出す
        if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) )
        {
            return;
        }
    }


    //構文を解析
    Type type;
    char InitBuf[8192];
    char ConstractParameter[VN_SIZE];
    Subscripts subscripts;
    if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
        return;


    //定数と２重定義されていないかを調べる
    if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
        compiler.errorMessenger.Output(15,VarName,cp);
        return;
    }

    //定数マクロとして定義されている場合
    if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) ){
        compiler.errorMessenger.Output(15,VarName,cp);
        return;
    }

    if( type.IsObject() ){
        if( type.GetClass().IsBlittableType() ){
            // Blittable型のときは基本型として扱う
            // ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
            if( compiler.IsLocalAreaCompiling()
                && compiler.GetCompilingUserProc().HasParentClass()
                && compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
            {
                // コンパイル中のメソッドがBlittable型クラスに属している
            }
            else{
                type = type.GetClass().GetBlittableType();
            }
        }
    }

    if(dwFlags&DIMFLAG_STATIC)
    {
        if( compiler.IsGlobalAreaCompiling() )
        {
            compiler.errorMessenger.Output(60,NULL,cp);
            return;
        }

        /////////////////////
        // Static変数
        // ※"Static.Object.Method.Variable"
        /////////////////////

        char temporary[VN_SIZE];
        GetNowStaticVarFullName(VarName,temporary);

        dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );

        /*
        Note: 静的変数のコンストラクタ呼び出しは
            _System_InitStaticLocalVariables関数内で一括して行う
        */
    }
    else{
        dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
    }
}
void OpcodeDim(char *Parameter,DWORD dwFlags){
    int i,i2,i3,IsStr=0;
    char temporary[8192];

    for(i=0,i2=0;;i++,i2++){
        if(Parameter[i]=='\"') IsStr^=1;
        if(Parameter[i]=='('&&IsStr==0){
            i3=GetStringInPare(temporary+i2,Parameter+i);
            i+=i3-1;
            i2+=i3-1;
            continue;
        }
        if(Parameter[i]=='['&&IsStr==0){
            i3=GetStringInBracket(temporary+i2,Parameter+i);
            i+=i3-1;
            i2+=i3-1;
            continue;
        }
        if( Parameter[i] == '<' && IsStr == 0 )
        {
            if( IsGenericTypeSourcePart( Parameter + i ) )
            {
                // ジェネリクス構文
                i3=GetStringInGenericBracket(temporary+i2,Parameter+i);
                i+=i3-1;
                i2+=i3-1;
                continue;
            }
            else
            {
                // 一般構文
            }
        }
        if((Parameter[i]==','&&IsStr==0)||
            Parameter[i]=='\0'){
            temporary[i2]=0;

            dim(temporary,dwFlags);

            if(Parameter[i]=='\0') break;
            i2=-1;
            continue;
        }
        temporary[i2]=Parameter[i];
    }
}

void DebugVariable(void)
{
    char temporary[255];
    if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
    {
        // 未定義の場合は定義する
        sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
        sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
        sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
        sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
    }
}