Changeset 36 in dev


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

Boolean型に対応。

Files:
29 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
  • BasicCompiler64/Compile_Calc.cpp

    r11 r36  
    22#include "Opcode.h"
    33
    4 void ChangeTypeToDouble_ToFpuReg(int OldType){
    5     //現在のスタックの内容を実数レジスタに保存する
    6     //NumOpeの直後専用
    7     if(OldType==DEF_DOUBLE){
    8         //fld qword ptr[esp]
    9         op_fld_ptr_esp(DEF_DOUBLE);
    10 
    11         //add esp,8
    12         op_add_esp(8);
    13     }
    14     else if(OldType==DEF_SINGLE){
    15         //fld dword ptr[esp]
    16         op_fld_ptr_esp(DEF_SINGLE);
    17 
    18         //add esp,4
    19         op_add_esp(4);
    20     }
    21     else if(OldType==DEF_LONG){
    22         //fild dword ptr[esp]
    23         op_fld_ptr_esp(DEF_LONG);
    24 
    25         //add esp,4
    26         op_add_esp(4);
    27     }
    28     else if(OldType==DEF_DWORD){
    29         //pop eax
    30         op_pop(REG_EAX);
    31 
    32         //push 0
    33         op_push_value(0);
    34 
    35         //push eax
    36         op_push(REG_EAX);
    37 
    38         //fild qword ptr[esp]
    39         OpBuffer[obp++]=(char)0xDF;
    40         OpBuffer[obp++]=(char)0x2C;
    41         OpBuffer[obp++]=(char)0x24;
    42 
    43         //add esp,8
    44         op_add_esp(8);
    45     }
    46 }
    47 void ChangeTypeToDouble(int OldType){
    48     //現在のスタックの内容をdouble型に変換する
    49     //NumOpeの直後専用
    50     if(OldType==DEF_DOUBLE) return;
    51     else if(OldType==DEF_SINGLE){
    52         //fld dword ptr[esp]
    53         op_fld_ptr_esp(DEF_SINGLE);
    54 
    55         //sub esp,4
    56         op_sub_esp(4);
    57 
    58         //fstp qword ptr[esp]
    59         OpBuffer[obp++]=(char)0xDD;
    60         OpBuffer[obp++]=(char)0x1C;
    61         OpBuffer[obp++]=(char)0x24;
    62     }
    63     else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    64         //64ビット整数型
    65 
    66         //fild qword ptr[esp]
    67         op_fld_ptr_esp(DEF_INT64);
    68 
    69         //fstp qword ptr[esp]
    70         OpBuffer[obp++]=(char)0xDD;
    71         OpBuffer[obp++]=(char)0x1C;
    72         OpBuffer[obp++]=(char)0x24;
    73     }
    74     else if(IsWholeNumberType(OldType)){
    75         //その他整数型
    76 
    77         if(IsSignedType(OldType)){
    78             //符号あり
    79 
    80             if(OldType==DEF_INTEGER){
    81                 //pop eax
    82                 op_pop(REG_EAX);
    83 
    84                 //movsx eax,ax
    85                 OpBuffer[obp++]=(char)0x0F;
    86                 OpBuffer[obp++]=(char)0xBF;
    87                 OpBuffer[obp++]=(char)0xC0;
    88 
    89                 //push eax
    90                 op_push(REG_EAX);
    91             }
    92             else if(OldType==DEF_CHAR){
    93                 //pop eax
    94                 op_pop(REG_EAX);
    95 
    96                 //movsx eax,al
    97                 OpBuffer[obp++]=(char)0x0F;
    98                 OpBuffer[obp++]=(char)0xBE;
    99                 OpBuffer[obp++]=(char)0xC0;
    100 
    101                 //push eax
    102                 op_push(REG_EAX);
    103             }
    104 
    105             //fild dword ptr[esp]
    106             op_fld_ptr_esp(DEF_LONG);
    107 
    108             //sub esp,4
    109             op_sub_esp(4);
    110         }
    111         else{
    112             //符号なし
    113 
    114             //pop eax
    115             op_pop(REG_EAX);
    116 
    117             //push 0
    118             op_push_value(0);
    119 
    120             //push eax
    121             op_push(REG_EAX);
    122 
    123             //fild qword ptr[esp]
    124             OpBuffer[obp++]=(char)0xDF;
    125             OpBuffer[obp++]=(char)0x2C;
    126             OpBuffer[obp++]=(char)0x24;
    127         }
    128 
    129         //fstp qword ptr[esp]
    130         OpBuffer[obp++]=(char)0xDD;
    131         OpBuffer[obp++]=(char)0x1C;
    132         OpBuffer[obp++]=(char)0x24;
    133     }
    134     else SetError(9,NULL,cp);
    135 }
    136 void ChangeTypeToSingle(int OldType){
    137     //現在のスタックの内容をfloat型に変換する
    138     //NumOpeの直後専用
    139     if(OldType==DEF_SINGLE) return;
    140     else if(OldType==DEF_DOUBLE){
    141         //fld qword ptr[esp]
    142         op_fld_ptr_esp(DEF_DOUBLE);
    143 
    144         //add esp,4
    145         op_add_esp(4);
    146 
    147         //fstp dword ptr[esp]
    148         OpBuffer[obp++]=(char)0xD9;
    149         OpBuffer[obp++]=(char)0x1C;
    150         OpBuffer[obp++]=(char)0x24;
    151     }
    152     else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    153         //64ビット整数型
    154 
    155         //fild qword ptr[esp]
    156         op_fld_ptr_esp(DEF_INT64);
    157 
    158         //add esp,4
    159         op_add_esp(4);
    160 
    161         //fstp dword ptr[esp]
    162         OpBuffer[obp++]=(char)0xD9;
    163         OpBuffer[obp++]=(char)0x1C;
    164         OpBuffer[obp++]=(char)0x24;
    165     }
    166     else if(IsWholeNumberType(OldType)){
    167         //その他整数型
    168 
    169         if(IsSignedType(OldType)){
    170             //符号あり
    171 
    172             if(OldType==DEF_INTEGER){
    173                 //pop eax
    174                 op_pop(REG_EAX);
    175 
    176                 //movsx eax,ax
    177                 OpBuffer[obp++]=(char)0x0F;
    178                 OpBuffer[obp++]=(char)0xBF;
    179                 OpBuffer[obp++]=(char)0xC0;
    180 
    181                 //push eax
    182                 op_push(REG_EAX);
    183             }
    184             else if(OldType==DEF_CHAR){
    185                 //pop eax
    186                 op_pop(REG_EAX);
    187 
    188                 //movsx eax,al
    189                 OpBuffer[obp++]=(char)0x0F;
    190                 OpBuffer[obp++]=(char)0xBE;
    191                 OpBuffer[obp++]=(char)0xC0;
    192 
    193                 //push eax
    194                 op_push(REG_EAX);
    195             }
    196 
    197             //fild dword ptr[esp]
    198             op_fld_ptr_esp(DEF_LONG);
    199         }
    200         else{
    201             //符号なし
    202 
    203             //fild dword ptr[esp]
    204             op_fld_ptr_esp(DEF_LONG);
    205         }
    206 
    207         //fstp dword ptr[esp]
    208         OpBuffer[obp++]=(char)0xD9;
    209         OpBuffer[obp++]=(char)0x1C;
    210         OpBuffer[obp++]=(char)0x24;
    211     }
    212     else SetError(9,NULL,cp);
    213 }
    214 void ChangeTypeToInt64(int OldType){
    215     //現在のスタックの内容をInt64型に変換する
    216     //NumOpeの直後専用
    217     if(Is64Type(OldType)) return;
    218 
    219     else if(OldType==DEF_DOUBLE){
    220         //fld qword ptr[esp]
    221         op_fld_ptr_esp(DEF_DOUBLE);
    222 
    223         //fistp qword ptr[esp]
    224         OpBuffer[obp++]=(char)0xDF;
    225         OpBuffer[obp++]=(char)0x3C;
    226         OpBuffer[obp++]=(char)0x24;
    227     }
    228     else if(OldType==DEF_SINGLE){
    229         //fld dword ptr[esp]
    230         op_fld_ptr_esp(DEF_SINGLE);
    231 
    232         //sub esp,4
    233         op_sub_esp(4);
    234 
    235         //fistp qword ptr[esp]
    236         OpBuffer[obp++]=(char)0xDF;
    237         OpBuffer[obp++]=(char)0x3C;
    238         OpBuffer[obp++]=(char)0x24;
    239     }
    240     else if(IsWholeNumberType(OldType)){
    241         //その他整数
    242 
    243         if(IsSignedType(OldType)){
    244             //符号あり
    245 
    246             //pop eax
    247             op_pop(REG_EAX);
    248 
    249             //cdq
    250             OpBuffer[obp++]=(char)0x99;
    251 
    252             //push edx
    253             op_push(REG_EDX);
    254 
    255             //push eax
    256             op_push(REG_EAX);
    257         }
    258         else{
    259             //符号なし
    260 
    261             //pop eax
    262             op_pop(REG_EAX);
    263 
    264             //push 0
    265             op_push_value(0);
    266 
    267             //push eax
    268             op_push(REG_EAX);
    269         }
    270     }
    271     else SetError(9,NULL,cp);
    272 }
    273 void ChangeTypeToLong(int OldType){
    274     //現在のスタックの内容をLong型に変換する
    275     //NumOpeの直後専用
    276     if(OldType==DEF_DOUBLE){
    277         //fld qword ptr[esp]
    278         op_fld_ptr_esp(DEF_DOUBLE);
    279 
    280         //add esp,4
    281         op_add_esp(4);
    282 
    283         //fistp dword ptr[esp]
    284         OpBuffer[obp++]=(char)0xDB;
    285         OpBuffer[obp++]=(char)0x1C;
    286         OpBuffer[obp++]=(char)0x24;
    287     }
    288     else if(OldType==DEF_SINGLE){
    289         //fld dword ptr[esp]
    290         op_fld_ptr_esp(DEF_SINGLE);
    291 
    292         //fistp dword ptr[esp]
    293         OpBuffer[obp++]=(char)0xDB;
    294         OpBuffer[obp++]=(char)0x1C;
    295         OpBuffer[obp++]=(char)0x24;
    296     }
    297     else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    298         //pop eax
    299         op_pop(REG_EAX);
    300 
    301         //add esp,4
    302         op_add_esp(4);
    303 
    304         //push eax
    305         op_push(REG_EAX);
    306     }
    307 }
    308 void ChangeTypeToInteger(int OldType){
    309     //現在のスタックの内容をInteger型に変換する
    310     if(OldType==DEF_BYTE||OldType==DEF_CHAR||
    311         OldType==DEF_WORD||OldType==DEF_INTEGER) return;
    312 
    313     ChangeTypeToLong(OldType);
    314 
    315     //pop eax
    316     op_pop(REG_EAX);
    317 
    318     //and eax,0000FFFFh
    319     OpBuffer[obp++]=(char)0x25;
    320     *((long *)(OpBuffer+obp))=0x0000FFFF;
    321     obp+=sizeof(long);
    322 
    323     //push eax
    324     op_push(REG_EAX);
    325 }
    326 void ChangeTypeToByte(int OldType){
    327     //現在のスタックの内容をbyte型に変換する
    328     if(OldType==DEF_BYTE||OldType==DEF_CHAR) return;
    329 
    330     ChangeTypeToLong(OldType);
    331 
    332     //pop eax
    333     op_pop(REG_EAX);
    334 
    335     //and eax,000000FFh
    336     OpBuffer[obp++]=(char)0x25;
    337     *((long *)(OpBuffer+obp))=0x000000FF;
    338     obp+=sizeof(long);
    339 
    340     //push eax
    341     op_push(REG_EAX);
    342 }
    343 
    3444void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
    3455    /////////////////////////////////////////////////
     
    3477    /////////////////////////////////////////////////
    3488
     9    if(VarType==DEF_BOOLEAN){
     10        //bool
     11        SetBooleanVariable(CalcType,pRelativeVar);
     12    }
    34913    if(VarType==DEF_CHAR||VarType==DEF_BYTE){
    35014        //8ビット変数へalレジスタの内容を格納する
  • BasicCompiler64/Compile_Set_Var.cpp

    r28 r36  
    298298    }
    299299}
     300void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
     301    if(type==DEF_DOUBLE){
     302        //Double型
     303
     304        //cvttsd2si rax,xmm0
     305        op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     306    }
     307    else if(type==DEF_SINGLE){
     308        //Single型
     309
     310        //cvttss2si rax,xmm0
     311        op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     312    }
     313
     314    //cmp rax,0
     315    op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
     316
     317    //setne al
     318    op_setne( REG_RAX );
     319
     320    SetWholeVariable( sizeof(char), DEF_BYTE, pRelative);
     321}
    300322void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative){
    301323    if(type==DEF_DOUBLE){
  • BasicCompiler64/Compile_Statement.cpp

    r34 r36  
    293293void OpcodeWhile(char *Parameter){
    294294    extern HANDLE hHeap;
    295     int i2;
    296295
    297296    //Continueアドレスのバックアップとセット
  • BasicCompiler64/Compile_Var.cpp

    r34 r36  
    864864    else if(type==DEF_INTEGER||type==DEF_WORD)
    865865        *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
    866     else if(type==DEF_CHAR||type==DEF_BYTE)
     866    else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN)
    867867        *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
    868868
     
    10341034        obp+=sizeof(long)+sizeof(short);
    10351035    }
    1036     else if(type==DEF_CHAR||type==DEF_BYTE){
     1036    else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN){
    10371037        //mov byte ptr[rsp+offset],value
    10381038        op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
  • BasicCompiler64/NumOpe_Logical.cpp

    r3 r36  
    8888    int reg;
    8989
    90     if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
     90    if( type[sp - 1] == DEF_BOOLEAN ){
     91        SetOneTermToReg_Whole32Calc(type[sp-1],&reg);
     92
     93        if( reg != REG_RAX ){
     94            //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
     95            pobj_sf->pop(REG_RAX);
     96        }
     97
     98        //cmp reg,0
     99        op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0);
     100
     101        //setne al
     102        op_setne( REG_RAX );
     103
     104        //and rax,000000FFh
     105        op_and64_value(REG_RAX,(int)0xFF);
     106
     107        //neg
     108        op_neg( REG_RAX );
     109
     110        //sbb rax, rax
     111        op_sbb_RR( sizeof(_int64), REG_RAX, REG_RAX );
     112
     113        //add rax, 1
     114        op_add64_value( REG_RAX, 1 );
     115
     116        if( reg != REG_RAX ){
     117            //mov reg,rax
     118            op_mov_RR( reg, REG_RAX );
     119
     120            //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
     121            pobj_sf->push(REG_RAX);
     122        }
     123
     124        if(reg==REG_R14){
     125            //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
     126            pobj_sf->push(REG_R14);
     127        }
     128    }
     129    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    91130        SetOneTermToReg_Whole64Calc(type[sp-1],&reg);
    92131
  • BasicCompiler64/NumOpe_Relation.cpp

    r3 r36  
    137137    op_zero_reg(reg1);
    138138
    139     //jmp 7(xorを飛び越す)
     139    //jmp 7(次のmovを飛び越す)
    140140    OpBuffer[obp++]=(char)0xEB;
    141141    OpBuffer[obp++]=(char)0x07;
     
    143143
    144144    ///////////////////
    145     // TRUEをセット
     145    // Trueをセット
    146146    ///////////////////
    147147
    148     //mov reg1,-1
    149     op_mov_RV(sizeof(_int64),reg1,-1);
     148    //mov reg1,1
     149    op_mov_RV(sizeof(_int64),reg1,1);
    150150
    151151
     
    159159    *pStackPointer=sp;
    160160
    161     type[sp-1]=DEF_LONG;
     161    type[sp-1]=DEF_BOOLEAN;
    162162
    163163    return 1;
  • BasicCompiler64/NumOpe_TypeOperation.cpp

    r3 r36  
    2222        op_movsx64_FromReg8(reg,reg);
    2323    }
    24     else if(type==DEF_BYTE){
     24    else if(type==DEF_BYTE || type==DEF_BOOLEAN){
    2525        //and reg,00000000000000FFh
    2626        op_and64_value(reg,(int)0x00FF);
     
    4040        op_movsx32_FromReg8(reg,reg);
    4141    }
    42     else if(type==DEF_BYTE){
     42    else if(type==DEF_BYTE || type==DEF_BOOLEAN){
    4343        //and reg,000000FFh
    4444        op_and32_value(reg,(int)0xFF);
  • BasicCompiler64/Opcode.h

    r34 r36  
    243243
    244244//Compile_Calc.cpp
    245 void ChangeTypeToDouble_ToFpuReg(int OldType);
    246 void ChangeTypeToDouble(int OldType);
    247 void ChangeTypeToSingle(int OldType);
    248 void ChangeTypeToInt64(int OldType);
    249 void ChangeTypeToLong(int OldType);
    250 void ChangeTypeToInteger(int OldType);
    251 void ChangeTypeToByte(int OldType);
    252245void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
    253246void OpcodeCalc(char *Command);
     
    292285void SetDoubleVariable(int type,RELATIVE_VAR *pRelative);
    293286void SetSingleVariable(int type,RELATIVE_VAR *pRelative);
     287void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
    294288void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
    295289
     
    303297#define EXP_TYPE_VAR    4
    304298int NumOpEx(char *Command,double *pDbl,DWORD *pdwType,RELATIVE_VAR *pRelativeVar);
    305 
    306 //SetVar.cpp
    307 BOOL SetVariable(DWORD dwVarType,RELATIVE_VAR *pVarRelativeVar,
    308                  DWORD dwExpType,DWORD dwType,void *data);
    309299
    310300//Compile_Calc_PushVar.cpp
     
    475465void op_sub64_reg               (int reg1,int reg2);
    476466void op_sub32_reg               (int reg1,int reg2);
     467void op_sbb_RR                  ( int op_size, int reg1, int reg2 );
    477468void op_imul_reg                (int op_size,int reg1,int reg2);
    478469void op_imul_value              (int op_size,int reg,int i32data);
     
    488479void op_xor_reg                 (int op_size,int reg1,int reg2);
    489480void op_not_reg                 (int op_size,int reg);
     481void op_neg                     ( int reg );
    490482void op_test                    (int reg1,int reg2);
    491483void op_cmp_reg                 (int op_size,int reg1,int reg2);
    492484void op_cmp_value               (int op_size,int reg,char byte_data);
     485void op_setne                   (int reg);
    493486void op_movlpd_MR               (int xmm_reg,int base_reg,int offset,char mod);
    494487void op_movlpd_RM               (int xmm_reg,int base_reg,int offset,char mod);
  • BasicCompiler64/amd64_main.cpp

    r19 r36  
    824824    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    825825}
     826void op_sbb_RR( int op_size, int reg1, int reg2 ){
     827    //sbb reg1,reg2
     828
     829    //rexプリフィックス
     830    set_rex(0,reg1,0,reg2);
     831
     832    //オペコード
     833    OpBuffer[obp++]=(char)0x1B;
     834
     835    //レジスタ
     836    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
     837}
    826838
    827839
     
    12831295    OpBuffer[obp++]=(char)(0xD0| REGISTER_OPERAND(reg));
    12841296}
     1297void op_neg( int reg ){
     1298    //neg reg
     1299
     1300    //オペコード
     1301    OpBuffer[obp++]=(char)0xF7;
     1302
     1303    //レジスタ
     1304    OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg));
     1305}
    12851306
    12861307
     
    13821403    //8ビット値
    13831404    OpBuffer[obp++]=byte_data;
     1405}
     1406void op_setne( int reg ){
     1407    //オペコード
     1408    OpBuffer[obp++]=(char)0x0F;
     1409    OpBuffer[obp++]=(char)0x95;
     1410
     1411    //レジスタ
     1412    OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) );
    13841413}
    13851414
  • BasicCompiler64/varlist.cpp

    r3 r36  
    129129                temporary[1]=0;
    130130                sprintf(lptv->item.pszText,"%s %d(&H%X)'%s'",VarName,byteData,byteData,temporary);
     131            }
     132            else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
     133        }
     134        else if(type==DEF_BOOLEAN){
     135            if(ReadProcessMemory(hDebugProcess,(void *)offset,&byteData,sizeof(BYTE),&stAccBytes)){
     136                if( byteData ) lstrcpy( temporary, "True" );
     137                else lstrcpy( temporary, "False" );
     138
     139                wsprintf(lptv->item.pszText,"%s %s",VarName,temporary);
    131140            }
    132141            else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
  • BasicCompiler_Common/BasicFixed.h

    r26 r36  
    3232#define DEF_DOUBLE      0x0000000A
    3333
     34//bool型
     35#define DEF_BOOLEAN     0x0000000B
     36
    3437//文字列型
    35 #define DEF_STRING      0x0000000B
     38#define DEF_STRING      0x0000000C
    3639
    3740//ポインタ型
    38 #define DEF_PTR_VOID    0x0000000C
    39 #define DEF_PTR_PROC    0x0000000D
     41#define DEF_PTR_VOID    0x0000000D
     42#define DEF_PTR_PROC    0x0000000E
    4043
    4144//特殊型
  • BasicCompiler_Common/Overload.cpp

    r31 r36  
    4646}
    4747
    48 BOOL OverloadCheck(PARAMETER_INFO *ppi1,int ParmNum1,PARAMETER_INFO *ppi2,int ParmNum2){
    49     //パラメータの個数が不一致の場合
    50     if(ParmNum1!=ParmNum2) return 0;
    51 
    52     int i;
    53     for(i=0;i<ParmNum1;i++){
    54         if(ppi1[i].type!=ppi2[i].type) return 0;
    55         else{
    56             if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
    57                 if(ppi1[i].u.index!=ppi2[i].u.index) return 0;
    58             }
    59         }
    60     }
    61 
    62     return 1;
    63 }
    64 BOOL OverloadCheckLevel2(PARAMETER_INFO *ppi1,int ParmNum1,PARAMETER_INFO *ppi2,int ParmNum2){
    65     //パラメータの個数が不一致の場合
    66     if(ParmNum1!=ParmNum2) return 0;
    67 
    68     int i;
    69     for(i=0;i<ParmNum1;i++){
    70         if(ppi1[i].type!=ppi2[i].type){
    71             if(!(
    72                 IsNaturalWholeNumberType(ppi1[i].type)&&IsNaturalWholeNumberType(ppi2[i].type)||
    73                 IsRealNumberType(ppi1[i].type)&&IsRealNumberType(ppi2[i].type)
    74                 )) return 0;
    75         }
    76         else{
    77             if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
    78                 if(ppi1[i].u.index!=ppi2[i].u.index) return 0;
    79             }
    80         }
    81     }
    82 
    83     return 1;
    84 }
    8548SUBINFO *OverloadSolution(char *name,SUBINFO **ppsi,int num,PARAMETER_INFO *ppi,int ParmNum,TYPEINFO *pReturnTypeInfo){
    8649    // オーバーロードの解決
  • BasicCompiler_Common/Variable.cpp

    r34 r36  
    5656}
    5757BOOL IsWholeNumberType(int type){
    58     return (IsNaturalWholeNumberType(type)||IsPtrType(type));
     58    return (
     59        IsNaturalWholeNumberType(type)
     60        || IsPtrType(type)
     61        || type == DEF_BOOLEAN
     62        );
    5963}
    6064BOOL IsRealNumberType(int type){
     
    132136    else if(type==DEF_INTEGER||type==DEF_WORD)
    133137        return sizeof(WORD);
    134     else if(type==DEF_CHAR||type==DEF_BYTE)
     138    else if(type==DEF_CHAR||type==DEF_BYTE || type == DEF_BOOLEAN)
    135139        return sizeof(BYTE);
    136140
     
    187191    else if(lstrcmpi(TypeName,"Double")==0)     return DEF_DOUBLE;
    188192
     193    //bool型
     194    else if( lstrcmpi( TypeName, "Boolean" ) == 0 ) return DEF_BOOLEAN;
     195
    189196    //ポインタ型
    190197    //※VoidPtr型以外のポインタ型はTypeDef宣言により定義される
     
    253260    else if(type==DEF_SINGLE)       lstrcpy(name,"Single");
    254261    else if(type==DEF_DOUBLE)       lstrcpy(name,"Double");
     262
     263    //bool型
     264    else if(type==DEF_BOOLEAN)      lstrcpy(name,"Boolean");
    255265
    256266    //オブジェクト
  • BasicCompiler_Common/calculation.cpp

    r15 r36  
    628628                                    }
    629629                                }
     630                                else if(i2==DEF_BOOLEAN){
     631                                    BYTE byteData;
     632                                    if(i3=ReadProcessMemory(hDebugProcess,offset,&byteData,sizeof(BYTE),&stAccBytes)){
     633                                        i64nums[pnum]=(_int64)byteData;
     634                                    }
     635                                }
    630636                                else return 0;
    631637
  • ProjectEditor/SubOperation.cpp

    r24 r36  
    415415    if(str[0]=='a'||str[0]=='A'){
    416416        if(lstrcmpi(str,"Abstract")==0) return COM_ABSTRACT;
     417        if(lstrcmpi(str,"As")==0) return -1;
    417418    }
    418419    else if(str[0]=='b'||str[0]=='B'){
    419420        if(lstrcmpi(str,"Beep")==0) return COM_BEEP;
     421        if(lstrcmpi(str,"Boolean")==0) return -1;
     422        if(lstrcmpi(str,"Byte")==0) return -1;
    420423    }
    421424    else if(str[0]=='c'||str[0]=='C'){
    422425        if(lstrcmpi(str,"Case")==0) return -1;
     426        if(lstrcmpi(str,"Char")==0) return -1;
    423427        if(lstrcmpi(str,"ChDir")==0) return COM_CHDIR;
    424428        if(lstrcmpi(str,"Circle")==0) return COM_CIRCLE;
     
    438442        if(lstrcmpi(str,"Dim")==0) return COM_DIM;
    439443        if(lstrcmpi(str,"Do")==0) return COM_DO;
     444        if(lstrcmpi(str,"Double")==0) return -1;
     445        if(lstrcmpi(str,"DWord")==0) return -1;
    440446    }
    441447    else if(str[0]=='e'||str[0]=='E'){
     
    458464    }
    459465    else if(str[0]=='f'||str[0]=='F'){
     466        if(lstrcmp(str,"False")==0) return -1;
    460467        if(lstrcmpi(str,"Field")==0) return COM_FIELD;
    461468        if(lstrcmpi(str,"For")==0) return COM_FOR;
     
    471478        if(lstrcmpi(str,"Inherits")==0) return COM_INHERITS;
    472479        if(lstrcmpi(str,"Input")==0) return COM_INPUT;
     480        if(lstrcmpi(str,"Int64")==0) return -1;
     481        if(lstrcmpi(str,"Integer")==0) return -1;
    473482        if(lstrcmpi(str,"Interface")==0) return COM_INTERFACE;
    474483    }
     
    480489        if(lstrcmpi(str,"Line")==0) return COM_LINE;
    481490        if(lstrcmpi(str,"Locate")==0) return COM_LOCATE;
     491        if(lstrcmpi(str,"Long")==0) return -1;
    482492        if(lstrcmpi(str,"Loop")==0) return COM_LOOP;
    483493    }
     
    503513        if(lstrcmpi(str,"Public")==0) return COM_PUBLIC;
    504514    }
     515    else if(str[0]=='q'||str[0]=='Q'){
     516        if(lstrcmpi(str,"QWord")==0) return -1;
     517    }
    505518    else if(str[0]=='r'||str[0]=='R'){
    506519        if(lstrcmpi(str,"Randomize")==0) return COM_RANDOMIZE;
     
    511524        if(lstrcmpi(str,"Select")==0) return COM_SELECT;
    512525        if(lstrcmpi(str,"SelectCase")==0) return COM_SELECT;
     526        if(lstrcmpi(str,"Single")==0) return -1;
    513527        if(lstrcmpi(str,"Sleep")==0) return COM_SLEEP;
    514528        if(lstrcmpi(str,"Static")==0) return -1;
     
    518532    else if(str[0]=='t'||str[0]=='T'){
    519533        if(lstrcmpi(str,"Then")==0) return -1;
     534        if(lstrcmp(str,"True")==0) return -1;
    520535        if(lstrcmpi(str,"Type")==0) return COM_TYPE;
    521536        if(lstrcmpi(str,"TypeDef")==0) return COM_TYPEDEF;
     
    532547        if(lstrcmpi(str,"Window")==0) return COM_WINDOW;
    533548        if(lstrcmpi(str,"With")==0) return COM_WITH;
     549        if(lstrcmpi(str,"Word")==0) return -1;
    534550        if(lstrcmpi(str,"Write")==0) return COM_WRITE;
    535551    }
Note: See TracChangeset for help on using the changeset viewer.