Changeset 75 in dev


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

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

Files:
2 added
71 edited

Legend:

Unmodified
Added
Removed
  • BasicCompiler32/CParameter.cpp

    r73 r75  
    22#include "opcode.h"
    33
    4 int ParamImpl::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     4int ParamImpl::NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum ){
     5    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     6
    57    ///////////////////////////////////////////////////////
    68    // 一時オブジェクトをあらかじめスタックに積んでおく
     
    1315
    1416    BOOL bEllipse;
    15     if(pi_num){
    16         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     17    if(params.size()){
     18        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    1719        else bEllipse=0;
    1820    }
     
    2224        useTempParameters[i2] = false;
    2325
    24         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    25 
    26         if(i2==0&&ppi[i2].name){
    27             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     26        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     27
     28        if(i2==0){
     29            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    2830                //オブジェクトメンバの第一パラメータのThisポインタ
    2931                continue;
    3032            }
    3133        }
    32         if((i2==0||i2==1)&&ppi[i2].name){
    33             if(lstrcmp(ppi[i2].name,FuncName)==0){
     34        if( i2==0||i2==1 ){
     35            if( params[i2]->GetVarName() == procName ){
    3436                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    3537                continue;
     
    3739        }
    3840
    39         TYPEINFO DummyTypeInfo;
     41        Type DummyTypeInfo;
    4042        BOOL bByVal;
    4143        if(bEllipse){
     
    4446        }
    4547        else{
    46             DummyTypeInfo.type=ppi[i2].type;
    47             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    48             bByVal=ppi[i2].bByVal;
     48            DummyTypeInfo.type=params[i2]->GetBasicType();
     49            DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
     50            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    4951        }
    5052
     
    8082                    type,
    8183                    lpVarIndex,
    82                     FuncName,
    83                     i2);
    84 
    85                 if( result ){
    86                     useTempParameters[i2] = true;
    87                     useTempObject = true;
    88 
    89                     types[i2].type = type;
    90                     types[i2].u.lpIndex = lpVarIndex;
    91                 }
    92             }
    93         }
    94     }
    95 
    96     return nCountOfTempObjects * PTR_SIZE;
    97 }
    98 int ParamImpl::NewTempParameters( const char *procName, const Parameters &params, int SecondParmNum ){
    99     ///////////////////////////////////////////////////////
    100     // 一時オブジェクトをあらかじめスタックに積んでおく
    101     ///////////////////////////////////////////////////////
    102 
    103     useTempObject = false;
    104 
    105     //一時参照の数
    106     nCountOfTempObjects = 0;
    107 
    108     BOOL bEllipse;
    109     if(params.size()){
    110         if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    111         else bEllipse=0;
    112     }
    113     else bEllipse=0;
    114 
    115     for(int i2=ParmsNum-1;i2>=0;i2--){
    116         useTempParameters[i2] = false;
    117 
    118         if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
    119 
    120         if(i2==0){
    121             if( params[i2]->GetVarName() == "_System_LocalThis" ){
    122                 //オブジェクトメンバの第一パラメータのThisポインタ
    123                 continue;
    124             }
    125         }
    126         if( i2==0||i2==1 ){
    127             if( params[i2]->GetVarName() == procName ){
    128                 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    129                 continue;
    130             }
    131         }
    132 
    133         TYPEINFO DummyTypeInfo;
    134         BOOL bByVal;
    135         if(bEllipse){
    136             DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
    137             bByVal=1;
    138         }
    139         else{
    140             DummyTypeInfo.type=params[i2]->GetBasicType();
    141             DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
    142             bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    143         }
    144 
    145 
    146         if( !bByVal ){
    147             //ポインタ参照
    148             if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    149                 //ポインタ指定
    150                 continue;
    151             }
    152 
    153             LONG_PTR lpVarIndex;
    154             if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
    155                 //変数ではないとき
    156                 int reg = REG_RAX;
    157                 int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    158                 //↑ここでスタックに積む
    159 
    160                 nCountOfTempObjects++;
    161 
    162                 if( type != DEF_STRUCT ){
    163                     //一時参照を作成
    164 
    165                     //push esp
    166                     op_push( REG_ESP );
    167 
    168                     nCountOfTempObjects++;
    169                 }
    170 
    171                 bool result = CheckDifferentType(
    172                     DummyTypeInfo.type,
    173                     DummyTypeInfo.u.lpIndex,
    174                     type,
    175                     lpVarIndex,
    176                     procName,
     84                    procName.c_str(),
    17785                    i2);
    17886
     
    205113
    206114                //call free
    207                 extern SubInfo *pSub_free;
     115                extern UserProc *pSub_free;
    208116                op_call(pSub_free);
    209117            }
     
    232140
    233141    //call calloc
    234     extern SubInfo *pSub_calloc;
     142    extern UserProc *pSub_calloc;
    235143    op_call(pSub_calloc);
    236144
     
    239147
    240148
    241     TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    242     TYPEINFO CalcType;
     149    Type BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
     150    Type CalcType;
    243151    CalcType.type=NumOpe_GetType_Old(Parameter,&BaseType,&CalcType.u.lpIndex);
    244152
     
    276184
    277185        //call constructor
    278         op_call(pobj_Class->GetCopyConstructorMethod()->psi);
     186        op_call(pobj_Class->GetCopyConstructorMethod()->pUserProc);
    279187
    280188
     
    300208
    301209                //call constructor
    302                 op_call(pobj_Class->GetConstructorMethod()->psi);
     210                op_call(pobj_Class->GetConstructorMethod()->pUserProc);
    303211            }
    304212*/
     
    313221}
    314222
    315 int ParamImpl::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
     223int ParamImpl::SetParameter( const string &procName, const Parameters &params, int SecondParmNum ){
     224    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     225
    316226    ///////////////////////////////////////////////////////////
    317227    // パラメータをレジスタ及びスタックフレームにセット
     
    320230
    321231    BOOL bEllipse;
    322     if(pi_num){
    323         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     232    if( params.size() ){
     233        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    324234        else bEllipse=0;
    325235    }
     
    328238    BOOL bHas_System_LocalThis=0;
    329239    if(ParmsNum>=1){
    330         if(lstrcmp(ppi[0].name,"_System_LocalThis")==0)
     240        if( params[0]->GetVarName() == "_System_LocalThis" ){
    331241            bHas_System_LocalThis=1;
     242        }
    332243    }
    333244
    334245    //戻り値用の変数名を取得
    335     const char *lpszVarNameToReturn = (FuncName[0]==1&&FuncName[1]==ESC_OPERATOR)?"_System_ReturnValue":FuncName;
     246    const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();
    336247
    337248    //パラメータをレジスタとスタックに格納
     
    343254    int nCountOfNowTempObjects = 0;
    344255    for(i2=ParmsNum-1;i2>=0;i2--){
    345         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    346 
    347         if(i2==0&&ppi[i2].name){
    348             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     256        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     257
     258        if(i2==0){
     259            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    349260                //オブジェクトメンバの第一パラメータのThisポインタ
    350261                continue;
    351262            }
    352263        }
    353         if((i2==0||i2==1)&&ppi[i2].name){
    354             if(lstrcmp(ppi[i2].name,lpszVarNameToReturn)==0){
     264        if(i2==0||i2==1){
     265            if( params[i2]->GetVarName() == lpszVarNameToReturn ){
    355266                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    356267                continue;
     
    358269        }
    359270
    360         TYPEINFO DummyTypeInfo;
     271        Type DummyTypeInfo;
    361272        BOOL bByVal;
    362273        if(bEllipse){
     
    365276        }
    366277        else{
    367             DummyTypeInfo.type=ppi[i2].type;
    368             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    369             bByVal=ppi[i2].bByVal;
     278            DummyTypeInfo.type=params[i2]->GetBasicType();
     279            DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
     280            bByVal = (params[i2]->IsRef() == false ) ? TRUE:FALSE;
    370281        }
    371282
     
    375286            if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    376287                char temp2[255];
    377                 sprintf(temp2,"%s関数の第%dパラメータ",FuncName,i2+1);
     288                sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
    378289                SetError(19,temp2,cp);
    379290                continue;
     
    417328                    CalcType,
    418329                    lpCalcIndex,
    419                     FuncName,
     330                    procName.c_str(),
    420331                    i3);
    421332            }
     
    530441    return ParmSize;
    531442}
    532 int ParamImpl::SetParameter( const char *procName, const Parameters &params, int SecondParmNum ){
    533     ///////////////////////////////////////////////////////////
    534     // パラメータをレジスタ及びスタックフレームにセット
    535     ///////////////////////////////////////////////////////////
    536     int i2,i3;
    537 
    538     BOOL bEllipse;
    539     if( params.size() ){
    540         if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    541         else bEllipse=0;
    542     }
    543     else bEllipse=0;
    544 
    545     BOOL bHas_System_LocalThis=0;
    546     if(ParmsNum>=1){
    547         if( params[0]->GetVarName() == "_System_LocalThis" ){
    548             bHas_System_LocalThis=1;
    549         }
    550     }
    551 
    552     //戻り値用の変数名を取得
    553     const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName;
    554 
    555     //パラメータをレジスタとスタックに格納
    556     int CalcType;
    557     LONG_PTR lpCalcIndex;
    558     BOOL bCalcUseHeap;
    559     int ParmSize=0;
    560     RELATIVE_VAR RelativeVar;
    561     int nCountOfNowTempObjects = 0;
    562     for(i2=ParmsNum-1;i2>=0;i2--){
    563         if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
    564 
    565         if(i2==0){
    566             if( params[i2]->GetVarName() == "_System_LocalThis" ){
    567                 //オブジェクトメンバの第一パラメータのThisポインタ
    568                 continue;
    569             }
    570         }
    571         if(i2==0||i2==1){
    572             if( params[i2]->GetVarName() == lpszVarNameToReturn ){
    573                 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    574                 continue;
    575             }
    576         }
    577 
    578         TYPEINFO DummyTypeInfo;
    579         BOOL bByVal;
    580         if(bEllipse){
    581             DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
    582             bByVal=1;
    583         }
    584         else{
    585             DummyTypeInfo.type=params[i2]->GetBasicType();
    586             DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
    587             bByVal = (params[i2]->IsRef() == false ) ? TRUE:FALSE;
    588         }
    589 
    590         if(bByVal==1){
    591             //値参照
    592 
    593             if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    594                 char temp2[255];
    595                 sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
    596                 SetError(19,temp2,cp);
    597                 continue;
    598             }
    599 
    600             if(DummyTypeInfo.type==DEF_STRUCT){
    601                 SetStructParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
    602                 goto next;
    603             }
    604 
    605 
    606             extern LONG_PTR ProcPtr_BaseIndex;
    607             LONG_PTR back_ProcPtr_BaseIndex;
    608             back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
    609             if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
    610             else ProcPtr_BaseIndex=-1;
    611 
    612             CalcType=NumOpe(Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
    613 
    614             ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
    615 
    616             if(CalcType==-1) break;
    617 
    618             if(CalcType==DEF_OBJECT){
    619                 if( DummyTypeInfo.type != DEF_OBJECT
    620                     ||
    621                     DummyTypeInfo.type == DEF_OBJECT &&
    622                     !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
    623                         //キャスト演算子のオーバーロードに対応する
    624                         CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
    625                 }
    626             }
    627 
    628             if(!bEllipse){
    629                 //型チェック
    630                 if(bHas_System_LocalThis) i3=i2-1;
    631                 else i3=i2;
    632                 CheckDifferentType(
    633                     DummyTypeInfo.type,
    634                     DummyTypeInfo.u.lpIndex,
    635                     CalcType,
    636                     lpCalcIndex,
    637                     procName,
    638                     i3);
    639             }
    640 
    641             if(DummyTypeInfo.type==DEF_DOUBLE){
    642                 ChangeTypeToDouble(CalcType);
    643                 ParmSize+=sizeof(long)*2;
    644             }
    645             else if(DummyTypeInfo.type==DEF_SINGLE){
    646                 ChangeTypeToSingle(CalcType);
    647                 ParmSize+=sizeof(long);
    648             }
    649             else if(DummyTypeInfo.type==DEF_INT64||DummyTypeInfo.type==DEF_QWORD){
    650                 ChangeTypeToInt64(CalcType);
    651                 ParmSize+=sizeof(long)*2;
    652             }
    653             else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||DummyTypeInfo.type==DEF_OBJECT||DummyTypeInfo.type==DEF_STRUCT||
    654                 (IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
    655                 ChangeTypeToLong(CalcType);
    656                 ParmSize+=sizeof(long);
    657             }
    658             else if(DummyTypeInfo.type==DEF_INTEGER||DummyTypeInfo.type==DEF_WORD || (isUnicode&&DummyTypeInfo.type==DEF_CHAR)){
    659                 ChangeTypeToInteger(CalcType);
    660                 ParmSize+=sizeof(long);
    661             }
    662             else if(DummyTypeInfo.type==DEF_SBYTE||DummyTypeInfo.type==DEF_BYTE||DummyTypeInfo.type==DEF_BOOLEAN || (isUnicode==false&&DummyTypeInfo.type==DEF_CHAR)){
    663                 ChangeTypeToByte(CalcType);
    664                 ParmSize+=sizeof(long);
    665             }
    666             else{
    667                 SetError(300,NULL,cp);
    668             }
    669         }
    670         else{
    671             //ポインタ参照
    672             if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    673                 //ポインタ指定
    674                 i3=NumOpe(Parms[i2]+2,0,0,0);
    675 
    676                 ChangeTypeToLong(i3);
    677             }
    678             else{
    679                 if( useTempParameters[i2] ){
    680                     //一時オブジェクトをコピー
    681 
    682                     if( types[i2].type != DEF_STRUCT ){
    683                         // 一時参照のための領域を考慮する
    684                         nCountOfNowTempObjects++;
    685                     }
    686 
    687                     nCountOfNowTempObjects++;
    688 
    689                     //mov eax, dword ptr[esp+offset]
    690                     op_mov_RM(
    691                         sizeof(long),
    692                         REG_EAX,
    693                         REG_ESP,
    694                         ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects ) ) * PTR_SIZE,
    695                         MOD_BASE_DISP32 );
    696 
    697                     //push eax
    698                     op_push(REG_EAX);
    699                 }
    700                 else{
    701                     //変数のアドレスを取得
    702                     int VarType;
    703                     LONG_PTR lpVarIndex;
    704                     if(GetVarOffset(
    705                         false,
    706                         false,
    707                         Parms[i2],
    708                         &VarType,
    709                         &RelativeVar,
    710                         &lpVarIndex)){
    711                             if(DummyTypeInfo.type!=DEF_ANY){
    712                                 //型チェックを行う
    713                                 if(DummyTypeInfo.type==VarType){
    714                                     if(DummyTypeInfo.type==DEF_OBJECT){
    715                                         if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
    716                                             SetError(11,Parms[i2],cp);
    717                                         }
    718                                     }
    719                                     else if(DummyTypeInfo.type==DEF_STRUCT){
    720                                         if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
    721                                             SetError(11,Parms[i2],cp);
    722                                         }
    723                                     }
    724                                 }
    725                                 else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
    726                                     //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    727                                 }
    728                                 else{
    729                                     SetError(11,Parms[i2],cp);
    730                                 }
    731                             }
    732 
    733                             //変数アドレスをレジスタにセット
    734                             SetVarPtrToEax(&RelativeVar);
    735 
    736                             //push eax
    737                             op_push(REG_EAX);
    738                     }
    739                 }
    740             }
    741 
    742             ParmSize+=PTR_SIZE;
    743         }
    744 
    745 next:;
    746     }
    747 
    748     return ParmSize;
    749 }
  • BasicCompiler32/Compile_Calc.cpp

    r67 r75  
    415415    int i,i2,i3;
    416416    char variable[VN_SIZE];
     417
     418
     419
     420    //////////////////////////////////////
     421    // インクリメント・デクリメント
     422    //////////////////////////////////////
    417423
    418424    for(i=0;;i++){
     
    465471            }
    466472
    467             LONG_PTR lp;
    468             if(GetVarType(variable,&lp,0)!=-1){
     473            if(GetVarType(variable,Type(),0)){
    469474                //変数リストに該当したとき
    470475                SetError(1,NULL,cp);
     
    510515
    511516    char ObjName[VN_SIZE],array_element[VN_SIZE];
    512     CClass *pobj_c;
    513517    GetArrayElement(variable,ObjName,array_element);
    514518    if(array_element[0]){
    515         i2=GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
    516         if(i2==DEF_OBJECT){
     519        Type varType;
     520        if( GetVarType(ObjName,varType,0) && varType.IsObject() ){
    517521            char temporary[VN_SIZE];
    518522            sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
     
    522526
    523527            int idProc;
    524             void *pInfo;
    525             idProc=GetProc(temporary,&pInfo);
     528            void *pProc;
     529            idProc=GetProc(temporary,(void **)&pProc);
    526530            if(idProc){
    527                 CallProc(idProc,pInfo,temporary,temp2,NULL);
     531                CallProc(idProc,pProc,temporary,temp2,Type());
    528532                return;
    529533            }
     
    542546    ////////////////////////////////////////
    543547
    544     int VarType,CalcType;
    545     LONG_PTR lpVarIndex,lpCalcIndex;
     548    Type varType;
     549
     550    //型を識別
     551    if( !GetVarType(variable,varType,false) ){
     552
     553        // プロパティ用のメソッドを呼び出す
     554        if(!CallPropertyMethod( variable, Command+i+1, Type() )){
     555            //エラーを表示
     556            GetVarType(variable,varType,true);
     557        }
     558
     559        return;
     560    }
     561
     562    extern LONG_PTR ProcPtr_BaseIndex;
     563    if(varType.IsProcPtr()) ProcPtr_BaseIndex=varType.GetIndex();
     564    else ProcPtr_BaseIndex=-1;
     565
    546566    RELATIVE_VAR VarRelativeVar;
    547     BOOL bCalcUseHeap;
    548 
    549     //型を識別
    550     VarType=GetVarType(variable,&lpVarIndex,0);
    551     if(VarType==-1){
    552 
    553         // プロパティ用のメソッドを呼び出す
    554         if(!CallPropertyMethod(variable,Command+i+1,NULL)){
    555             //エラーを表示
    556             GetVarType(variable,&lpVarIndex,1);
    557         }
    558 
    559         return;
    560     }
    561 
    562     extern LONG_PTR ProcPtr_BaseIndex;
    563     if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
    564     else ProcPtr_BaseIndex=-1;
    565 
    566     if(VarType==DEF_STRUCT){
     567    if( varType.IsStruct() ){
    567568        //代入コピーに備える
    568569
     
    570571        if(!GetVarOffsetReadWrite(
    571572            variable,
    572             &VarType,
    573573            &VarRelativeVar,
    574             &lpVarIndex)) return;
     574            varType)) return;
    575575
    576576        SetVarPtrToEax(&VarRelativeVar);
     
    582582
    583583    //NumOpe...(スタックに答えが格納される)
    584     CalcType=NumOpe(Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
    585     if(VarType==-1||CalcType==-1) return;
     584    BOOL bCalcUseHeap;
     585    Type calcType;
     586    if( !NumOpe(Command+i+1,varType,calcType,&bCalcUseHeap) ){
     587        return;
     588    }
    586589
    587590    //変数アドレスを取得
    588591    if(!GetVarOffsetReadWrite(
    589592        variable,
    590         &VarType,
    591593        &VarRelativeVar,
    592         &lpVarIndex)) return;
    593 
    594     if(VarType&FLAG_PTR){
     594        varType)) return;
     595
     596    if(varType.GetBasicType()&FLAG_PTR){
    595597        SetError(14,variable,cp);
    596598        return;
    597599    }
    598600
    599     if(VarType==DEF_STRUCT){
    600         //オブジェクトインスタンスへの代入
    601         SetStructVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
     601    if( varType.IsStruct() ){
     602        //構造体インスタンスへの代入
     603        SetStructVariable(varType,calcType,bCalcUseHeap);
    602604        return;
    603605    }
    604606
    605     if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
     607    if( calcType.IsObject() && !calcType.Equals( varType ) ){
    606608        //キャスト演算子のオーバーロードに対応する
    607         CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
     609        CallCastOperatorProc(calcType,bCalcUseHeap,varType);
    608610    }
    609611
     
    614616    /////////////////////////////////
    615617
    616     CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
     618    CheckDifferentType(varType,calcType,0,0);
    617619
    618620
     
    622624
    623625    //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
    624     RestoreDefaultRegisterFromStackMemory( CalcType );
    625 
    626     SetVariableFromEax( VarType, CalcType, &VarRelativeVar );
    627 /*
    628     TODO: 消す
    629     if(VarType==DEF_BOOLEAN){
    630         //bool
    631         SetBooleanVariable(CalcType,&VarRelativeVar);
    632     }
    633     else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
    634         //8ビット整数型変数へスタックの内容を格納する
    635         Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    636     }
    637     else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
    638         //16ビット整数型変数へスタックの内容を格納する
    639         Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    640     }
    641     else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
    642         //32ビット整数型変数へスタックの内容を格納する
    643         if(VarType==DEF_LONG)
    644             SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    645         else
    646             SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    647     }
    648     else if(VarType==DEF_INT64||VarType==DEF_QWORD){
    649         //64ビット整数型変数へスタックの内容を格納する
    650         SetInt64Variable(CalcType,&VarRelativeVar);
    651     }
    652     else if(VarType==DEF_DOUBLE){
    653         //Double型変数へスタックの内容を格納する
    654         SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    655     }
    656     else if(VarType==DEF_SINGLE){
    657         //Single型変数へスタックの内容を格納する
    658         SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    659     }*/
    660 }
    661 
    662 
    663 // TODO: 消す
    664 /*
    665 void SetRefVariable( const char *varname, const char *expression ){
    666     ////////////////////////////////////////
    667     // 変数のタイプ型を識別して、演算を行う
    668     ////////////////////////////////////////
    669 
    670     int VarType,CalcType;
    671     LONG_PTR lpVarIndex,lpCalcIndex;
    672     RELATIVE_VAR VarRelativeVar;
    673     BOOL bCalcUseHeap;
    674 
    675     //型を識別
    676     VarType=GetVarType(varname,&lpVarIndex,0);
    677     if(VarType==-1){
    678         SetError(300,NULL,cp);
    679         return;
    680     }
    681 
    682     extern LONG_PTR ProcPtr_BaseIndex;
    683     if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
    684     else ProcPtr_BaseIndex=-1;
    685 
    686     if(VarType==DEF_OBJECT){
    687         //代入演算のオーバーロード オペレータに備える
    688 
    689         //変数アドレスを取得
    690         if(!GetVarOffsetReadWrite(
    691             varname,
    692             &VarType,
    693             &VarRelativeVar,
    694             &lpVarIndex)) return;
    695 
    696         SetVarPtrToEax(&VarRelativeVar);
    697 
    698         //push eax
    699         op_push(REG_EAX);
    700     }
    701 
    702 
    703     //NumOpe...(スタックに答えが格納される)
    704     CalcType=NumOpe(expression,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
    705     if(VarType==-1||CalcType==-1) return;
    706 
    707     //変数アドレスを取得
    708     if(!GetVarOffsetReadWrite(
    709         varname,
    710         &VarType,
    711         &VarRelativeVar,
    712         &lpVarIndex)) return;
    713 
    714     if(VarType&FLAG_PTR){
    715         SetError(14,varname,cp);
    716         return;
    717     }
    718 
    719 
    720     if( VarType == DEF_OBJECT
    721         && (VarRelativeVar.dwKind == VAR_REFLOCAL || VarRelativeVar.dwKind == VAR_REFGLOBAL ) ){
    722         // 参照型オブジェクトへの代入(初期化)はポインタ変数と同様の処理に値する
    723         PTR_LEVEL_UP( VarType );
    724 
    725         if( VarRelativeVar.dwKind == VAR_REFGLOBAL ){
    726             VarRelativeVar.dwKind = VAR_GLOBAL;
    727         }
    728         else if( VarRelativeVar.dwKind == VAR_REFLOCAL ){
    729             VarRelativeVar.dwKind = VAR_LOCAL;
    730         }
    731 
    732         if( CalcType == DEF_OBJECT ){
    733             //右辺値が実体オブジェクトのときは、参照をコピー
    734             PTR_LEVEL_UP( CalcType );
    735         }
    736     }
    737     else{
    738         SetError(300,NULL,cp);
    739     }
    740 
    741 
    742     /////////////////////////////////
    743     // 右辺、左辺の型チェックを行う
    744     /////////////////////////////////
    745 
    746     CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
    747 
    748 
    749     /////////////////////////////////////////////////
    750     // スタックの内容を変数にコピーするコードを抽出
    751     /////////////////////////////////////////////////
    752 
    753     if(VarType==DEF_BOOLEAN){
    754         //bool
    755         SetBooleanVariable(CalcType,&VarRelativeVar);
    756     }
    757     else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
    758         //8ビット整数型変数へスタックの内容を格納する
    759         Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    760     }
    761     else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
    762         //16ビット整数型変数へスタックの内容を格納する
    763         Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    764     }
    765     else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
    766         //32ビット整数型変数へスタックの内容を格納する
    767         if(VarType==DEF_LONG)
    768             SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    769         else
    770             SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    771     }
    772     else if(VarType==DEF_INT64||VarType==DEF_QWORD){
    773         //64ビット整数型変数へスタックの内容を格納する
    774         SetInt64Variable(CalcType,&VarRelativeVar);
    775     }
    776     else if(VarType==DEF_DOUBLE){
    777         //Double型変数へスタックの内容を格納する
    778         SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    779     }
    780     else if(VarType==DEF_SINGLE){
    781         //Single型変数へスタックの内容を格納する
    782         SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    783     }
    784 }
    785 */
     626    RestoreDefaultRegisterFromStackMemory( calcType.GetBasicType() );
     627
     628    SetVariableFromEax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar);
     629}
  • BasicCompiler32/Compile_CallProc.cpp

    r73 r75  
    88void Call_DebugSys_SaveContext(){
    99    //call _System_GetEip
    10     extern SubInfo *pSub_System_GetEip;
     10    extern UserProc *pSub_System_GetEip;
    1111    op_call(pSub_System_GetEip);
    1212
     
    1818
    1919    //call _DebugSys_SaveContext
    20     extern SubInfo *pSub_DebugSys_SaveContext;
     20    extern UserProc *pSub_DebugSys_SaveContext;
    2121    op_call(pSub_DebugSys_SaveContext);
    2222}
     
    3232
    3333
    34 int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex){
     34int Opcode_CallProcPtr(char *variable,char *Parameter,ProcPointer *pProcPointer,LONG_PTR *plpIndex){
    3535    extern HANDLE hHeap;
    3636    int i;
     
    5252
    5353    //エラーチェック
    54     if( !pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum) ){
     54    if( !pobj_parameter->ErrorCheck(variable,pProcPointer->Params() ) ){
    5555        //パラメータにエラーがあるときは処理を終える
    56         return pi->ReturnType;
     56        return pProcPointer->ReturnType().GetBasicType();
    5757    }
    5858
    5959    //一時オブジェクトを生成
    60     pobj_parameter->NewTempParameters( variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum );
     60    pobj_parameter->NewTempParameters( variable,pProcPointer->Params() );
    6161
    6262    //レジスタ、スタックフレームにセット
    63     pobj_parameter->SetParameter(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);
     63    pobj_parameter->SetParameter(variable,pProcPointer->Params() );
    6464
    6565
     
    8989    delete pobj_parameter;
    9090
    91     if(plpIndex) *plpIndex=pi->u.ReturnIndex;
    92 
    93     return pi->ReturnType;
     91    if(plpIndex) *plpIndex=pProcPointer->ReturnType().GetIndex();
     92
     93    return pProcPointer->ReturnType().GetBasicType();
    9494}
    9595
    96 void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType){
     96void Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,char *ObjectName,int RefType){
    9797    int i2;
    9898
    99     if(psi->dwType==SUBTYPE_MACRO){
    100         if(lstrcmpi(psi->name,"Print")==0){
     99    if( pUserProc->IsMacro() ){
     100        if( lstrcmpi( pUserProc->GetName().c_str(), "Print" ) == 0 ){
    101101            Opcode_Print(Parameter,0);
    102102            return;
    103103        }
    104         if(lstrcmpi(psi->name,"Input")==0){
     104        if( lstrcmpi( pUserProc->GetName().c_str(), "Input" ) == 0 ){
    105105            Opcode_Input(Parameter);
    106106            return;
    107107        }
    108         if(lstrcmpi(psi->name,"Write")==0){
     108        if( lstrcmpi( pUserProc->GetName().c_str(), "Write" ) == 0 ){
    109109            Opcode_Print(Parameter,1);
    110110            return;
     
    112112    }
    113113
    114     psi->bUse=1;
     114    pUserProc->Using();
    115115
    116116    bool isStatic = false;
    117117    CClass *pobj_c = NULL;
    118118    CMethod *pMethod = NULL;
    119     if(psi->pobj_ParentClass){
     119    if( pUserProc->GetParentClassPtr() ){
    120120        //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
    121121        if(ObjectName[0]){
     
    141141            if(dwFlags&PROCFLAG_NEW){
    142142                //New演算子によるコンストラクタ呼び出し
    143                 pobj_c=psi->pobj_ParentClass;
     143                pobj_c=pUserProc->GetParentClassPtr();
    144144            }
    145145            else{
     
    154154        /////////////////////////////////
    155155        pMethod = NULL;
    156         if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( psi );
     156        if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( pUserProc );
    157157        if( ! pMethod ){
    158158            //動的メソッドが取得できなかったときは静的メソッドを当たる
    159             pMethod = pobj_c->GetStaticMethodInfo( psi );
     159            pMethod = pobj_c->GetStaticMethodInfo( pUserProc );
    160160            if( !pMethod ){
    161161                SetError(300,NULL,cp);
     
    178178                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    179179                if(dwAccess==ACCESS_NON){
    180                     SetError(109,psi->name,cp);
     180                    SetError(109,pUserProc->GetName(),cp);
    181181                    return;
    182182                }
     
    185185                if(dwAccess==ACCESS_PRIVATE||
    186186                    dwAccess==ACCESS_NON){
    187                     SetError(109,psi->name,cp);
     187                    SetError(109,pUserProc->GetName(),cp);
    188188                    return;
    189189                }
    190190                if(dwAccess==ACCESS_PROTECTED){
    191                     SetError(110,psi->name,cp);
     191                    SetError(110,pUserProc->GetName(),cp);
    192192                    return;
    193193                }
     
    197197            //クラス内部からの呼び出し(継承によるACCESS_NONのみをエラーとする)
    198198            if(dwAccess==ACCESS_NON){
    199                 SetError(109,psi->name,cp);
     199                SetError(109,pUserProc->GetName(),cp);
    200200                return;
    201201            }
     
    210210
    211211    char temporary[VN_SIZE]={0};
    212     if( psi->pobj_ParentClass && isStatic == false ){
     212    if( pUserProc->GetParentClassPtr() && isStatic == false ){
    213213        //_System_LocalThis(第一パラメータ)のダミーを作成
    214214        lstrcpy(temporary,"0,");
     
    230230
    231231    //エラーチェック
    232     if( !pobj_parameter->ErrorCheck(psi->name,psi->realParams,psi->SecondParmNum) ){
     232    if( !pobj_parameter->ErrorCheck(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetSecondParmNum() ) ){
    233233        //パラメータにエラーがあるときは処理を終える
    234234        return;
    235235    }
    236236
    237     if(psi->dwType==SUBTYPE_MACRO){
     237    if(pUserProc->IsMacro()){
    238238        //マクロ関数の場合は、パラメータ省略を考慮する
    239         pobj_parameter->MacroParameterSupport( psi->realParams );
     239        pobj_parameter->MacroParameterSupport( pUserProc->RealParams() );
    240240    }
    241241
    242242    //一時オブジェクトを生成
    243     int tempSize = pobj_parameter->NewTempParameters( psi->name,psi->realParams,psi->RealSecondParmNum );
     243    int tempSize = pobj_parameter->NewTempParameters( pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() );
    244244
    245245    //レジスタ、スタックフレームにセット
    246     int ParmSize;
    247     ParmSize=pobj_parameter->SetParameter(psi->name,psi->realParams,psi->RealSecondParmNum);
    248 
    249     if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
     246    int ParmSize = pobj_parameter->SetParameter(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() );
     247
     248    if(pUserProc->ReturnType().IsStruct() ){
    250249        //////////////////////////////////////////////////////
    251250        // 戻り値に構造体インスタンスを持つ場合
     
    253252        //////////////////////////////////////////////////////
    254253
    255         int object_size = psi->u.Return_pobj_c->GetSize();
     254        int object_size = pUserProc->ReturnType().GetClass().GetSize();
    256255
    257256        //push object_size
     
    259258
    260259        //call calloc
    261         extern SubInfo *pSub_calloc;
     260        extern UserProc *pSub_calloc;
    262261        op_call(pSub_calloc);
    263262
     
    267266
    268267
    269     if( psi->pobj_ParentClass && isStatic == false ){
     268    if( pUserProc->GetParentClassPtr() && isStatic == false ){
    270269        //////////////////////////////////////////////////////
    271270        // メンバ関数の場合
     
    310309    }
    311310
    312     if(psi->bVirtual){
     311    if( pUserProc->IsVirtual() ){
    313312        //仮想関数(オブジェクトメソッド)呼び出し
    314313        //pObj->func_table->func1
     
    320319        OpBuffer[obp++]=(char)0x11;
    321320
    322         i2 = pobj_c->GetFuncNumInVtbl( psi );
     321        i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
    323322
    324323        //call dword ptr[edx+func_index]
     
    339338
    340339        //call ProcAddr
    341         op_call(psi);
    342     }
    343 
    344     if(psi->bCdecl){
     340        op_call(pUserProc);
     341    }
     342
     343    if(pUserProc->IsCdecl()){
    345344        //add esp,ParmSize
    346345        op_add_esp(ParmSize);
     
    354353}
    355354
    356 int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex){
     355int Opcode_CallDllProc(char *Parameter,DllProc *pDllProc,LONG_PTR *plpIndex){
    357356    char *temporary;
    358357
     
    361360    extern BOOL bDebugCompile;
    362361    extern BOOL bDebugSupportProc;
    363     if(bDebugCompile&&bDebugSupportProc==0&&lstrcmp(pdi->name,"DebugBreak")!=0)
     362    if(bDebugCompile&&bDebugSupportProc==0&& pDllProc->GetName() != "DebugBreak" ){
    364363        Call_DebugSys_SaveContext();
    365 
    366     pdi->bUse=1;
     364    }
    367365
    368366
     
    376374
    377375    //エラーチェック
    378     if( !pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum) ){
     376    if( !pobj_parameter->ErrorCheck( pDllProc->GetName(), pDllProc->Params() ) ){
    379377        //パラメータにエラーがあるときは処理を終える
    380         return pdi->ReturnType;
     378        return pDllProc->ReturnType().GetBasicType();
    381379    }
    382380
    383381    //一時オブジェクトを生成
    384     pobj_parameter->NewTempParameters( pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum );
     382    pobj_parameter->NewTempParameters( pDllProc->GetName(), pDllProc->Params() );
    385383
    386384    //レジスタ、スタックフレームにセット
    387     int ParmSize;
    388     ParmSize=pobj_parameter->SetParameter(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);
     385    int ParmSize = pobj_parameter->SetParameter(pDllProc->GetName(), pDllProc->Params() );
    389386
    390387
     
    392389
    393390    //call dword ptr[LookupTable]
     391    pDllProc->Using();
    394392    OpBuffer[obp++]=(char)0xFF;
    395393    OpBuffer[obp++]=(char)0x15;
    396     pobj_ImportAddrSchedule->add(pdi);
     394    pobj_ImportAddrSchedule->add(pDllProc);
    397395    obp+=sizeof(long);
    398396
    399     if(pdi->bCdecl){
     397    if(pDllProc->IsCdecl()){
    400398        //add esp,ParmSize
    401399        op_add_esp(ParmSize);
     
    408406    delete pobj_parameter;
    409407
    410     if(plpIndex) *plpIndex=pdi->u.ReturnIndex;
     408    if(plpIndex) *plpIndex=pDllProc->ReturnType().GetIndex();
    411409
    412410    HeapDefaultFree(temporary);
    413411
    414     return pdi->ReturnType;
     412    return pDllProc->ReturnType().GetBasicType();
    415413}
  • BasicCompiler32/Compile_Func.cpp

    r73 r75  
    207207    }
    208208
    209     TYPEINFO TypeInfo={type,lpIndex};
     209    Type TypeInfo={type,lpIndex};
    210210    if(IsStringObjectType(TypeInfo)){
    211211        //Stringオブジェクトの場合
     
    243243void Opcode_Func_AddressOf(const char *name){
    244244    extern int cp;
    245     SubInfo *psi;
     245    UserProc *pUserProc;
    246246
    247247    extern LONG_PTR ProcPtr_BaseIndex;
     
    249249        //左辺の型にのっとり、オーバーロードを解決
    250250
    251         std::vector<SubInfo *> subs;
     251        std::vector<UserProc *> subs;
    252252        GetOverloadSubHash( name, subs );
    253253        if( subs.size() == 0 ){
     
    257257
    258258        //オーバーロードを解決
    259         extern PROCPTRINFO *pProcPtrInfo;
    260         psi=OverloadSolution(name,subs,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
    261 
    262         if(!psi){
     259        extern ProcPointer **ppProcPtrInfo;
     260        pUserProc=OverloadSolution(name,subs,ppProcPtrInfo[ProcPtr_BaseIndex]->Params(), Type() );
     261
     262        if(!pUserProc){
    263263            SetError(27,name,cp);
    264264            return;
     
    266266    }
    267267    else{
    268         psi=GetSubHash(name);
    269         if(!psi){
     268        pUserProc=GetSubHash(name);
     269        if(!pUserProc){
    270270            SetError(27,name,cp);
    271271            return;
     
    273273    }
    274274
    275 
    276     if(psi->bVirtual){
     275    if( pUserProc->IsVirtual() ){
    277276        ///////////////////////////////
    278277        // 仮想関数の場合
     
    324323        OpBuffer[obp++]=(char)0x11;
    325324
    326         int i2 = pobj_c->GetFuncNumInVtbl( psi );
     325        int i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
    327326
    328327        //mov eax,dword ptr[edx+func_index]
     
    339338        //mov eax,ProcAddr
    340339        OpBuffer[obp++]=(char)0xB8;
    341         pobj_SubAddrSchedule->add(psi,0);
     340        pobj_SubAddrSchedule->add(pUserProc,0);
    342341        obp+=sizeof(long);
    343342    }
    344343
    345     psi->bUse=1;
     344    pUserProc->Using();
    346345}
    347346void Opcode_Func_SizeOf(const char *Parameter){
     
    361360    op_mov_RV( REG_EAX, size );
    362361}
    363 void Opcode_Func_VarPtr( const char *Parameter, TYPEINFO &ReturnTypeInfo ){
     362void Opcode_Func_VarPtr( const char *Parameter, Type &ReturnTypeInfo ){
    364363    RELATIVE_VAR RelativeVar;
    365364
     
    439438}
    440439
    441 void Opcode_CallFunc( const char *Parameter, const int FuncNum, TYPEINFO &ReturnTypeInfo ){
     440void Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &ReturnTypeInfo ){
    442441    switch(FuncNum){
    443442        case FUNC_FIX:
  • BasicCompiler32/Compile_Object.cpp

    r73 r75  
    22#include "opcode.h"
    33
    4 void _call_constructor(CClass *pobj_c, const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     4void _call_constructor( const CClass *pobj_c, const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    55    ////////////////////////////
    66    // コンストラクタの呼び出し
     
    3131    ////////////////////////
    3232
    33     std::vector<SubInfo *> subs;
     33    std::vector<UserProc *> subs;
    3434    pobj_c->EnumMethod( pobj_c->name, subs );
    3535
    36     SubInfo *psi;
     36    UserProc *pUserProc;
    3737    if( subs.size() > 0 ){
    3838        //オーバーロードを解決
    39         psi=OverloadSolutionWithStrParam(pobj_c->name,
    40             subs,CreateParameter,"",NULL);
    41 
    42         if(!psi) return;
     39        pUserProc=OverloadSolutionWithStrParam(pobj_c->name,
     40            subs,CreateParameter,"");
     41
     42        if(!pUserProc) return;
    4343    }
    4444
    4545    //コンストラクタを呼び出す
    4646    Opcode_CallProc(CreateParameter,
    47         psi,
     47        pUserProc,
    4848        PROCFLAG_NEW,"",0);
    4949
     
    7474    }
    7575}
    76 void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
     76void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType ){
    7777    int typeSize = classObj.GetSize();
    7878
     
    8282    }
    8383
     84    BOOL bSomeObjects=0;
    8485    if(objectSizeStr[0]){
    85         int type = NumOpe(objectSizeStr,0,0,0);
    86         ChangeTypeToLong(type);
     86        bSomeObjects=1;
     87
     88        Type tempType;
     89        NumOpe(objectSizeStr,Type(),tempType);
     90        if( !tempType.IsWhole() ) SetError(49,NULL,cp);
     91        ChangeTypeToLong(tempType.GetBasicType());
    8792
    8893        //pop eax
     
    129134    }
    130135
    131     if( baseTypeInfo.type == DEF_OBJECT ){
    132         //DeleteはGCで処理
     136    if( baseType.IsObject() ){
     137        // オブジェクト インスタンス
     138        // ※DeleteはGCで処理
    133139
    134140        //call _System_GC_malloc_ForObject
    135         extern SubInfo *pSub_System_GC_malloc_ForObject;
     141        extern UserProc *pSub_System_GC_malloc_ForObject;
    136142        op_call(pSub_System_GC_malloc_ForObject);
    137143    }
    138144    else{
    139         //明示的なDeleteが必要
     145        // オブジェクトポインタ
     146        // ※明示的なDeleteが必要
    140147
    141148        //call _System_GC_malloc_ForObjectPtr
    142         extern SubInfo *pSub_System_GC_malloc_ForObjectPtr;
     149        extern UserProc *pSub_System_GC_malloc_ForObjectPtr;
    143150        op_call(pSub_System_GC_malloc_ForObjectPtr);
    144151    }
     
    184191    //mov ecx,DestructorProcAddr
    185192    OpBuffer[obp++]=(char)0xB9;
    186     pobj_SubAddrSchedule->add(method->psi,0);
    187     method->psi->bUse=1;
     193    pobj_SubAddrSchedule->add(method->pUserProc,0);
     194    method->pUserProc->Using();
    188195    obp+=sizeof(long);
    189196
     
    209216    ////////////////////////////
    210217
    211     BOOL bSomeObjects;
    212     if(objectSizeStr[0]) bSomeObjects=1;
    213     else bSomeObjects=0;
    214218    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
    215219}
    216 int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
    217     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
    218     int i,i2;
    219 
    220     i=0;
    221 
    222     if(Parameter[0]=='['){
    223         i=GetStringInBracket(objectSizeStr,Parameter);
    224 
    225         SlideString(objectSizeStr+1,-1);
    226         objectSizeStr[i-2]=0;
    227     }
    228     else objectSizeStr[0]=0;
    229 
    230     for(i2=0;;i++,i2++){
    231         if(Parameter[i]=='('){
    232             TypeName[i2]=0;
    233 
    234             //コンストラクタに渡すパラメータを取得
    235             i2=GetStringInPare(CreateParameter,Parameter+i);
    236             RemoveStringPare(CreateParameter);
    237             i+=i2;
    238             if(Parameter[i]!='\0'){
    239                 SetError(42,NULL,cp);
    240                 return -1;
    241             }
    242             break;
    243         }
    244         TypeName[i2]=Parameter[i];
    245         if(Parameter[i]=='\0'){
    246             CreateParameter[0]=0;
    247             break;
    248         }
    249     }
    250 
    251     int type,TypeSize;
    252     type=GetTypeFixed(TypeName,plpIndex);
    253     if(type==-1){
    254         SetError(3,TypeName,cp);
    255         return -1;
    256     }
    257     TypeSize=GetTypeSize(type,*plpIndex);
    258 
    259     if(type!=DEF_OBJECT){
    260         ////////////////////////
    261         // 通常のデータ型の場合
    262         ////////////////////////
    263 
    264         SetError(121,NULL,cp);
    265         return -1;
    266     }
    267 
    268     CClass *pobj_c;
    269     pobj_c=(CClass *)*plpIndex;
    270 
    271     Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
    272 
    273     if( baseTypeInfo.type == DEF_OBJECT ){
    274         return DEF_OBJECT;
    275     }
    276     return DEF_PTR_OBJECT;
    277 }
    278 
    279220void OpcodeDelete(const char *Parameter, bool isSweeping){
    280     int type;
    281 
    282     type=NumOpe(Parameter,0,0,0);
    283     if(type==-1) return;
    284     if(!(type==DEF_PTR_OBJECT||type==DEF_PTR_VOID)) SetError(122,NULL,cp);
     221    Type tempType;
     222    if( !NumOpe(Parameter,Type(),tempType) ){
     223        return;
     224    }
     225    if(!( tempType.IsObjectPtr() || tempType.IsVoidPtr() )) SetError(122,NULL,cp);
    285226
    286227    //pop eax
     
    376317    if( isSweeping ){
    377318        //call _System_GC_free_for_SweepingDelete
    378         extern SubInfo *pSub_System_GC_free_for_SweepingDelete;
     319        extern UserProc *pSub_System_GC_free_for_SweepingDelete;
    379320        op_call(pSub_System_GC_free_for_SweepingDelete);
    380321    }
    381322    else{
    382323        //call free
    383         extern SubInfo *pSub_free;
     324        extern UserProc *pSub_free;
    384325        op_call(pSub_free);
    385326    }
  • BasicCompiler32/Compile_ProcOp.cpp

    r73 r75  
    33
    44
    5 void SystemProc(char *name){
     5void SystemProc( const char *name ){
    66    if(lstrcmp(name,"_System_GetEip")==0){
    77        //mov eax,dword ptr[esp]
     
    6969                    cp=GlobalVar[i].source_code_address;
    7070
    71                     TYPEINFO TypeInfo;
     71                    Type TypeInfo;
    7272                    TypeInfo.type=GlobalVar[i].type;
    7373                    TypeInfo.u.lpIndex=GlobalVar[i].u.index;
     
    214214}
    215215
    216 void CompileBufferInProcedure(SubInfo *psi){
     216void CompileBufferInProcedure(UserProc *pUserProc){
    217217    extern char *basbuf;
    218218    extern HANDLE hHeap;
    219     extern SubInfo **ppSubHash;
     219    extern UserProc **ppSubHash;
    220220    extern BOOL bDebugCompile;
    221221    int i3,i4,VarSize,LocalVarSchedule,EspOffsetSchedule,BufferSize,BaseOffset;
     
    224224    BufferSize=128;
    225225
    226     if(psi->bUse==0||psi->bCompile) return;
    227 
    228     psi->bCompile=1;
     226    if( pUserProc->IsUsing() == false || pUserProc->IsCompiled() ) return;
     227
     228    pUserProc->CompleteCompile();
    229229
    230230    extern BOOL bSystemProc;
    231     if(memcmp(psi->name,"_System_",8)==0) bSystemProc=1;
     231    if(memcmp(pUserProc->GetName().c_str(),"_System_",8)==0) bSystemProc=1;
    232232    else bSystemProc=0;
    233233
    234234    extern BOOL bDebugSupportProc;
    235     if(memcmp(psi->name,"_DebugSys_",10)==0){
     235    if(memcmp(pUserProc->GetName().c_str(),"_DebugSys_",10)==0){
    236236        if(!bDebugCompile){
    237             psi->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
    238             psi->VarNum=0;
     237            pUserProc->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
     238            pUserProc->VarNum=0;
    239239            return;
    240240        }
     
    243243    else bDebugSupportProc=0;
    244244
    245     psi->CompileAddress=obp;
    246 
    247     if(psi->bSystem){
     245    pUserProc->beginOpAddress=obp;
     246
     247    if(pUserProc->IsSystem()){
    248248        extern int MaxLocalVarNum;
    249249        extern int AllLocalVarSize;
     
    251251        AllLocalVarSize=0;
    252252
    253         SystemProc(psi->name);
    254 
    255         psi->EndOpAddr=obp;
    256         psi->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
    257         psi->VarNum=0;
     253        SystemProc(pUserProc->GetName().c_str());
     254
     255        pUserProc->endOpAddress=obp;
     256        pUserProc->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
     257        pUserProc->VarNum=0;
    258258        return;
    259259    }
    260260
    261     cp=psi->address;
     261    cp=pUserProc->GetCodePos();
    262262    for(;;cp++){
    263263        if(IsCommandDelimitation(basbuf[cp])) break;
     
    280280
    281281    //パラメータ用の変数データを考慮
    282     for(i3=psi->realParams.size()-1;i3>=0;i3--){
    283         Parameter &param = *psi->realParams[i3];
     282    for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){
     283        Parameter &param = *pUserProc->RealParams()[i3];
    284284
    285285        //変数データを追加
     
    297297        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
    298298            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
    299                 if(psi->bExport)
     299                if(pUserProc->IsExport())
    300300                    SetError(24,NULL,cp);
    301301        }
     
    340340
    341341    //コンパイル中の関数が属するクラス
    342     pobj_CompilingClass=psi->pobj_ParentClass;
     342    pobj_CompilingClass=pUserProc->GetParentClassPtr();
    343343
    344344    //コンパイルスタートをクラス管理クラスに追加
    345     pobj_DBClass->StartCompile( psi );
     345    pobj_DBClass->StartCompile( pUserProc );
    346346
    347347    //コンパイル中の関数
    348     extern SubInfo *pCompilingSubInfo;
    349     pCompilingSubInfo=psi;
     348    extern UserProc *pCompilingUserProc;
     349    pCompilingUserProc=pUserProc;
    350350
    351351
     
    373373    OpBuffer[obp++]=(char)0x57;
    374374
    375     if(psi->ReturnType!=DEF_NON){
     375    if( !pUserProc->ReturnType().IsNull() ){
    376376        //戻り値が存在するとき
    377377
    378         char *temp;
    379         if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR) temp="_System_ReturnValue";
    380         else temp=psi->name;
    381 
    382         if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
     378        const char *temp = pUserProc->GetName().c_str();
     379        if( temp[0]==1&&temp[1]==ESC_OPERATOR ){
     380            temp = "_System_ReturnValue";
     381        }
     382
     383        if( pUserProc->ReturnType().IsStruct() ){
    383384            //戻り値用の構造体(値型)はパラメータで引き渡される
    384385        }
    385386        else{
    386387            //戻り値用の変数の定義
    387             if( psi->isReturnRef ){
    388                 sprintf(temporary,"%c%c",1,ESC_BYREF);
    389             }
    390             else temporary[0]=0;
    391 
    392             sprintf(temporary+lstrlen(temporary),"%s%c%c",temp,1,ESC_AS);
    393             GetTypeName(psi->ReturnType,psi->u.ReturnIndex,temporary+lstrlen(temporary));
     388            sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() );
    394389
    395390            OpcodeDim(temporary,0);
     
    444439
    445440        //call _DebugSys_StartProc
    446         extern SubInfo *pSub_DebugSys_StartProc;
     441        extern UserProc *pSub_DebugSys_StartProc;
    447442        op_call(pSub_DebugSys_StartProc);
    448443    }
    449444
    450445    if(pobj_CompilingClass){
    451         if(lstrcmp(psi->name,pobj_CompilingClass->name)==0){
     446        if( pUserProc->GetName() == pobj_CompilingClass->name ){
    452447            ////////////////////////////////////
    453448            // コンストラクタをコンパイルするとき
     
    497492
    498493                    Opcode_CallProc(temporary,
    499                         pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->psi,
     494                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
    500495                        0,
    501496                        "",
     
    505500                    //基底クラスのコンストラクタを暗黙的に呼び出す
    506501                    Opcode_CallProc("",
    507                         pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->psi,
     502                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
    508503                        0,
    509504                        "",
     
    548543            }
    549544        }
    550         else if(psi->name[0]=='~'){
     545        else if( pUserProc->IsDestructor() ){
    551546            //デストラクタをコンパイルしたとき
    552547
     
    559554    //////////////////////////////////////////
    560555    ////// プロシージャ内をコンパイル ////////
    561     if(psi->dwType==SUBTYPE_SUB) CompileBuffer(ESC_ENDSUB,0);
    562     else if(psi->dwType==SUBTYPE_FUNCTION) CompileBuffer(ESC_ENDFUNCTION,0);
    563     else if(psi->dwType==SUBTYPE_MACRO) CompileBuffer(ESC_ENDMACRO,0);
     556    if(pUserProc->IsMacro()) CompileBuffer(ESC_ENDMACRO,0);
     557    else{
     558        if(pUserProc->IsSub()) CompileBuffer(ESC_ENDSUB,0);
     559        else if(pUserProc->IsFunction()) CompileBuffer(ESC_ENDFUNCTION,0);
     560    }
    564561    //////////////////////////////////////////
    565562    //////////////////////////////////////////
     
    573570            pobj_CompilingClass->NotifyFinishConstructorCompile();
    574571        }
    575         else if(psi->name[0]=='~'){
     572        else if( pUserProc->IsDestructor() ){
    576573            ////////////////////////////////////
    577574            //デストラクタをコンパイルしたとき
     
    588585                if( method ){
    589586                    Opcode_CallProc("",
    590                         method->psi,
     587                        method->pUserProc,
    591588                        0,
    592589                        "",
     
    631628
    632629                            //call destructor
    633                             op_call( method->psi );
     630                            op_call( method->pUserProc );
    634631                        }
    635632                    }
     
    666663    HeapDefaultFree(WithInfo.pWithCp);
    667664
    668     //重複エラー情報管理のメモリを解放
    669     for(i3=0;i3<SynonymErrorNum;i3++) HeapDefaultFree(SynonymErrorWords[i3]);
    670     HeapDefaultFree(SynonymErrorWords);
    671 
    672665    //push ebp
    673666    AllLocalVarSize+=sizeof(long);
     
    686679
    687680        //call _DebugSys_EndProc
    688         extern SubInfo *pSub_DebugSys_EndProc;
     681        extern UserProc *pSub_DebugSys_EndProc;
    689682        op_call(pSub_DebugSys_EndProc);
    690683    }
    691684
    692     if(psi->ReturnType!=DEF_NON){
     685    if( !pUserProc->ReturnType().IsNull() ){
    693686        //戻り値をeax、edxに設定
    694687        RELATIVE_VAR RelativeVar;
    695688        LONG_PTR lpIndex;
    696689
    697         char *temp;
    698         if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
     690        const char *temp = pUserProc->GetName().c_str();
     691        if( temp[0]==1 && temp[1]==ESC_OPERATOR ){
    699692            temp="_System_ReturnValue";
    700         else temp=psi->name;
     693        }
    701694        GetVarOffsetReadWrite(temp,&i3,&RelativeVar,&lpIndex);
    702695
    703         i3=psi->ReturnType;
     696        i3=pUserProc->ReturnType().GetBasicType();
    704697
    705698        if(i3==DEF_OBJECT || i3==DEF_STRUCT){
     
    808801
    809802        //call _esp_error
    810         extern SubInfo *pSub_esp_error;
     803        extern UserProc *pSub_esp_error;
    811804        op_call( pSub_esp_error );
    812805
     
    824817    op_add_esp(AllLocalVarSize-BaseOffset);
    825818
    826     if(BaseOffset==0||psi->bCdecl){
     819    if( BaseOffset==0 || pUserProc->IsCdecl() ){
    827820        //ret 0
    828821        OpBuffer[obp++]=(char)0xC3;
     
    835828    }
    836829
    837     psi->EndOpAddr=obp;
    838     psi->pVar=LocalVar;
    839     psi->VarNum=MaxLocalVarNum;
     830    pUserProc->endOpAddress=obp;
     831    pUserProc->pVar=LocalVar;
     832    pUserProc->VarNum=MaxLocalVarNum;
     833
     834
     835    //重複エラー情報管理のメモリを解放
     836    for(i3=0;i3<SynonymErrorNum;i3++) HeapDefaultFree(SynonymErrorWords[i3]);
     837    HeapDefaultFree(SynonymErrorWords);
     838    SynonymErrorWords=0;
     839
    840840
    841841    //ローカル変数のネーム情報は後に解放する
    842842}
    843843void CompileLocal(){
    844     extern SubInfo **ppSubHash;
     844    extern UserProc **ppSubHash;
    845845    int i2;
    846     SubInfo *psi;
     846    UserProc *pUserProc;
    847847
    848848    extern BOOL bDll;
    849849    if(bDll){
    850850        //DLLの場合はグローバル変数を初期化するための関数を一番初めにコンパイルする
    851         psi=GetSubHash("_System_InitDllGlobalVariables");
    852         if(psi){
    853             CompileBufferInProcedure(psi);
     851        pUserProc=GetSubHash("_System_InitDllGlobalVariables");
     852        if(pUserProc){
     853            CompileBufferInProcedure(pUserProc);
    854854        }
    855855        else SetError(300,NULL,cp);
     
    858858    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    859859    //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
    860     extern SubInfo *pSub_System_InitStaticLocalVariables;
    861     pSub_System_InitStaticLocalVariables->bCompile=1;
     860    extern UserProc *pSub_System_InitStaticLocalVariables;
     861    pSub_System_InitStaticLocalVariables->CompleteCompile();
    862862
    863863    //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
    864     extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
    865     pSub_System_Call_Destructor_of_GlobalObject->bCompile=1;
     864    extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
     865    pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile();
    866866
    867867Repeat:
    868868    for(i2=0;i2<MAX_HASH;i2++){
    869         psi=ppSubHash[i2];
    870         while(psi){
    871             CompileBufferInProcedure(psi);
    872             psi=psi->pNextData;
     869        pUserProc=ppSubHash[i2];
     870        while(pUserProc){
     871            CompileBufferInProcedure(pUserProc);
     872            pUserProc=pUserProc->pNextData;
    873873        }
    874874    }
     
    876876    //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合
    877877    for(i2=0;i2<MAX_HASH;i2++){
    878         psi=ppSubHash[i2];
    879         while(psi){
    880             if(psi->bUse&&psi->bCompile==0){
     878        pUserProc=ppSubHash[i2];
     879        while(pUserProc){
     880            if( pUserProc->IsUsing() && pUserProc->IsCompiled() == false ){
    881881                goto Repeat;
    882882            }
    883883
    884             psi=psi->pNextData;
     884            pUserProc=pUserProc->pNextData;
    885885        }
    886886    }
    887887
    888888    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    889     pSub_System_InitStaticLocalVariables->bCompile=0;
     889    pSub_System_InitStaticLocalVariables->KillCompileStatus();
    890890    CompileBufferInProcedure(pSub_System_InitStaticLocalVariables);
    891891
    892892    //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
    893     pSub_System_Call_Destructor_of_GlobalObject->bCompile=0;
     893    pSub_System_Call_Destructor_of_GlobalObject->KillCompileStatus();
    894894    CompileBufferInProcedure(pSub_System_Call_Destructor_of_GlobalObject);
    895895}
  • BasicCompiler32/Compile_Set_Var.cpp

    r73 r75  
    77}
    88
    9 void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap){
     9void SetStructVariable( const Type &varType, const Type &calcType, BOOL bUseHeap){
    1010/*
    1111    TODO: 消す
     
    3737
    3838
    39     if( CalcType == DEF_STRUCT ){
    40         CClass *pVarClass = (CClass *)lpVarIndex;
    41         CClass *pCalcClass = (CClass *)lpCalcIndex;
    42 
    43 
    44         if( pVarClass->IsEquals( pCalcClass ) ){        //等しい
     39    if( calcType.IsStruct() ){
     40        if( varType.GetClass().IsEquals( &calcType.GetClass() ) ){          //等しい
    4541
    4642                //双方のオブジェクト型が一致、または派生・継承関係にあるとき
    4743                //※コピーを行う
    4844
    49                 int object_size = pVarClass->GetSize();
     45                int object_size = varType.GetClass().GetSize();
    5046
    5147                //mov ecx,object_size
     
    7167
    7268                    //call free
    73                     extern SubInfo *pSub_free;
     69                    extern UserProc *pSub_free;
    7470                    op_call(pSub_free);
    7571                }
  • BasicCompiler32/Compile_Statement.cpp

    r73 r75  
    55    int i,i2;
    66    char buffer[8192];
    7     SubInfo *psi;
     7    UserProc *pUserProc;
    88
    99    for(i=0;;i++){
     
    4141        //////////////////////////////
    4242
    43         psi=GetSubHash(Command);
     43        pUserProc=GetSubHash(Command);
    4444
    4545        //GetSubHash内でエラー提示が行われた場合
    46         if(psi==(SubInfo *)-1) return;
    47 
    48         if(psi==0){
     46        if(pUserProc==(UserProc *)-1) return;
     47
     48        if(pUserProc==0){
    4949            char temporary[VN_SIZE];
    5050            lstrcpy(temporary,Command);
    5151
    5252            CharUpper(temporary);
    53             psi=GetSubHash(temporary);
     53            pUserProc=GetSubHash(temporary);
    5454
    5555            //GetSubHash内でエラー提示が行われた場合
    56             if(psi==(SubInfo *)-1) return;
    57         }
    58 
    59         if(psi){
    60             if(psi->dwType!=SUBTYPE_MACRO) SetError(10,Command,cp);
    61 
    62             Opcode_CallProc("",psi,0,"",0);
     56            if(pUserProc==(UserProc *)-1) return;
     57        }
     58
     59        if(pUserProc){
     60            if( !pUserProc->IsMacro() ) SetError(10,Command,cp);
     61
     62            Opcode_CallProc("",pUserProc,0,"",0);
    6363
    6464            return;
     
    963963
    964964int CaseTypeSize;
    965 void OpcodeSelect(char *Parameter){
     965void OpcodeSelect(const char *lpszParams){
    966966    extern DWORD *pCaseSchedule;
    967967    extern int CaseScheduleNum;
     
    987987
    988988    LONG_PTR lpIndex;
    989     type1=NumOpe(Parameter,0,0,&lpIndex);
     989    type1=NumOpe(lpszParams,0,0,&lpIndex);
    990990    if(type1==DEF_INTEGER||
    991991        type1==DEF_WORD||
     
    10761076                    pobj_c=(CClass *)lpIndex;
    10771077
    1078                     std::vector<SubInfo *> subs;
     1078                    std::vector<UserProc *> subs;
    10791079                    pobj_c->EnumMethod( CALC_EQUAL, subs );
    10801080                    if( subs.size() == 0 ){
     
    10821082                    }
    10831083
    1084                     PARAMETER_INFO *ppi = (PARAMETER_INFO *)HeapAlloc(hHeap,0,sizeof(PARAMETER_INFO)*3);
    1085                     int iParmNum=0;
    1086                     ppi[iParmNum].bArray=0;
    1087                     ppi[iParmNum].bByVal=0;
    1088                     ppi[iParmNum].name=0;
    1089                     ppi[iParmNum].type=type2;
    1090                     ppi[iParmNum].u.index=lpIndex2;
    1091                     ppi[iParmNum].SubScripts[0]=-1;
    1092                     iParmNum++;
     1084                    Parameters params;
     1085                    params.push_back( new Parameter( "", Type( type2, lpIndex2 ) ) );
    10931086
    10941087                    //オーバーロードを解決
    1095                     SubInfo *psi;
    1096                     psi=OverloadSolution("==",subs,ppi,iParmNum,NULL);
    1097                     HeapDefaultFree(ppi);
    1098 
    1099                     if(!psi){
     1088                    UserProc *pUserProc;
     1089                    pUserProc=OverloadSolution("==",subs, params, NULL);
     1090
     1091                    delete params[0];
     1092
     1093                    if(!pUserProc){
    11001094                        //エラー
    11011095                        return;
     
    11161110
    11171111                    //call operator_proc    ※ ==演算子
    1118                     op_call(psi);
     1112                    op_call(pUserProc);
    11191113
    11201114                    //test eax,eax
     
    13301324        //戻り値をセット
    13311325        if(Parameter[0]){
    1332             extern SubInfo *pCompilingSubInfo;
    1333             char *temp;
    1334             if(pCompilingSubInfo->name[0]==1&&pCompilingSubInfo->name[1]==ESC_OPERATOR)
    1335                 temp="_System_ReturnValue";
    1336             else temp=pCompilingSubInfo->name;
    1337 
    1338             /*
    1339             TODO: 消す
    1340             if( pCompilingSubInfo->isReturnRef ){
    1341                 //参照型
    1342                 SetRefVariable( temp, Parameter );
    1343             }
    1344             else{
    1345                 //値型*/
    1346                 char temporary[VN_SIZE];
    1347                 sprintf(temporary,"%s=%s",temp,Parameter);
    1348                 OpcodeCalc(temporary);
    1349             //}
     1326            extern UserProc *pCompilingUserProc;
     1327            const char *temp = "_System_ReturnValue";
     1328            if(pCompilingUserProc->GetName()[0]==1&&pCompilingUserProc->GetName()[1]==ESC_OPERATOR)
     1329            {
     1330            }
     1331            else temp=pCompilingUserProc->GetName().c_str();
     1332
     1333            char temporary[VN_SIZE];
     1334            sprintf(temporary,"%s=%s",temp,Parameter);
     1335            OpcodeCalc(temporary);
    13501336        }
    13511337
     
    14601446    OpcodeCalc(temp2);
    14611447
    1462     SubInfo *psi;
    1463     if(bFile) psi=GetSubHash("INPUT_FromFile");
    1464     else psi=GetSubHash("INPUT_FromPrompt");
    1465     if(!psi){
     1448    UserProc *pUserProc;
     1449    if(bFile) pUserProc=GetSubHash("INPUT_FromFile");
     1450    else pUserProc=GetSubHash("INPUT_FromPrompt");
     1451    if(!pUserProc){
    14661452        SetError(3,"Input",cp);
    14671453        return;
    14681454    }
    1469     Opcode_CallProc(buffer,psi,0,"",0);
     1455    Opcode_CallProc(buffer,pUserProc,0,"",0);
    14701456}
    14711457void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
     
    15621548    OpcodeCalc(temp2);
    15631549
    1564     SubInfo *psi;
    1565     if(bFile) psi=GetSubHash("PRINTUSING_ToFile");
    1566     else psi=GetSubHash("PRINTUSING_ToPrompt");
    1567     if(!psi){
     1550    UserProc *pUserProc;
     1551    if(bFile) pUserProc=GetSubHash("PRINTUSING_ToFile");
     1552    else pUserProc=GetSubHash("PRINTUSING_ToPrompt");
     1553    if(!pUserProc){
    15681554        SetError(3,"Print",cp);
    15691555        return;
    15701556    }
    1571     Opcode_CallProc(buffer,psi,0,"",0);
     1557    Opcode_CallProc(buffer,pUserProc,0,"",0);
    15721558}
    15731559void Opcode_Print(const char *Parameter,BOOL bWrite){
     
    16661652    if(sw) lstrcat(buffer,"+Ex\"\\r\\n\"");
    16671653
    1668     SubInfo *psi;
    1669     if(bFile) psi=GetSubHash("PRINT_ToFile");
    1670     else psi=GetSubHash("PRINT_ToPrompt");
    1671     if(!psi){
     1654    UserProc *pUserProc;
     1655    if(bFile) pUserProc=GetSubHash("PRINT_ToFile");
     1656    else pUserProc=GetSubHash("PRINT_ToPrompt");
     1657    if(!pUserProc){
    16721658        SetError(3,"Print",cp);
    16731659        return;
    16741660    }
    1675     Opcode_CallProc(buffer,psi,0,"",0);
     1661    Opcode_CallProc(buffer,pUserProc,0,"",0);
    16761662}
    16771663
  • BasicCompiler32/Compile_Var.cpp

    r73 r75  
    1111int AllLocalVarSize;
    1212
    13 void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
    14     int i2;
    15 
     13void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){
    1614    PushLongVariable(pRelativeVar);
    1715
    18     i2=NumOpe(lpPtrOffset,0,0,0);
    19     ChangeTypeToLong(i2);
     16    Type type;
     17    NumOpe( lpPtrOffset, Type(), type );
     18    ChangeTypeToLong( type.GetBasicType() );
    2019
    2120    //pop ebx
    2221    op_pop(REG_EBX);
    2322
    24     if(PTR_LEVEL(*pType)){
    25         *pType = PTR_LEVEL_DOWN( *pType );
    26 
    27         i2=GetTypeSize(*pType,lpIndex);
    28         if(i2>=2){
     23    if( resultType.PtrLevel() ){
     24        resultType.PtrLevelDown();
     25
     26        int typeSize = resultType.GetSize();
     27        if(typeSize>=2){
    2928            //imul ebx,i2
    30             op_imul_RV( REG_EBX, i2 );
     29            op_imul_RV( REG_EBX, typeSize );
    3130        }
    3231    }
     
    5857    }
    5958}
    60 BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
     59bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){
    6160    extern HANDLE hHeap;
    62     int i,i2,i3,i4,TypeSize;
     61    int i,i2,i3,i4;
    6362    char temporary[VN_SIZE],*pParm[MAX_PARMS];
    6463
     
    110109
    111110    for(i=i3-1;i>=0;i--){
    112         TYPEINFO TypeInfo;
     111        Type tempType;
    113112        BOOL bUseHeap;
    114         TypeInfo.type=NumOpe(pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
    115         if(TypeInfo.type==DEF_OBJECT){
     113        NumOpe( pParm[i], Type( DEF_LONG ), tempType, &bUseHeap );
     114        if( tempType.IsObject() ){
    116115            //キャスト演算子のオーバーロードに対応する
    117116            CallCastOperatorProc(
    118                 TypeInfo.type,TypeInfo.u.lpIndex,
    119                 bUseHeap,DEF_LONG,-1);
    120             TypeInfo.type=DEF_LONG;
    121         }
    122         ChangeTypeToLong(TypeInfo.type);
     117                tempType,
     118                bUseHeap, Type(DEF_LONG) );
     119            tempType.SetBasicType( DEF_LONG );
     120        }
     121        ChangeTypeToLong( tempType.GetBasicType() );
    123122
    124123        //pop eax
     
    144143    op_pop(REG_EAX);
    145144
    146     TypeSize=GetTypeSize(type,lpIndex);
    147 
    148145    //imul eax,TypeSize
    149146    OpBuffer[obp++]=(char)0x69;
    150147    OpBuffer[obp++]=(char)0xC0;
    151     *((long *)(OpBuffer+obp))=TypeSize;
     148    *((long *)(OpBuffer+obp)) = type.GetSize();
    152149    obp+=sizeof(long);
    153150
     
    161158    return 1;
    162159}
    163 BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
     160bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
    164161    int i;
    165162
    166     //クラス、配列の構成要素を解析する
     163
     164    //////////////////////////////////////
     165    // クラス、配列の構成要素を解析する
     166    //////////////////////////////////////
     167
    167168    char VarName[VN_SIZE];      //変数名
    168169    char array[VN_SIZE];        //第1次配列
     
    171172    CClass::RefType refType;
    172173    lstrcpy(VarName,member);
    173     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
     174    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
     175
    174176
    175177    ////////////////////////////
     
    177179    ////////////////////////////
    178180
    179     int offset=pobj_c->GetMemberOffset( VarName, &i );
    180     if(i==pobj_c->iMemberNum){
     181    int offset = objClass.GetMemberOffset( VarName, &i );
     182    if(i==objClass.iMemberNum){
    181183        if(isErrorEnabled) SetError(103,VarName,cp);
    182         return 0;
    183     }
    184 
    185     CMember *pMember=pobj_c->ppobj_Member[i];
     184        return false;
     185    }
     186
     187    CMember *pMember=objClass.ppobj_Member[i];
     188
    186189
    187190    //アクセシビリティをチェック
    188     if(pobj_c==pobj_CompilingClass){
     191    if(&objClass==pobj_CompilingClass){
    189192        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    190193        if(pMember->dwAccess==ACCESS_NON){
    191194            if(isErrorEnabled) SetError(107,VarName,cp);
    192             return 0;
     195            return false;
    193196        }
    194197    }
     
    197200            pMember->dwAccess==ACCESS_NON){
    198201            if(isErrorEnabled) SetError(107,VarName,cp);
    199             return 0;
     202            return false;
    200203        }
    201204        else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
    202205            if(isErrorEnabled) SetError(108,VarName,cp);
    203             return 0;
     206            return false;
    204207        }
    205208    }
     
    209212    if( pMember->IsConst() &&       //定数メンバである
    210213        isWriteAccess &&                            //書き込みアクセスを要求されている
    211         pobj_c->IsCompilingConstructor() == false   //コンストラクタ コンパイル中を除く
     214        objClass.IsCompilingConstructor() == false  //コンストラクタ コンパイル中を除く
    212215        ){
    213216            //Const定義の変数に書き込みアクセスをしようとした場合
     
    215218    }
    216219
    217     *pType=pMember->TypeInfo.type;
    218     *plpNestIndex=pMember->TypeInfo.u.lpIndex;
     220    resultType = *pMember;
    219221
    220222    //ポインタ変数の場合
    221     if(IsPtrType(*pType)){
     223    if( resultType.IsPointer() ){
    222224        if(pMember->SubScripts[0]==-1){
    223225            lstrcpy(lpPtrOffset,array);
     
    228230        if(lpPtrOffset[0]){
    229231            if(isErrorEnabled) SetError(16,member,cp);
    230             return 0;
     232            return false;
    231233        }
    232234    }
     
    242244    if(array[0]){
    243245        //配列オフセット
    244         if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex))
     246        if(!GetArrayOffset(pMember->SubScripts,array,*pMember)){
    245247            if(isErrorEnabled) SetError(14,member,cp);
     248        }
    246249    }
    247250    else if(pMember->SubScripts[0]!=-1){
    248         *pType|=FLAG_PTR;
     251        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    249252    }
    250253
     
    252255        //入れ子構造の場合
    253256
    254         if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     257        if( resultType.IsObject() || resultType.IsStruct() ){
    255258            if( refType != CClass::Dot ){
    256259                if(isErrorEnabled) SetError(104,member,cp);
    257                 return 0;
    258             }
    259 
    260             if( *pType==DEF_OBJECT ){
     260                return false;
     261            }
     262
     263            if( resultType.IsObject() ){
    261264                // 参照内容へのポインタを抽出
    262265                SetRelativeOffset( *pRelativeVar );
    263266            }
    264267        }
    265         else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
     268        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
    266269            //構造体ポインタ型メンバ変数
    267270
    268271            if(lpPtrOffset[0]){
    269272                //pObj[n].member
    270                 if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
    271                     if(isErrorEnabled) SetError(104,member,cp);
    272                     return 0;
     273                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
     274                    && refType != CClass::Dot ){
     275                        if(isErrorEnabled) SetError(104,member,cp);
     276                        return false;
    273277                }
    274278
    275279                //直接参照に切り替え
    276                 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     280                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    277281                pRelativeVar->dwKind=VAR_DIRECTMEM;
    278282
     
    281285            else{
    282286                //pObj->member
    283                 if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
    284                     if(isErrorEnabled) SetError(104,member,cp);
    285                     return 0;
     287                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
     288                    && refType != CClass::Pointer ){
     289                        if(isErrorEnabled) SetError(104,member,cp);
     290                        return false;
    286291                }
    287292
     
    289294            }
    290295        }
    291         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
     296        else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
     297            || resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
    292298            //構造体ポインタのポインタ型メンバ変数
    293299
     
    296302                if( refType != CClass::Pointer ){
    297303                    if(isErrorEnabled) SetError(104,member,cp);
    298                     return 0;
     304                    return false;
    299305                }
    300306
    301307                //直接参照に切り替え
    302                 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     308                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    303309                pRelativeVar->dwKind=VAR_DIRECTMEM;
    304310
     
    311317            else{
    312318                if(isErrorEnabled) SetError(104,member,cp);
    313                 return 0;
    314             }
    315         }
    316 
    317         if(!GetMemberOffset(
     319                return false;
     320            }
     321        }
     322
     323        if(!_member_offset(
    318324            isErrorEnabled,
    319325            isWriteAccess,
    320             pMember->TypeInfo.u.pobj_Class,
     326            pMember->GetClass(),
    321327            NestMember,
    322             pType,
    323328            pRelativeVar,
    324             plpNestIndex,
    325             0)) return 0;
     329            resultType,
     330            0)) return false;
    326331    }
    327332
    328333    if(lpPtrOffset[0]){
    329         SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
     334        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    330335        pRelativeVar->dwKind=VAR_DIRECTMEM;
    331336    }
    332337
    333     return 1;
     338    return true;
    334339}
    335340void GetWithName(char *buffer){
     
    355360}
    356361
    357 BOOL GetVarOffset(bool isErrorEnabled, bool isWriteAccess, const char *NameBuffer, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpIndex, int *pss){
    358     extern BOOL bCompilingGlobal;
     362bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){
    359363    int i;
    360     LONG_PTR lpIndex;
    361364    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    362365
     
    373376
    374377        void *pInfo;
    375         int idProc=GetProc(VarName,&pInfo);
     378        int idProc=GetProc(VarName,(void **)&pInfo);
    376379
    377380        if(idProc){
    378381            pRelativeVar->dwKind=VAR_DIRECTMEM;
     382
     383            Type type;
    379384
    380385
     
    383388            ////////////////
    384389
    385             *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
     390            CallProc(idProc,pInfo,VarName,array,type);
    386391
    387392            //戻り値をecxにコピー
     
    389394
    390395
    391             LONG_PTR lp2;
    392             if(!GetMemberOffset(
     396            if(!_member_offset(
    393397                isErrorEnabled,
    394398                isWriteAccess,
    395                 (CClass *)lpIndex,
    396                 member,pType,pRelativeVar,&lp2,0)) return 0;
    397             if(plpIndex) *plpIndex=lp2;
    398 
    399             return 1;
     399                type.GetClass(),
     400                member,pRelativeVar,resultType,0)) return false;
     401
     402            return true;
    400403        }
    401404    }
     
    405408    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    406409
    407     int *pSubScripts;
    408     bool bConst;
    409 
    410     if(bCompilingGlobal==0){
    411         ////////////////////
     410    const int *pSubScripts;
     411    bool bConst = false;
     412
     413
     414    if( UserProc::IsLocalAreaCompiling() ){
     415        //////////////////
    412416        // ローカル変数
    413         ////////////////////
    414 
    415         for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    416             if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
    417                 && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
    418                 ){
    419                     if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    420             }
    421         }
    422         if(i>=0){
     417        //////////////////
     418
     419        const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
     420        if( pVar ){
    423421            //ポインタ変数の場合
    424             if(IsPtrType(LocalVar[i].type)){
    425                 if(LocalVar[i].SubScripts[0]==-1){
     422            if( pVar->IsPointer() ){
     423                if( !pVar->IsArray() ){
    426424                    lstrcpy(lpPtrOffset,array);
    427425                    array[0]=0;
     
    432430                    SetError(16,variable,cp);
    433431                    pRelativeVar->dwKind=NON_VAR;
    434                     return 0;
     432                    return false;
    435433                }
    436434            }
    437435
    438             pRelativeVar->offset=-LocalVar[i].offset;
     436            pRelativeVar->offset=-pVar->offset;
    439437            pRelativeVar->bOffsetOffset=0;
    440             if(LocalVar[i].fRef) pRelativeVar->dwKind=VAR_REFLOCAL;
     438            if( pVar->IsRef() ){
     439                // 参照型
     440                pRelativeVar->dwKind = VAR_REFLOCAL;
     441            }
    441442            else pRelativeVar->dwKind=VAR_LOCAL;
    442             *pType=LocalVar[i].type;
    443             lpIndex=LocalVar[i].u.index;
    444             if(plpIndex) *plpIndex=lpIndex;
    445             pSubScripts=LocalVar[i].SubScripts;
    446             bConst = LocalVar[i].bConst;
     443            resultType = *pVar;
     444            pSubScripts=pVar->GetSubScriptsPtr();
     445            bConst = pVar->IsConst();
    447446
    448447            goto ok;
     
    461460            SetThisPtrToReg(REG_ECX);
    462461
    463             *pType=DEF_OBJECT;
    464462            pRelativeVar->dwKind=VAR_DIRECTMEM;
    465463
    466             if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
    467             return 1;
     464            resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     465            return true;
    468466        }
    469467
     
    500498
    501499        pRelativeVar->dwKind=VAR_DIRECTMEM;
    502         if(!GetMemberOffset(
     500        if(!_member_offset(
    503501            isErrorEnabled,
    504502            isWriteAccess,
    505             pobj_CompilingClass,
     503            *pobj_CompilingClass,
    506504            variable,
    507             pType,
    508505            pRelativeVar,
    509             &lpIndex,1)) return 0;
    510         if(plpIndex) *plpIndex=lpIndex;
    511         return 1;
     506            resultType,1)) return false;
     507        return true;
    512508    }
    513509
    514510NonClassMember:
    515511
    516     //////////////////////////
    517     // 静的ローカル変数
    518     // ※"Static.Object.Method.Variable"
    519     //////////////////////////
    520 
    521     char temporary[VN_SIZE];
    522     extern SubInfo *pCompilingSubInfo;
    523     if(pCompilingSubInfo){
    524         GetNowStaticVarFullName(VarName,temporary);
    525 
    526         for(i=0;i<MaxGlobalVarNum;i++){
    527             if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
    528         }
    529         if(i!=MaxGlobalVarNum){
     512    {
     513        const Variable *pVar;
     514
     515        //////////////////////////
     516        // 静的ローカル変数
     517        // ※"Static.Object.Method.Variable"
     518        //////////////////////////
     519
     520        char temporary[VN_SIZE];
     521        if( UserProc::IsLocalAreaCompiling() ){
     522            GetNowStaticVarFullName(VarName,temporary);
     523
     524            pVar = globalVars.Find( temporary );
     525            if( pVar ){
     526                goto GlobalOk;
     527            }
     528        }
     529
     530
     531        //////////////////////////
     532        // クラスの静的メンバ
     533        //////////////////////////
     534
     535        if(member[0]){
     536            lstrcpy(temporary,member);
     537
     538            char tempMember[VN_SIZE];
     539            char tempArray[VN_SIZE];
     540            {
     541                CClass::RefType refType;
     542                GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
     543            }
     544
     545            char temp2[VN_SIZE];
     546            sprintf(temp2,"%s.%s",VarName,temporary);
     547            pVar = globalVars.Find( temp2 );
     548            if( pVar ){
     549                lstrcpy(member,tempMember);
     550                lstrcpy(array,tempArray);
     551                goto GlobalOk;
     552            }
     553        }
     554
     555        if(pobj_CompilingClass){
     556            //自身のクラスから静的メンバを参照する場合
     557            char temp2[VN_SIZE];
     558            sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
     559            pVar = globalVars.Find( temp2 );
     560            if( pVar ){
     561                goto GlobalOk;
     562            }
     563        }
     564
     565        /////////////////////
     566        // グローバル変数
     567        /////////////////////
     568
     569        pVar = globalVars.BackSearch( VarName );
     570        if( pVar ){
    530571            goto GlobalOk;
    531572        }
    532     }
    533 
    534 
    535     //////////////////////////
    536     // クラスの静的メンバ
    537     //////////////////////////
    538 
    539     if(member[0]){
    540         lstrcpy(temporary,member);
    541 
    542         char tempMember[VN_SIZE];
    543         char tempArray[VN_SIZE];
    544         {
    545             CClass::RefType refType;
    546             GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
    547         }
    548 
    549         char temp2[VN_SIZE];
    550         sprintf(temp2,"%s.%s",VarName,temporary);
    551         for(i=0;i<MaxGlobalVarNum;i++){
    552             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    553         }
    554 
    555         if(i!=MaxGlobalVarNum){
    556             lstrcpy(member,tempMember);
    557             lstrcpy(array,tempArray);
    558             goto GlobalOk;
    559         }
    560     }
    561 
    562     if(pobj_CompilingClass){
    563         //自身のクラスから静的メンバを参照する場合
    564         char temp2[VN_SIZE];
    565         sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
    566         for(i=0;i<MaxGlobalVarNum;i++){
    567             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    568         }
    569 
    570         if(i!=MaxGlobalVarNum){
    571             goto GlobalOk;
    572         }
    573     }
    574 
    575 
    576     ////////////////////
    577     // グローバル変数
    578     ////////////////////
    579 
    580     for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    581         if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
    582             && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
    583             ){
    584                 if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    585         }
    586     }
    587     if(i>=0){
    588         goto GlobalOk;
    589     }
    590 
    591 
    592     if(isErrorEnabled) SetError(3,variable,cp);
    593     pRelativeVar->dwKind=NON_VAR;
    594     return 0;
     573
     574        if(isErrorEnabled) SetError(3,variable,cp);
     575        pRelativeVar->dwKind=NON_VAR;
     576        return false;
     577
    595578
    596579
    597580GlobalOk:
    598 
    599     //ポインタ変数の場合
    600     if(IsPtrType(GlobalVar[i].type)){
    601         if(GlobalVar[i].SubScripts[0]==-1){
    602             lstrcpy(lpPtrOffset,array);
    603             array[0]=0;
    604         }
    605     }
    606     else{
    607         if(lpPtrOffset[0]){
    608             SetError(16,variable,cp);
    609             pRelativeVar->dwKind=NON_VAR;
    610             return 0;
    611         }
    612     }
    613 
    614     pRelativeVar->offset=GlobalVar[i].offset;
    615     pRelativeVar->bOffsetOffset=0;
    616     if(GlobalVar[i].fRef){
    617         // 参照型
    618         pRelativeVar->dwKind = VAR_REFGLOBAL;
    619     }
    620     else pRelativeVar->dwKind=VAR_GLOBAL;
    621     *pType=GlobalVar[i].type;
    622     lpIndex=GlobalVar[i].u.index;
    623     if(plpIndex) *plpIndex=lpIndex;
    624     pSubScripts=GlobalVar[i].SubScripts;
    625     bConst = GlobalVar[i].bConst;
     581        //ポインタ変数の場合
     582        if( pVar->IsPointer() ){
     583            if( !pVar->IsArray() ){
     584                lstrcpy(lpPtrOffset,array);
     585                array[0]=0;
     586            }
     587        }
     588        else{
     589            if(lpPtrOffset[0]){
     590                SetError(16,variable,cp);
     591                pRelativeVar->dwKind=NON_VAR;
     592                return false;
     593            }
     594        }
     595
     596        pRelativeVar->offset=pVar->offset;
     597        pRelativeVar->bOffsetOffset=0;
     598        if( pVar->IsRef() ){
     599            // 参照型
     600            pRelativeVar->dwKind = VAR_REFGLOBAL;
     601        }
     602        else pRelativeVar->dwKind=VAR_GLOBAL;
     603        resultType = *pVar;
     604        pSubScripts=pVar->GetSubScriptsPtr();
     605        bConst = pVar->IsConst();
     606    }
     607
    626608
    627609
     
    630612    if( bConst && isWriteAccess ){
    631613        //Const定義の変数に書き込みアクセスをしようとした場合
    632         if( *pType == DEF_OBJECT ){
     614        if( resultType.IsObject() ){
    633615            //オブジェクト定数
    634616            SetError(130, VarName, cp );
     
    642624    if(array[0]==0&&pSubScripts[0]!=-1){
    643625        //配列の先頭ポインタを示す場合
    644         *pType|=FLAG_PTR;
     626        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    645627        if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
    646         return 1;
     628        return true;
    647629    }
    648630
     
    655637    }
    656638    if(array[0]){
    657         if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
     639        if(!GetArrayOffset(pSubScripts,array,resultType)){
    658640            SetError(14,variable,cp);
    659641            pRelativeVar->dwKind=NON_VAR;
    660             return 0;
     642            return false;
    661643        }
    662644    }
    663645    if(member[0]){
    664         if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     646        if( resultType.IsObject() || resultType.IsStruct() ){
    665647            //実態オブジェクトのメンバを参照(obj.member)
    666648            if( refType != CClass::Dot ){
    667649                SetError(104,VarName,cp);
    668650                pRelativeVar->dwKind=NON_VAR;
    669                 return 0;
    670             }
    671 
    672             if( *pType==DEF_OBJECT ){
     651                return false;
     652            }
     653
     654            if( resultType.IsObject() ){
    673655                // 参照内容へのポインタを抽出
    674656                SetRelativeOffset( *pRelativeVar );
    675657            }
    676658        }
    677         else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
     659        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
    678660            //ポインタオブジェクトが示すメンバを参照
    679661            if(lpPtrOffset[0]){
     
    682664                    SetError(104,VarName,cp);
    683665                    pRelativeVar->dwKind=NON_VAR;
    684                     return 0;
     666                    return false;
    685667                }
    686                 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     668                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    687669                pRelativeVar->dwKind=VAR_DIRECTMEM;
    688670            }
     
    692674                    SetError(104,VarName,cp);
    693675                    pRelativeVar->dwKind=NON_VAR;
    694                     return 0;
     676                    return false;
    695677                }
    696678
     
    703685            }
    704686        }
    705         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
     687        else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) || resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    706688            //ポインタオブジェクトが示すメンバを参照
    707689            if(lpPtrOffset[0]){
     
    710692                    SetError(104,VarName,cp);
    711693                    pRelativeVar->dwKind=NON_VAR;
    712                     return 0;
     694                    return false;
    713695                }
    714696
    715                 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     697                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    716698                pRelativeVar->dwKind=VAR_DIRECTMEM;
    717699
     
    726708                SetError(104,VarName,cp);
    727709                pRelativeVar->dwKind=NON_VAR;
    728                 return 0;
     710                return false;
    729711            }
    730712        }
     
    732714            SetError(102,VarName,cp);
    733715            pRelativeVar->dwKind=NON_VAR;
    734             return 0;
    735         }
    736 
    737         LONG_PTR lp2;
    738         if(!GetMemberOffset(
     716            return false;
     717        }
     718
     719        if(!_member_offset(
    739720            isErrorEnabled,
    740721            isWriteAccess,
    741             (CClass *)lpIndex,
    742             member,pType,pRelativeVar,&lp2,0)) return 0;
    743         if(plpIndex) *plpIndex=lp2;
    744 
    745         return 1;
     722            resultType.GetClass(),
     723            member,pRelativeVar,resultType,0)) return false;
     724
     725        return true;
    746726    }
    747727
    748728    if(lpPtrOffset[0]){
    749         SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
     729        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    750730        pRelativeVar->dwKind=VAR_DIRECTMEM;
    751731    }
    752732
    753     return 1;
     733    return true;
    754734}
    755735
    756 BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
     736bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,char *InitBuf){
    757737    extern BYTE *initGlobalBuf;
    758     int i,i2,i3,TypeSize;
     738    int i,i2,i3;
    759739    char temporary[VN_SIZE];
    760740
     
    763743        InitBuf[lstrlen(InitBuf)-1]=0;
    764744
    765         TypeSize=GetTypeSize(type,lpIndex);
     745        int typeSize = type.GetSize();
    766746
    767747        if(SubScripts[0]!=-1){
    768             TypeSize*=JumpSubScripts(SubScripts+1);
     748            typeSize*=JumpSubScripts(SubScripts+1);
    769749            i=0;
    770750            i2=0;
     
    776756                i=GetOneParameter(InitBuf,i,temporary);
    777757                if(!SetInitGlobalData(
    778                     offset+i2*TypeSize,
     758                    offset+i2*typeSize,
    779759                    type,
    780                     lpIndex,
    781760                    SubScripts+1,
    782                     temporary)) return 0;
     761                    temporary)) return false;
    783762                i2++;
    784763                if(InitBuf[i]=='\0') break;
    785764            }
    786             return -1;
    787         }
    788 
    789         if(type==DEF_STRUCT){
    790             CClass *pobj_c;
    791             pobj_c=(CClass *)lpIndex;
    792 
    793             for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
     765            return true;
     766        }
     767
     768        if(type.IsStruct()){
     769            const CClass &objClass = type.GetClass();
     770
     771            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
    794772                i=GetOneParameter(InitBuf,i,temporary);
    795773
    796                 i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
     774                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
    797775
    798776                if(!SetInitGlobalData(offset+i3,
    799                     pobj_c->ppobj_Member[i2]->TypeInfo.type,
    800                     pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
    801                     pobj_c->ppobj_Member[i2]->SubScripts,
    802                     temporary)) return 0;
     777                    *objClass.ppobj_Member[i2],
     778                    objClass.ppobj_Member[i2]->SubScripts,
     779                    temporary)) return false;
    803780
    804781                if(InitBuf[i]=='\0') break;
    805782            }
    806             if(i2+1!=pobj_c->iMemberNum){
     783            if(i2+1!=objClass.iMemberNum){
    807784                SetError(41,0,cp);
    808                 return 0;
    809             }
    810             return 1;
     785                return false;
     786            }
     787            return true;
    811788        }
    812789
    813790        SetError(41,0,cp);
    814         return 0;
     791        return false;
    815792    }
    816793
     
    820797    ///////////////////////////////////////
    821798
    822     if( type == DEF_OBJECT || type == DEF_STRUCT ){
     799    if( type.IsObject() || type.IsStruct() ){
    823800        //オブジェクトまたは構造体の場合はありえない
    824801        SetError(300,NULL,cp);
    825         return 0;
     802        return false;
    826803    }
    827804
    828805    if(SubScripts[0]!=-1){
    829806        SetError(41,0,cp);
    830         return 0;
     807        return false;
    831808    }
    832809
    833810    double dbl;
    834811    _int64 i64data;
    835     int CalcType;
    836     LONG_PTR lpCalcIndex;
    837     CalcType=StaticCalculation(true, InitBuf,type,&i64data,&lpCalcIndex);
    838     if(IsRealNumberType(CalcType)){
     812    Type calcType;
     813
     814    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
     815        //動的データだった場合
     816        return false;
     817    }
     818    if( calcType.IsReal() ){
    839819        memcpy(&dbl,&i64data,sizeof(double));
    840820        i64data=(_int64)dbl;
     
    845825    CheckDifferentType(
    846826        type,
    847         lpIndex,
    848         CalcType,
    849         lpCalcIndex,
     827        calcType,
    850828        0,0);
    851829
    852     if(type==DEF_DOUBLE)
     830    if( type.IsDouble() ){
    853831        *(double *)(initGlobalBuf+offset)=(double)dbl;
    854     else if(type==DEF_SINGLE)
     832    }
     833    else if( type.IsSingle() ){
    855834        *(float *)(initGlobalBuf+offset)=(float)dbl;
    856     else if(type==DEF_INT64||type==DEF_QWORD)
     835    }
     836    else if( type.Is64() ){
    857837        *(_int64 *)(initGlobalBuf+offset)=i64data;
    858     else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
    859         if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
     838    }
     839    else if( type.IsLong() || type.IsDWord() || type.IsPointer() ){
     840        if(type.GetBasicType()==typeOfPtrChar&&calcType.GetIndex()==LITERAL_STRING){
    860841            //文字列定数のとき
    861842
     
    881862        }
    882863    }
    883     else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR))
     864    else if( type.IsWord() || type.IsInteger() ){
    884865        *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
    885     else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR))
     866    }
     867    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    886868        *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
    887     //String型が未完成
    888     return 1;
     869    }
     870
     871    return true;
    889872}
    890 BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
    891     int i,i2,i3,TypeSize;
     873bool InitLocalVar(int offset,const Type &type,const int *SubScripts,char *InitBuf){
     874    int i,i2,i3;
    892875    char temporary[VN_SIZE];
    893876
     
    896879        InitBuf[lstrlen(InitBuf)-1]=0;
    897880
    898         TypeSize=GetTypeSize(type,lpIndex);
     881        int typeSize = type.GetSize();
    899882
    900883        if(SubScripts[0]!=-1){
    901             TypeSize*=JumpSubScripts(SubScripts+1);
     884            typeSize*=JumpSubScripts(SubScripts+1);
    902885            i=0;
    903886            i2=0;
     
    905888                if(SubScripts[0]<i2){
    906889                    SetError(41,0,cp);
    907                     return 0;
     890                    return false;
    908891                }
    909892                i=GetOneParameter(InitBuf,i,temporary);
    910893                if(!InitLocalVar(
    911                     offset+i2*TypeSize,
     894                    offset+i2*typeSize,
    912895                    type,
    913                     lpIndex,
    914896                    SubScripts+1,
    915                     temporary)) return 0;
     897                    temporary)) return false;
    916898                i2++;
    917899                if(InitBuf[i]=='\0') break;
    918900            }
    919             return -1;
    920         }
    921 
    922         if(type==DEF_STRUCT){
    923             CClass *pobj_c;
    924             pobj_c=(CClass *)lpIndex;
    925 
    926             for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
     901            return true;
     902        }
     903
     904        if(type.IsStruct()){
     905            const CClass &objClass = type.GetClass();
     906
     907            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
    927908                i=GetOneParameter(InitBuf,i,temporary);
    928909
    929                 i3 = pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
     910                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
    930911
    931912                if(!InitLocalVar(offset+i3,
    932                     pobj_c->ppobj_Member[i2]->TypeInfo.type,
    933                     pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
    934                     pobj_c->ppobj_Member[i2]->SubScripts,
    935                     temporary)) return 0;
     913                    *objClass.ppobj_Member[i2],
     914                    objClass.ppobj_Member[i2]->SubScripts,
     915                    temporary)) return false;
    936916
    937917                if(InitBuf[i]=='\0') break;
    938918            }
    939             if(i2+1!=pobj_c->iMemberNum){
     919            if(i2+1!=objClass.iMemberNum){
    940920                SetError(41,0,cp);
    941921                return 0;
    942922            }
    943             return 1;
     923            return true;
    944924        }
    945925
    946926        SetError(41,0,cp);
    947         return 0;
     927        return false;
    948928    }
    949929
     
    955935    if(SubScripts[0]!=-1){
    956936        SetError(41,0,cp);
    957         return 0;
     937        return false;
    958938    }
    959939
    960940    double dbl;
    961941    _int64 i64data;
    962     int CalcType;
    963     LONG_PTR lpCalcIndex;
    964     CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
    965     if(!CalcType){
     942    Type calcType;
     943
     944    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
    966945        //動的データだった場合
    967         return 0;
    968     }
    969     if(IsRealNumberType(CalcType)){
     946        return false;
     947    }
     948    if( calcType.IsReal() ){
    970949        memcpy(&dbl,&i64data,sizeof(double));
    971950        i64data=(_int64)dbl;
     
    976955    CheckDifferentType(
    977956        type,
    978         lpIndex,
    979         CalcType,
    980         lpCalcIndex,
     957        calcType,
    981958        0,0);
    982959
    983     if(type==DEF_DOUBLE){
     960    if( type.IsDouble() ){
    984961        //mov eax,HILONG(dbl)
    985962        OpBuffer[obp++]=(char)0xB8;
     
    1006983        obp+=sizeof(long);
    1007984    }
    1008     else if(type==DEF_SINGLE){
     985    else if( type.IsSingle() ){
    1009986        float flt;
    1010987        flt=(float)dbl;
     
    1021998        obp+=sizeof(long);
    1022999    }
    1023     else if(type==DEF_INT64||type==DEF_QWORD){
     1000    else if( type.Is64() ){
    10241001        //mov eax,HILONG(i64data)
    10251002        OpBuffer[obp++]=(char)0xB8;
     
    10461023        obp+=sizeof(long);
    10471024    }
    1048     else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
    1049         if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
     1025    else if( type.IsDWord() || type.IsLong() || type.IsPointer() ){
     1026        if(type.GetBasicType()==typeOfPtrChar&&calcType.GetIndex()==LITERAL_STRING){
    10501027            //文字列定数のとき
    10511028
     
    10751052        obp+=sizeof(long);
    10761053    }
    1077     else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR)){
     1054    else if( type.IsWord() || type.IsInteger() ){
    10781055        //mov ax,InitValue
    10791056        OpBuffer[obp++]=(char)0x66;
     
    10901067        obp+=sizeof(long);
    10911068    }
    1092     else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR)){
     1069    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    10931070        //mov byte ptr[ebp+offset],InitValue
    10941071        OpBuffer[obp++]=(char)0xC6;
     
    11001077        obp+=sizeof(BYTE);
    11011078    }
    1102     //String型が未完成
    1103     return 1;
     1079
     1080    return true;
    11041081}
    11051082
    1106 void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
    1107     extern BOOL bCompilingGlobal;
    1108     if(bCompilingGlobal){
     1083void dim(bool isRef, char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
     1084    if( UserProc::IsGlobalAreaCompiling() ){
    11091085        /////////////////////////
    11101086        // グローバル変数
    11111087        /////////////////////////
    11121088
    1113         AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1089        AddGlobalVariable(isRef,VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
    11141090    }
    11151091    else{
     
    11181094        /////////////////
    11191095
    1120         int i2,i3;
    1121 
    1122         for(i2=0;i2<MaxLocalVarNum;i2++){
    1123             if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
    1124                 if(lstrcmp(LocalVar[i2].name,VarName)==0){
    1125                     //2重定義のエラー
    1126                     SetError(15,VarName,cp);
    1127                     return;
    1128                 }
    1129             }
    1130         }
    1131 
    1132         LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    1133         VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
    1134         MaxLocalVarNum++;
    1135 
    1136         if( isRef ){
    1137             //参照型
    1138             pVar->fRef = REF_VARIABLE;
    1139             TypeSize = PTR_SIZE;
    1140         }
    1141         else pVar->fRef=0;
    1142 
    1143         for(i2=1,i3=0;i3<255;i3++){
    1144             //配列要素数
    1145             pVar->SubScripts[i3]=SubScripts[i3];
    1146 
    1147             if(SubScripts[i3]==-1) break;
    1148             i2*=SubScripts[i3]+1;
    1149         }
    1150         int VarSize=TypeSize*i2;
    1151         if(VarSize%4) VarSize+=4-(VarSize%4);
    1152 
    1153         //変数データを追加
    1154         lstrcpy(pVar->name,VarName);
    1155         if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
    1156         else pVar->bConst = false;
    1157         if(SubScripts[0]==-1) pVar->bArray=0;
    1158         else pVar->bArray=1;
    1159         pVar->type=TypeInfo.type;
    1160         pVar->u.index=TypeInfo.u.lpIndex;
    1161         AllLocalVarSize+=VarSize;
    1162         pVar->offset=AllLocalVarSize;
     1096        if( UserProc::CompilingUserProc().localVars.BackSearch( VarName ) ){
     1097            //2重定義のエラー
     1098            SetError(15,VarName,cp);
     1099            return;
     1100        }
     1101
     1102        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
     1103
     1104        Variable *pVar = new Variable( VarName, type, isConst, isRef );
     1105
     1106        if( SubScripts[0] != -1 ){
     1107            //配列あり
     1108            pVar->SetArray( SubScripts );
     1109        }
     1110
     1111        //コンストラクタ用パラメータ
     1112        pVar->paramStrForConstructor = ConstractParameter;
    11631113
    11641114        //レキシカルスコープ
     
    11671117        pVar->bLiving=TRUE;
    11681118
     1119        //エラー用
     1120        pVar->source_code_address=cp;
     1121
     1122        // 変数を追加
     1123        UserProc::CompilingUserProc().localVars.push_back( pVar );
     1124
     1125        //アラインメントを考慮
     1126        if( pVar->IsStruct() ){
     1127            int alignment = pVar->GetClass().iAlign;
     1128            if( alignment ){
     1129                if( AllLocalVarSize % alignment ){
     1130                    AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
     1131                }
     1132            }
     1133        }
     1134
     1135        AllLocalVarSize += pVar->GetMemorySize();
     1136        pVar->offset = AllLocalVarSize;
     1137
     1138        //レキシカルスコープ
     1139        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
     1140        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1141        pVar->bLiving=TRUE;
     1142
    11691143        if(InitBuf[0]){
    11701144            //初期代入時のみ、書き込みアクセスを許可する
    1171             bool bConstBack = pVar->bConst;
    1172             pVar->bConst = false;
     1145            if( isConst ){
     1146                pVar->ConstOff();
     1147            }
    11731148
    11741149            int result = 0;
    1175             if( pVar->type != DEF_OBJECT ){
     1150            if( !pVar->IsObject() ){
    11761151                result = InitLocalVar(-pVar->offset,
    1177                     pVar->type,
    1178                     pVar->u.index,
    1179                     pVar->SubScripts,
     1152                    *pVar,
     1153                    pVar->GetSubScriptsPtr(),
    11801154                    InitBuf);
    11811155            }
     
    11881162            }
    11891163
    1190             pVar->bConst = bConstBack;
     1164            if( isConst ){
     1165                pVar->ConstOn();
     1166            }
    11911167        }
    11921168        else{
     
    11951171
    11961172            //push VarSize
    1197             op_push_V(VarSize);
     1173            op_push_V( pVar->GetMemorySize() );
    11981174
    11991175            //mov eax,ebp
     
    12131189            OpBuffer[obp++]=(char)0xFF;
    12141190            OpBuffer[obp++]=(char)0x15;
    1215             DECLAREINFO *pdi;
    1216             pdi=GetDeclareHash("FillMemory");
    1217             pdi->bUse=1;
    1218             pobj_ImportAddrSchedule->add(pdi);
     1191            DllProc *pDllProc = GetDeclareHash("FillMemory");
     1192            pDllProc->Using();
     1193            pobj_ImportAddrSchedule->add(pDllProc);
    12191194            obp+=sizeof(long);
    12201195        }
     
    12221197
    12231198    //New呼び出し
    1224     if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
     1199    if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
    12251200        char objectSize[255];
    12261201        if( SubScripts[0] == -1 ){
     
    12331208            sprintf( objectSize, "%d", SubScripts[0] );
    12341209        }
    1235         Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
     1210        Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
    12361211
    12371212        //pop eax
    12381213        op_pop( REG_EAX );
    12391214
    1240         int type;
    1241         LONG_PTR lpIndex;
    12421215        RELATIVE_VAR RelativeVar;
    1243         GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
     1216        GetVarOffset( true, false, VarName, &RelativeVar, Type() );
    12441217        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
    12451218            SetError();
     
    12481221    }
    12491222
    1250     if(TypeInfo.type==DEF_OBJECT){
    1251         if(TypeInfo.u.pobj_Class->IsAbstract()){
     1223    if( type.IsObject() ){
     1224        if( type.GetClass().IsAbstract() ){
    12521225            //抽象クラスだったとき
    1253             SetError(125,TypeInfo.u.pobj_Class->name,cp);
    1254         }
    1255     }
    1256 }
    1257 void dim(char *Parameter,DWORD dwFlags){
    1258     extern BOOL bCompilingGlobal;
    1259     extern HANDLE hHeap;
    1260     int i2;
    1261     char VarName[VN_SIZE];
    1262 
    1263 
    1264     //参照型かどうか
    1265     bool isRef = false;
    1266 
    1267     i2 = 0;
    1268 
    1269     if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
    1270         //参照型
    1271         isRef = true;
    1272         Parameter += 2;
    1273     }
    1274 
    1275 
    1276     if(dwFlags & DIMFLAG_CONST){
    1277         //////////////////////////////////
    1278         // 定数変数の場合を考慮
    1279         //////////////////////////////////
    1280         for(;;i2++){
    1281             if(Parameter[i2] == '=' ||
    1282                 Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
    1283                 Parameter[i2] =='('){
    1284                     VarName[i2] = 0;
    1285                     break;
    1286             }
    1287             VarName[i2] = Parameter[i2];
    1288         }
    1289 
    1290         //定数と2重定義されていないる場合は抜け出す
    1291         if(CDBConst::obj.GetType(VarName)){
    1292             return;
    1293         }
    1294 
    1295         //定数マクロとして定義されている場合は抜け出す
    1296         if(GetConstHash(VarName)){
    1297             return;
    1298         }
    1299     }
    1300 
    1301 
    1302     //構文を解析
    1303     int SubScripts[MAX_ARRAYDIM];
    1304     TYPEINFO TypeInfo;
    1305     char InitBuf[8192];
    1306     char ConstractParameter[VN_SIZE];
    1307     if(!GetDimentionFormat(Parameter, isRef, VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
    1308         return;
    1309 
    1310 
    1311     //定数と2重定義されていないかを調べる
    1312     if(CDBConst::obj.GetType(VarName)){
    1313         SetError(15,VarName,cp);
    1314         return;
    1315     }
    1316 
    1317     //定数マクロとして定義されている場合
    1318     if(GetConstHash(VarName)){
    1319         SetError(15,VarName,cp);
    1320         return;
    1321     }
    1322 
    1323 
    1324     //タイプサイズを取得
    1325     int TypeSize;
    1326     TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
    1327 
    1328     if(dwFlags&DIMFLAG_STATIC){
    1329         if(bCompilingGlobal){
    1330             SetError(60,NULL,cp);
    1331             return;
    1332         }
    1333 
    1334         /////////////////////
    1335         // Static変数
    1336         // ※"Static.Object.Method.Variable"
    1337         /////////////////////
    1338 
    1339         char temporary[VN_SIZE];
    1340         GetNowStaticVarFullName(VarName,temporary);
    1341 
    1342         dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    1343 
    1344         /*
    1345         Note: 静的変数のコンストラクタ呼び出しは
    1346             _System_InitStaticLocalVariables関数内で一括して行う
    1347         */
    1348     }
    1349     else{
    1350         dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    1351     }
    1352 }
    1353 void OpcodeDim(char *Parameter,DWORD dwFlags){
    1354     int i,i2,i3,IsStr=0;
    1355     char temporary[8192];
    1356 
    1357     for(i=0,i2=0;;i++,i2++){
    1358         if(Parameter[i]=='\"') IsStr^=1;
    1359         if(Parameter[i]=='('&&IsStr==0){
    1360             i3=GetStringInPare(temporary+i2,Parameter+i);
    1361             i+=i3-1;
    1362             i2+=i3-1;
    1363             continue;
    1364         }
    1365         if(Parameter[i]=='['&&IsStr==0){
    1366             i3=GetStringInBracket(temporary+i2,Parameter+i);
    1367             i+=i3-1;
    1368             i2+=i3-1;
    1369             continue;
    1370         }
    1371         if((Parameter[i]==','&&IsStr==0)||
    1372             Parameter[i]=='\0'){
    1373             temporary[i2]=0;
    1374 
    1375             dim(temporary,dwFlags);
    1376 
    1377             if(Parameter[i]=='\0') break;
    1378             i2=-1;
    1379             continue;
    1380         }
    1381         temporary[i2]=Parameter[i];
     1226            SetError(125,type.GetClass().name,cp);
     1227        }
    13821228    }
    13831229}
  • BasicCompiler32/MakePeHdr.cpp

    r73 r75  
    88// 特殊関数の構造体ポインタ
    99////////////////////////////
    10 SubInfo
     10UserProc
    1111    *pSub_System_StartupProgram,
    1212    *pSub_DebugSys_StartProc,
     
    150150
    151151    //関数ポインタ情報を初期化
    152     extern PROCPTRINFO *pProcPtrInfo;
     152    extern ProcPointer **ppProcPtrInfo;
    153153    extern int ProcPtrInfoNum;
    154     pProcPtrInfo=(PROCPTRINFO *)HeapAlloc(hHeap,0,1);
     154    ppProcPtrInfo=(ProcPointer **)HeapAlloc(hHeap,0,1);
    155155    ProcPtrInfoNum=0;
    156156
     
    184184
    185185    if(pSub_System_StartupProgram=GetSubHash("_System_StartupProgram",1))
    186         pSub_System_StartupProgram->bUse=1;
     186        pSub_System_StartupProgram->Using();
    187187
    188188    if(pSub_DebugSys_StartProc=GetSubHash("_DebugSys_StartProc",1))
    189         pSub_DebugSys_StartProc->bUse=1;
     189        pSub_DebugSys_StartProc->Using();
    190190
    191191    if(pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc",1))
    192         pSub_DebugSys_EndProc->bUse=1;
     192        pSub_DebugSys_EndProc->Using();
    193193
    194194    if(pSub_DebugSys_SaveContext=GetSubHash("_DebugSys_SaveContext",1))
    195         pSub_DebugSys_SaveContext->bUse=1;
     195        pSub_DebugSys_SaveContext->Using();
    196196
    197197    if(pSub_System_GetEip=GetSubHash("_System_GetEip",1)){
    198         pSub_System_GetEip->bUse=1;
    199         pSub_System_GetEip->bSystem=1;
     198        pSub_System_GetEip->Using();
     199        pSub_System_GetEip->ThisIsSystemProc();
    200200    }
    201201
    202202    if(pSub_System_InitDllGlobalVariables=GetSubHash("_System_InitDllGlobalVariables",1)){
    203         pSub_System_InitDllGlobalVariables->bUse=1;
    204         pSub_System_InitDllGlobalVariables->bSystem=1;
     203        pSub_System_InitDllGlobalVariables->Using();
     204        pSub_System_InitDllGlobalVariables->ThisIsSystemProc();
    205205    }
    206206
    207207    if(pSub_System_InitStaticLocalVariables=GetSubHash("_System_InitStaticLocalVariables",1)){
    208         pSub_System_InitStaticLocalVariables->bUse=1;
    209         pSub_System_InitStaticLocalVariables->bSystem=1;
     208        pSub_System_InitStaticLocalVariables->Using();
     209        pSub_System_InitStaticLocalVariables->ThisIsSystemProc();
    210210    }
    211211
    212212    if(pSub_System_Call_Destructor_of_GlobalObject=GetSubHash("_System_Call_Destructor_of_GlobalObject",1)){
    213         pSub_System_Call_Destructor_of_GlobalObject->bUse=1;
    214         pSub_System_Call_Destructor_of_GlobalObject->bSystem=1;
     213        pSub_System_Call_Destructor_of_GlobalObject->Using();
     214        pSub_System_Call_Destructor_of_GlobalObject->ThisIsSystemProc();
    215215    }
    216216
    217217    if(pSub_System_GetSp=GetSubHash("_System_GetSp",1)){
    218         pSub_System_GetSp->bUse=1;
    219         pSub_System_GetSp->bSystem=1;
     218        pSub_System_GetSp->Using();
     219        pSub_System_GetSp->ThisIsSystemProc();
    220220    }
    221221
    222222    if(pSub_pow=GetSubHash("pow",1))
    223         pSub_pow->bUse=1;
     223        pSub_pow->Using();
    224224
    225225    if(pSub_calloc=GetSubHash("calloc",1))
    226         pSub_calloc->bUse=1;
     226        pSub_calloc->Using();
    227227
    228228    if(pSub_realloc=GetSubHash("realloc",1))
    229         pSub_realloc->bUse=1;
     229        pSub_realloc->Using();
    230230
    231231    if(pSub_free=GetSubHash("free",1))
    232         pSub_free->bUse=1;
     232        pSub_free->Using();
    233233
    234234    if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
    235         pSub_System_GC_malloc_ForObject->bUse = 1;
     235        pSub_System_GC_malloc_ForObject->Using();
    236236
    237237    if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
    238         pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
     238        pSub_System_GC_malloc_ForObjectPtr->Using();
    239239
    240240    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
    241         pSub_System_GC_free_for_SweepingDelete->bUse = 1;
     241        pSub_System_GC_free_for_SweepingDelete->Using();
    242242
    243243    pSub_allrem=GetSubHash("_allrem");
    244     pSub_allrem->bUse=1;
    245     pSub_allrem->bSystem=1;
     244    pSub_allrem->Using();
     245    pSub_allrem->ThisIsSystemProc();
    246246
    247247    pSub_aullrem=GetSubHash("_aullrem");
    248     pSub_aullrem->bUse=1;
    249     pSub_aullrem->bSystem=1;
     248    pSub_aullrem->Using();
     249    pSub_aullrem->ThisIsSystemProc();
    250250
    251251    pSub_allmul=GetSubHash("_allmul");
    252     pSub_allmul->bUse=1;
    253     pSub_allmul->bSystem=1;
     252    pSub_allmul->Using();
     253    pSub_allmul->ThisIsSystemProc();
    254254
    255255    pSub_alldiv=GetSubHash("_alldiv");
    256     pSub_alldiv->bUse=1;
    257     pSub_alldiv->bSystem=1;
     256    pSub_alldiv->Using();
     257    pSub_alldiv->ThisIsSystemProc();
    258258
    259259    pSub_aulldiv=GetSubHash("_aulldiv");
    260     pSub_aulldiv->bUse=1;
    261     pSub_aulldiv->bSystem=1;
     260    pSub_aulldiv->Using();
     261    pSub_aulldiv->ThisIsSystemProc();
    262262
    263263    pSub_allshl=GetSubHash("_allshl");
    264     pSub_allshl->bUse=1;
    265     pSub_allshl->bSystem=1;
     264    pSub_allshl->Using();
     265    pSub_allshl->ThisIsSystemProc();
    266266
    267267    pSub_allshr=GetSubHash("_allshr");
    268     pSub_allshr->bUse=1;
    269     pSub_allshr->bSystem=1;
     268    pSub_allshr->Using();
     269    pSub_allshr->ThisIsSystemProc();
    270270
    271271    pSub_aullshr=GetSubHash("_aullshr");
    272     pSub_aullshr->bUse=1;
    273     pSub_aullshr->bSystem=1;
     272    pSub_aullshr->Using();
     273    pSub_aullshr->ThisIsSystemProc();
    274274
    275275    pSub_esp_error=GetSubHash("_esp_error");
    276     pSub_esp_error->bUse=1;
     276    pSub_esp_error->Using();
    277277
    278278
     
    391391
    392392        //call _System_Call_Destructor_of_GlobalObject
    393         extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
     393        extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
    394394        op_call(pSub_System_Call_Destructor_of_GlobalObject);
    395395
     
    425425    for(i=0;i<SynonymErrorNum;i++) HeapDefaultFree(SynonymErrorWords[i]);
    426426    HeapDefaultFree(SynonymErrorWords);
     427    SynonymErrorWords=0;
    427428
    428429
     
    451452    ////////////////////////////////
    452453    for(i=0;i<MAX_HASH;i++){
    453         extern DECLAREINFO **ppDeclareHash;
    454         DECLAREINFO *pdi;
    455         pdi=ppDeclareHash[i];
    456         while(pdi){
    457             if(pdi->bUse==0){
    458                 pdi=pdi->pNextData;
     454        extern DllProc **ppDeclareHash;
     455        const DllProc *pDllProc = ppDeclareHash[i];
     456        while(pDllProc){
     457            if( !pDllProc->IsUsing() ){
     458                pDllProc=pDllProc->pNextData;
    459459                continue;
    460460            }
     
    462462            //エラーチェック
    463463            HINSTANCE hLib;
    464             hLib=LoadLibrary(pdi->file);
     464            hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() );
    465465            if(!hLib){
    466466                extern char OutputFileName[MAX_PATH];
     
    468468                _splitpath(OutputFileName,temp2,temp3,NULL,NULL);
    469469                lstrcat(temp2,temp3);
    470                 lstrcpy(temp3,pdi->file);
     470                lstrcpy(temp3,pDllProc->GetDllFileName().c_str());
    471471                GetFullPath(temp3,temp2);
    472472                hLib=LoadLibrary(temp3);
    473473
    474474                if(!hLib){
    475                     SetError(-106,pdi->file,pdi->pos);
     475                    SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
    476476                }
    477477            }
    478478
    479479            if(hLib){
    480                 if(!GetProcAddress(hLib,pdi->alias)){
     480                if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
    481481                    FreeLibrary(hLib);
    482                     SetError(-107,pdi->alias,pdi->pos);
     482                    SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
    483483                }
    484484                FreeLibrary(hLib);
    485485            }
    486486
    487             pdi=pdi->pNextData;
     487            pDllProc=pDllProc->pNextData;
    488488        }
    489489    }
     
    522522        ExportNamesLength=lstrlen(lpExportNames)+1;
    523523
    524         extern SubInfo **ppSubHash;
    525         SubInfo *psi,*psi2;
     524        extern UserProc **ppSubHash;
     525        UserProc *pUserProc,*psi2;
    526526        while(1){
    527527            //辞書順にサーチ
    528528            temporary[0]=0;
    529529            for(i=0,psi2=0;i<MAX_HASH;i++){
    530                 psi=ppSubHash[i];
    531                 while(psi){
    532                     if(psi->bExport){
     530                pUserProc=ppSubHash[i];
     531                while(pUserProc){
     532                    if(pUserProc->IsExport()){
    533533                        if(temporary[0]=='\0'){
    534                             lstrcpy(temporary,psi->name);
    535                             psi2=psi;
     534                            lstrcpy(temporary,pUserProc->GetName().c_str());
     535                            psi2=pUserProc;
    536536                        }
    537537                        else{
    538538                            i3=lstrlen(temporary);
    539                             i4=lstrlen(psi->name);
     539                            i4=(int)pUserProc->GetName().size();
    540540                            if(i3<i4) i3=i4;
    541                             if(memcmp(temporary,psi->name,i3)>0){
    542                                 lstrcpy(temporary,psi->name);
    543                                 psi2=psi;
     541                            if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
     542                                lstrcpy(temporary,pUserProc->GetName().c_str());
     543                                psi2=pUserProc;
    544544                            }
    545545                        }
    546546                    }
    547                     psi=psi->pNextData;
     547                    pUserProc=pUserProc->pNextData;
    548548                }
    549549            }
    550550            if(psi2==0) break;
    551             psi=psi2;
    552 
    553             psi->bExport=0;
    554 
    555             if(lstrcmpi(psi->name,"DllMain")==0)
    556                 DllMain_EntryPoint=psi->CompileAddress;
     551            pUserProc=psi2;
     552
     553            pUserProc->ExportOff();
     554
     555            if( pUserProc->GetName() == "DllMain" ){
     556                DllMain_EntryPoint=pUserProc->beginOpAddress;
     557            }
    557558
    558559            lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
    559             lpdwExportAddressTable[ExportNum]=psi->CompileAddress;
     560            lpdwExportAddressTable[ExportNum]=pUserProc->beginOpAddress;
    560561
    561562            lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
     
    565566            lpwExportOrdinalTable[ExportNum]=ExportNum;
    566567
    567             lstrcpy(lpExportNames+ExportNamesLength,psi->name);
     568            lstrcpy(lpExportNames+ExportNamesLength,pUserProc->GetName().c_str());
    568569            ExportNamesLength+=lstrlen(lpExportNames+ExportNamesLength)+1;
    569570
     
    598599    //インポートDLL情報
    599600    /////////////////////
    600     extern DECLAREINFO **ppDeclareHash;
    601     DECLAREINFO *pdi;
     601    extern DllProc **ppDeclareHash;
    602602    char **ppDllNames;
    603603    int ImportDllNum;
     
    621621    ImportDllNum=0;
    622622    for(i=0;i<MAX_HASH;i++){
    623         pdi=ppDeclareHash[i];
    624         while(pdi){
    625             if(pdi->dwType==DECLARE_STATIC||
    626                 pdi->bUse==0){
    627                 pdi=pdi->pNextData;
     623        const DllProc *pDllProc=ppDeclareHash[i];
     624        while(pDllProc){
     625            if( !pDllProc->IsUsing() ){
     626                pDllProc=pDllProc->pNextData;
    628627                continue;
    629628            }
    630629
    631             if(lstrlen(pdi->file)>16){
     630            if( pDllProc->GetDllFileName().size() > 16 ){
    632631                SetError(7,NULL,cp);
    633632                break;
    634633            }
    635634            for(i2=0;i2<ImportDllNum;i2++){
    636                 if(lstrcmp(ppDllNames[i2],pdi->file)==0) break;
     635                if( pDllProc->GetDllFileName() == ppDllNames[i2] ){
     636                    break;
     637                }
    637638            }
    638639            if(i2==ImportDllNum){
    639640                ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **));
    640641                ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16);
    641                 lstrcpy(ppDllNames[ImportDllNum],pdi->file);
     642                lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str());
    642643                ImportDllNum++;
    643644            }
    644645
    645             pdi=pdi->pNextData;
     646            pDllProc=pDllProc->pNextData;
    646647        }
    647648    }
     
    660661        pImportTable[i].Name=i3+i*0x10;
    661662        for(i2=0;i2<MAX_HASH;i2++){
    662             pdi=ppDeclareHash[i2];
    663             while(pdi){
    664                 if(pdi->dwType==DECLARE_STATIC||
    665                     pdi->bUse==0){
    666                     pdi=pdi->pNextData;
     663            const DllProc *pDllProc=ppDeclareHash[i2];
     664            while(pDllProc){
     665                if( !pDllProc->IsUsing() ){
     666                    pDllProc=pDllProc->pNextData;
    667667                    continue;
    668668                }
    669669
    670                 if(lstrcmp(ppDllNames[i],pdi->file)==0){
     670                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    671671                    //ルックアップデータのサイズを追加
    672672                    LookupSize+=sizeof(DWORD);
    673673                }
    674674
    675                 pdi=pdi->pNextData;
     675                pDllProc=pDllProc->pNextData;
    676676            }
    677677        }
     
    691691    for(i=0,i5=0;i<ImportDllNum;i++){
    692692        for(i2=0;i2<MAX_HASH;i2++){
    693             pdi=ppDeclareHash[i2];
    694             while(pdi){
    695                 if(pdi->dwType==DECLARE_STATIC||
    696                     pdi->bUse==0){
    697                     pdi=pdi->pNextData;
     693            DllProc *pDllProc=ppDeclareHash[i2];
     694            while(pDllProc){
     695                if( !pDllProc->IsUsing() ){
     696                    pDllProc=pDllProc->pNextData;
    698697                    continue;
    699698                }
    700699
    701                 if(lstrcmp(ppDllNames[i],pdi->file)==0){
     700                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    702701                    //ルックアップの位置をセット(後にインポート アドレス テーブルにセットしなおされる)
    703                     pdi->LookupAddress=i3+(i5*sizeof(DWORD));
     702                    pDllProc->SetLookupAddress( i3+(i5*sizeof(DWORD)) );
    704703
    705704                    //ルックアップ テーブル
     
    709708                    pHintTable[HintSize++]=0;
    710709                    pHintTable[HintSize++]=0;
    711                     lstrcpy(pHintTable+HintSize,pdi->alias);
    712                     i4=lstrlen(pdi->alias);
     710                    lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str());
     711                    i4=(int)pDllProc->GetAlias().size();
    713712                    HintSize+=i4+1;
    714713                    if(i4%2==0) pHintTable[HintSize++]=0;
     
    720719                }
    721720
    722                 pdi=pdi->pNextData;
     721                pDllProc=pDllProc->pNextData;
    723722            }
    724723        }
     
    993992
    994993        for(i2=0;i2<MAX_HASH;i2++){
    995             pdi=ppDeclareHash[i2];
    996             while(pdi){
    997                 if(pdi->bUse==0){
    998                     pdi=pdi->pNextData;
     994            const DllProc *pDllProc=ppDeclareHash[i2];
     995            while(pDllProc){
     996                if( !pDllProc->IsUsing() ){
     997                    pDllProc=pDllProc->pNextData;
    999998                    continue;
    1000999                }
    10011000
    1002                 if(lstrcmp(ppDllNames[i],pdi->file)==0){
     1001                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
    10031002                    //ルックアップ テーブル
    10041003                    pLookupTable[i5++]+=MemPos_ImportSection;
    10051004                }
    10061005
    1007                 pdi=pdi->pNextData;
     1006                pDllProc=pDllProc->pNextData;
    10081007            }
    10091008        }
     
    10281027    // インポートテーブルスケジュール(インポート アドレス テーブルを指し示させる)
    10291028    for(i=0;i<pobj_ImportAddrSchedule->num;i++){
    1030         DECLAREINFO *pdi;
    1031         pdi=pobj_ImportAddrSchedule->ppdi[i];
     1029        const DllProc *pDllProc=pobj_ImportAddrSchedule->ppdi[i];
    10321030        *((long *)(OpBuffer+pobj_ImportAddrSchedule->pObpValues[i]))=
    10331031            ImageBase+
     
    10351033            LookupSize+         //ルックアップテーブル
    10361034            HintSize+           //ヒント名(関数名)テーブル
    1037             pdi->LookupAddress;
     1035            pDllProc->GetLookupAddress();
    10381036    }
    10391037    delete pobj_ImportAddrSchedule;
     
    10431041    // プロシージャポインタスケジュール
    10441042    for(i=0;i<pobj_SubAddrSchedule->num;i++){
    1045         if(pobj_SubAddrSchedule->ppsi[i]->CompileAddress==0
    1046             &&pobj_SubAddrSchedule->ppsi[i]->EndOpAddr==0){
     1043        if(pobj_SubAddrSchedule->ppsi[i]->beginOpAddress==0
     1044            &&pobj_SubAddrSchedule->ppsi[i]->endOpAddress==0){
    10471045            SetError(300,NULL,-1);
    10481046        }
     
    10501048        if(pobj_SubAddrSchedule->pbCall[i]){
    10511049            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1052                 pobj_SubAddrSchedule->ppsi[i]->CompileAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
     1050                pobj_SubAddrSchedule->ppsi[i]->beginOpAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
    10531051        }
    10541052        else{
    10551053            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1056                 pobj_SubAddrSchedule->ppsi[i]->CompileAddress+ImageBase+MemPos_CodeSection;
     1054                pobj_SubAddrSchedule->ppsi[i]->beginOpAddress+ImageBase+MemPos_CodeSection;
    10571055        }
    10581056    }
  • BasicCompiler32/NumOpe.cpp

    r69 r75  
    7878
    7979    extern CClass *pobj_StringClass;
    80     TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
     80    Type baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
    8181    Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
    8282
     
    9797    if(Command[0]==1&& Command[1]==ESC_NEW ){
    9898        //New演算子(オブジェクト生成)
    99         TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
     99        Type baseTypeInfo = { BaseType, lpBaseIndex };
    100100        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
    101101
     
    157157            if(type[sp-2]==DEF_OBJECT){
    158158                //オーバーロードされたオペレータを呼び出す
    159                 TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
     159                Type BaseTypeInfo={BaseType,lpBaseIndex};
    160160                i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
    161161                if(i2==0){
     
    195195                        CClass *pobj_Class;
    196196                        pobj_Class=(CClass *)lpBaseIndex;
    197                         TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
     197                        Type BaseTypeInfo = {BaseType,lpBaseIndex};
    198198                        if(IsStringObjectType(BaseTypeInfo)){
    199199                            //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
     
    342342                        i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
    343343                        if(i2==DEF_OBJECT){
    344                             TYPEINFO RetTypeInfo;
     344                            Type RetTypeInfo;
    345345                            CallIndexerGetterProc(pobj_c,variable,array_element,RetTypeInfo);
    346346                            type[sp]=RetTypeInfo.type;
     
    500500
    501501                    if(GetSubHash(VarName,0)){
    502                         TYPEINFO RetTypeInfo;
     502                        Type RetTypeInfo;
    503503                        CallPropertyMethod(term,NULL,&RetTypeInfo);
    504504
  • BasicCompiler32/NumOpe_Arithmetic.cpp

    r73 r75  
    270270
    271271            //call _allmul
    272             extern SubInfo *pSub_allmul;
     272            extern UserProc *pSub_allmul;
    273273            op_call(pSub_allmul);
    274274
     
    460460
    461461            //call _aullrem
    462             extern SubInfo *pSub_aullrem;
     462            extern UserProc *pSub_aullrem;
    463463            op_call(pSub_aullrem);
    464464        }
     
    467467
    468468            //call _allrem
    469             extern SubInfo *pSub_allrem;
     469            extern UserProc *pSub_allrem;
    470470            op_call(pSub_allrem);
    471471        }
     
    720720
    721721            //call _aulldiv
    722             extern SubInfo *pSub_aulldiv;
     722            extern UserProc *pSub_aulldiv;
    723723            op_call(pSub_aulldiv);
    724724        }
     
    727727
    728728            //call _alldiv
    729             extern SubInfo *pSub_alldiv;
     729            extern UserProc *pSub_alldiv;
    730730            op_call(pSub_alldiv);
    731731        }
     
    10001000
    10011001    //call pow
    1002     extern SubInfo *pSub_pow;
     1002    extern UserProc *pSub_pow;
    10031003    op_call(pSub_pow);
    10041004
     
    11561156
    11571157        //call _allshl
    1158         extern SubInfo *pSub_allshl;
     1158        extern UserProc *pSub_allshl;
    11591159        op_call(pSub_allshl);
    11601160
     
    13611361
    13621362            //call _aullshr
    1363             extern SubInfo *pSub_aullshr;
     1363            extern UserProc *pSub_aullshr;
    13641364            op_call(pSub_aullshr);
    13651365        }
     
    13681368
    13691369            //call _allshr
    1370             extern SubInfo *pSub_allshr;
     1370            extern UserProc *pSub_allshr;
    13711371            op_call(pSub_allshr);
    13721372        }
  • BasicCompiler32/Opcode.h

    r73 r75  
    102102//NumOpe.cpp
    103103void PushReturnValue(int type);
    104 int NumOpe(const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap=0);
     104bool NumOpe( const char *Command,
     105           const Type &baseType,
     106           Type &resultType,
     107           BOOL *pbUseHeap = NULL );
    105108
    106109//NumOpe_Arithmetic.cpp
     
    136139//Compile_Set_Var.cpp
    137140BOOL IsUse_ecx(RELATIVE_VAR *pRelativeVar);
    138 void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
     141void SetStructVariable( const Type &varType, const Type &calcType, BOOL bUseHeap);
    139142void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
    140143void SetWholeVariable( int varSize,int calcType, RELATIVE_VAR *pRelative );
     
    174177
    175178//Compile_Object.cpp
    176 void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo );
    177 int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo );
     179void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType );
    178180void OpcodeDelete(const char *Parameter, bool isSweeping);
    179181
     
    182184void GetWithName(char *buffer);
    183185void SetThisPtrToReg(int reg);
    184 BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss=0);
    185 BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf);
     186bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = 0);
     187bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,char *InitBuf);
    186188#define DIMFLAG_INITDEBUGVAR            1
    187189#define DIMFLAG_NONCALL_CONSTRACTOR     2
    188190#define DIMFLAG_STATIC                  4
    189191#define DIMFLAG_CONST                   8
    190 void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
    191 void OpcodeDim(char *Parameter,DWORD dwFlag);
     192void dim(bool isRef, char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
    192193void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
    193194
     
    201202class ParamImpl{
    202203    char *Parms[255];
    203     TYPEINFO types[255];
     204    Type types[255];
    204205    int ParmsNum;
    205206
    206     TYPEINFO ReturnTypeInfo;
     207    Type ReturnTypeInfo;
    207208
    208209    //一時オブジェクト管理用
     
    213214public:
    214215    ParamImpl(const char *buffer);
    215     ParamImpl(const PARAMETER_INFO *pParamInfo, const int ParmNum);
    216     ParamImpl::ParamImpl(const Parameters &params);
     216    ParamImpl(const Parameters &params);
    217217    ~ParamImpl();
    218     void SetReturnType(TYPEINFO *pTypeInfo);
     218    void SetReturnType( const Type &returnType );
    219219
    220220private:
    221     BOOL _overload_check( Parameters &params,TYPEINFO *pReturnTypeInfo,int overload_level);
    222     SubInfo *OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs );
     221    BOOL _overload_check( const Parameters &params,Type *pReturnTypeInfo,int overload_level);
     222    UserProc *OverloadSolutionWithReturnType( const char *name, std::vector<UserProc *> &subs );
    223223public:
    224     SubInfo *OverloadSolution( const char *name, std::vector<SubInfo *> &subs );
    225 
    226     BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    227     bool ErrorCheck( const char *procName, const Parameters &params, int SecondParmNum );
    228     void MacroParameterSupport(PARAMETER_INFO *ppi);
     224    UserProc *OverloadSolution( const char *name, std::vector<UserProc *> &subs );
     225
     226    bool ErrorCheck( const string &procName, const Parameters &params, int SecondParmNum = -1 );
    229227    void MacroParameterSupport( const Parameters &params );
    230228    void SetStructParameter(CClass *pobj_Class,LPSTR Parameter);
    231     int SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    232     int SetParameter( const char *procName, const Parameters &params, int SecondParmNum );
     229    int SetParameter( const string &procName, const Parameters &params, int SecondParmNum = -1 );
    233230
    234231    //一時オブジェクトパラメータの生成と破棄
    235     int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
    236     int NewTempParameters( const char *procName, const Parameters &params, int SecondParmNum );
     232    int NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum = -1 );
    237233    void DeleteTempParameters();
    238234};
     
    241237void AddLocalVarAddrSchedule();
    242238#define PROCFLAG_NEW    1
    243 int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
    244 void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType);
    245 int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
     239int Opcode_CallProcPtr(char *variable,char *Parameter,ProcPointer *pProcPointer,LONG_PTR *plpIndex);
     240void Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,char *ObjectName,int RefType);
     241int Opcode_CallDllProc(char *Parameter,DllProc *pDllProc,LONG_PTR *plpIndex);
    246242
    247243//Compile_ProcOp.cpp
     
    251247int GetFunctionType(int FuncNum);
    252248int GetFunctionFromName(char *FuncName);
    253 void Opcode_CallFunc( const char *Parameter, const int FuncNum, TYPEINFO &ReturnTypeInfo );
     249void Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &ReturnTypeInfo );
    254250
    255251//OperatorProc.cpp
    256252void FreeTempObject(int reg,CClass *pobj_c);
    257 int CallOperatorProc(int idCalc,TYPEINFO *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
    258 void CallCastOperatorProc(int &CalcType,LONG_PTR &lpCalcIndex,BOOL bCalcUseHeap,int ToType,LONG_PTR lpToIndex);
    259 void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo);
     253int CallOperatorProc(int idCalc,Type *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
     254void CallCastOperatorProc(Type &calcType,BOOL bCalcUseHeap,const Type &toType);
     255void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,Type &RetTypeInfo);
    260256
    261257//Compile_Statement.cpp
     
    268264void OpcodeContinue(void);
    269265void OpcodeExitSub(void);
    270 void OpcodeSelect(char *Parameter);
     266void OpcodeSelect(const char *Parameter);
    271267void OpcodeCase(char *Parameter);
    272268void OpcodeGosub(char *Parameter);
     
    344340void fpu_cast_end();
    345341
    346 void op_call(SubInfo *psi);
     342void op_call(UserProc *pUserProc);
  • BasicCompiler32/OperatorProc.cpp

    r73 r75  
    1111
    1212        //call DestructorProcAddr
    13         op_call( method->psi );
     13        op_call( method->pUserProc );
    1414    }
    1515
     
    1818
    1919    //call free
    20     extern SubInfo *pSub_free;
     20    extern UserProc *pSub_free;
    2121    op_call(pSub_free);
    2222}
    2323
    24 int CallOperatorProc(int idCalc,TYPEINFO *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
     24int CallOperatorProc(int idCalc,Type *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
    2525    //オーバーロードされたオペレータ関数を呼び出す
    2626    CClass *pobj_c;
    2727    pobj_c=(CClass *)index_stack[sp-2];
    2828
    29     std::vector<SubInfo *> subs;
     29    std::vector<UserProc *> subs;
    3030    pobj_c->EnumMethod( idCalc, subs );
    3131    if( subs.size() == 0 ){
     
    4141    int i;
    4242    BOOL bReturnTypeIsObject=1;
    43     TYPEINFO ReturnType={DEF_OBJECT,subs[0]->u.ReturnIndex};
    44     foreach( SubInfo *psi, subs ){
    45         if(psi->ReturnType!=DEF_OBJECT)
     43    Type ReturnType={DEF_OBJECT,subs[0]->ReturnType().GetIndex()};
     44    foreach( UserProc *pUserProc, subs ){
     45        if(pUserProc->ReturnType().IsObject())
    4646            bReturnTypeIsObject=0;
    4747    }
     
    6161    /////////////////////////////////////////////
    6262
    63     PARAMETER_INFO *ppi = (PARAMETER_INFO *)HeapAlloc(hHeap,0,sizeof(PARAMETER_INFO)*3);
    64     int iParmNum=0;
    65 
    66     if(bTwoTerm){
    67         ppi[iParmNum].bArray=0;
    68         ppi[iParmNum].bByVal=0;
    69         ppi[iParmNum].name=0;
    70         ppi[iParmNum].type=type[sp-1];
    71         ppi[iParmNum].u.index=index_stack[sp-1];
    72         ppi[iParmNum].SubScripts[0]=-1;
    73         iParmNum++;
    74     }
    75 
     63    Parameters params;
     64
     65    if(bTwoTerm){
     66        params.push_back( new Parameter( "", Type( type[sp-1], index_stack[sp-1] ) ) );
     67    }
    7668
    7769    //オーバーロードを解決
     
    7971    if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
    8072    else GetCalcName(idCalc,temporary);
    81     SubInfo *psi;
    82     psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
    83 
    84     if(!psi){
    85         HeapDefaultFree(ppi);
     73    Type returnType;
     74    if( pBaseTypeInfo ){
     75        returnType.SetBasicType( pBaseTypeInfo->type );
     76        returnType.SetIndex( pBaseTypeInfo->u.lpIndex );
     77    }
     78    UserProc *pUserProc = OverloadSolution( temporary, subs, params, returnType );
     79
     80    if(!pUserProc){
     81        if(bTwoTerm){
     82            delete params[0];
     83        }
    8684        return -1;
    8785    }
    8886    else{
    8987        //オーバーロードされていないが、パラメータ個数が一致しないとき
    90         if(iParmNum!=psi->params.size()){
    91             HeapDefaultFree(ppi);
     88        if(params.size()!=pUserProc->Params().size()){
     89            if(bTwoTerm){
     90                delete params[0];
     91            }
    9292            return -1;
    9393        }
    9494    }
    9595
    96     for(i=0;i<iParmNum;i++){
     96    for(i=0;i<(int)params.size();i++){
    9797        CheckDifferentType(
    98             psi->params[i]->GetBasicType(),
    99             psi->params[i]->GetIndex(),
    100             ppi[i].type,
    101             ppi[i].u.index,
     98            pUserProc->Params()[i]->GetBasicType(),
     99            pUserProc->Params()[i]->GetIndex(),
     100            params[i]->GetBasicType(),
     101            params[i]->GetIndex(),
    102102            "",
    103103            i);
    104104    }
    105105
    106     HeapDefaultFree(ppi);
     106    if(bTwoTerm){
     107        delete params[0];
     108    }
    107109
    108110    int right_side_size = GetTypeSize(type[sp-1],index_stack[sp-1]);
    109111
    110112    if(bTwoTerm){
    111         if( psi->realParams[1]->IsStruct() &&psi->realParams[1]->IsRef() == false ){
     113        if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){
    112114            //一時オブジェクトはメソッド内で破棄される
    113115            bUseHeap[sp-1]=0;
     
    116118
    117119
    118     if(psi->ReturnType==DEF_STRUCT){
     120    if( pUserProc->ReturnType().IsStruct() ){
    119121        //////////////////////////////////////////////////////
    120122        // 戻り値に構造体インスタンスを持つ場合
     
    122124        //////////////////////////////////////////////////////
    123125
    124         int object_size = psi->u.Return_pobj_c->GetSize();
     126        int object_size = pUserProc->ReturnType().GetClass().GetSize();
    125127
    126128        //push object_size
     
    128130
    129131        //call calloc
    130         extern SubInfo *pSub_calloc;
     132        extern UserProc *pSub_calloc;
    131133        op_call(pSub_calloc);
    132134
     
    180182        }
    181183
    182         if( psi->realParams[1]->IsRef() ){
     184        if( pUserProc->RealParams()[1]->IsRef() ){
    183185            //一時参照を作成
    184186
     
    191193    }
    192194
    193     if(psi->ReturnType==DEF_STRUCT){
     195    if( pUserProc->ReturnType().IsStruct() ){
    194196        //push ebx
    195197        op_push(REG_EBX);
     
    200202
    201203    //call operator_proc
    202     op_call(psi);
    203 
    204     if(bTwoTerm){
    205         if( psi->realParams[1]->IsRef() ){
     204    op_call(pUserProc);
     205
     206    if(bTwoTerm){
     207        if( pUserProc->RealParams()[1]->IsRef() ){
    206208            //一時参照を破棄
    207209            op_pop( REG_NON );
     
    209211    }
    210212
    211     if(psi->ReturnType!=DEF_NON){
     213    if( !pUserProc->ReturnType().IsNull() ){
    212214        //スタックへプッシュ
    213         PushReturnValue(psi->ReturnType);
     215        PushReturnValue(pUserProc->ReturnType().GetBasicType());
    214216    }
    215217
     
    222224
    223225    sp--;
    224     type[sp-1]=psi->ReturnType;
    225     index_stack[sp-1]=psi->u.ReturnIndex;
    226 
    227     if(psi->ReturnType==DEF_STRUCT){
     226    type[sp-1]=pUserProc->ReturnType().GetBasicType();
     227    index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
     228
     229    if( pUserProc->ReturnType().IsStruct() ){
    228230        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    229231        //※後にfreeする必要あり
     
    254256    array_bUseHeap[1]=0;
    255257
    256     TYPEINFO BaseTypeInfo={ToType,lpToIndex};
     258    Type BaseTypeInfo={ToType,lpToIndex};
    257259
    258260    int iRet;
     
    272274    SetError(-1,"キャスト演算子がオーバーロードされていません。",cp);
    273275}
    274 void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo){
    275     std::vector<SubInfo *> subs;
     276void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,Type &RetTypeInfo){
     277    std::vector<UserProc *> subs;
    276278    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
    277279    if( subs.size() == 0 ){
     
    280282
    281283    Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
    282     RetTypeInfo.type = subs[0]->ReturnType;
    283     RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
    284 }
     284    RetTypeInfo.type = subs[0]->ReturnType().GetBasicType();
     285    RetTypeInfo.u.lpIndex = subs[0]->ReturnType().GetIndex();
     286}
  • BasicCompiler32/VarList.cpp

    r73 r75  
    348348    if(pobj_dti->lplpSpBase[i2]==0) return;
    349349
    350     extern SubInfo **ppSubHash;
    351     SubInfo *psi;
     350    extern UserProc **ppSubHash;
     351    UserProc *pUserProc;
    352352    for(i3=0,sw=0;i3<MAX_HASH;i3++){
    353         psi=ppSubHash[i3];
    354         while(psi){
    355             if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
    356                 pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
     353        pUserProc=ppSubHash[i3];
     354        while(pUserProc){
     355            if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
     356                pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
    357357                sw=1;
    358358                break;
    359359            }
    360360
    361             psi=psi->pNextData;
     361            pUserProc=pUserProc->pNextData;
    362362        }
    363363        if(sw) break;
    364364    }
    365     if(!psi) return;
    366 
    367     for(i=0;i<psi->VarNum;i++){
    368         VARIABLE *pVar=&psi->pVar[i];
     365    if(!pUserProc) return;
     366
     367    for(i=0;i<pUserProc->VarNum;i++){
     368        VARIABLE *pVar=&pUserProc->pVar[i];
    369369
    370370        //スコープ外の場合は無視
     
    416416
    417417    TreeView_DeleteAllItems(hVarTree_This);
    418     if(!psi->pobj_ParentClass) return;
     418    if(!pUserProc->GetParentClassPtr()) return;
    419419
    420420    //Thisポインタを取得
    421421    LONG_PTR pThis;
    422     for(i=0;i<psi->VarNum;i++){
    423         if(lstrcmp(psi->pVar[i].name,"_System_LocalThis")==0) break;
    424     }
    425     if(i==psi->VarNum) return;
    426     lpData=pobj_dti->lplpSpBase[i2]+psi->pVar[i].offset;
     422    for(i=0;i<pUserProc->VarNum;i++){
     423        if(lstrcmp(pUserProc->pVar[i].name,"_System_LocalThis")==0) break;
     424    }
     425    if(i==pUserProc->VarNum) return;
     426    lpData=pobj_dti->lplpSpBase[i2]+pUserProc->pVar[i].offset;
    427427    ReadProcessMemory(hDebugProcess,(void *)lpData,&pThis,sizeof(LONG_PTR),&lpAccBytes);
    428428
    429     for(i=0;i<psi->pobj_ParentClass->iMemberNum;i++){
    430         offset = psi->pobj_ParentClass->GetMemberOffset( psi->pobj_ParentClass->ppobj_Member[i]->name, &i2 );
    431 
    432         if(psi->pobj_ParentClass->ppobj_Member[i]->SubScripts[0]!=-1){
     429    for(i=0;i<pUserProc->GetParentClassPtr()->iMemberNum;i++){
     430        offset = pUserProc->GetParentClassPtr()->GetMemberOffset( pUserProc->GetParentClassPtr()->ppobj_Member[i]->name, &i2 );
     431
     432        if(pUserProc->GetParentClassPtr()->ppobj_Member[i]->SubScripts[0]!=-1){
    433433            //配列
    434434            sprintf(temporary,"%s %s(&H%X)",
    435                 psi->pobj_ParentClass->ppobj_Member[i]->name,
     435                pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
    436436                STRING_ARRAY,
    437437                offset);
     
    442442            VarList_Array(hVarTree_This,hParent,
    443443                pThis+offset,
    444                 psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.type,
    445                 psi->pobj_ParentClass->ppobj_Member[i]->SubScripts,
    446                 psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.u.lpIndex);
     444                pUserProc->GetParentClassPtr()->ppobj_Member[i]->TypeInfo.type,
     445                pUserProc->GetParentClassPtr()->ppobj_Member[i]->SubScripts,
     446                pUserProc->GetParentClassPtr()->ppobj_Member[i]->TypeInfo.u.lpIndex);
    447447        }
    448448        else{
    449449            VarList_Insert(hVarTree_This,&tv,
    450                 psi->pobj_ParentClass->ppobj_Member[i]->name,
    451                 psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.type,
     450                pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
     451                pUserProc->GetParentClassPtr()->ppobj_Member[i]->TypeInfo.type,
    452452                pThis+offset,
    453                 psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.u.lpIndex);
     453                pUserProc->GetParentClassPtr()->ppobj_Member[i]->TypeInfo.u.lpIndex);
    454454        }
    455455    }
     
    583583
    584584    //プロシージャ コンボボックス
    585     extern SubInfo **ppSubHash;
    586     SubInfo *psi;
     585    extern UserProc **ppSubHash;
     586    UserProc *pUserProc;
    587587    int sw;
    588588    SendMessage(hProcCombo,CB_RESETCONTENT,0,0);
    589589    for(i2=pobj_dti->iProcLevel;i2>=0;i2--){
    590590        for(i3=0,sw=0;i3<MAX_HASH;i3++){
    591             psi=ppSubHash[i3];
    592             while(psi){
    593                 if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
    594                     pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
    595                     lstrcpy(temporary,psi->name);
     591            pUserProc=ppSubHash[i3];
     592            while(pUserProc){
     593                if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
     594                    pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
     595                    lstrcpy(temporary,pUserProc->GetName().c_str());
    596596                    sw=1;
    597597                    break;
    598598                }
    599                 psi=psi->pNextData;
     599                pUserProc=pUserProc->pNextData;
    600600            }
    601601            if(sw) break;
    602602        }
    603         if(!psi){
     603        if(!pUserProc){
    604604            if(i2==0){
    605605                lstrcpy(temporary,"Global");
     
    706706
    707707    if(pobj_dti->lplpSpBase[i2]){
    708         extern SubInfo **ppSubHash;
    709         SubInfo *psi;
     708        extern UserProc **ppSubHash;
     709        UserProc *pUserProc;
    710710        for(i3=0,sw=0;i3<MAX_HASH;i3++){
    711             psi=ppSubHash[i3];
    712             while(psi){
    713                 if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
    714                     pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
     711            pUserProc=ppSubHash[i3];
     712            while(pUserProc){
     713                if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
     714                    pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
    715715                    sw=1;
    716716                    break;
    717717                }
    718718
    719                 psi=psi->pNextData;
     719                pUserProc=pUserProc->pNextData;
    720720            }
    721721            if(sw) break;
     
    723723
    724724
    725         if(psi){
    726             LocalVar=psi->pVar;
    727             MaxLocalVarNum=psi->VarNum;
    728 
    729             pobj_CompilingClass=psi->pobj_ParentClass;
     725        if(pUserProc){
     726            LocalVar=pUserProc->pVar;
     727            MaxLocalVarNum=pUserProc->VarNum;
     728
     729            pobj_CompilingClass=pUserProc->GetParentClassPtr();
    730730        }
    731731    }
  • BasicCompiler32/WatchList.cpp

    r73 r75  
    308308ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip){
    309309    int i;
    310     SubInfo *psi;
     310    UserProc *pUserProc;
    311311
    312312    //ripからプロシージャを取得
    313     psi=GetSubFromObp(obp_Rip);
    314 
    315     for(i=0;i<psi->VarNum;i++){
    316         if(lstrcmp(psi->pVar[i].name,"_System_LocalThis")==0) break;
    317     }
    318     if(i==psi->VarNum) return 0;
    319 
    320     return psi->pVar[i].offset;
     313    pUserProc=GetSubFromObp(obp_Rip);
     314
     315    for(i=0;i<pUserProc->VarNum;i++){
     316        if(lstrcmp(pUserProc->pVar[i].name,"_System_LocalThis")==0) break;
     317    }
     318    if(i==pUserProc->VarNum) return 0;
     319
     320    return pUserProc->pVar[i].offset;
    321321}
    322322int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
  • BasicCompiler32/increment.cpp

    r64 r75  
    33
    44void IncDec(int idCalc, char *lpszLeft, char *lpszRight){
    5     int VarType;
    6     LONG_PTR lpVarIndex;
    7     RELATIVE_VAR VarRelativeVar;
    8 
    95
    106    ///////////////////////////
     
    128    ///////////////////////////
    139
     10    RELATIVE_VAR VarRelativeVar;
     11    Type varType;
    1412    if(!GetVarOffsetReadWrite(
    1513        lpszLeft,
    16         &VarType,
    1714        &VarRelativeVar,
    18         &lpVarIndex)) return;
     15        varType)) return;
    1916
    2017    if(IsUse_ecx(&VarRelativeVar)){
     
    2825    ///////////////////////////////////
    2926
    30     if(IsRealNumberType(VarType)){
     27    if( varType.IsReal() ){
    3128        //実数
    32         SetReg_RealVariable(VarType,&VarRelativeVar);
     29        SetReg_RealVariable(varType.GetBasicType(),&VarRelativeVar);
    3330    }
    3431    else{
    3532        //整数
    36         SetReg_WholeVariable(VarType,&VarRelativeVar,REG_EAX);
     33        SetReg_WholeVariable(varType.GetBasicType(),&VarRelativeVar,REG_EAX);
    3734    }
    3835
    3936   
    40     if(IsWholeNumberType(VarType)&&lstrcmp(lpszRight,"1")==0&&
     37    if(varType.IsWhole()&&lstrcmp(lpszRight,"1")==0&&
    4138        (idCalc==CALC_ADDITION||idCalc==CALC_SUBTRACTION)){
    4239        ////////////////////////////////////////////
     
    4441        ////////////////////////////////////////////
    4542
    46         if(Is64Type(VarType)){
     43        if( varType.Is64() ){
    4744            if(idCalc==CALC_ADDITION){
    4845                //64ビット インクリメント
     
    8077        op_push(REG_ECX);
    8178
    82 
    83         if(VarType==DEF_DOUBLE){
     79        if( varType.IsDouble() ){
    8480            //sub esp,8
    8581            op_sub_esp(8);
    8682
    8783            //fstp qword ptr[esp]
    88             op_fstp_basereg(VarType,REG_ESP);
    89         }
    90         else if(VarType==DEF_SINGLE){
     84            op_fstp_basereg(varType.GetBasicType(),REG_ESP);
     85        }
     86        else if( varType.IsSingle() ){
    9187            //sub esp,4
    9288            op_sub_esp(4);
    9389
    9490            //fstp dword ptr[esp]
    95             op_fstp_basereg(VarType,REG_ESP);
    96         }
    97         else if(Is64Type(VarType)){
     91            op_fstp_basereg(varType.GetBasicType(),REG_ESP);
     92        }
     93        else if( varType.Is64() ){
    9894            //push edx
    9995            op_push(REG_EDX);
     
    107103        }
    108104
    109         int CalcType;
    110         CalcType=NumOpe(lpszRight,VarType,lpVarIndex,0);
    111 
    112         if(VarType==DEF_DOUBLE)         ChangeTypeToDouble(CalcType);
    113         else if(VarType==DEF_SINGLE)    ChangeTypeToSingle(CalcType);
    114         else ChangeTypeToWhole(CalcType,VarType);
    115 
    116         int type[255],sp;
     105        Type calcType;
     106        if( !NumOpe(lpszRight,varType,calcType) ){
     107            return;
     108        }
     109
     110        if( varType.IsDouble() )        ChangeTypeToDouble(calcType.GetBasicType());
     111        else if( varType.IsSingle() )   ChangeTypeToSingle(calcType.GetBasicType());
     112        else ChangeTypeToWhole(calcType.GetBasicType(),varType.GetBasicType());
     113
     114        int type_stack[255],sp;
    117115        LONG_PTR index_stack[255];
    118         type[0]=VarType;
    119         type[1]=VarType;
    120         index_stack[0]=lpVarIndex;
    121         index_stack[1]=lpVarIndex;
     116        type_stack[0]=varType.GetBasicType();
     117        type_stack[1]=varType.GetBasicType();
     118        index_stack[0]=varType.GetIndex();
     119        index_stack[1]=varType.GetIndex();
    122120        sp=2;
    123121
    124122        switch(idCalc){
    125123            case CALC_XOR:
    126                 Calc_Xor(type,index_stack,&sp);
     124                Calc_Xor(type_stack,index_stack,&sp);
    127125                break;
    128126            case CALC_OR:
    129                 Calc_Or(type,index_stack,&sp);
     127                Calc_Or(type_stack,index_stack,&sp);
    130128                break;
    131129            case CALC_AND:
    132                 Calc_And(type,index_stack,&sp);
     130                Calc_And(type_stack,index_stack,&sp);
    133131                break;
    134132            case CALC_SHL:
    135                 Calc_SHL(type,&sp);
     133                Calc_SHL(type_stack,&sp);
    136134                break;
    137135            case CALC_SHR:
    138                 Calc_SHR(type,&sp);
     136                Calc_SHR(type_stack,&sp);
    139137                break;
    140138            case CALC_ADDITION:
    141139            case CALC_SUBTRACTION:
    142140            case CALC_PRODUCT:
    143                 CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp);
     141                CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp);
    144142                break;
    145143            case CALC_MOD:
    146                 Calc_Mod(type,&sp);
     144                Calc_Mod(type_stack,&sp);
    147145                break;
    148146            case CALC_QUOTIENT:
    149                 Calc_Divide(type,&sp,VarType);
     147                Calc_Divide(type_stack,&sp,varType.GetBasicType());
    150148                break;
    151149            case CALC_INTQUOTIENT:
    152                 Calc_IntDivide(type,index_stack,&sp);
     150                Calc_IntDivide(type_stack,index_stack,&sp);
    153151                break;
    154152            case CALC_POWER:
    155                 Calc_Power(type,&sp);
    156                 break;
    157         }
    158 
    159 
    160         if(VarType==DEF_DOUBLE){
     153                Calc_Power(type_stack,&sp);
     154                break;
     155        }
     156
     157
     158        if( varType.IsDouble() ){
    161159            //fld qword ptr[esp]
    162             op_fld_basereg(VarType,REG_ESP);
     160            op_fld_basereg(varType.GetBasicType(),REG_ESP);
    163161
    164162            //add esp,8
    165163            op_add_esp(8);
    166164        }
    167         else if(VarType==DEF_SINGLE){
     165        else if( varType.IsSingle() ){
    168166            //fld dword ptr[esp]
    169             op_fld_basereg(VarType,REG_ESP);
     167            op_fld_basereg(varType.GetBasicType(),REG_ESP);
    170168
    171169            //add esp,4
    172170            op_add_esp(4);
    173171        }
    174         else if(Is64Type(VarType)){
     172        else if( varType.Is64() ){
    175173            //pop eax
    176174            op_pop(REG_EAX);
     
    200198    }
    201199
    202     SetVariableFromEax(VarType,VarType,&VarRelativeVar);
     200    SetVariableFromEax(varType.GetBasicType(),varType.GetBasicType(),&VarRelativeVar);
    203201}
  • BasicCompiler32/op32_main.cpp

    r73 r75  
    974974/////////////////////////////
    975975
    976 void op_call(SubInfo *psi){
     976void op_call(UserProc *pUserProc){
    977977    OpBuffer[obp++]=(char)0xE8;
    978     pobj_SubAddrSchedule->add(psi,1);
    979     psi->bUse=1;
     978    pobj_SubAddrSchedule->add(pUserProc,1);
     979    pUserProc->Using();
    980980    obp+=sizeof(long);
    981981}
  • BasicCompiler64/BasicCompiler.vcproj

    r71 r75  
    2222            UseOfMFC="0"
    2323            ATLMinimizesCRunTimeLibraryUsage="false"
    24             CharacterSet="0"
     24            CharacterSet="2"
    2525            >
    2626            <Tool
     
    5252                MinimalRebuild="true"
    5353                BasicRuntimeChecks="0"
    54                 RuntimeLibrary="3"
     54                RuntimeLibrary="1"
    5555                UsePrecompiledHeader="0"
    5656                PrecompiledHeaderFile=".\Debug/BasicCompiler.pch"
     
    125125            UseOfMFC="0"
    126126            ATLMinimizesCRunTimeLibraryUsage="false"
    127             CharacterSet="0"
     127            CharacterSet="2"
    128128            >
    129129            <Tool
     
    322322            UseOfMFC="0"
    323323            ATLMinimizesCRunTimeLibraryUsage="false"
    324             CharacterSet="0"
     324            CharacterSet="2"
    325325            >
    326326            <Tool
     
    473473                >
    474474                <File
     475                    RelativePath="..\BasicCompiler_Common\Parameter.h"
     476                    >
     477                </File>
     478                <File
     479                    RelativePath="..\BasicCompiler_Common\Procedure.h"
     480                    >
     481                </File>
     482                <File
    475483                    RelativePath="..\BasicCompiler_Common\Type.h"
     484                    >
     485                </File>
     486                <File
     487                    RelativePath="..\BasicCompiler_Common\Variable.h"
    476488                    >
    477489                </File>
     
    15221534                    >
    15231535                    <File
    1524                         RelativePath="..\BasicCompiler_Common\Variable.cpp"
    1525                         >
    1526                     </File>
    1527                     <File
    1528                         RelativePath="..\BasicCompiler_Common\Variable.h"
     1536                        RelativePath="..\BasicCompiler_Common\VariableOpe.cpp"
     1537                        >
     1538                    </File>
     1539                    <File
     1540                        RelativePath="..\BasicCompiler_Common\VariableOpe.h"
    15291541                        >
    15301542                    </File>
     
    15451557                    Name="Procedure"
    15461558                    >
    1547                     <File
    1548                         RelativePath="..\BasicCompiler_Common\Parameter.h"
    1549                         >
    1550                     </File>
    15511559                    <File
    15521560                        RelativePath="..\BasicCompiler_Common\ParamImpl.cpp"
     
    15631571                >
    15641572                <File
     1573                    RelativePath="..\BasicCompiler_Common\Procedure.cpp"
     1574                    >
     1575                </File>
     1576                <File
    15651577                    RelativePath="..\BasicCompiler_Common\Type.cpp"
     1578                    >
     1579                </File>
     1580                <File
     1581                    RelativePath="..\BasicCompiler_Common\Variable.cpp"
    15661582                    >
    15671583                </File>
  • BasicCompiler64/CParameter.cpp

    r73 r75  
    22#include "opcode.h"
    33
    4 int ParamImpl::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     4int ParamImpl::NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum ){
     5    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     6
    57    ///////////////////////////////////////////////////////
    68    // 一時オブジェクトをあらかじめスタックに積んでおく
     
    1214
    1315    BOOL bEllipse;
    14     if(pi_num){
    15         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     16    if(params.size()){
     17        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    1618        else bEllipse=0;
    1719    }
     
    2123        useTempParameters[i2] = false;
    2224
    23         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    24 
    25         if(i2==0&&ppi[i2].name){
    26             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     25        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     26
     27        if(i2==0){
     28            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    2729                //オブジェクトメンバの第一パラメータのThisポインタ
    2830                continue;
    2931            }
    3032        }
    31         if((i2==0||i2==1)&&ppi[i2].name){
    32             if(lstrcmp(ppi[i2].name,FuncName)==0){
     33        if( i2==0||i2==1 ){
     34            if( params[i2]->GetVarName() == procName ){
    3335                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    3436                continue;
     
    3638        }
    3739
    38         TYPEINFO DummyTypeInfo;
     40        Type dummyType;
    3941        BOOL bByVal;
    4042        if(bEllipse){
    41             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     43            NumOpe_GetType( Parms[i2], Type(), dummyType );
    4244            bByVal=1;
    4345        }
    4446        else{
    45             DummyTypeInfo.type=ppi[i2].type;
    46             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    47             bByVal=ppi[i2].bByVal;
     47            dummyType = *params[i2];
     48            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    4849        }
    4950
     
    5657            }
    5758
    58             LONG_PTR lpVarIndex;
    59             if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
     59            if( !GetVarType( Parms[i2], Type(), FALSE ) ){
    6060                //変数ではないとき
    6161                int reg = REG_RAX;
    62                 int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    63 
    64                 if( type != DEF_STRUCT ){
     62                Type calcType;
     63                NumOpe( &reg, Parms[i2], dummyType, calcType );
     64
     65                if( !calcType.IsStruct() ){
    6566                    //一時参照を作成
    6667                    pobj_sf->push( reg );
     
    7677
    7778                bool result = CheckDifferentType(
    78                     DummyTypeInfo.type,
    79                     DummyTypeInfo.u.lpIndex,
    80                     type,
    81                     lpVarIndex,
    82                     FuncName,
     79                    dummyType,
     80                    calcType,
     81                    procName.c_str(),
    8382                    i2);
    8483
     
    8786                    useTempObject = true;
    8887
    89                     types[i2].type = type;
    90                     types[i2].u.lpIndex = lpVarIndex;
     88                    types[i2] = calcType;
    9189                }
    9290            }
     
    104102    for(int i2=ParmsNum-1;i2>=0;i2--){
    105103        if( useTempParameters[i2] ){
    106             if( types[i2].type == DEF_STRUCT ){
     104            if( types[i2].IsStruct() ){
    107105                // 構造体の一時メモリ
    108106
     
    112110
    113111                //call free
    114                 extern SubInfo *pSub_free;
     112                extern UserProc *pSub_free;
    115113                op_call(pSub_free);
    116114            }
     
    123121}
    124122
    125 void ParamImpl::SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
     123void ParamImpl::SetStructParameter( int reg, const Type &baseType, const char *expression ){
    126124    //////////////////////////////////////////////////////
    127125    /////    レジスタ資源のバックアップ
     
    129127    //////////////////////////////////////////////////////
    130128
    131         int object_size = pobj_Class->GetSize();
     129        int object_size = baseType.GetClass().GetSize();
    132130
    133131        //mov rcx,object_size
     
    135133
    136134        //call calloc
    137         extern SubInfo *pSub_calloc;
     135        extern UserProc *pSub_calloc;
    138136        op_call(pSub_calloc);
    139137
     
    144142        pobj_sf->push(REG_R11);
    145143
    146         TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    147         TYPEINFO CalcType;
    148         CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
    149 
    150         /*
    151         TODO: 消す
    152         if( pobj_Class->GetCopyConstructorMethod()
    153             && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
    154             ////////////////////////////////////
    155             // コピーコンストラクタを呼び出す
    156             ////////////////////////////////////
    157 
    158             BOOL bUseHeap;
    159             int temp_reg=REG_RDX;
    160             CalcType.type=NumOpe(&temp_reg,Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    161 
    162             if(bUseHeap){
    163                 //mov r14,rdx
    164                 op_mov_RR(REG_R14,REG_RDX);
    165             }
    166 
    167             //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    168             pobj_sf->ref(REG_R11);
    169 
    170             //mov rcx,this
    171             op_mov_RR(REG_RCX,REG_R11);
    172 
    173             //call constructor
    174             op_call(pobj_Class->GetCopyConstructorMethod()->psi);
    175 
    176 
    177             if(bUseHeap){
    178                 FreeTempObject(REG_R14,pobj_Class);
    179             }
    180         }
    181         else{
    182             if( pobj_Class->GetConstructorMethod() ){
    183                 ////////////////////////////////
    184                 // コンストラクタを呼び出す
    185                 ////////////////////////////////
    186 
    187                 //mov rcx,this
    188                 op_mov_RR(REG_RCX,REG_R11);
    189 
    190                 //call constructor
    191                 op_call(pobj_Class->GetConstructorMethod()->psi);
    192             }
    193             */
    194 
    195 
    196             BOOL bUseHeap;
    197             int temp_reg=REG_RAX;
    198             CalcType.type=NumOpe(&temp_reg,Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    199 
    200 
    201             //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    202             pobj_sf->ref(REG_R11);
    203 
    204 
    205             RELATIVE_VAR RelativeVar;
    206             RelativeVar.bOffsetOffset=0;
    207             RelativeVar.offset=0;
    208             RelativeVar.dwKind=VAR_DIRECTMEM;
    209 
    210             SetStructVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
    211 
    212         //}
     144
     145        Type calcType;
     146        BOOL bUseHeap;
     147        int temp_reg=REG_RAX;
     148        NumOpe( &temp_reg,
     149            expression,
     150            baseType,
     151            calcType,
     152            &bUseHeap );
     153
     154
     155        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
     156        pobj_sf->ref(REG_R11);
     157
     158
     159        RELATIVE_VAR RelativeVar;
     160        RelativeVar.bOffsetOffset=0;
     161        RelativeVar.offset=0;
     162        RelativeVar.dwKind=VAR_DIRECTMEM;
     163
     164        SetStructVariableFromRax(
     165            baseType,
     166            calcType,
     167            &RelativeVar,bUseHeap);
     168
    213169
    214170        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
     
    225181
    226182
    227 void ParamImpl::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
     183void ParamImpl::SetParameter( const string &procName, const Parameters &params, int SecondParmNum ){
     184    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     185
    228186    ///////////////////////////////////////////////////////////
    229187    // パラメータをレジスタ及びスタックフレームにセット
     
    232190
    233191    BOOL bEllipse;
    234     if(pi_num){
    235         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     192    if( params.size() ){
     193        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    236194        else bEllipse=0;
    237195    }
     
    240198    BOOL bHas_System_LocalThis=0;
    241199    if(ParmsNum>=1){
    242         if(lstrcmp(ppi[0].name,"_System_LocalThis")==0)
     200        if( params[0]->GetVarName() == "_System_LocalThis" ){
    243201            bHas_System_LocalThis=1;
     202        }
    244203    }
    245204
    246205    //戻り値用の変数名を取得
    247     const char *lpszVarNameToReturn = (FuncName[0]==1&&FuncName[1]==ESC_OPERATOR)?"_System_ReturnValue":FuncName;
     206    const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();
    248207
    249208    //パラメータをレジスタとスタックに格納
    250     int CalcType;
    251     LONG_PTR lpCalcIndex;
    252     BOOL bCalcUseHeap;
    253209    int ParmSize=0;
    254210    int reg,temp_reg;
    255211    RELATIVE_VAR RelativeVar;
    256212    for(i2=ParmsNum-1;i2>=0;i2--){
    257         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    258 
    259         if(i2==0&&ppi[i2].name){
    260             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     213        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     214
     215        if(i2==0){
     216            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    261217                //オブジェクトメンバの第一パラメータのThisポインタ
    262218                continue;
    263219            }
    264220        }
    265         if((i2==0||i2==1)&&ppi[i2].name){
    266             if(lstrcmp(ppi[i2].name,lpszVarNameToReturn)==0){
     221        if(i2==0||i2==1){
     222            if( params[i2]->GetVarName() == lpszVarNameToReturn ){
    267223                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    268224                continue;
     
    270226        }
    271227
    272         TYPEINFO DummyTypeInfo;
     228        Type dummyType;
    273229        BOOL bByVal;
    274230        if(bEllipse){
    275             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     231            NumOpe_GetType( Parms[i2], Type(), dummyType );
    276232            bByVal=1;
    277233        }
    278234        else{
    279             DummyTypeInfo.type=ppi[i2].type;
    280             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    281             bByVal=ppi[i2].bByVal;
     235            dummyType = *params[i2];
     236            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    282237        }
    283238
    284239        int xmm_temp_sw=0;
    285         if(IsRealNumberType(DummyTypeInfo.type)&&bByVal){
     240        if(dummyType.IsReal()&&bByVal){
    286241            //実数型
    287242            if(i2==0) reg=REG_XMM0;
     
    308263            if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    309264                char temp2[255];
    310                 sprintf(temp2,"%s関数の第%dパラメータ",FuncName,i2+1);
     265                sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
    311266                SetError(19,temp2,cp);
    312267                continue;
    313268            }
    314269
    315             if(DummyTypeInfo.type==DEF_STRUCT){
    316                 SetStructParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
     270            if( dummyType.IsStruct() ){
     271                SetStructParameter( reg, dummyType, Parms[i2] );
    317272                goto next;
    318273            }
     
    321276
    322277            extern LONG_PTR ProcPtr_BaseIndex;
    323             LONG_PTR back_ProcPtr_BaseIndex;
    324             back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
    325             if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
    326             else ProcPtr_BaseIndex=-1;
    327 
    328             CalcType=NumOpe(&temp_reg,Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
     278            LONG_PTR back_ProcPtr_BaseIndex = ProcPtr_BaseIndex;
     279            if( dummyType.IsProcPtr() ){
     280                ProcPtr_BaseIndex = dummyType.GetIndex();
     281            }
     282            else{
     283                ProcPtr_BaseIndex=-1;
     284            }
     285
     286            BOOL bCalcUseHeap;
     287            Type calcType;
     288            if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){
     289                break;
     290            }
    329291
    330292            ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
    331293
    332             if(CalcType==-1) break;
    333 
    334             if(CalcType==DEF_OBJECT){
    335                 if( DummyTypeInfo.type != DEF_OBJECT
     294            if( calcType.IsObject() ){
     295                if( !dummyType.IsObject()
    336296                    ||
    337                     DummyTypeInfo.type == DEF_OBJECT &&
    338                     !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
     297                    dummyType.IsObject() &&
     298                    !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
    339299                        //キャスト演算子のオーバーロードに対応する
    340                         CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     300                        CallCastOperatorProc( reg, calcType, bCalcUseHeap,dummyType );
    341301                }
    342302            }
     
    344304
    345305            if(bEllipse){
    346                 if(IsRealNumberType(CalcType)){
     306                if( calcType.IsReal() ){
    347307                    //整数レジスタへコピー
    348308                    //※cdeclの拡張パラメータは実数の場合も汎用レジスタで引渡し
     
    358318                    }
    359319                }
    360                 else if(IsWholeNumberType(CalcType)){
     320                else if( calcType.IsWhole() ){
    361321                    //整数型の場合は、64ビットへ拡張する
    362                     ExtendTypeTo64(CalcType,temp_reg);
     322                    ExtendTypeTo64( calcType.GetBasicType(), temp_reg );
    363323                }
    364324            }
     
    369329                else i3=i2;
    370330                CheckDifferentType(
    371                     DummyTypeInfo.type,
    372                     DummyTypeInfo.u.lpIndex,
    373                     CalcType,
    374                     lpCalcIndex,
    375                     FuncName,
     331                    dummyType,
     332                    calcType,
     333                    procName.c_str(),
    376334                    i3);
    377335
    378 
    379                 if(DummyTypeInfo.type==DEF_DOUBLE){
     336                if( dummyType.IsDouble() ){
    380337                    //Double型へ変換
    381                     ChangeTypeToXmm_Double(CalcType,reg,temp_reg);
    382                 }
    383                 else if(DummyTypeInfo.type==DEF_SINGLE){
     338                    ChangeTypeToXmm_Double(calcType.GetBasicType(),reg,temp_reg);
     339                }
     340                else if( dummyType.IsSingle() ){
    384341                    //Single型へ変換
    385                     ChangeTypeToXmm_Single(CalcType,reg,temp_reg);
    386                 }
    387                 else if(IsWholeNumberType(DummyTypeInfo.type)){
     342                    ChangeTypeToXmm_Single(calcType.GetBasicType(),reg,temp_reg);
     343                }
     344                else if( dummyType.IsWhole() ){
    388345                    //実数型 → 整数型
    389                     ChangeTypeToWhole(CalcType,DummyTypeInfo.type,reg,temp_reg);
     346                    ChangeTypeToWhole(calcType.GetBasicType(),dummyType.GetBasicType(),reg,temp_reg);
    390347                }
    391348            }
     
    397354
    398355                temp_reg=reg;
    399                 CalcType=NumOpe(&temp_reg,Parms[i2]+2,0,0,&lpCalcIndex);
    400                 if(CalcType==-1) break;
    401 
    402                 int ptr_type;
    403                 ptr_type=GetPtrType(DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     356                Type calcType;
     357                if( !NumOpe(&temp_reg, Parms[i2]+2, dummyType, calcType) ){
     358                    break;
     359                }
     360
     361                dummyType.PtrLevelUp();
    404362
    405363                //型チェック
     
    407365                else i3=i2;
    408366                CheckDifferentType(
    409                     ptr_type,
    410                     DummyTypeInfo.u.lpIndex,
    411                     CalcType,
    412                     lpCalcIndex,
    413                     FuncName,
     367                    dummyType,
     368                    calcType,
     369                    procName.c_str(),
    414370                    i3);
    415371
    416                 if(IsRealNumberType(CalcType)){
     372                if( calcType.IsReal() ){
    417373                    //実数型 → 整数型
    418                     ChangeTypeToWhole(CalcType,DEF_QWORD,reg,temp_reg);
     374                    ChangeTypeToWhole( calcType.GetBasicType(), DEF_QWORD,reg,temp_reg);
    419375                }
    420376            }
     
    428384                else{
    429385                    //変数のアドレスを取得
    430                     int VarType;
    431                     LONG_PTR lpVarIndex;
     386                    Type varType;
    432387                    if(GetVarOffset(
    433388                        false,
    434389                        false,
    435390                        Parms[i2],
    436                         &VarType,
    437391                        &RelativeVar,
    438                         &lpVarIndex)){
    439 
    440                             if(DummyTypeInfo.type!=DEF_ANY){
     392                        varType)){
     393
     394                            if( !dummyType.IsAny() ){
    441395                                //型チェックを行う
    442                                 if(DummyTypeInfo.type==VarType){
    443                                     if(DummyTypeInfo.type==DEF_OBJECT){
    444                                         if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
     396                                if( dummyType.GetBasicType() == varType.GetBasicType() ){
     397                                    if( dummyType.IsObject() ){
     398                                        if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){
    445399                                            SetError(11,Parms[i2],cp);
    446400                                        }
    447401                                    }
    448                                     else if(DummyTypeInfo.type==DEF_STRUCT){
    449                                         if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     402                                    else if( dummyType.IsStruct() ){
     403                                        if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){
    450404                                            SetError(11,Parms[i2],cp);
    451405                                        }
    452406                                    }
    453407                                }
    454                                 else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
     408                                else if( (varType.GetBasicType()&FLAG_PTR)
     409                                    &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){
    455410                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    456411                                }
     
    494449
    495450    //パラメータが収まるだけのスタックフレームを確保
    496     pobj_sf->parameter_allocate(pi_num*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
     451    pobj_sf->parameter_allocate((int)params.size()*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
    497452}
    498453void ParamImpl::BackupParameter(int pi_num){
  • BasicCompiler64/Compile_Calc.cpp

    r64 r75  
    8484            }
    8585
    86             LONG_PTR lp;
    87             if(GetVarType(variable,&lp,0)!=-1){
     86            if(GetVarType(variable,Type(),0)){
    8887                //変数リストに該当したとき
    8988                SetError(1,NULL,cp);
     
    129128
    130129    char ObjName[VN_SIZE],array_element[VN_SIZE];
    131     CClass *pobj_c;
    132130    GetArrayElement(variable,ObjName,array_element);
    133131    if(array_element[0]){
    134         i2=GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
    135         if(i2==DEF_OBJECT){
     132        Type varType;
     133        if( GetVarType(ObjName,varType,0) && varType.IsObject() ){
    136134            char temporary[VN_SIZE];
    137135            sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
     
    141139
    142140            int idProc;
    143             void *pInfo;
    144             idProc=GetProc(temporary,&pInfo);
     141            void *pProc;
     142            idProc=GetProc(temporary,(void **)&pProc);
    145143            if(idProc){
    146                 CallProc(idProc,pInfo,temporary,temp2,NULL);
     144                CallProc(idProc,pProc,temporary,temp2,Type());
    147145                return;
    148146            }
     
    161159    ////////////////////////////////////////
    162160
    163     int VarType,CalcType;
    164     LONG_PTR lpVarIndex,lpCalcIndex;
    165     BOOL bCalcUseHeap;
     161    Type varType;
    166162
    167163    //型を識別
    168     VarType=GetVarType(variable,&lpVarIndex,0);
    169     if(VarType==-1){
     164    if( !GetVarType(variable,varType,false) ){
    170165
    171166        // プロパティ用のメソッドを呼び出す
    172         if(!CallPropertyMethod(variable,Command+i+1,NULL)){
     167        if(!CallPropertyMethod( variable, Command+i+1, Type() )){
    173168            //エラーを表示
    174             GetVarType(variable,&lpVarIndex,1);
     169            GetVarType(variable,varType,true);
    175170        }
    176171
     
    179174
    180175    extern LONG_PTR ProcPtr_BaseIndex;
    181     if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
     176    if(varType.IsProcPtr()) ProcPtr_BaseIndex=varType.GetIndex();
    182177    else ProcPtr_BaseIndex=-1;
    183178
    184179    //NumOpe...(rax、またはxmm0に答えが格納される)
    185180    int reg=REG_RAX;
    186     CalcType=NumOpe(&reg,Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
    187 
    188     if(reg!=REG_RAX&&IsWholeNumberType(CalcType)){
     181    BOOL bCalcUseHeap;
     182    Type calcType;
     183    if( !NumOpe(&reg,Command+i+1,varType,calcType,&bCalcUseHeap) ){
     184        return;
     185    }
     186
     187    if(reg!=REG_RAX&&calcType.IsWhole()||
     188        varType.IsNull()||calcType.IsNull()){
    189189        SetError(300,NULL,cp);
    190190    }
    191 
    192     if(VarType==-1||CalcType==-1) return;
    193191
    194192    //結果を格納しているレジスタをブロッキング
     
    199197    if(!GetVarOffsetReadWrite(
    200198        variable,
    201         &VarType,
    202199        &VarRelativeVar,
    203         &lpVarIndex,
    204         NULL)) return;
     200        varType)) return;
    205201
    206202    //レジスタのブロッキングを解除
    207203    pobj_BlockReg->clear();
    208204
    209     if(VarType&FLAG_PTR){
     205    if(varType.GetBasicType()&FLAG_PTR){
    210206        SetError(14,variable,cp);
    211207        return;
    212208    }
    213209
    214     if(VarType==DEF_STRUCT ){
     210    if( varType.IsStruct() ){
    215211        //構造体インスタンスへの代入
    216         SetStructVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
    217         return;
    218     }
    219 
    220     if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
     212        SetStructVariableFromRax(varType,calcType,&VarRelativeVar,bCalcUseHeap);
     213        return;
     214    }
     215
     216    if( calcType.IsObject() && !calcType.Equals( varType ) ){
    221217        //キャスト演算子のオーバーロードに対応する
    222         CallCastOperatorProc(REG_RAX,CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
     218        CallCastOperatorProc(REG_RAX,calcType,bCalcUseHeap,varType);
    223219    }
    224220
     
    228224    /////////////////////////////////
    229225
    230     CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
     226    CheckDifferentType(varType,calcType,0,0);
    231227
    232228
     
    234230    // rax(実数はxmm0)の内容を変数にコピー
    235231    /////////////////////////////////////////////////
    236     SetVariableFromRax(VarType,CalcType,&VarRelativeVar);
     232    SetVariableFromRax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar);
    237233}
    238 
    239 // TODO: 消す
    240 /*
    241 void SetRefVariable( const char *varname, const char *expression ){
    242     ////////////////////////////////////////
    243     // 変数のタイプ型を識別して、演算を行う
    244     ////////////////////////////////////////
    245 
    246     int VarType,CalcType;
    247     LONG_PTR lpVarIndex,lpCalcIndex;
    248     BOOL bCalcUseHeap;
    249 
    250     //型を識別
    251     VarType=GetVarType(varname,&lpVarIndex,0);
    252     if(VarType==-1){
    253         SetError(300,NULL,cp);
    254         return;
    255     }
    256 
    257     extern LONG_PTR ProcPtr_BaseIndex;
    258     if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
    259     else ProcPtr_BaseIndex=-1;
    260 
    261     //NumOpe...(rax、またはxmm0に答えが格納される)
    262     int reg=REG_RAX;
    263     CalcType=NumOpe(&reg,expression,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
    264 
    265     //結果を格納しているレジスタをブロッキング
    266     pobj_BlockReg->lock(reg);
    267 
    268 &n