Changeset 73 in dev for BasicCompiler32


Ignore:
Timestamp:
Mar 16, 2007, 11:07:14 PM (17 years ago)
Author:
dai_9181
Message:

Parameterクラスを適用。32bit側は動くようになったので、64bitのほうを調整する。

Location:
BasicCompiler32
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/BasicCompiler.vcproj

    r71 r73  
    11141114                        >
    11151115                    </File>
    1116                     <File
    1117                         RelativePath="..\BasicCompiler_Common\Type.h"
    1118                         >
    1119                     </File>
    11201116                </Filter>
    11211117                <Filter
    … …  
    12781274                    Name="Procedure"
    12791275                    >
    1280                     <File
    1281                         RelativePath="..\BasicCompiler_Common\Parameter.h"
    1282                         >
    1283                     </File>
    12841276                    <File
    12851277                        RelativePath="..\BasicCompiler_Common\ParamImpl.cpp"
    … …  
    19261918                        />
    19271919                    </FileConfiguration>
     1920                </File>
     1921            </Filter>
     1922            <Filter
     1923                Name="CommonClasses"
     1924                >
     1925                <File
     1926                    RelativePath="..\BasicCompiler_Common\Procedure.cpp"
     1927                    >
     1928                </File>
     1929                <File
     1930                    RelativePath="..\BasicCompiler_Common\Type.cpp"
     1931                    >
    19281932                </File>
    19291933            </Filter>
    … …  
    19741978                <File
    19751979                    RelativePath="..\BasicCompiler_Common\TypeDef.h"
     1980                    >
     1981                </File>
     1982            </Filter>
     1983            <Filter
     1984                Name="CommonClasses"
     1985                >
     1986                <File
     1987                    RelativePath="..\BasicCompiler_Common\Parameter.h"
     1988                    >
     1989                </File>
     1990                <File
     1991                    RelativePath="..\BasicCompiler_Common\Procedure.h"
     1992                    >
     1993                </File>
     1994                <File
     1995                    RelativePath="..\BasicCompiler_Common\Type.h"
    19761996                    >
    19771997                </File>

  • BasicCompiler32/CParameter.cpp

    r71 r73  
    4040        BOOL bByVal;
    4141        if(bEllipse){
    42             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     42            DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
    4343            bByVal=1;
    4444        }
    … …  
    9696    return nCountOfTempObjects * PTR_SIZE;
    9797}
     98int 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,
     177                    i2);
     178
     179                if( result ){
     180                    useTempParameters[i2] = true;
     181                    useTempObject = true;
     182
     183                    types[i2].type = type;
     184                    types[i2].u.lpIndex = lpVarIndex;
     185                }
     186            }
     187        }
     188    }
     189
     190    return nCountOfTempObjects * PTR_SIZE;
     191}
    98192
    99193void ParamImpl::DeleteTempParameters(){
    … …  
    111205
    112206                //call free
    113                 extern SUBINFO *pSub_free;
     207                extern SubInfo *pSub_free;
    114208                op_call(pSub_free);
    115209            }
    … …  
    138232
    139233    //call calloc
    140     extern SUBINFO *pSub_calloc;
     234    extern SubInfo *pSub_calloc;
    141235    op_call(pSub_calloc);
    142236
    … …  
    147241    TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    148242    TYPEINFO CalcType;
    149     CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
     243    CalcType.type=NumOpe_GetType_Old(Parameter,&BaseType,&CalcType.u.lpIndex);
    150244
    151245    /*
    … …  
    267361        BOOL bByVal;
    268362        if(bEllipse){
    269             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     363            DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
    270364            bByVal=1;
    271365        }
    … …  
    436530    return ParmSize;
    437531}
     532int 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
     745next:;
     746    }
     747
     748    return ParmSize;
     749}

  • BasicCompiler32/Compile_CallProc.cpp

    r71 r73  
    88void Call_DebugSys_SaveContext(){
    99    //call _System_GetEip
    10     extern SUBINFO *pSub_System_GetEip;
     10    extern SubInfo *pSub_System_GetEip;
    1111    op_call(pSub_System_GetEip);
    1212
    … …  
    1818
    1919    //call _DebugSys_SaveContext
    20     extern SUBINFO *pSub_DebugSys_SaveContext;
     20    extern SubInfo *pSub_DebugSys_SaveContext;
    2121    op_call(pSub_DebugSys_SaveContext);
    2222}
    … …  
    9494}
    9595
    96 void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
     96void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType){
    9797    int i2;
    9898
    … …  
    230230
    231231    //エラーチェック
    232     if( !pobj_parameter->ErrorCheck(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->SecondParmNum) ){
     232    if( !pobj_parameter->ErrorCheck(psi->name,psi->realParams,psi->SecondParmNum) ){
    233233        //パラメータにエラーがあるときは処理を終える
    234234        return;
    … …  
    237237    if(psi->dwType==SUBTYPE_MACRO){
    238238        //マクロ関数の場合は、パラメータ省略を考慮する
    239         pobj_parameter->MacroParameterSupport(psi->pRealParmInfo);
     239        pobj_parameter->MacroParameterSupport( psi->realParams );
    240240    }
    241241
    242242    //一時オブジェクトを生成
    243     int tempSize = pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );
     243    int tempSize = pobj_parameter->NewTempParameters( psi->name,psi->realParams,psi->RealSecondParmNum );
    244244
    245245    //レジスタ、スタックフレームにセット
    246246    int ParmSize;
    247     ParmSize=pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);
     247    ParmSize=pobj_parameter->SetParameter(psi->name,psi->realParams,psi->RealSecondParmNum);
    248248
    249249    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
    … …  
    259259
    260260        //call calloc
    261         extern SUBINFO *pSub_calloc;
     261        extern SubInfo *pSub_calloc;
    262262        op_call(pSub_calloc);
    263263

  • BasicCompiler32/Compile_Func.cpp

    r64 r73  
    243243void Opcode_Func_AddressOf(const char *name){
    244244    extern int cp;
    245     SUBINFO *psi;
     245    SubInfo *psi;
    246246
    247247    extern LONG_PTR ProcPtr_BaseIndex;
    … …  
    249249        //左辺の型にのっとり、オーバーロードを解決
    250250
    251         std::vector<SUBINFO *> subs;
     251        std::vector<SubInfo *> subs;
    252252        GetOverloadSubHash( name, subs );
    253253        if( subs.size() == 0 ){

  • BasicCompiler32/Compile_Object.cpp

    r68 r73  
    3131    ////////////////////////
    3232
    33     std::vector<SUBINFO *> subs;
     33    std::vector<SubInfo *> subs;
    3434    pobj_c->EnumMethod( pobj_c->name, subs );
    3535
    36     SUBINFO *psi;
     36    SubInfo *psi;
    3737    if( subs.size() > 0 ){
    3838        //オーバーロードを解決
    … …  
    133133
    134134        //call _System_GC_malloc_ForObject
    135         extern SUBINFO *pSub_System_GC_malloc_ForObject;
     135        extern SubInfo *pSub_System_GC_malloc_ForObject;
    136136        op_call(pSub_System_GC_malloc_ForObject);
    137137    }
    … …  
    140140
    141141        //call _System_GC_malloc_ForObjectPtr
    142         extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
     142        extern SubInfo *pSub_System_GC_malloc_ForObjectPtr;
    143143        op_call(pSub_System_GC_malloc_ForObjectPtr);
    144144    }
    … …  
    208208    // コンストラクタの呼び出し
    209209    ////////////////////////////
    210 
    211     if( lstrcmp(classObj.name,"proc")==0){
    212         int i=0;
    213     }
    214210
    215211    BOOL bSomeObjects;
    … …  
    380376    if( isSweeping ){
    381377        //call _System_GC_free_for_SweepingDelete
    382         extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
     378        extern SubInfo *pSub_System_GC_free_for_SweepingDelete;
    383379        op_call(pSub_System_GC_free_for_SweepingDelete);
    384380    }
    385381    else{
    386382        //call free
    387         extern SUBINFO *pSub_free;
     383        extern SubInfo *pSub_free;
    388384        op_call(pSub_free);
    389385    }

  • BasicCompiler32/Compile_ProcOp.cpp

    r64 r73  
    214214}
    215215
    216 void CompileBufferInProcedure(SUBINFO *psi){
     216void CompileBufferInProcedure(SubInfo *psi){
    217217    extern char *basbuf;
    218218    extern HANDLE hHeap;
    219     extern SUBINFO **ppSubHash;
     219    extern SubInfo **ppSubHash;
    220220    extern BOOL bDebugCompile;
    221221    int i3,i4,VarSize,LocalVarSchedule,EspOffsetSchedule,BufferSize,BaseOffset;
    … …  
    280280
    281281    //パラメータ用の変数データを考慮
    282     for(i3=psi->RealParmNum-1;i3>=0;i3--){
     282    for(i3=psi->realParams.size()-1;i3>=0;i3--){
     283        Parameter &param = *psi->realParams[i3];
     284
    283285        //変数データを追加
    284286        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    285287
    286         lstrcpy(LocalVar[MaxLocalVarNum].name,psi->pRealParmInfo[i3].name);
     288        lstrcpy( LocalVar[MaxLocalVarNum].name,param.GetVarName().c_str() );
    287289
    288290        // TODO: パラメータのConst定義の指定が未完成
    289291        LocalVar[MaxLocalVarNum].bConst=false;
    290292
    291         LocalVar[MaxLocalVarNum].bArray=psi->pRealParmInfo[i3].bArray;
    292         memcpy(LocalVar[MaxLocalVarNum].SubScripts,psi->pRealParmInfo[i3].SubScripts,MAX_ARRAYDIM*sizeof(int));
    293 
    294         LocalVar[MaxLocalVarNum].type=psi->pRealParmInfo[i3].type;
     293        LocalVar[MaxLocalVarNum].bArray=param.IsArray()?TRUE:FALSE;
     294        memcpy(LocalVar[MaxLocalVarNum].SubScripts,param.GetSubScriptsPtr(),MAX_ARRAYDIM*sizeof(int));
     295
     296        LocalVar[MaxLocalVarNum].type=param.GetBasicType();
    295297        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
    296298            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
    … …  
    299301        }
    300302
    301         LocalVar[MaxLocalVarNum].u.index=psi->pRealParmInfo[i3].u.index;
    302 
    303         if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_STRUCT){
     303        LocalVar[MaxLocalVarNum].u.index=param.GetIndex();
     304
     305        if( param.IsRef() == false && param.IsStruct() ){
    304306            //構造体のByValパラメータ
    305307            LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
    … …  
    307309        }
    308310        else{
    309             if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].bArray==0){
     311            if( param.IsRef() == false && param.IsArray() == false ){
    310312                LocalVar[MaxLocalVarNum].fRef=0;
    311313                VarSize=GetTypeSize(LocalVar[MaxLocalVarNum].type,LocalVar[MaxLocalVarNum].u.index);
    … …  
    344346
    345347    //コンパイル中の関数
    346     extern SUBINFO *pCompilingSubInfo;
     348    extern SubInfo *pCompilingSubInfo;
    347349    pCompilingSubInfo=psi;
    348350
    … …  
    442444
    443445        //call _DebugSys_StartProc
    444         extern SUBINFO *pSub_DebugSys_StartProc;
     446        extern SubInfo *pSub_DebugSys_StartProc;
    445447        op_call(pSub_DebugSys_StartProc);
    446448    }
    … …  
    684686
    685687        //call _DebugSys_EndProc
    686         extern SUBINFO *pSub_DebugSys_EndProc;
     688        extern SubInfo *pSub_DebugSys_EndProc;
    687689        op_call(pSub_DebugSys_EndProc);
    688690    }
    … …  
    806808
    807809        //call _esp_error
    808         extern SUBINFO *pSub_esp_error;
     810        extern SubInfo *pSub_esp_error;
    809811        op_call( pSub_esp_error );
    810812
    … …  
    840842}
    841843void CompileLocal(){
    842     extern SUBINFO **ppSubHash;
     844    extern SubInfo **ppSubHash;
    843845    int i2;
    844     SUBINFO *psi;
     846    SubInfo *psi;
    845847
    846848    extern BOOL bDll;
    … …  
    856858    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    857859    //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
    858     extern SUBINFO *pSub_System_InitStaticLocalVariables;
     860    extern SubInfo *pSub_System_InitStaticLocalVariables;
    859861    pSub_System_InitStaticLocalVariables->bCompile=1;
    860862
    861863    //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
    862     extern SUBINFO *pSub_System_Call_Destructor_of_GlobalObject;
     864    extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
    863865    pSub_System_Call_Destructor_of_GlobalObject->bCompile=1;
    864866

  • BasicCompiler32/Compile_Set_Var.cpp

    r67 r73  
    7171
    7272                    //call free
    73                     extern SUBINFO *pSub_free;
     73                    extern SubInfo *pSub_free;
    7474                    op_call(pSub_free);
    7575                }

  • BasicCompiler32/Compile_Statement.cpp

    r67 r73  
    55    int i,i2;
    66    char buffer[8192];
    7     SUBINFO *psi;
     7    SubInfo *psi;
    88
    99    for(i=0;;i++){
    … …  
    4444
    4545        //GetSubHash内でエラー提示が行われた場合
    46         if(psi==(SUBINFO *)-1) return;
     46        if(psi==(SubInfo *)-1) return;
    4747
    4848        if(psi==0){
    … …  
    5454
    5555            //GetSubHash内でエラー提示が行われた場合
    56             if(psi==(SUBINFO *)-1) return;
     56            if(psi==(SubInfo *)-1) return;
    5757        }
    5858
    … …  
    10761076                    pobj_c=(CClass *)lpIndex;
    10771077
    1078                     std::vector<SUBINFO *> subs;
     1078                    std::vector<SubInfo *> subs;
    10791079                    pobj_c->EnumMethod( CALC_EQUAL, subs );
    10801080                    if( subs.size() == 0 ){
    … …  
    10931093
    10941094                    //オーバーロードを解決
    1095                     SUBINFO *psi;
     1095                    SubInfo *psi;
    10961096                    psi=OverloadSolution("==",subs,ppi,iParmNum,NULL);
    10971097                    HeapDefaultFree(ppi);
    … …  
    13301330        //戻り値をセット
    13311331        if(Parameter[0]){
    1332             extern SUBINFO *pCompilingSubInfo;
     1332            extern SubInfo *pCompilingSubInfo;
    13331333            char *temp;
    13341334            if(pCompilingSubInfo->name[0]==1&&pCompilingSubInfo->name[1]==ESC_OPERATOR)
    … …  
    14601460    OpcodeCalc(temp2);
    14611461
    1462     SUBINFO *psi;
     1462    SubInfo *psi;
    14631463    if(bFile) psi=GetSubHash("INPUT_FromFile");
    14641464    else psi=GetSubHash("INPUT_FromPrompt");
    … …  
    15621562    OpcodeCalc(temp2);
    15631563
    1564     SUBINFO *psi;
     1564    SubInfo *psi;
    15651565    if(bFile) psi=GetSubHash("PRINTUSING_ToFile");
    15661566    else psi=GetSubHash("PRINTUSING_ToPrompt");
    … …  
    16661666    if(sw) lstrcat(buffer,"+Ex\"\\r\\n\"");
    16671667
    1668     SUBINFO *psi;
     1668    SubInfo *psi;
    16691669    if(bFile) psi=GetSubHash("PRINT_ToFile");
    16701670    else psi=GetSubHash("PRINT_ToPrompt");

  • BasicCompiler32/Compile_Var.cpp

    r69 r73  
    520520
    521521    char temporary[VN_SIZE];
    522     extern SUBINFO *pCompilingSubInfo;
     522    extern SubInfo *pCompilingSubInfo;
    523523    if(pCompilingSubInfo){
    524524        GetNowStaticVarFullName(VarName,temporary);

  • BasicCompiler32/MakePeHdr.cpp

    r67 r73  
    88// 特殊関数の構造体ポインタ
    99////////////////////////////
    10 SUBINFO
     10SubInfo
    1111    *pSub_System_StartupProgram,
    1212    *pSub_DebugSys_StartProc,
    … …  
    391391
    392392        //call _System_Call_Destructor_of_GlobalObject
    393         extern SUBINFO *pSub_System_Call_Destructor_of_GlobalObject;
     393        extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
    394394        op_call(pSub_System_Call_Destructor_of_GlobalObject);
    395395
    … …  
    522522        ExportNamesLength=lstrlen(lpExportNames)+1;
    523523
    524         extern SUBINFO **ppSubHash;
    525         SUBINFO *psi,*psi2;
     524        extern SubInfo **ppSubHash;
     525        SubInfo *psi,*psi2;
    526526        while(1){
    527527            //辞書順にサーチ

  • BasicCompiler32/NumOpe_Arithmetic.cpp

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

  • BasicCompiler32/Opcode.h

    r71 r73  
    214214    ParamImpl(const char *buffer);
    215215    ParamImpl(const PARAMETER_INFO *pParamInfo, const int ParmNum);
     216    ParamImpl::ParamImpl(const Parameters &params);
    216217    ~ParamImpl();
    217218    void SetReturnType(TYPEINFO *pTypeInfo);
    218219
    219220private:
    220     BOOL _overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level);
    221     SUBINFO *OverloadSolutionWithReturnType( const char *name, std::vector<SUBINFO *> &subs );
     221    BOOL _overload_check( Parameters &params,TYPEINFO *pReturnTypeInfo,int overload_level);
     222    SubInfo *OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs );
    222223public:
    223     SUBINFO *OverloadSolution( const char *name, std::vector<SUBINFO *> &subs );
     224    SubInfo *OverloadSolution( const char *name, std::vector<SubInfo *> &subs );
    224225
    225226    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
     227    bool ErrorCheck( const char *procName, const Parameters &params, int SecondParmNum );
    226228    void MacroParameterSupport(PARAMETER_INFO *ppi);
     229    void MacroParameterSupport( const Parameters &params );
    227230    void SetStructParameter(CClass *pobj_Class,LPSTR Parameter);
    228231    int SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
     232    int SetParameter( const char *procName, const Parameters &params, int SecondParmNum );
    229233
    230234    //一時オブジェクトパラメータの生成と破棄
    231235    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
     236    int NewTempParameters( const char *procName, const Parameters &params, int SecondParmNum );
    232237    void DeleteTempParameters();
    233238};
    … …  
    237242#define PROCFLAG_NEW    1
    238243int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
    239 void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
     244void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType);
    240245int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
    241246
    … …  
    339344void fpu_cast_end();
    340345
    341 void op_call(SUBINFO *psi);
     346void op_call(SubInfo *psi);

  • BasicCompiler32/OperatorProc.cpp

    r67 r73  
    1818
    1919    //call free
    20     extern SUBINFO *pSub_free;
     20    extern SubInfo *pSub_free;
    2121    op_call(pSub_free);
    2222}
    … …  
    2727    pobj_c=(CClass *)index_stack[sp-2];
    2828
    29     std::vector<SUBINFO *> subs;
     29    std::vector<SubInfo *> subs;
    3030    pobj_c->EnumMethod( idCalc, subs );
    3131    if( subs.size() == 0 ){
    … …  
    4242    BOOL bReturnTypeIsObject=1;
    4343    TYPEINFO ReturnType={DEF_OBJECT,subs[0]->u.ReturnIndex};
    44     foreach( SUBINFO *psi, subs ){
     44    foreach( SubInfo *psi, subs ){
    4545        if(psi->ReturnType!=DEF_OBJECT)
    4646            bReturnTypeIsObject=0;
    … …  
    7979    if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
    8080    else GetCalcName(idCalc,temporary);
    81     SUBINFO *psi;
     81    SubInfo *psi;
    8282    psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
    8383
    … …  
    8888    else{
    8989        //オーバーロードされていないが、パラメータ個数が一致しないとき
    90         if(iParmNum!=psi->ParmNum){
     90        if(iParmNum!=psi->params.size()){
    9191            HeapDefaultFree(ppi);
    9292            return -1;
    … …  
    9696    for(i=0;i<iParmNum;i++){
    9797        CheckDifferentType(
    98             psi->pParmInfo[i].type,
    99             psi->pParmInfo[i].u.index,
     98            psi->params[i]->GetBasicType(),
     99            psi->params[i]->GetIndex(),
    100100            ppi[i].type,
    101101            ppi[i].u.index,
    … …  
    109109
    110110    if(bTwoTerm){
    111         if(psi->pRealParmInfo[1].type==DEF_STRUCT&&psi->pRealParmInfo[1].bByVal){
     111        if( psi->realParams[1]->IsStruct() &&psi->realParams[1]->IsRef() == false ){
    112112            //一時オブジェクトはメソッド内で破棄される
    113113            bUseHeap[sp-1]=0;
    … …  
    128128
    129129        //call calloc
    130         extern SUBINFO *pSub_calloc;
     130        extern SubInfo *pSub_calloc;
    131131        op_call(pSub_calloc);
    132132
    … …  
    180180        }
    181181
    182         if( !psi->pRealParmInfo[1].bByVal ){
     182        if( psi->realParams[1]->IsRef() ){
    183183            //一時参照を作成
    184184
    … …  
    203203
    204204    if(bTwoTerm){
    205         if( !psi->pRealParmInfo[1].bByVal ){
     205        if( psi->realParams[1]->IsRef() ){
    206206            //一時参照を破棄
    207207            op_pop( REG_NON );
    … …  
    273273}
    274274void CallIndexerGetterProc(CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo){
    275     std::vector<SUBINFO *> subs;
     275    std::vector<SubInfo *> subs;
    276276    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
    277277    if( subs.size() == 0 ){

  • BasicCompiler32/VarList.cpp

    r69 r73  
    348348    if(pobj_dti->lplpSpBase[i2]==0) return;
    349349
    350     extern SUBINFO **ppSubHash;
    351     SUBINFO *psi;
     350    extern SubInfo **ppSubHash;
     351    SubInfo *psi;
    352352    for(i3=0,sw=0;i3<MAX_HASH;i3++){
    353353        psi=ppSubHash[i3];
    … …  
    583583
    584584    //プロシージャ コンボボックス
    585     extern SUBINFO **ppSubHash;
    586     SUBINFO *psi;
     585    extern SubInfo **ppSubHash;
     586    SubInfo *psi;
    587587    int sw;
    588588    SendMessage(hProcCombo,CB_RESETCONTENT,0,0);
    … …  
    706706
    707707    if(pobj_dti->lplpSpBase[i2]){
    708         extern SUBINFO **ppSubHash;
    709         SUBINFO *psi;
     708        extern SubInfo **ppSubHash;
     709        SubInfo *psi;
    710710        for(i3=0,sw=0;i3<MAX_HASH;i3++){
    711711            psi=ppSubHash[i3];

  • BasicCompiler32/WatchList.cpp

    r64 r73  
    308308ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip){
    309309    int i;
    310     SUBINFO *psi;
     310    SubInfo *psi;
    311311
    312312    //ripからプロシージャを取得

  • BasicCompiler32/op32_main.cpp

    r67 r73  
    974974/////////////////////////////
    975975
    976 void op_call(SUBINFO *psi){
     976void op_call(SubInfo *psi){
    977977    OpBuffer[obp++]=(char)0xE8;
    978978    pobj_SubAddrSchedule->add(psi,1);
Note: See TracChangeset for help on using the changeset viewer.