Changeset 36 in dev for BasicCompiler32


Ignore:
Timestamp:
Jan 20, 2007, 4:55:26 AM (17 years ago)
Author:
dai_9181
Message:

Boolean型に対応。

Location:
BasicCompiler32
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/CParameter.cpp

    r31 r36  
    658658                ParmSize+=sizeof(long);
    659659            }
    660             else if(DummyTypeInfo.type==DEF_CHAR||DummyTypeInfo.type==DEF_BYTE){
     660            else if(DummyTypeInfo.type==DEF_CHAR||DummyTypeInfo.type==DEF_BYTE||DummyTypeInfo.type==DEF_BOOLEAN){
    661661                ChangeTypeToByte(CalcType);
    662662                ParmSize+=sizeof(long);

  • BasicCompiler32/Compile_Calc.cpp

    r28 r36  
    318318void ChangeTypeToInteger(int OldType){
    319319    //現在のスタックの内容をInteger型に変換する
    320     if(OldType==DEF_BYTE||
     320    if(OldType==DEF_BOOLEAN||
     321        OldType==DEF_BYTE||
    321322        OldType==DEF_WORD||OldType==DEF_INTEGER) return;
    322323    else if(OldType==DEF_CHAR){
    … …  
    567568    /////////////////////////////////////////////////
    568569
    569     if(VarType==DEF_CHAR||VarType==DEF_BYTE){
     570    if(VarType==DEF_BOOLEAN){
     571        //bool
     572        SetBooleanVariable(CalcType,&VarRelativeVar);
     573    }
     574    else if(VarType==DEF_CHAR||VarType==DEF_BYTE){
    570575        //8ビット整数型変数へスタックの内容を格納する
    571576        Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);

  • BasicCompiler32/Compile_ProcOp.cpp

    r34 r36  
    777777            obp+=sizeof(long);
    778778        }
    779         else if(i3==DEF_CHAR||i3==DEF_BYTE){
     779        else if(i3==DEF_CHAR||i3==DEF_BYTE||i3==DEF_BOOLEAN){
    780780            //xor eax,eax（eaxを0に初期化する）
    781781            op_zero_reg(REG_EAX);

  • BasicCompiler32/Compile_Set_Var.cpp

    r28 r36  
    874874    }
    875875}
     876void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
     877    if(type==DEF_DOUBLE){
     878        // TODO: 実装
     879    }
     880    else if(type==DEF_SINGLE){
     881        // TODO: 実装
     882    }
     883    else if(type==DEF_INT64||type==DEF_QWORD){
     884        // TODO: 実装
     885
     886        //pop eax
     887        op_pop(REG_EAX);
     888
     889        //cmp eax,0
     890        op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     891
     892        //setne al
     893        op_setne( REG_EAX );
     894
     895        //pop ecx
     896        op_pop(REG_ECX);
     897
     898        //cmp ecx,0
     899        op_cmp_value(GetTypeSize(type,-1),REG_ECX,0);
     900
     901        //setne cl
     902        op_setne( REG_ECX );
     903
     904        //or al,cl
     905        op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
     906    }
     907    else{
     908        if(!IsWholeNumberType(type)){
     909            //不正な型の場合
     910            SetError(9,NULL,cp);
     911            return;
     912        }
     913
     914        //pop eax
     915        op_pop(REG_EAX);
     916    }
     917
     918    //cmp eax,0
     919    op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     920
     921    //setne al
     922    op_setne( REG_EAX );
     923
     924    //push eax
     925    op_push(REG_EAX);
     926
     927    Set8Variable(DEF_BYTE,pRelative->dwKind,pRelative->offset,pRelative->bOffsetOffset);
     928}

  • BasicCompiler32/Compile_Statement.cpp

    r34 r36  
    10111011        type1==DEF_WORD||
    10121012        type1==DEF_CHAR||
    1013         type1==DEF_BYTE) CaseTypeSize=sizeof(long);
     1013        type1==DEF_BYTE||
     1014        type1==DEF_BOOLEAN) CaseTypeSize=sizeof(long);
    10141015    else{
    10151016        CaseTypeSize=GetTypeSize(type1,lpIndex);

  • BasicCompiler32/Compile_Var.cpp

    r34 r36  
    837837    else if(type==DEF_INTEGER||type==DEF_WORD)
    838838        *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
    839     else if(type==DEF_CHAR||type==DEF_BYTE)
     839    else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN)
    840840        *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
    841841    //String型が未完成
    … …  
    10501050        obp+=sizeof(long);
    10511051    }
    1052     else if(type==DEF_CHAR||type==DEF_BYTE){
     1052    else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN){
    10531053        //mov byte ptr[ebp+offset],InitValue
    10541054        OpBuffer[obp++]=(char)0xC6;

  • BasicCompiler32/NumOpe.cpp

    r35 r36  
    5757        op_push(REG_EBX);
    5858    }
    59     else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||
     59    else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||type==DEF_BOOLEAN||
    6060        IsPtrType(type)){
    6161        //push eax
    … …  
    418418                            PushCharVariable(&RelativeVar);
    419419                        }
    420                         else if(i2==DEF_BYTE){
     420                        else if(i2==DEF_BYTE||i2==DEF_BOOLEAN){
    421421                            PushByteVariable(&RelativeVar);
    422422                        }
    … …  
    718718            i3=(long)i64data;
    719719
    720             if(i2==DEF_CHAR||i2==DEF_BYTE) i3=i3&0x000000FF;
     720            if(i2==DEF_CHAR||i2==DEF_BYTE||i2==DEF_BOOLEAN) i3=i3&0x000000FF;
    721721            if(i2==DEF_INTEGER||i2==DEF_WORD) i3=i3&0x0000FFFF;
    722722

  • BasicCompiler32/NumOpe_Logical.cpp

    r3 r36  
    450450    }
    451451
    452     if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
     452    if( type[sp - 1] == DEF_BOOLEAN ){
     453        //pop eax
     454        op_pop( REG_EAX );
     455
     456        //cmp eax,0
     457        op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);
     458
     459        //setne al
     460        op_setne( REG_EAX );
     461
     462        //and eax,000000FFh
     463        op_and_RV(REG_EAX,(int)0xFF);
     464
     465        //neg
     466        op_neg( REG_EAX );
     467
     468        //sbb eax, eax
     469        op_sbb_RR( REG_EAX, REG_EAX );
     470
     471        //add eax, 1
     472        op_add_RV8( REG_EAX, 1 );
     473
     474        //push eax
     475        op_push( REG_EAX );
     476    }
     477    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    453478        ////////////////////
    454479        // 64ビット整数演算

  • BasicCompiler32/NumOpe_Relation.cpp

    r3 r36  
    8484        OpBuffer[obp++]=(char)0xE0;
    8585
    86         //mov ecx,0xFFFFFFFF
    87         OpBuffer[obp++]=(char)0xB9;
    88         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     86        //mov ecx,1
     87        OpBuffer[obp++]=(char)0xB9;
     88        *((long *)(OpBuffer+obp))=1;
    8989        obp+=sizeof(long);
    9090
    … …  
    166166        OpBuffer[TrueSchedule]=obp-(TrueSchedule+1);
    167167
    168         //mov eax,0FFFFFFFFh
     168        //mov eax,1
    169169        OpBuffer[obp++]=(char)0xB8;
    170         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     170        *((long *)(OpBuffer+obp))=1;
    171171        obp+=sizeof(long);
    172172
    … …  
    199199        op_sub_esp(4);
    200200
    201         //mov ecx,0FFFFFFFFh
    202         OpBuffer[obp++]=(char)0xB9;
    203         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     201        //mov ecx,1
     202        OpBuffer[obp++]=(char)0xB9;
     203        *((long *)(OpBuffer+obp))=1;
    204204        obp+=sizeof(long);
    205205
    … …  
    235235
    236236    sp--;
    237     type_stack[sp-1]=DEF_LONG;
     237    type_stack[sp-1]=DEF_BOOLEAN;
    238238
    239239    *pStackPointer=sp;
    … …  
    320320        OpBuffer[obp++]=(char)0xE0;
    321321
    322         //mov ecx,0xFFFFFFFF
    323         OpBuffer[obp++]=(char)0xB9;
    324         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     322        //mov ecx,1
     323        OpBuffer[obp++]=(char)0xB9;
     324        *((long *)(OpBuffer+obp))=1;
    325325        obp+=sizeof(long);
    326326
    … …  
    404404        OpBuffer[TrueSchedule]=obp-(TrueSchedule+1);
    405405
    406         //mov eax,0FFFFFFFFh
     406        //mov eax,1
    407407        OpBuffer[obp++]=(char)0xB8;
    408         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     408        *((long *)(OpBuffer+obp))=1;
    409409        obp+=sizeof(long);
    410410
    … …  
    437437        op_sub_esp(4);
    438438
    439         //mov ecx,0FFFFFFFFh
    440         OpBuffer[obp++]=(char)0xB9;
    441         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     439        //mov ecx,1
     440        OpBuffer[obp++]=(char)0xB9;
     441        *((long *)(OpBuffer+obp))=1;
    442442        obp+=sizeof(long);
    443443
    … …  
    473473
    474474    sp--;
    475     type_stack[sp-1]=DEF_LONG;
     475    type_stack[sp-1]=DEF_BOOLEAN;
    476476
    477477    *pStackPointer=sp;
    … …  
    561561        OpBuffer[obp++]=(char)0xE0;
    562562
    563         //mov ecx,0xFFFFFFFF
    564         OpBuffer[obp++]=(char)0xB9;
    565         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     563        //mov ecx,1
     564        OpBuffer[obp++]=(char)0xB9;
     565        *((long *)(OpBuffer+obp))=1;
    566566        obp+=sizeof(long);
    567567
    … …  
    656656        OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
    657657
    658         //mov eax,0FFFFFFFFh
     658        //mov eax,1
    659659        OpBuffer[obp++]=(char)0xB8;
    660         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     660        *((long *)(OpBuffer+obp))=1;
    661661        obp+=sizeof(long);
    662662
    … …  
    678678        op_sub_esp(4);
    679679
    680         //mov ecx,0FFFFFFFFh
    681         OpBuffer[obp++]=(char)0xB9;
    682         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     680        //mov ecx,1
     681        OpBuffer[obp++]=(char)0xB9;
     682        *((long *)(OpBuffer+obp))=1;
    683683        obp+=sizeof(long);
    684684
    … …  
    714714
    715715    sp--;
    716     type_stack[sp-1]=DEF_LONG;
     716    type_stack[sp-1]=DEF_BOOLEAN;
    717717
    718718    *pStackPointer=sp;
    … …  
    798798        OpBuffer[obp++]=(char)0xE0;
    799799
    800         //mov ecx,0xFFFFFFFF
    801         OpBuffer[obp++]=(char)0xB9;
    802         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     800        //mov ecx,1
     801        OpBuffer[obp++]=(char)0xB9;
     802        *((long *)(OpBuffer+obp))=1;
    803803        obp+=sizeof(long);
    804804
    … …  
    893893        OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
    894894
    895         //mov eax,0FFFFFFFFh
     895        //mov eax,1
    896896        OpBuffer[obp++]=(char)0xB8;
    897         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     897        *((long *)(OpBuffer+obp))=1;
    898898        obp+=sizeof(long);
    899899
    … …  
    915915        op_sub_esp(4);
    916916
    917         //mov ecx,0FFFFFFFFh
    918         OpBuffer[obp++]=(char)0xB9;
    919         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     917        //mov ecx,1
     918        OpBuffer[obp++]=(char)0xB9;
     919        *((long *)(OpBuffer+obp))=1;
    920920        obp+=sizeof(long);
    921921
    … …  
    947947
    948948    sp--;
    949     type_stack[sp-1]=DEF_LONG;
     949    type_stack[sp-1]=DEF_BOOLEAN;
    950950
    951951    *pStackPointer=sp;
    … …  
    10291029        OpBuffer[obp++]=(char)0xE0;
    10301030
    1031         //mov ecx,0xFFFFFFFF
    1032         OpBuffer[obp++]=(char)0xB9;
    1033         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     1031        //mov ecx,1
     1032        OpBuffer[obp++]=(char)0xB9;
     1033        *((long *)(OpBuffer+obp))=1;
    10341034        obp+=sizeof(long);
    10351035
    … …  
    10961096        OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
    10971097
    1098         //mov eax,0FFFFFFFFh
     1098        //mov eax,1
    10991099        OpBuffer[obp++]=(char)0xB8;
    1100         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     1100        *((long *)(OpBuffer+obp))=1;
    11011101        obp+=sizeof(long);
    11021102
    … …  
    11261126        OpBuffer[obp++]=(char)0x05;
    11271127
    1128         //mov eax,0FFFFFFFFh
     1128        //mov eax,1
    11291129        OpBuffer[obp++]=(char)0xB8;
    1130         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     1130        *((long *)(OpBuffer+obp))=1;
    11311131        obp+=sizeof(long);
    11321132
    … …  
    11381138
    11391139    sp--;
    1140     type[sp-1]=DEF_LONG;
     1140    type[sp-1]=DEF_BOOLEAN;
    11411141
    11421142    *pStackPointer=sp;
    … …  
    12201220        OpBuffer[obp++]=(char)0xE0;
    12211221
    1222         //mov ecx,0xFFFFFFFF
    1223         OpBuffer[obp++]=(char)0xB9;
    1224         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     1222        //mov ecx,1
     1223        OpBuffer[obp++]=(char)0xB9;
     1224        *((long *)(OpBuffer+obp))=1;
    12251225        obp+=sizeof(long);
    12261226
    … …  
    12761276        obp++;
    12771277
    1278         //mov eax,0FFFFFFFFh
     1278        //mov eax,1
    12791279        OpBuffer[obp++]=(char)0xB8;
    1280         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
     1280        *((long *)(OpBuffer+obp))=1;
    12811281        obp+=sizeof(long);
    12821282
    … …  
    13131313        OpBuffer[obp++]=(char)0xC3;
    13141314
    1315         //jz 5（次のmovを飛び越す）
     1315        //jnz 4（次のxorとjmpを飛び越す）
    13161316        OpBuffer[obp++]=(char)0x74;
     1317        OpBuffer[obp++]=(char)0x04;
     1318
     1319        //xor eax,eax
     1320        OpBuffer[obp++]=(char)0x33;
     1321        OpBuffer[obp++]=(char)0xC0;
     1322
     1323        //jmp 5
     1324        OpBuffer[obp++]=(char)0xEB;
    13171325        OpBuffer[obp++]=(char)0x05;
    13181326
    1319         //mov eax,0FFFFFFFFh
     1327        //mov eax,1
    13201328        OpBuffer[obp++]=(char)0xB8;
    1321         *((long *)(OpBuffer+obp))=0xFFFFFFFF;
    1322         obp+=sizeof(long);
    1323 
    1324         //not eax
    1325         OpBuffer[obp++]=(char)0xF7;
    1326         OpBuffer[obp++]=(char)0xD0;
     1329        *((long *)(OpBuffer+obp))=1;
     1330        obp+=sizeof(long);
    13271331
    13281332        //mov dword ptr[esp],eax
    … …  
    13331337
    13341338    sp--;
    1335     type[sp-1]=DEF_LONG;
     1339    type[sp-1]=DEF_BOOLEAN;
    13361340
    13371341    *pStackPointer=sp;

  • BasicCompiler32/NumOpe_TypeOperation.cpp

    r3 r36  
    8787        op_push(REG_EAX);
    8888    }
    89     else if(type==DEF_BYTE){
     89    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    9090        //pop eax
    9191        op_pop(REG_EAX);

  • BasicCompiler32/Opcode.h

    r34 r36  
    140140void Set16Variable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
    141141void Set8Variable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
     142void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
    142143
    143144//increment.cpp
    … …  
    296297void op_sub_RV8         (int reg,char cValue);
    297298void op_sbb_RV8         (int reg,char cValue);
     299void op_sbb_RR          ( int reg1, int reg2 );
    298300void op_and_RV          (int reg,int value);
     301void op_or_RR           ( int op_size, int reg1, int reg2 );
     302void op_neg             ( int reg );
    299303void op_cdq             ();
    300304
    … …  
    306310void op_add_esp(int num);
    307311void op_sub_esp(int num);
     312void op_cmp_value(int op_size,int reg,char byte_data);
     313void op_setne( int reg );
    308314void op_test(int reg1,int reg2);
    309315void op_fld_ptr_esp(int type);

  • BasicCompiler32/VarList.cpp

    r3 r36  
    128128                temporary[1]=0;
    129129                sprintf(lptv->item.pszText,"%s %d(&H%X)'%s'",VarName,byteData,byteData,temporary);
     130            }
     131            else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
     132        }
     133        else if(type==DEF_BOOLEAN){
     134            if(ReadProcessMemory(hDebugProcess,(void *)offset,&byteData,sizeof(BYTE),&dwAccessByte)){
     135                if( byteData ) lstrcpy( temporary, "True" );
     136                else lstrcpy( temporary, "False" );
     137                sprintf(lptv->item.pszText,"%s %s",VarName,temporary);
    130138            }
    131139            else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);

  • BasicCompiler32/increment.cpp

    r11 r36  
    9292        op_movsx_R32R8(reg,reg);
    9393    }
    94     else if(type==DEF_BYTE){
     94    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    9595        //and reg,000000FFh
    9696        op_and_RV(reg,(int)0xFF);
    … …  
    102102        op_movsx_R16R8(reg,reg);
    103103    }
    104     else if(type==DEF_BYTE){
     104    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    105105        //and reg,000000FFh
    106106        op_and_RV(reg,(int)0xFF);

  • BasicCompiler32/op32_main.cpp

    r3 r36  
    360360    OpBuffer[obp++]=cValue;
    361361}
     362void op_sbb_RR( int reg1, int reg2 ){
     363    //sbb reg1,reg2
     364
     365    //オペコード
     366    OpBuffer[obp++]=(char)0x1B;
     367
     368    //レジスタ
     369    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
     370}
     371
    362372
    363373
    … …  
    370380    //and reg,value
    371381
    372     //16ビット演算の命令プリフィックス
    373     char op_prefix=0;
    374 
    375     //オペコード
    376     char opcode=(char)0x81;
    377 
    378     __op_format(op_prefix,opcode,0,0,reg,value,MOD_REG);
     382    if(reg==REG_RAX){
     383        //eaxのみ特殊
     384
     385        // [8bit rex] 0010 0101 [32bit offset]
     386        OpBuffer[obp++]=(char)0x25;
     387        *((long *)(OpBuffer+obp))=value;
     388        obp+=sizeof(long);
     389    }
     390    else{
     391        //16ビット演算の命令プリフィックス
     392        char op_prefix=0;
     393
     394        //オペコード
     395        char opcode=(char)0x81;
     396
     397        __op_format(op_prefix,opcode,0,0,reg,value,MOD_REG);
     398    }
     399}
     400
     401void op_or_RR( int op_size, int reg1, int reg2 ){
     402    //16ビット演算のプリフィックス
     403    if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
     404
     405    //オペコード
     406    if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x0A;
     407    else OpBuffer[obp++]=(char)0x0B;
     408
     409    //レジスタ
     410    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
     411}
     412
     413
     414
     415void op_neg( int reg ){
     416    //neg reg
     417
     418    //オペコード
     419    OpBuffer[obp++]=(char)0xF7;
     420
     421    //レジスタ
     422    OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg));
    379423}
    380424
    … …  
    481525        OpBuffer[obp++]=(char)num;
    482526    }
     527}
     528
     529
     530
     531/////////////////////
     532// cmp関連
     533/////////////////////
     534void op_cmp_value(int op_size,int reg,char byte_data){
     535    //cmp reg,byte_data
     536
     537    if(op_size==sizeof(char)&&reg==REG_EAX){
     538        //alレジスタの場合は特殊
     539        OpBuffer[obp++]=(char)0x3C;
     540
     541        //8ビット値
     542        OpBuffer[obp++]=byte_data;
     543
     544        return;
     545    }
     546
     547    //16ビット演算のプリフィックス
     548    if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
     549
     550    //オペコード
     551    if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x80;
     552    else OpBuffer[obp++]=(char)0x83;
     553
     554    //レジスタ
     555    OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg));
     556
     557    //8ビット値
     558    OpBuffer[obp++]=byte_data;
     559}
     560void op_setne( int reg ){
     561    //オペコード
     562    OpBuffer[obp++]=(char)0x0F;
     563    OpBuffer[obp++]=(char)0x95;
     564
     565    //レジスタ
     566    OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) );
    483567}
    484568
Note: See TracChangeset for help on using the changeset viewer.