Changeset 290 in dev for trunk/abdev/BasicCompiler32


Ignore:
Timestamp:
Aug 21, 2007, 11:00:25 PM (17 years ago)
Author:
dai_9181
Message:

ジェネリクスのベースを実装

Location:
trunk/abdev/BasicCompiler32
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r265 r290  
    373373}
    374374
    375 void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
     375void SetVariableFromEax( const Type &varType,int CalcType,RELATIVE_VAR *pRelativeVar){
    376376    /////////////////////////////////////////////////
    377377    // eaxの内容を変数にコピーするコードを抽出
    378378    /////////////////////////////////////////////////
    379379
    380     if(VarType==DEF_BOOLEAN){
     380    if( varType.IsBoolean() )
     381    {
    381382        //bool
    382383        SetBooleanVariable(CalcType,pRelativeVar);
    383384    }
    384     else if( IsRealNumberType( VarType ) ){
     385    else if( varType.IsReal() )
     386    {
    385387        // Double/Single型変数へレジスタの値を代入
    386         SetRealVariable(VarType, CalcType, pRelativeVar);
    387     }
    388     else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
    389         int typeSize = GetTypeSize( VarType, -1 );
     388        SetRealVariable(varType.GetBasicType(), CalcType, pRelativeVar);
     389    }
     390    else if( varType.IsWhole() || varType.IsObject() )
     391    {
     392        int typeSize = varType.GetSize();
    390393
    391394        //整数変数へraxの値を格納する
    … …  
    640643    RestoreDefaultRegisterFromStackMemory( calcType.GetBasicType() );
    641644
    642     SetVariableFromEax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar);
    643 }
     645    SetVariableFromEax(varType,calcType.GetBasicType(),&VarRelativeVar);
     646}

  • trunk/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp

    r253 r290  
    5959    }
    6060}
    61 void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head){
     61void SetReg_WholeVariable( Type &type, RELATIVE_VAR *pRelativeVar,int reg, bool is64Head)
     62{
    6263    int varSize;
    6364
    64     varSize=GetTypeSize(type,-1);
     65    varSize = type.GetSize();
    6566
    6667    if(varSize==sizeof(_int64)){
    … …  
    7273
    7374        //下位32ビットをeaxにロード
    74         SetReg_WholeVariable(DEF_LONG,pRelativeVar,REG_EAX);
     75        SetReg_WholeVariable( Type(DEF_LONG),pRelativeVar,REG_EAX);
    7576
    7677        //上位32ビットをedxにロード
    77         SetReg_WholeVariable(DEF_LONG,pRelativeVar,REG_EDX, true);
     78        SetReg_WholeVariable( Type(DEF_LONG),pRelativeVar,REG_EDX, true);
    7879
    7980        return;

  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r265 r290  
    8181}
    8282
    83 bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
     83bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName ){
    8484    int i2;
    8585
    … …  
    115115                Type varType;
    116116                GetVarType( ObjectName, varType, false );
    117                 pobj_c = &varType.GetClass();
    118                 if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
     117                if( NATURAL_TYPE( varType.GetBasicType() ) == DEF_OBJECT )
     118                {
     119                    pobj_c = &varType.GetClass();
     120                }
     121                else
     122                {
    119123                    pobj_c=compiler.GetObjectModule().meta.GetClasses().Find(ObjectName);
    120124                    if( pobj_c ){

  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r265 r290  
    259259
    260260        char ObjectName[VN_SIZE];
    261         int RefType;
    262         SplitObjectName(name,ObjectName,&RefType);
     261        ReferenceKind referenceKind;
     262        SplitObjectName(name,ObjectName, referenceKind );
    263263
    264264        if(ObjectName[0]){
    … …  
    274274
    275275                //参照タイプが整合しているかをチェック
    276                 if(type.GetBasicType()!=RefType) SetError(104,ObjectName,cp);
     276                if( !( type.IsObject() && referenceKind == RefDot
     277                    || type.IsObjectPtr() && referenceKind == RefPointer ) )
     278                {
     279                    SetError(104,ObjectName,cp);
     280                }
    277281
    278282                if(type.IsObjectPtr()){

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r263 r290  
    5252    Opcode_CallProc(CreateParameter,
    5353        pUserProc,
    54         PROCFLAG_NEW,"",0);
     54        PROCFLAG_NEW,"");
    5555
    5656    {
    … …  
    6565            Opcode_CallProc(temporary,
    6666                subs[0],
    67                 PROCFLAG_NEW,"",0);
     67                PROCFLAG_NEW,"");
    6868        }
    6969        else{

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r285 r290  
    267267
    268268    //コンパイル中の関数が属するクラス
    269     compiler.pCompilingClass=pUserProc->GetParentClassPtr();
     269    compiler.pCompilingClass = pUserProc->GetParentClassPtr();
    270270
    271271    //コンパイルスタートをクラス管理クラスに追加
    … …  
    495495                        &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
    496496                        0,
    497                         "",
    498                         0);
     497                        ""
     498                    );
    499499                }
    500500            }
    … …  
    587587                        &method->GetUserProc(),
    588588                        0,
    589                         "",
    590                         0);
     589                        ""
     590                    );
    591591                }
    592592            }
    … …  
    629629        GetVarOffsetReadWrite(temp,&RelativeVar,Type());
    630630
    631         i3=pUserProc->ReturnType().GetBasicType();
    632 
    633         if(i3==DEF_OBJECT || i3==DEF_STRUCT){
     631        const Type &returnType = pUserProc->ReturnType();
     632        if( returnType.IsObject() || returnType.IsStruct() )
     633        {
    634634            SetVarPtrToEax(&RelativeVar);
    635             if( i3==DEF_OBJECT ){
     635            if( returnType.IsObject() )
     636            {
    636637                //mov eax,dword ptr[eax]
    637638                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
    638639            }
    639640        }
    640         else if( i3==DEF_DOUBLE
    641             || i3 == DEF_SINGLE )
     641        else if( returnType.IsReal() )
    642642        {
    643643            //fld qword ptr[ebp+offset]
    644644            compiler.codeGenerator.localVarPertialSchedules.push_back(
    645                 compiler.codeGenerator.op_fld_base_offset( i3, REG_EBP, RelativeVar.offset, Schedule::None, true )
     645                compiler.codeGenerator.op_fld_base_offset( returnType.GetBasicType(), REG_EBP, RelativeVar.offset, Schedule::None, true )
    646646            );
    647647        }
    648         else if(i3==DEF_INT64||i3==DEF_QWORD){
    649             //mov eax,dword ptr[ebp+offset]
    650             compiler.codeGenerator.localVarPertialSchedules.push_back(
    651                 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
    652             );
    653 
    654             //mov edx,dword ptr[ebp+offset+sizeof(long)]
    655             compiler.codeGenerator.localVarPertialSchedules.push_back(
    656                 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EBP, RelativeVar.offset+sizeof(long), MOD_BASE_DISP32, Schedule::None, true )
    657             );
    658         }
    659         else if(i3==DEF_LONG||i3==DEF_DWORD||
    660             IsPtrType(i3))
     648        else if( returnType.Is64() )
    661649        {
    662650            //mov eax,dword ptr[ebp+offset]
    … …  
    664652                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
    665653            );
    666         }
    667         else if(i3==DEF_INTEGER||i3==DEF_WORD || (Smoothie::IsUnicode()&&i3==DEF_CHAR)){
     654
     655            //mov edx,dword ptr[ebp+offset+sizeof(long)]
     656            compiler.codeGenerator.localVarPertialSchedules.push_back(
     657                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EBP, RelativeVar.offset+sizeof(long), MOD_BASE_DISP32, Schedule::None, true )
     658            );
     659        }
     660        else if( returnType.GetSize() == sizeof(long) )
     661        {
     662            //mov eax,dword ptr[ebp+offset]
     663            compiler.codeGenerator.localVarPertialSchedules.push_back(
     664                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
     665            );
     666        }
     667        else if( returnType.GetSize() == sizeof(short) )
     668        {
    668669            //xor eax,eax（eaxを0に初期化する）
    669670            compiler.codeGenerator.op_zero_reg(REG_EAX);
    … …  
    674675            );
    675676        }
    676         else if(i3==DEF_SBYTE||i3==DEF_BYTE||i3==DEF_BOOLEAN || (Smoothie::IsUnicode()==false&&i3==DEF_CHAR)){
     677        else if( returnType.GetSize() == sizeof(char) )
     678        {
    677679            //xor eax,eax（eaxを0に初期化する）
    678680            compiler.codeGenerator.op_zero_reg(REG_EAX);
    … …  
    682684                compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
    683685            );
     686        }
     687        else
     688        {
     689            SetError();
    684690        }
    685691    }

  • trunk/abdev/BasicCompiler32/Compile_Set_Var.cpp

    r253 r290  
    188188
    189189    //cmp eax,0
    190     compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     190    compiler.codeGenerator.op_cmp_value(Type(type,-1).GetSize(),REG_EAX,0);
    191191
    192192    //setne al

  • trunk/abdev/BasicCompiler32/Compile_Statement.cpp

    r285 r290  
    8181            }
    8282
    83             Opcode_CallProc("",pUserProc,0,"",0);
     83            Opcode_CallProc("",pUserProc,0,"");
    8484
    8585            return;

  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r288 r290  
    160160    return 1;
    161161}
    162 bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
     162bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const Type &classType, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess)
     163{
     164    const CClass &objClass = classType.GetClass();
    163165
    164166    //////////////////////////////////////
    … …  
    221223    resultType = pMember->GetType();
    222224
     225
     226    /////////////////////////////////////////////////////////
     227    // ☆★☆ ジェネリクスサポート ☆★☆
     228
     229    if( resultType.IsTypeParameter() )
     230    {
     231        // 型パラメータだったとき
     232        if( classType.HasActualGenericType() )
     233        {
     234            // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
     235            resultType = classType.GetDummyActualGenericType();
     236        }
     237        else
     238        {
     239            // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
     240            resultType.SetBasicType( DEF_OBJECT );
     241        }
     242    }
     243
     244    //
     245    /////////////////////////////////////////////////////////
     246
     247
    223248    //ポインタ変数の場合
    224249    if( resultType.IsPointer() ){
    … …  
    321346            isErrorEnabled,
    322347            isWriteAccess,
    323             pMember->GetType().GetClass(),
     348            pMember->GetType(),
    324349            NestMember,
    325350            pRelativeVar,
    … …  
    345370    RelativeVar.offset=-LocalVar_ThisPtrOffset;
    346371
    347     SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
     372    SetReg_WholeVariable(Type(DEF_PTR_VOID),&RelativeVar,reg);
    348373}
    349374
    … …  
    472497            isErrorEnabled,
    473498            isWriteAccess,
    474             *compiler.pCompilingClass,
     499            Type( DEF_OBJECT, *compiler.pCompilingClass ),
    475500            variable,
    476501            pRelativeVar,
    … …  
    701726            isErrorEnabled,
    702727            isWriteAccess,
    703             resultType.GetClass(),
     728            resultType,
    704729            member,pRelativeVar,resultType,0)) return false;
    705730
    … …  
    12041229            SetError();
    12051230        }
    1206         SetVariableFromEax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
     1231        SetVariableFromEax( Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() ), DEF_OBJECT, &RelativeVar );
    12071232    }
    12081233}

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r288 r290  
    397397        InitGCVariables();
    398398
    399         if( compiler.IsStaticLibrary() )
     399        //if( compiler.IsStaticLibrary() )
    400400        {
    401401            //_System_StartupProgramの呼び出し
    … …  
    504504    }
    505505
    506     CompileMessage( "リンク中..." );
     506    extern BOOL bError;
     507    if( !bError )
     508    {
     509        CompileMessage( "リンク中..." );
     510    }
    507511
    508512

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r276 r290  
    122122    else if( resultType.IsWhole() || resultType.IsObject()){
    123123        //整数型
    124         SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,useReg);
     124        SetReg_WholeVariable(resultType,&relativeVar,useReg);
    125125    }
    126126    else if( resultType.IsStruct() ){
    … …  
    142142    return true;
    143143}
    144 bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
     144bool TermMemberOpe( const Type &leftType, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member )
     145{
     146    const CClass &objClass = leftType.GetClass();
     147
    145148    const int useReg = REG_EAX;
    146149
    147     if( GetMemberType( objClass, member, resultType, 0, false ) ){
     150    if( GetMemberType( leftType, member, resultType, 0, false ) ){
    148151        // メンバが見つかったとき
    149152
    … …  
    157160            true,   //エラー表示あり
    158161            false,  //読み込み専用
    159             objClass,
     162            leftType,
    160163            member,&relativeVar,resultType,0)){
    161164                return false;
    … …  
    194197                compiler.codeGenerator.op_push( useReg );
    195198
    196                 if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
     199                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft) ){
    197200
    198201                    return false;
    … …  
    217220
    218221                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     222
     223
     224                /////////////////////////////////////////////////////////
     225                // ☆★☆ ジェネリクスサポート ☆★☆
     226
     227                if( resultType.IsTypeParameter() )
     228                {
     229                    // 型パラメータだったとき
     230                    if( leftType.HasActualGenericType() )
     231                    {
     232                        // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
     233                        resultType = leftType.GetDummyActualGenericType();
     234                    }
     235                    else
     236                    {
     237                        // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
     238                        resultType.SetBasicType( DEF_OBJECT );
     239                    }
     240                }
     241
     242                //
     243                /////////////////////////////////////////////////////////
    219244            }
    220245           
    … …  
    227252bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
    228253    char parameter[VN_SIZE];
     254
     255    if( (string)term=="a.x")
     256    {
     257        int test=0;
     258    }
    229259
    230260    // Withを解決
    … …  
    279309        }
    280310
    281         return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
     311        return TermMemberOpe( leftType, baseType, resultType, termFull, termLeft, member );
    282312    }
    283313globalArea:

  • trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp

    r225 r290  
    217217        }
    218218
    219         if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)){
     219        if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)){
    220220            if(AnswerType==DEF_SINGLE){
    221221                //add esp,4
    … …  
    652652    }
    653653                                                            //↓ここだけ例外DWord
    654     if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)||type[sp-2]==DEF_DWORD){
     654    if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)||type[sp-2]==DEF_DWORD){
    655655        if(AnswerType==DEF_SINGLE){
    656656            //add esp,4
    … …  
    997997    sp=*pStackPointer;
    998998
    999     int CastType;
    1000     CastType=type[sp-1];
    1001     if((CastType&FLAG_CAST)==0){
     999    int castBasicType = type[sp-1];
     1000    if((castBasicType&FLAG_CAST)==0){
    10021001        SetError(47,NULL,cp);
    10031002        return 0;
    10041003    }
    1005     CastType=CastType&(~FLAG_CAST);
    1006 
    1007     if(IsPtrType(CastType)){
    1008         ChangeTypeToLong(type[sp-2]);
    1009     }
    1010     else if(IsRealNumberType(CastType)){
    1011         if(CastType==DEF_DOUBLE) ChangeTypeToDouble(type[sp-2]);
    1012         else if(CastType==DEF_SINGLE) ChangeTypeToSingle(type[sp-2]);
    1013     }
    1014     else ChangeTypeToWhole(type[sp-2],CastType);
    1015 
    1016     type[sp-2]=CastType;
    1017     index_stack[sp-2]=index_stack[sp-1];
     1004    castBasicType = castBasicType&(~FLAG_CAST);
     1005
     1006    Type oldType( type[sp-2], index_stack[sp-2] );
     1007    Type castType( castBasicType, index_stack[sp-1] );
     1008
     1009    if( castType.IsPointer() )
     1010    {
     1011        ChangeTypeToLong( oldType.GetBasicType() );
     1012    }
     1013    else if( castType.IsReal() )
     1014    {
     1015        if( castType.IsDouble() )
     1016        {
     1017            ChangeTypeToDouble( oldType.GetBasicType() );
     1018        }
     1019        else if( castType.IsSingle() )
     1020        {
     1021            ChangeTypeToSingle( oldType.GetBasicType() );
     1022        }
     1023    }
     1024    else
     1025    {
     1026        ChangeTypeToWhole( oldType, castType );
     1027    }
     1028
     1029    type[sp-2] = castType.GetBasicType();
     1030    index_stack[sp-2] = castType.GetIndex();
    10181031
    10191032    sp--;

  • trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp

    r225 r290  
    450450
    451451        //cmp eax,0
    452         compiler.codeGenerator.op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);
     452        compiler.codeGenerator.op_cmp_value(Type(type[sp-1],-1).GetSize(),REG_EAX,0);
    453453
    454454        //setne al

  • trunk/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp

    r235 r290  
    88#include "Opcode.h"
    99
    10 void ExtendStackTo32(int type);
    11 void ExtendStackTo64(int type){
    12     if(Is64Type(type)) return;
     10void ExtendStackTo32( const Type &oldType );
     11
     12void ExtendStackTo64( const Type &oldType )
     13{
     14    if( oldType.Is64() )
     15    {
     16        return;
     17    }
    1318
    1419    //32ビットに拡張
    15     ExtendStackTo32(type);
     20    ExtendStackTo32( oldType );
    1621
    1722    //64ビットに拡張
    18     if(IsSignedType(type)){
     23    if( oldType.IsSigned() )
     24    {
    1925        //符号あり
    2026
    … …  
    4450    }
    4551}
    46 void ExtendStackTo32(int type){
    47     if(GetTypeSize(type,-1)==sizeof(long)) return;
    48 
    49     if(Is64Type(type)){
     52void ExtendStackTo32( const Type &oldType )
     53{
     54    if( oldType.GetSize() == sizeof(long) )
     55    {
     56        return;
     57    }
     58
     59    if( oldType.Is64() )
     60    {
    5061        //pop eax
    5162        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    5768        compiler.codeGenerator.op_push(REG_EAX);
    5869    }
    59     else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
     70    else if( oldType.IsInteger() )
     71    {
    6072        //pop eax
    6173        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    6779        compiler.codeGenerator.op_push(REG_EAX);
    6880    }
    69     else if(type==DEF_WORD){
     81    else if( oldType.IsWord() )
     82    {
    7083        //pop eax
    7184        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    7790        compiler.codeGenerator.op_push(REG_EAX);
    7891    }
    79     else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
     92    else if( oldType.IsSByte() )
     93    {
    8094        //pop eax
    8195        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    87101        compiler.codeGenerator.op_push(REG_EAX);
    88102    }
    89     else if(type==DEF_BYTE||type==DEF_BOOLEAN){
     103    else if( oldType.IsByte() || oldType.IsBoolean() )
     104    {
    90105        //pop eax
    91106        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    98113    }
    99114}
    100 void ExtendStackTo16(int type){
    101     if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
     115void ExtendStackTo16( const Type &oldType ){
     116    if( oldType.IsSByte() )
     117    {
    102118        //pop eax
    103119        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    109125        compiler.codeGenerator.op_push(REG_EAX);
    110126    }
    111     else if(type==DEF_BYTE){
     127    else if( oldType.IsByte() )
     128    {
    112129        //pop eax
    113130        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    120137    }
    121138}
    122 void ExtendStackTo8(int type){
    123     if(Is64Type(type)){
     139void ExtendStackTo8( const Type &oldType )
     140{
     141    if( oldType.Is64() )
     142    {
    124143        //pop eax
    125144        compiler.codeGenerator.op_pop(REG_EAX);
    … …  
    134153
    135154
    136 void ChangeTypeToWhole(int OldType,int NewType){
    137     if(OldType==DEF_DOUBLE){
    138         if(Is64Type(NewType)){
     155void ChangeTypeToWhole( const Type &oldType, const Type &newType ){
     156    if( oldType.IsDouble() )
     157    {
     158        if( newType.Is64() )
     159        {
    139160            //fld qword ptr[esp]
    140161            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    … …  
    154175        }
    155176    }
    156     else if(OldType==DEF_SINGLE){
    157         if(Is64Type(NewType)){
     177    else if( oldType.IsSingle() )
     178    {
     179        if( newType.Is64() )
     180        {
    158181            //fld dword ptr[esp]
    159182            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    … …  
    176199        //整数から整数へ変換
    177200
    178         if(Is64Type(NewType)){
    179             ExtendStackTo64(OldType);
    180         }
    181         else if(GetTypeSize(NewType,-1)==sizeof(long)){
    182             ExtendStackTo32(OldType);
    183         }
    184         else if(GetTypeSize(NewType,-1)==sizeof(short)){
    185             ExtendStackTo16(OldType);
    186         }
    187         else if(GetTypeSize(NewType,-1)==sizeof(char)){
    188             ExtendStackTo8(OldType);
    189         }
    190     }
    191 }
     201        if( newType.Is64() )
     202        {
     203            ExtendStackTo64( oldType );
     204        }
     205        else if( newType.GetSize()==sizeof(long)){
     206            ExtendStackTo32( oldType );
     207        }
     208        else if( newType.GetSize()==sizeof(short)){
     209            ExtendStackTo16( oldType );
     210        }
     211        else if( newType.GetSize()==sizeof(char)){
     212            ExtendStackTo8( oldType );
     213        }
     214    }
     215}

  • trunk/abdev/BasicCompiler32/Opcode.h

    r261 r290  
    5959void ChangeTypeToInteger(int OldType);
    6060void ChangeTypeToByte(int OldType);
    61 void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
     61void SetVariableFromEax( const Type &varType, int CalcType,RELATIVE_VAR *pRelativeVar);
    6262void OpcodeCalc( const char *Command );
    6363
    … …  
    110110
    111111//NumOpe_TypeOperation.cpp
    112 void ExtendStackTo64(int type);
    113 void ChangeTypeToWhole(int OldType,int NewType);
     112void ExtendStackTo64( const Type &oldType );
     113void ChangeTypeToWhole( const Type &oldType, const Type &newType );
    114114
    115115//Compile_Set_Var.cpp
    … …  
    147147//Compile_Calc_PushVar.cpp
    148148void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar);
    149 void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false);
     149void SetReg_WholeVariable( Type &type, RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false);
    150150void PushLongVariable(RELATIVE_VAR *pRelativeVar);
    151151
    … …  
    156156//Compile_Var.cpp
    157157void SetRelativeOffset( RELATIVE_VAR &relativeVar );
    158 bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
     158bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const Type &classType, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
    159159void SetThisPtrToReg(int reg);
    160160bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts = NULL );
    … …  
    208208#define PROCFLAG_NEW    1
    209209bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
    210 bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
     210bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName );
    211211bool Opcode_CallDllProc( const char *lpszParms, const DllProc *pDllProc );
    212212

  • trunk/abdev/BasicCompiler32/OperatorProc.cpp

    r225 r290  
    7979    for(int i=0;i<(int)params.size();i++){
    8080        CheckDifferentType(
    81             pUserProc->Params()[i]->GetBasicType(),
    82             pUserProc->Params()[i]->GetIndex(),
    83             params[i]->GetBasicType(),
    84             params[i]->GetIndex(),
     81            *pUserProc->Params()[i],
     82            *params[i],
    8583            "",
    8684            i);
    … …  
    9189    }
    9290
    93     int right_side_size = GetTypeSize(type_stack[sp-1],index_stack[sp-1]);
     91    int right_side_size = Type(type_stack[sp-1],index_stack[sp-1]).GetSize();
    9492
    9593    if(bTwoTerm){
    … …  
    261259    }
    262260
    263     Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
     261    Opcode_CallProc(Parameter,subs[0],0,ObjectName);
    264262    resultType = subs[0]->ReturnType();
    265263}

  • trunk/abdev/BasicCompiler32/increment.cpp

    r225 r290  
    3535    else{
    3636        //整数
    37         SetReg_WholeVariable(varType.GetBasicType(),&VarRelativeVar,REG_EAX);
     37        SetReg_WholeVariable(varType,&VarRelativeVar,REG_EAX);
    3838    }
    3939
    … …  
    114114        if( varType.IsDouble() )        ChangeTypeToDouble(calcType.GetBasicType());
    115115        else if( varType.IsSingle() )   ChangeTypeToSingle(calcType.GetBasicType());
    116         else ChangeTypeToWhole(calcType.GetBasicType(),varType.GetBasicType());
     116        else ChangeTypeToWhole( calcType, varType );
    117117
    118118        int type_stack[255],sp;
    … …  
    202202    }
    203203
    204     SetVariableFromEax(varType.GetBasicType(),varType.GetBasicType(),&VarRelativeVar);
     204    SetVariableFromEax(varType,varType.GetBasicType(),&VarRelativeVar);
    205205}
Note: See TracChangeset for help on using the changeset viewer.