Changeset 75 in dev for BasicCompiler64/Compile_Var.cpp


Ignore:
Timestamp:
Mar 20, 2007, 4:36:16 AM (17 years ago)
Author:
dai_9181
Message:

TYPEINFO→Typeへのリファクタリングを実施。64bitはほぼ完了。32bitが全般的に未完成。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/Compile_Var.cpp

    r73 r75  
    33
    44//変数
    5 VARIABLE *GlobalVar;
     5Variables globalVars;
    66int MaxGlobalVarNum;
    77int AllGlobalVarSize;
    88int AllInitGlobalVarSize;
    9 VARIABLE *LocalVar;
     9
    1010int MaxLocalVarNum;
    1111int AllLocalVarSize;
    1212
    1313
    14 void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
    15     int i2;
    16 
    17 
     14void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){
    1815    /////////////////////////////////////////////
    1916    // 先頭ポインタをr12に取得してメモリへ退避
    … …  
    3128
    3229    int reg=REG_NON;
    33     i2=NumOpe(&reg,lpPtrOffset,0,0,0);
    34     if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
    35     ExtendTypeTo64(i2,reg);
     30    Type type;
     31    NumOpe( &reg, lpPtrOffset, Type(), type );
     32    if( !type.IsWhole() ){
     33        SetError(46,NULL,cp);
     34    }
     35    ExtendTypeTo64(type.GetBasicType(),reg);
    3636
    3737    if(reg==REG_R14){
    … …  
    4040    }
    4141
    42     if(PTR_LEVEL(*pType)){
    43         *pType = PTR_LEVEL_DOWN( *pType );
    44 
    45         i2=GetTypeSize(*pType,lpIndex);
    46         if(i2>=2){
     42    if( resultType.PtrLevel() ){
     43        resultType.PtrLevelDown();
     44
     45        int typeSize = resultType.GetSize();
     46        if(typeSize>=2){
    4747            //imul reg,i2
    48             op_imul_RV(sizeof(_int64),reg,i2);
     48            op_imul_RV(sizeof(_int64),reg,typeSize);
    4949        }
    5050    }
    … …  
    8080    }
    8181}
    82 BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
     82bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){
    8383    extern HANDLE hHeap;
    84     int i,i2,i3,i4,TypeSize;
     84    int i,i2,i3,i4;
    8585    char temporary[VN_SIZE],*pParm[MAX_PARMS];
    8686
    … …  
    101101            if(SubScripts[i3]==-1){
    102102                for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    103                 return 0;
     103                return false;
    104104            }
    105105
    … …  
    114114                if(SubScripts[i3]!=-1){
    115115                    for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    116                     return 0;
     116                    return false;
    117117                }
    118118                break;
    … …  
    136136
    137137        int reg=REG_NON;
    138         TYPEINFO TypeInfo;
     138        Type type;
    139139        BOOL bUseHeap;
    140         TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
    141         if(TypeInfo.type==DEF_OBJECT){
     140        NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &bUseHeap );
     141        if( type.IsObject() ){
    142142            //キャスト演算子のオーバーロードに対応する
    143143            CallCastOperatorProc(reg,
    144                 TypeInfo.type,TypeInfo.u.lpIndex,
    145                 bUseHeap,DEF_LONG,-1);
    146             TypeInfo.type=DEF_LONG;
    147         }
    148 
    149         if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
    150         ExtendTypeTo64(TypeInfo.type,reg);
     144                type,
     145                bUseHeap, Type(DEF_LONG) );
     146            type.SetBasicType( DEF_LONG );
     147        }
     148
     149        if( !type.IsWhole() ){
     150            SetError(46,NULL,cp);
     151        }
     152        ExtendTypeTo64( type.GetBasicType(), reg );
    151153
    152154        if(reg==REG_R14){
    … …  
    168170        HeapDefaultFree(pParm[i]);
    169171    }
    170 
    171     TypeSize=GetTypeSize(type,lpIndex);
    172172
    173173    //imul r12,TypeSize
    … …  
    175175    OpBuffer[obp++]=(char)0x69;
    176176    OpBuffer[obp++]=(char)0xE4;
    177     *((long *)(OpBuffer+obp))=TypeSize;
     177    *((long *)(OpBuffer+obp))=type.GetSize();
    178178    obp+=sizeof(long);
    179179
    … …  
    186186    OpBuffer[obp++]=(char)0xDC;
    187187
    188     return 1;
     188    return true;
    189189}
    190 BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
     190bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
    191191    int i;
    192192
    … …  
    202202    CClass::RefType refType;
    203203    lstrcpy(VarName,member);
    204     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
     204    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
    205205
    206206
    … …  
    209209    ////////////////////////////
    210210
    211     int offset = pobj_c->GetMemberOffset( VarName, &i );
    212     if(i==pobj_c->iMemberNum){
     211    int offset = objClass.GetMemberOffset( VarName, &i );
     212    if(i==objClass.iMemberNum){
    213213        if(isErrorEnabled) SetError(103,VarName,cp);
    214         return 0;
    215     }
    216 
    217     CMember *pMember=pobj_c->ppobj_Member[i];
     214        return false;
     215    }
     216
     217    CMember *pMember=objClass.ppobj_Member[i];
    218218
    219219
    220220    //アクセシビリティをチェック
    221     if(pobj_c==pobj_CompilingClass){
     221    if(&objClass==pobj_CompilingClass){
    222222        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    223223        if(pMember->dwAccess==ACCESS_NON){
    224224            if(isErrorEnabled) SetError(107,VarName,cp);
    225             return 0;
     225            return false;
    226226        }
    227227    }
    … …  
    230230            pMember->dwAccess==ACCESS_NON){
    231231            if(isErrorEnabled) SetError(107,VarName,cp);
    232             return 0;
     232            return false;
    233233        }
    234234        else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
    235235            if(isErrorEnabled) SetError(108,VarName,cp);
    236             return 0;
     236            return false;
    237237        }
    238238    }
    … …  
    242242    if( pMember->IsConst() &&       //定数メンバである
    243243        isWriteAccess &&                            //書き込みアクセスを要求されている
    244         pobj_c->IsCompilingConstructor() == false   //コンストラクタ コンパイル中を除く
     244        objClass.IsCompilingConstructor() == false  //コンストラクタ コンパイル中を除く
    245245        ){
    246246            //Const定義の変数に書き込みアクセスをしようとした場合
    … …  
    248248    }
    249249
    250     *pType=pMember->TypeInfo.type;
    251     *plpNestIndex=pMember->TypeInfo.u.lpIndex;
     250    resultType = *pMember;
    252251
    253252    //ポインタ変数の場合
    254     if(IsPtrType(*pType)){
     253    if( resultType.IsPointer() ){
    255254        if(pMember->SubScripts[0]==-1){
    256255            lstrcpy(lpPtrOffset,array);
    … …  
    261260        if(lpPtrOffset[0]){
    262261            if(isErrorEnabled) SetError(16,member,cp);
    263             return 0;
     262            return false;
    264263        }
    265264    }
    … …  
    276275    if(array[0]){
    277276        //配列オフセット
    278         if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
     277        if(!GetArrayOffset(pMember->SubScripts,array,*pMember)){
    279278            if(isErrorEnabled) SetError(14,member,cp);
    280279        }
    281280    }
    282281    else if(pMember->SubScripts[0]!=-1){
    283         *pType|=FLAG_PTR;
     282        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    284283    }
    285284
    … …  
    287286        //入れ子構造の場合
    288287
    289         if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     288        if( resultType.IsObject() || resultType.IsStruct() ){
    290289            if( refType != CClass::Dot ){
    291290                if(isErrorEnabled) SetError(104,member,cp);
    292                 return 0;
    293             }
    294 
    295             if( *pType==DEF_OBJECT ){
     291                return false;
     292            }
     293
     294            if( resultType.IsObject() ){
    296295                // 参照内容へのポインタを抽出
    297296                SetRelativeOffset( *pRelativeVar );
    298297            }
    299298        }
    300         else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
     299        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
    301300            //構造体ポインタ型メンバ変数
    302301
    303302            if(lpPtrOffset[0]){
    304303                //pObj[n].member
    305                 if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
    306                     if(isErrorEnabled) SetError(104,member,cp);
    307                     return 0;
     304                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
     305                    && refType != CClass::Dot ){
     306                        if(isErrorEnabled) SetError(104,member,cp);
     307                        return false;
    308308                }
    309309
    310310                //直接参照に切り替え
    311                 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     311                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    312312                pRelativeVar->dwKind=VAR_DIRECTMEM;
    313313
    … …  
    316316            else{
    317317                //pObj->member
    318                 if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
    319                     if(isErrorEnabled) SetError(104,member,cp);
    320                     return 0;
     318                if( (resultType.IsObjectPtr() || resultType.IsStructPtr() )
     319                    && refType != CClass::Pointer ){
     320                        if(isErrorEnabled) SetError(104,member,cp);
     321                        return false;
    321322                }
    322323
    … …  
    324325            }
    325326        }
    326         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
     327        else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
     328            || resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
    327329            //構造体ポインタのポインタ型メンバ変数
    328330
    … …  
    331333                if( refType != CClass::Pointer ){
    332334                    if(isErrorEnabled) SetError(104,member,cp);
    333                     return 0;
     335                    return false;
    334336                }
    335337
    336338                //直接参照に切り替え
    337                 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     339                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    338340                pRelativeVar->dwKind=VAR_DIRECTMEM;
    339341
    … …  
    345347            else{
    346348                if(isErrorEnabled) SetError(104,member,cp);
    347                 return 0;
    348             }
    349         }
    350 
    351         if(!GetMemberOffset(
     349                return false;
     350            }
     351        }
     352
     353        if(!_member_offset(
    352354            isErrorEnabled,
    353355            isWriteAccess,
    354             pMember->TypeInfo.u.pobj_Class,
     356            pMember->GetClass(),
    355357            NestMember,
    356             pType,
    357358            pRelativeVar,
    358             plpNestIndex,
    359             0)) return 0;
     359            resultType,
     360            0)) return false;
    360361    }
    361362
    362363    if(lpPtrOffset[0]){
    363         SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     364        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    364365        pRelativeVar->dwKind=VAR_DIRECTMEM;
    365366    }
    366367
    367     return 1;
     368    return true;
    368369}
    369370void GetWithName(char *buffer){
    … …  
    380381    //自身のオブジェクトのThisポインタをregにコピー
    381382
    382     extern VARIABLE *LocalVar;
    383383    RELATIVE_VAR RelativeVar;
    384384    RelativeVar.dwKind=VAR_LOCAL;
    … …  
    388388    SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
    389389}
    390 BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    391     extern BOOL bCompilingGlobal;
     390bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){
    392391    int i;
    393     LONG_PTR lpIndex;
    394392    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    395393
    … …  
    406404
    407405        void *pInfo;
    408         int idProc=GetProc(VarName,&pInfo);
     406        int idProc=GetProc(VarName,(void **)&pInfo);
    409407
    410408        if(idProc){
    411409            pRelativeVar->dwKind=VAR_DIRECTMEM;
     410
     411            Type type;
    412412
    413413            //////////////////////////////////////////////////////
    … …  
    420420                ////////////////
    421421
    422                 *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
     422                CallProc(idProc,pInfo,VarName,array,type);
    423423
    424424                //戻り値をr11にコピー
    … …  
    430430            }////////////////////////////////////////////
    431431
    432             LONG_PTR lp2;
    433             if(!GetMemberOffset(
     432            if(!_member_offset(
    434433                isErrorEnabled,
    435434                isWriteAccess,
    436                 (CClass *)lpIndex,
    437                 member,pType,pRelativeVar,&lp2,0)) return 0;
    438             if(plpIndex) *plpIndex=lp2;
    439 
    440             return 1;
     435                type.GetClass(),
     436                member,pRelativeVar,resultType,0)) return false;
     437
     438            return true;
    441439        }
    442440    }
    … …  
    447445    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    448446
    449     int *pSubScripts;
     447    const int *pSubScripts;
    450448    bool bConst = false;
    451449
    452450
    453     if(bCompilingGlobal==0){
     451    if( UserProc::IsLocalAreaCompiling() ){
    454452        //////////////////
    455453        // ローカル変数
    456454        //////////////////
    457455
    458         for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    459             if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
    460                 && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
    461                 ){
    462                     if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    463             }
    464         }
    465         if(i>=0){
     456        const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
     457        if( pVar ){
    466458            //ポインタ変数の場合
    467             if(IsPtrType(LocalVar[i].type)){
    468                 if(LocalVar[i].SubScripts[0]==-1){
     459            if( pVar->IsPointer() ){
     460                if( !pVar->IsArray() ){
    469461                    lstrcpy(lpPtrOffset,array);
    470462                    array[0]=0;
    … …  
    475467                    SetError(16,variable,cp);
    476468                    pRelativeVar->dwKind=NON_VAR;
    477                     return 0;
     469                    return false;
    478470                }
    479471            }
    480472
    481             pRelativeVar->offset=-LocalVar[i].offset;
     473            pRelativeVar->offset=-pVar->offset;
    482474            pRelativeVar->bOffsetOffset=0;
    483             if(LocalVar[i].fRef){
     475            if( pVar->IsRef() ){
    484476                // 参照型
    485477                pRelativeVar->dwKind = VAR_REFLOCAL;
    486478            }
    487479            else pRelativeVar->dwKind=VAR_LOCAL;
    488             *pType=LocalVar[i].type;
    489             lpIndex=LocalVar[i].u.index;
    490             if(plpIndex) *plpIndex=lpIndex;
    491             pSubScripts=LocalVar[i].SubScripts;
    492             bConst = LocalVar[i].bConst;
     480            resultType = *pVar;
     481            pSubScripts=pVar->GetSubScriptsPtr();
     482            bConst = pVar->IsConst();
    493483
    494484            goto ok;
    … …  
    506496            SetThisPtrToReg(REG_R11);
    507497
    508             *pType=DEF_OBJECT;
    509498            pRelativeVar->dwKind=VAR_DIRECTMEM;
    510499
    511             if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
    512             return 1;
     500            resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     501            return true;
    513502        }
    514503
    … …  
    542531
    543532        pRelativeVar->dwKind=VAR_DIRECTMEM;
    544         if(!GetMemberOffset(
     533        if(!_member_offset(
    545534            isErrorEnabled,
    546535            isWriteAccess,
    547             pobj_CompilingClass,
     536            *pobj_CompilingClass,
    548537            variable,
    549             pType,
    550538            pRelativeVar,
    551             &lpIndex,1)) return 0;
    552         if(plpIndex) *plpIndex=lpIndex;
    553         return 1;
     539            resultType,1)) return false;
     540        return true;
    554541    }
    555542
    556543NonClassMember:
    557544
    558     //////////////////////////
    559     // 静的ローカル変数
    560     // ※"Static.Object.Method.Variable"
    561     //////////////////////////
    562 
    563     char temporary[VN_SIZE];
    564     extern SubInfo *pCompilingSubInfo;
    565     if(pCompilingSubInfo){
    566         GetNowStaticVarFullName(VarName,temporary);
    567 
    568         for(i=0;i<MaxGlobalVarNum;i++){
    569             if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
    570         }
    571         if(i!=MaxGlobalVarNum){
     545    {
     546        const Variable *pVar;
     547
     548        //////////////////////////
     549        // 静的ローカル変数
     550        // ※"Static.Object.Method.Variable"
     551        //////////////////////////
     552
     553        char temporary[VN_SIZE];
     554        if( UserProc::IsLocalAreaCompiling() ){
     555            GetNowStaticVarFullName(VarName,temporary);
     556
     557            pVar = globalVars.Find( temporary );
     558            if( pVar ){
     559                goto GlobalOk;
     560            }
     561        }
     562
     563
     564        //////////////////////////
     565        // クラスの静的メンバ
     566        //////////////////////////
     567
     568        if(member[0]){
     569            lstrcpy(temporary,member);
     570
     571            char tempMember[VN_SIZE];
     572            char tempArray[VN_SIZE];
     573            {
     574                CClass::RefType refType;
     575                GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
     576            }
     577
     578            char temp2[VN_SIZE];
     579            sprintf(temp2,"%s.%s",VarName,temporary);
     580            pVar = globalVars.Find( temp2 );
     581            if( pVar ){
     582                lstrcpy(member,tempMember);
     583                lstrcpy(array,tempArray);
     584                goto GlobalOk;
     585            }
     586        }
     587
     588        if(pobj_CompilingClass){
     589            //自身のクラスから静的メンバを参照する場合
     590            char temp2[VN_SIZE];
     591            sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
     592            pVar = globalVars.Find( temp2 );
     593            if( pVar ){
     594                goto GlobalOk;
     595            }
     596        }
     597
     598        /////////////////////
     599        // グローバル変数
     600        /////////////////////
     601
     602        pVar = globalVars.BackSearch( VarName );
     603        if( pVar ){
    572604            goto GlobalOk;
    573605        }
    574     }
    575 
    576 
    577     //////////////////////////
    578     // クラスの静的メンバ
    579     //////////////////////////
    580 
    581     if(member[0]){
    582         lstrcpy(temporary,member);
    583 
    584         char tempMember[VN_SIZE];
    585         char tempArray[VN_SIZE];
    586         {
    587             CClass::RefType refType;
    588             GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
    589         }
    590 
    591         char temp2[VN_SIZE];
    592         sprintf(temp2,"%s.%s",VarName,temporary);
    593         for(i=0;i<MaxGlobalVarNum;i++){
    594             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    595         }
    596 
    597         if(i!=MaxGlobalVarNum){
    598             lstrcpy(member,tempMember);
    599             lstrcpy(array,tempArray);
    600             goto GlobalOk;
    601         }
    602     }
    603 
    604     if(pobj_CompilingClass){
    605         //自身のクラスから静的メンバを参照する場合
    606         char temp2[VN_SIZE];
    607         sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
    608         for(i=0;i<MaxGlobalVarNum;i++){
    609             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    610         }
    611 
    612         if(i!=MaxGlobalVarNum){
    613             goto GlobalOk;
    614         }
    615     }
    616 
    617     /////////////////////
    618     // グローバル変数
    619     /////////////////////
    620 
    621     for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    622         if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
    623             && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
    624             ){
    625                 if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    626         }
    627     }
    628     if(i>=0){
    629         goto GlobalOk;
    630     }
    631 
    632     if(isErrorEnabled) SetError(3,variable,cp);
    633     pRelativeVar->dwKind=NON_VAR;
    634     return 0;
     606
     607        if(isErrorEnabled) SetError(3,variable,cp);
     608        pRelativeVar->dwKind=NON_VAR;
     609        return false;
    635610
    636611
    637612
    638613GlobalOk:
    639     //ポインタ変数の場合
    640     if(IsPtrType(GlobalVar[i].type)){
    641         if(GlobalVar[i].SubScripts[0]==-1){
    642             lstrcpy(lpPtrOffset,array);
    643             array[0]=0;
    644         }
    645     }
    646     else{
    647         if(lpPtrOffset[0]){
    648             SetError(16,variable,cp);
    649             pRelativeVar->dwKind=NON_VAR;
    650             return 0;
    651         }
    652     }
    653 
    654     pRelativeVar->offset=GlobalVar[i].offset;
    655     pRelativeVar->bOffsetOffset=0;
    656     if(GlobalVar[i].fRef){
    657         // 参照型
    658         pRelativeVar->dwKind = VAR_REFGLOBAL;
    659     }
    660     else pRelativeVar->dwKind=VAR_GLOBAL;
    661     *pType=GlobalVar[i].type;
    662     lpIndex=GlobalVar[i].u.index;
    663     if(plpIndex) *plpIndex=lpIndex;
    664     pSubScripts=GlobalVar[i].SubScripts;
    665     bConst = GlobalVar[i].bConst;
     614        //ポインタ変数の場合
     615        if( pVar->IsPointer() ){
     616            if( !pVar->IsArray() ){
     617                lstrcpy(lpPtrOffset,array);
     618                array[0]=0;
     619            }
     620        }
     621        else{
     622            if(lpPtrOffset[0]){
     623                SetError(16,variable,cp);
     624                pRelativeVar->dwKind=NON_VAR;
     625                return false;
     626            }
     627        }
     628
     629        pRelativeVar->offset=pVar->offset;
     630        pRelativeVar->bOffsetOffset=0;
     631        if( pVar->IsRef() ){
     632            // 参照型
     633            pRelativeVar->dwKind = VAR_REFGLOBAL;
     634        }
     635        else pRelativeVar->dwKind=VAR_GLOBAL;
     636        resultType = *pVar;
     637        pSubScripts=pVar->GetSubScriptsPtr();
     638        bConst = pVar->IsConst();
     639    }
    666640
    667641
    … …  
    671645    if( bConst && isWriteAccess ){
    672646        //Const定義の変数に書き込みアクセスをしようとした場合
    673         if( *pType == DEF_OBJECT ){
     647        if( resultType.IsObject() ){
    674648            //オブジェクト定数
    675649            SetError(130, VarName, cp );
    … …  
    683657    if(array[0]==0&&pSubScripts[0]!=-1){
    684658        //配列の先頭ポインタを示す場合
    685         *pType|=FLAG_PTR;
     659        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    686660        if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
    687         return 1;
     661        return true;
    688662    }
    689663
    … …  
    696670    }
    697671    if(array[0]){
    698         if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
     672        if(!GetArrayOffset(pSubScripts,array,resultType)){
    699673            SetError(14,variable,cp);
    700674            pRelativeVar->dwKind=NON_VAR;
    701             return 0;
     675            return false;
    702676        }
    703677    }
    704678    if(member[0]){
    705         if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     679        if( resultType.IsObject() || resultType.IsStruct() ){
    706680            //実態オブジェクトのメンバを参照（obj.member）
    707681            if( refType != CClass::Dot ){
    708682                SetError(104,VarName,cp);
    709683                pRelativeVar->dwKind=NON_VAR;
    710                 return 0;
    711             }
    712 
    713             if( *pType==DEF_OBJECT ){
     684                return false;
     685            }
     686
     687            if( resultType.IsObject() ){
    714688                // 参照内容へのポインタを抽出
    715689                SetRelativeOffset( *pRelativeVar );
    716690            }
    717691        }
    718         else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
     692        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
    719693            //ポインタオブジェクトが示すメンバを参照
    720694            if(lpPtrOffset[0]){
    … …  
    723697                    SetError(104,VarName,cp);
    724698                    pRelativeVar->dwKind=NON_VAR;
    725                     return 0;
     699                    return false;
    726700                }
    727                 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     701                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    728702                pRelativeVar->dwKind=VAR_DIRECTMEM;
    729703            }
    … …  
    733707                    SetError(104,VarName,cp);
    734708                    pRelativeVar->dwKind=NON_VAR;
    735                     return 0;
     709                    return false;
    736710                }
    737711
    … …  
    743717            }
    744718        }
    745         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
     719        else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) || resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    746720            //ポインタオブジェクトが示すメンバを参照
    747721            if(lpPtrOffset[0]){
    … …  
    750724                    SetError(104,VarName,cp);
    751725                    pRelativeVar->dwKind=NON_VAR;
    752                     return 0;
     726                    return false;
    753727                }
    754728
    755                 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     729                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    756730                pRelativeVar->dwKind=VAR_DIRECTMEM;
    757731
    … …  
    765739                SetError(104,VarName,cp);
    766740                pRelativeVar->dwKind=NON_VAR;
    767                 return 0;
     741                return false;
    768742            }
    769743        }
    … …  
    771745            SetError(102,VarName,cp);
    772746            pRelativeVar->dwKind=NON_VAR;
    773             return 0;
    774         }
    775 
    776         LONG_PTR lp2;
    777         if(!GetMemberOffset(
     747            return false;
     748        }
     749
     750        if(!_member_offset(
    778751            isErrorEnabled,
    779752            isWriteAccess,
    780             (CClass *)lpIndex,
    781             member,pType,pRelativeVar,&lp2,0)) return 0;
    782         if(plpIndex) *plpIndex=lp2;
    783 
    784         return 1;
     753            resultType.GetClass(),
     754            member,pRelativeVar,resultType,0)) return false;
     755
     756        return true;
    785757    }
    786758
    787759    if(lpPtrOffset[0]){
    788         SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     760        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    789761        pRelativeVar->dwKind=VAR_DIRECTMEM;
    790762    }
    791763
    792     return 1;
     764    return true;
    793765}
    794766
    795 BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
     767bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,char *InitBuf){
    796768    extern BYTE *initGlobalBuf;
    797     int i,i2,i3,TypeSize;
     769    int i,i2,i3;
    798770    char temporary[VN_SIZE];
    799771
    … …  
    802774        InitBuf[lstrlen(InitBuf)-1]=0;
    803775
    804         TypeSize=GetTypeSize(type,lpIndex);
     776        int typeSize = type.GetSize();
    805777
    806778        if(SubScripts[0]!=-1){
    807             TypeSize*=JumpSubScripts(SubScripts+1);
     779            typeSize*=JumpSubScripts(SubScripts+1);
    808780            i=0;
    809781            i2=0;
    … …  
    815787                i=GetOneParameter(InitBuf,i,temporary);
    816788                if(!SetInitGlobalData(
    817                     offset+i2*TypeSize,
     789                    offset+i2*typeSize,
    818790                    type,
    819                     lpIndex,
    820791                    SubScripts+1,
    821                     temporary)) return 0;
     792                    temporary)) return false;
    822793                i2++;
    823794                if(InitBuf[i]=='\0') break;
    824795            }
    825             return -1;
    826         }
    827 
    828         if(type==DEF_STRUCT){
    829             CClass *pobj_c;
    830             pobj_c=(CClass *)lpIndex;
    831 
    832             for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
     796            return true;
     797        }
     798
     799        if(type.IsStruct()){
     800            const CClass &objClass = type.GetClass();
     801
     802            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
    833803                i=GetOneParameter(InitBuf,i,temporary);
    834804
    835                 i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
     805                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
    836806
    837807                if(!SetInitGlobalData(offset+i3,
    838                     pobj_c->ppobj_Member[i2]->TypeInfo.type,
    839                     pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
    840                     pobj_c->ppobj_Member[i2]->SubScripts,
    841                     temporary)) return 0;
     808                    *objClass.ppobj_Member[i2],
     809                    objClass.ppobj_Member[i2]->SubScripts,
     810                    temporary)) return false;
    842811
    843812                if(InitBuf[i]=='\0') break;
    844813            }
    845             if(i2+1!=pobj_c->iMemberNum){
     814            if(i2+1!=objClass.iMemberNum){
    846815                SetError(41,0,cp);
    847                 return 0;
    848             }
    849             return 1;
     816                return false;
     817            }
     818            return true;
    850819        }
    851820
    852821        SetError(41,0,cp);
    853         return 0;
     822        return false;
    854823    }
    855824
    … …  
    859828    ///////////////////////////////////////
    860829
    861     if( type == DEF_OBJECT || type == DEF_STRUCT ){
     830    if( type.IsObject() || type.IsStruct() ){
    862831        //オブジェクトまたは構造体の場合はありえない
    863832        SetError(300,NULL,cp);
    864         return 0;
     833        return false;
    865834    }
    866835
    867836    if(SubScripts[0]!=-1){
    868837        SetError(41,0,cp);
    869         return 0;
     838        return false;
    870839    }
    871840
    872841    double dbl;
    873842    _int64 i64data;
    874     int CalcType;
    875     LONG_PTR lpCalcIndex;
    876 
    877     CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
    878     if(!CalcType){
     843    Type calcType;
     844
     845    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
    879846        //動的データだった場合
    880         return 0;
    881     }
    882     if(IsRealNumberType(CalcType)){
     847        return false;
     848    }
     849    if( calcType.IsReal() ){
    883850        memcpy(&dbl,&i64data,sizeof(double));
    884851        i64data=(_int64)dbl;
    … …  
    889856    CheckDifferentType(
    890857        type,
    891         lpIndex,
    892         CalcType,
    893         lpCalcIndex,
     858        calcType,
    894859        0,0);
    895860
    896     if(type==DEF_DOUBLE)
     861    if( type.IsDouble() ){
    897862        *(double *)(initGlobalBuf+offset)=(double)dbl;
    898     else if(type==DEF_SINGLE)
    899             *(float *)(initGlobalBuf+offset)=(float)dbl;
    900     else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    901         if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
     863    }
     864    else if( type.IsSingle() ){
     865        *(float *)(initGlobalBuf+offset)=(float)dbl;
     866    }
     867    else if( type.Is64() || type.IsPointer() ){
     868        if(type.GetBasicType()==typeOfPtrChar && type.GetIndex()==LITERAL_STRING){
    902869            //文字列定数のとき
    903870
    … …  
    923890        }
    924891    }
    925     else if(type==DEF_LONG||type==DEF_DWORD)
     892    else if( type.IsDWord() || type.IsLong() ){
    926893        *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
    927     else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR))
     894    }
     895    else if( type.IsWord() || type.IsInteger() ){
    928896        *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
    929     else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR))
     897    }
     898    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    930899        *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
    931 
    932     return 1;
     900    }
     901
     902    return true;
    933903}
    934 BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
    935     int i,i2,i3,TypeSize;
     904bool InitLocalVar(int offset,const Type &type,const int *SubScripts,char *InitBuf){
     905    int i,i2,i3;
    936906    char temporary[VN_SIZE];
    937907
    … …  
    940910        InitBuf[lstrlen(InitBuf)-1]=0;
    941911
    942         TypeSize=GetTypeSize(type,lpIndex);
     912        int typeSize = type.GetSize();
    943913
    944914        if(SubScripts[0]!=-1){
    945             TypeSize*=JumpSubScripts(SubScripts+1);
     915            typeSize*=JumpSubScripts(SubScripts+1);
    946916            i=0;
    947917            i2=0;
    … …  
    949919                if(SubScripts[0]<i2){
    950920                    SetError(41,0,cp);
    951                     return 0;
     921                    return false;
    952922                }
    953923                i=GetOneParameter(InitBuf,i,temporary);
    954924                if(!InitLocalVar(
    955                     offset+i2*TypeSize,
     925                    offset+i2*typeSize,
    956926                    type,
    957                     lpIndex,
    958927                    SubScripts+1,
    959                     temporary)) return 0;
     928                    temporary)) return false;
    960929                i2++;
    961930                if(InitBuf[i]=='\0') break;
    962931            }
    963             return -1;
    964         }
    965 
    966         if(type==DEF_STRUCT){
    967             CClass *pobj_c;
    968             pobj_c=(CClass *)lpIndex;
    969 
    970             for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
     932            return true;
     933        }
     934
     935        if(type.IsStruct()){
     936            const CClass &objClass = type.GetClass();
     937
     938            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
    971939                i=GetOneParameter(InitBuf,i,temporary);
    972940
    973                 i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
     941                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
    974942
    975943                if(!InitLocalVar(offset+i3,
    976                     pobj_c->ppobj_Member[i2]->TypeInfo.type,
    977                     pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
    978                     pobj_c->ppobj_Member[i2]->SubScripts,
    979                     temporary)) return 0;
     944                    *objClass.ppobj_Member[i2],
     945                    objClass.ppobj_Member[i2]->SubScripts,
     946                    temporary)) return false;
    980947
    981948                if(InitBuf[i]=='\0') break;
    982949            }
    983             if(i2+1!=pobj_c->iMemberNum){
     950            if(i2+1!=objClass.iMemberNum){
    984951                SetError(41,0,cp);
    985952                return 0;
    986953            }
    987             return 1;
     954            return true;
    988955        }
    989956
    990957        SetError(41,0,cp);
    991         return 0;
     958        return false;
    992959    }
    993960
    … …  
    999966    if(SubScripts[0]!=-1){
    1000967        SetError(41,0,cp);
    1001         return 0;
     968        return false;
    1002969    }
    1003970
    1004971    double dbl;
    1005972    _int64 i64data;
    1006     int CalcType;
    1007     LONG_PTR lpCalcIndex;
    1008     CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
    1009     if(!CalcType){
     973    Type calcType;
     974
     975    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
    1010976        //動的データだった場合
    1011         return 0;
    1012     }
    1013     if(IsRealNumberType(CalcType)){
     977        return false;
     978    }
     979    if( calcType.IsReal() ){
    1014980        memcpy(&dbl,&i64data,sizeof(double));
    1015981        i64data=(_int64)dbl;
    … …  
    1020986    CheckDifferentType(
    1021987        type,
    1022         lpIndex,
    1023         CalcType,
    1024         lpCalcIndex,
     988        calcType,
    1025989        0,0);
    1026990
    1027     if(type==DEF_DOUBLE){
     991    if( type.IsDouble() ){
    1028992        memcpy(&i64data,&dbl,sizeof(double));
    1029993
    … …  
    10371001        obp+=sizeof(long);
    10381002    }
    1039     else if(type==DEF_SINGLE){
     1003    else if( type.IsSingle() ){
    10401004        float flt;
    10411005        flt=(float)dbl;
    … …  
    10471011        obp+=sizeof(long)+sizeof(long);
    10481012    }
    1049     else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    1050         if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
     1013    else if( type.Is64() || type.IsPointer() ){
     1014        if(type.GetBasicType()==typeOfPtrChar && type.GetIndex()==LITERAL_STRING){
    10511015            //文字列定数のとき
    10521016
    … …  
    10881052        }
    10891053    }
    1090     else if(type==DEF_LONG||type==DEF_DWORD){
     1054    else if( type.IsDWord() || type.IsLong() ){
    10911055        //mov dword ptr[rsp+offset],value
    10921056        op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
    … …  
    10951059        obp+=sizeof(long)+sizeof(long);
    10961060    }
    1097     else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR)){
     1061    else if( type.IsWord() || type.IsInteger() ){
    10981062        //mov word ptr[rsp+offset],value
    10991063        op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
    … …  
    11021066        obp+=sizeof(long)+sizeof(short);
    11031067    }
    1104     else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR)){
     1068    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    11051069        //mov byte ptr[rsp+offset],value
    11061070        op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
    … …  
    11091073        obp+=sizeof(long)+sizeof(char);
    11101074    }
    1111     return 1;
     1075    return true;
    11121076}
    11131077
    1114 void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
    1115     extern BOOL bCompilingGlobal;
    1116     if(bCompilingGlobal){
     1078void dim(bool isRef, char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
     1079    if( UserProc::IsGlobalAreaCompiling() ){
    11171080        /////////////////////////
    11181081        // グローバル変数
    11191082        /////////////////////////
    11201083
    1121         AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1084        AddGlobalVariable(isRef,VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
    11221085    }
    11231086    else{
    … …  
    11261089        /////////////////
    11271090
    1128         int i2,i3;
    1129 
    1130         for(i2=0;i2<MaxLocalVarNum;i2++){
    1131             if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
    1132                 if(lstrcmp(LocalVar[i2].name,VarName)==0){
    1133                     //２重定義のエラー
    1134                     SetError(15,VarName,cp);
    1135                     return;
    1136                 }
    1137             }
    1138         }
    1139 
    1140         LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    1141         VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
    1142         MaxLocalVarNum++;
    1143 
    1144         if( isRef ){
    1145             //参照型
    1146             pVar->fRef = REF_VARIABLE;
    1147             TypeSize = PTR_SIZE;
    1148         }
    1149         else pVar->fRef=0;
    1150 
    1151         for(i2=1,i3=0;i3<255;i3++){
    1152             //配列要素数
    1153             pVar->SubScripts[i3]=SubScripts[i3];
    1154 
    1155             if(SubScripts[i3]==-1) break;
    1156             i2*=SubScripts[i3]+1;
    1157         }
    1158         int VarSize=TypeSize*i2;
    1159         if(VarSize%8) VarSize+=8-(VarSize%8);
    1160 
    1161         //変数データを追加
    1162         lstrcpy(pVar->name,VarName);
    1163         if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
    1164         else pVar->bConst = false;
    1165         if(SubScripts[0]==-1) pVar->bArray=0;
    1166         else pVar->bArray=1;
    1167         pVar->type=TypeInfo.type;
    1168         pVar->u.index=TypeInfo.u.lpIndex;
     1091        if( UserProc::CompilingUserProc().localVars.DuplicateCheck( VarName ) ){
     1092            //２重定義のエラー
     1093            SetError(15,VarName,cp);
     1094            return;
     1095        }
     1096
     1097        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
     1098
     1099        Variable *pVar = new Variable( VarName, type, isConst, isRef );
     1100
     1101        if( SubScripts[0] != -1 ){
     1102            //配列あり
     1103            pVar->SetArray( SubScripts );
     1104        }
     1105
     1106        //コンストラクタ用パラメータ
     1107        pVar->paramStrForConstructor = ConstractParameter;
     1108
     1109        //レキシカルスコープ
     1110        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
     1111        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1112        pVar->bLiving=TRUE;
     1113
     1114        //エラー用
     1115        pVar->source_code_address=cp;
     1116
     1117        // 変数を追加
     1118        UserProc::CompilingUserProc().localVars.push_back( pVar );
    11691119
    11701120        //アラインメントを考慮
    1171         if( pVar->type==DEF_STRUCT ){
    1172             int alignment = pVar->u.pobj_c->iAlign;
     1121        if( pVar->IsStruct() ){
     1122            int alignment = pVar->GetClass().iAlign;
    11731123            if( alignment ){
    11741124                if( AllLocalVarSize % alignment ){
    … …  
    11781128        }
    11791129
    1180         AllLocalVarSize+=VarSize;
    1181         pVar->offset=AllLocalVarSize;
     1130        AllLocalVarSize += pVar->GetMemorySize();
     1131        pVar->offset = AllLocalVarSize;
    11821132
    11831133        //レキシカルスコープ
    … …  
    11881138        if(InitBuf[0]){
    11891139            //初期代入時のみ、書き込みアクセスを許可する
    1190             bool bConstBack = pVar->bConst;
    1191             pVar->bConst = false;
     1140            if( isConst ){
     1141                pVar->ConstOff();
     1142            }
    11921143
    11931144            int result = 0;
    1194             if( pVar->type != DEF_OBJECT ){
     1145            if( !pVar->IsObject() ){
    11951146                result = InitLocalVar(-pVar->offset,
    1196                     pVar->type,
    1197                     pVar->u.index,
    1198                     pVar->SubScripts,
     1147                    *pVar,
     1148                    pVar->GetSubScriptsPtr(),
    11991149                    InitBuf);
    12001150            }
    … …  
    12071157            }
    12081158
    1209             pVar->bConst = bConstBack;
     1159            if( isConst ){
     1160                pVar->ConstOn();
     1161            }
    12101162        }
    12111163        else{
    … …  
    12161168
    12171169            //mov rdx, VarSize
    1218             op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
     1170            op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() );
    12191171
    12201172            //mov rcx, rsp
    … …  
    12281180
    12291181            //call FillMemory
    1230             DECLAREINFO *pdi;
    1231             pdi=GetDeclareHash("FillMemory");
    1232             op_call( pdi );
     1182            DllProc *pDllProc;
     1183            pDllProc=GetDeclareHash("FillMemory");
     1184            op_call( pDllProc );
    12331185        }
    12341186    }
    12351187
    12361188    //コンストラクタ呼び出し
    1237     if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
     1189    if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
    12381190        char objectSize[255];
    12391191        if( SubScripts[0] == -1 ){
    … …  
    12461198            sprintf( objectSize, "%d", SubScripts[0] );
    12471199        }
    1248         Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
    1249 
    1250         int type;
    1251         LONG_PTR lpIndex;
     1200        Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
     1201
     1202        Type tempType;
    12521203        RELATIVE_VAR RelativeVar;
    1253         GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
     1204        GetVarOffset( true, false, VarName, &RelativeVar, tempType );
    12541205        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
    12551206            SetError();
    … …  
    12581209    }
    12591210
    1260     if(TypeInfo.type==DEF_OBJECT){
    1261         if(TypeInfo.u.pobj_Class->IsAbstract()){
     1211    if( type.IsObject() ){
     1212        if( type.GetClass().IsAbstract() ){
    12621213            //抽象クラスだったとき
    1263             SetError(125,TypeInfo.u.pobj_Class->name,cp);
     1214            SetError(125,type.GetClass().name,cp);
    12641215        }
    12651216    }
    12661217}
    1267 void dim(char *Parameter,DWORD dwFlags){
    1268     extern BOOL bCompilingGlobal;
    1269     extern HANDLE hHeap;
    1270     int i2;
    1271     char VarName[VN_SIZE];
    1272 
    1273     //参照型かどうか
    1274     bool isRef = false;
    1275 
    1276     i2 = 0;
    1277 
    1278     if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
    1279         //参照型
    1280         isRef = true;
    1281         Parameter += 2;
    1282     }
    1283 
    1284     if(dwFlags & DIMFLAG_CONST){
    1285 
    1286         //////////////////////////////////
    1287         // 定数変数の場合を考慮
    1288         //////////////////////////////////
    1289         for(;;i2++){
    1290             if(Parameter[i2] == '=' ||
    1291                 Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
    1292                 Parameter[i2] =='('){
    1293                     VarName[i2] = 0;
    1294                     break;
    1295             }
    1296             VarName[i2] = Parameter[i2];
    1297         }
    1298 
    1299         //定数と２重定義されていないる場合は抜け出す
    1300         if(CDBConst::obj.GetType(VarName)){
    1301             return;
    1302         }
    1303 
    1304         //定数マクロとして定義されている場合は抜け出す
    1305         if(GetConstHash(VarName)){
    1306             return;
    1307         }
    1308     }
    1309 
    1310 
    1311     //構文を解析
    1312     int SubScripts[MAX_ARRAYDIM];
    1313     TYPEINFO TypeInfo;
    1314     char InitBuf[8192];
    1315     char ConstractParameter[VN_SIZE];
    1316     if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
    1317         return;
    1318 
    1319 
    1320     //定数と２重定義されていないかを調べる
    1321     if(CDBConst::obj.GetType(VarName)){
    1322         SetError(15,VarName,cp);
    1323         return;
    1324     }
    1325 
    1326     //定数マクロとして定義されている場合
    1327     if(GetConstHash(VarName)){
    1328         SetError(15,VarName,cp);
    1329         return;
    1330     }
    1331 
    1332 
    1333     //タイプサイズを取得
    1334     int TypeSize;
    1335     TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
    1336 
    1337     extern BOOL bCompilingGlobal;
    1338     if(dwFlags&DIMFLAG_STATIC){
    1339         if(bCompilingGlobal){
    1340             SetError(60,NULL,cp);
    1341             return;
    1342         }
    1343 
    1344         /////////////////////
    1345         // Static変数
    1346         // ※"Static.Object.Method.Variable"
    1347         /////////////////////
    1348 
    1349         char temporary[VN_SIZE];
    1350         GetNowStaticVarFullName(VarName,temporary);
    1351 
    1352         dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    1353 
    1354         /*
    1355         Note: 静的変数のコンストラクタ呼び出しは
    1356             _System_InitStaticLocalVariables関数内で一括して行う
    1357         */
    1358     }
    1359     else{
    1360         dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    1361     }
    1362 }
    1363 void OpcodeDim(char *Parameter,DWORD dwFlags){
    1364     int i,i2,i3,IsStr=0;
    1365     char temporary[8192];
    1366 
    1367     for(i=0,i2=0;;i++,i2++){
    1368         if(Parameter[i]=='\"') IsStr^=1;
    1369         if(Parameter[i]=='('&&IsStr==0){
    1370             i3=GetStringInPare(temporary+i2,Parameter+i);
    1371             i+=i3-1;
    1372             i2+=i3-1;
    1373             continue;
    1374         }
    1375         if(Parameter[i]=='['&&IsStr==0){
    1376             i3=GetStringInBracket(temporary+i2,Parameter+i);
    1377             i+=i3-1;
    1378             i2+=i3-1;
    1379             continue;
    1380         }
    1381         if((Parameter[i]==','&&IsStr==0)||
    1382             Parameter[i]=='\0'){
    1383             temporary[i2]=0;
    1384 
    1385             dim(temporary,dwFlags);
    1386 
    1387             if(Parameter[i]=='\0') break;
    1388             i2=-1;
    1389             continue;
    1390         }
    1391         temporary[i2]=Parameter[i];
    1392     }
    1393 }
    1394 
    13951218void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
    13961219    if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
Note: See TracChangeset for help on using the changeset viewer.