Changeset 254 in dev


Ignore:
Timestamp:
Jul 31, 2007, 4:30:31 AM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • trunk/abdev/BasicCompiler32/Compile_Statement.cpp

    r253 r254  
    792792
    793793void OpcodeExitSub(void){
    794     extern HANDLE hHeap;
    795 
    796794    if( UserProc::IsGlobalAreaCompiling() ){
    797795        SetError(12,"Exit Sub/Function",cp);
  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r253 r254  
    532532            const Type &baseType,
    533533            Type &resultType,
    534             BOOL *pbUseHeap ){
    535 
     534            BOOL *pbUseHeap )
     535{
    536536    int i,i2,i3;
    537537    char temporary[1024],temp2[1024];
     
    540540        SetError(1,NULL,cp);
    541541        return false;
    542     }
    543 
    544     if(expression[0]==1&& expression[1]==ESC_NEW ){
    545         //New演算子(オブジェクト生成)
    546 
    547         if( !Operator_New( expression+2, baseType, resultType ) ){
    548             return false;
    549         }
    550 
    551         return true;
    552542    }
    553543
     
    603593        //push eax
    604594        compiler.codeGenerator.op_push( REG_EAX );
     595
     596        return true;
     597    }
     598
     599    bool isLiteralCalculation;
     600    if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
     601    {
     602        return false;
     603    }
     604    if( isLiteralCalculation )
     605    {
     606        //右辺値が数値の定数式の場合
     607        _int64 i64data;
     608        StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
     609
     610        if( resultType.GetBasicSize() == sizeof(_int64) ){
     611            //64ビット(符号有り整数/実数)
     612
     613            //push HILONG(i64data)
     614            compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
     615
     616            //push LOLONG(i64data)
     617            compiler.codeGenerator.op_push_V(*(long *)(&i64data));
     618        }
     619        else if( resultType.IsSingle() ){
     620            //single実数
     621
     622            double dbl;
     623            memcpy(&dbl,&i64data,sizeof(_int64));
     624
     625            float flt;
     626            flt=(float)dbl;
     627            long l;
     628            memcpy(&l,&flt,sizeof(long));
     629
     630            //push flt
     631            compiler.codeGenerator.op_push_V(l);
     632        }
     633        else{
     634            //整数(符号有り/無し)
     635
     636            long l = (long)i64data;
     637
     638            if(resultType.GetBasicSize()==sizeof(char)) l = l & 0x000000FF;
     639            if(resultType.GetBasicSize()==sizeof(short)) l = l & 0x0000FFFF;
     640
     641            //push term
     642            compiler.codeGenerator.op_push_V(l);
     643        }
     644        return true;
     645    }
     646
     647    if(expression[0]==1&& expression[1]==ESC_NEW ){
     648        //New演算子(オブジェクト生成)
     649
     650        if( !Operator_New( expression+2, baseType, resultType ) ){
     651            return false;
     652        }
    605653
    606654        return true;
     
    10561104    if(bLiteralCalculation){
    10571105        //右辺値が数値の定数式の場合
    1058         Type resultType;
    1059         StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
    1060 
    1061         obp=BeforeObp;
    1062         pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
    1063         pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
    1064         pobj_Reloc->copy(pobj_BackReloc);
    1065 
    1066         if( resultType.GetBasicSize() == sizeof(_int64) ){
    1067             //64ビット(符号有り整数/実数)
    1068 
    1069             //push HILONG(i64data)
    1070             compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
    1071 
    1072             //push LOLONG(i64data)
    1073             compiler.codeGenerator.op_push_V(*(long *)(&i64data));
    1074         }
    1075         else if( resultType.IsSingle() ){
    1076             //single実数
    1077 
    1078             memcpy(&dbl,&i64data,sizeof(_int64));
    1079 
    1080             float flt;
    1081             flt=(float)dbl;
    1082             memcpy(&i3,&flt,sizeof(long));
    1083 
    1084             //push flt
    1085             compiler.codeGenerator.op_push_V(i3);
    1086         }
    1087         else{
    1088             //整数(符号有り/無し)
    1089 
    1090             i3=(long)i64data;
    1091 
    1092             if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
    1093             if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
    1094 
    1095             //push term
    1096             compiler.codeGenerator.op_push_V(i3);
    1097         }
    1098 
    1099         type_stack[0]=resultType.GetBasicType();
    1100         index_stack[0]=resultType.GetIndex();
     1106        SetError();
    11011107    }
    11021108    else{
  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r242 r254  
    317317                </File>
    318318                <File
    319                     RelativePath="..\BasicCompiler_Common\include\LexicalScopingImpl.h"
     319                    RelativePath="..\BasicCompiler_Common\include\LexicalScope.h"
    320320                    >
    321321                </File>
     
    11241124                    </File>
    11251125                    <File
    1126                         RelativePath="..\BasicCompiler_Common\src\LexicalScopingImpl.cpp"
     1126                        RelativePath="..\BasicCompiler_Common\src\LexicalScope.cpp"
    11271127                        >
    11281128                    </File>
  • trunk/abdev/BasicCompiler64/CodeGenerator.cpp

    r243 r254  
    7979#define INDEX_NON   0x04
    8080
    81 void CodeGenerator::set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp, Schedule::Type scheduleType ){
     81const PertialSchedule *CodeGenerator::set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp, Schedule::Type scheduleType, bool isPertialSchedule )
     82{
     83    const PertialSchedule *pPertialSchedule = NULL;
     84
    8285    if(mod==MOD_DISP32){
    8386        //ModR/Mバイト
     
    9497
    9598    //レジスタモードの場合は、ここで終了
    96     if(mod==MOD_REG) return;
     99    if(mod==MOD_REG) return pPertialSchedule;
    97100
    98101
     
    106109
    107110    //ディスプレースメントを必要としない場合は、ここで終了
    108     if(mod==MOD_BASE) return;
     111    if(mod==MOD_BASE) return pPertialSchedule;
    109112
    110113
     
    113116    //////////////////////////
    114117
    115     if(mod==MOD_BASE_DISP8) pNativeCode->Put( (char)disp );
    116     else{
     118    if(mod==MOD_BASE_DISP8)
     119    {
     120        pNativeCode->Put( (char)disp );
     121    }
     122    else
     123    {
     124        if( isPertialSchedule )
     125        {
     126            pertialSchedules.push_back( new PertialSchedule( pNativeCode->GetSize(), sizeof(long) ) );
     127            pPertialSchedule = pertialSchedules.back();
     128        }
     129
    117130        pNativeCode->Put( disp, scheduleType );
    118131    }
    119 }
    120 
    121 
    122 
    123 void CodeGenerator::__op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType ){
     132
     133    return pPertialSchedule;
     134}
     135
     136
     137
     138const PertialSchedule *CodeGenerator::__op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    124139    //命令プリフィックス
    125140    if(op_prefix) pNativeCode->Put( op_prefix );
     
    133148
    134149    //ModR/M, SIB, disp
    135     set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset, scheduleType );
     150    return set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset, scheduleType, isPertialSchedule );
    136151}
    137152
     
    175190    pNativeCode->Put( i64data );
    176191}
    177 void CodeGenerator::op_mov_RM(int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType ){
     192const PertialSchedule *CodeGenerator::op_mov_RM(int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    178193    //mov reg64,qword ptr[base_reg+offset]
    179194    //mov reg32,dword ptr[base_reg+offset]
     
    190205    else opcode=(char)0x8B;
    191206
    192     __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType);
    193 }
    194 void CodeGenerator::op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType ){
     207    return __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
     208}
     209const PertialSchedule *CodeGenerator::op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType, bool isPertialSchedule ){
    195210    //mov reg64,qword ptr[base_reg1+base_reg2+offset]
    196211    //mov reg32,dword ptr[base_reg1+base_reg2+offset]
    197212    //mov reg16,word ptr[base_reg1+base_reg2+offset]
    198213    //mov reg8,byte ptr[base_reg1+base_reg2+offset]
     214    const PertialSchedule *pPertialSchedule = NULL;
    199215
    200216    if(base_reg1==REG_RSP){
     
    226242
    227243        //オフセット値
     244        if( isPertialSchedule )
     245        {
     246            pertialSchedules.push_back( new PertialSchedule( pNativeCode->GetSize(), sizeof(long) ) );
     247            pPertialSchedule = pertialSchedules.back();
     248        }
    228249        pNativeCode->Put( offset, scheduleType );
    229250    }
     
    239260        pNativeCode->Put( (char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)) );
    240261    }
    241 }
    242 void CodeGenerator::op_mov_MR(int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType ){
     262
     263    return pPertialSchedule;
     264}
     265const PertialSchedule *CodeGenerator::op_mov_MR(int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    243266    //mov qword ptr[base_reg+offset],reg64
    244267    //mov dword ptr[base_reg+offset],reg32
     
    255278    else opcode=(char)0x89;
    256279
    257     __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType );
    258 }
    259 void CodeGenerator::op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType ){
     280    return __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
     281}
     282const PertialSchedule *CodeGenerator::op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType, bool isPertialSchedule ){
    260283    //mov qword ptr[base_reg1+base_reg2+offset],reg64
    261284    //mov dword ptr[base_reg1+base_reg2+offset],reg32
    262285    //mov word ptr[base_reg1+base_reg2+offset],reg16
    263286    //mov byte ptr[base_reg1+base_reg2+offset],reg8
     287    const PertialSchedule *pPertialSchedule = NULL;
    264288
    265289    if(base_reg1==REG_RSP){
     
    291315
    292316        //オフセット値
     317        if( isPertialSchedule )
     318        {
     319            pertialSchedules.push_back( new PertialSchedule( pNativeCode->GetSize(), sizeof(long) ) );
     320            pPertialSchedule = pertialSchedules.back();
     321        }
    293322        pNativeCode->Put( offset, scheduleType );
    294323    }
     
    304333        pNativeCode->Put( (char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)) );
    305334    }
    306 }
    307 
    308 void CodeGenerator::op_mov_MV(int op_size,int base_reg,int offset, Schedule::Type offsetScheduleType, BOOL bUseOffset,long i32data){
     335
     336    return pPertialSchedule;
     337}
     338
     339const PertialSchedule *CodeGenerator::op_mov_MV(int op_size,int base_reg,int offset, Schedule::Type offsetScheduleType, bool isPertialSchedule, BOOL bUseOffset,long i32data){
    309340    //mov ptr[base_reg+offset],i32data
    310341    //mov ptr[base_reg       ],i32data
     342    const PertialSchedule *pPertialSchedule = NULL;
    311343
    312344    //16ビット演算のプリフィックス
     
    326358
    327359        //ModR/M, SIB, disp
    328         set_mod_rm_sib_disp(MOD_BASE_DISP32,0,SCALE_NON,INDEX_NON,base_reg,offset, offsetScheduleType );
     360        pPertialSchedule = set_mod_rm_sib_disp(MOD_BASE_DISP32,0,SCALE_NON,INDEX_NON,base_reg,offset, offsetScheduleType, isPertialSchedule );
    329361    }
    330362    else{
     
    346378        pNativeCode->Put( (char)i32data );
    347379    }
     380
     381    return pPertialSchedule;
    348382}
    349383
     
    561595/////////////////////
    562596
    563 void CodeGenerator::op_add_RM(int op_size,int reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     597const PertialSchedule *CodeGenerator::op_add_RM(int op_size,int reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    564598    //add reg64,qword ptr[base_reg+offset]
    565599    //add reg32,dword ptr[base_reg+offset]
     
    576610    else opcode=(char)0x03;
    577611
    578     __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType );
    579 }
    580 
    581 void CodeGenerator::op_add_RV(int reg,long offset, Schedule::Type scheduleType ){
     612    return __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
     613}
     614
     615const PertialSchedule *CodeGenerator::op_add_RV(int reg,long offset, Schedule::Type scheduleType, bool isPertialSchedule ){
    582616    //add reg,offset
     617    const PertialSchedule *pPertialSchedule = NULL;
     618
    583619    char RexByte=-1;
    584620
     
    594630        pNativeCode->Put( (char)RexByte );
    595631        pNativeCode->Put( (char)0x05 );
    596         pNativeCode->Put( offset, scheduleType );
    597632    }
    598633    else{
     
    603638        pNativeCode->Put( (char)0x81 );
    604639        pNativeCode->Put( (char)(0xC0| REGISTER_OPERAND(reg)) );
    605         pNativeCode->Put( offset, scheduleType );
    606     }
     640    }
     641
     642    if( isPertialSchedule )
     643    {
     644        pertialSchedules.push_back( new PertialSchedule( pNativeCode->GetSize(), sizeof(long) ) );
     645        pPertialSchedule = pertialSchedules.back();
     646    }
     647    pNativeCode->Put( offset, scheduleType );
     648
     649    return pPertialSchedule;
    607650}
    608651void CodeGenerator::op_add_RR(int reg1,int reg2){
     
    13031346////////////////////
    13041347
    1305 void CodeGenerator::op_movlpd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     1348const PertialSchedule *CodeGenerator::op_movlpd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    13061349    //movlpd qword ptr[base_reg+offset],xmm_reg
    1307     __op_format(0,(char)0x66,(char)0x0F,(char)0x13,xmm_reg,base_reg,offset,mod, scheduleType );
    1308 }
    1309 void CodeGenerator::op_movlpd_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     1350    return __op_format(0,(char)0x66,(char)0x0F,(char)0x13,xmm_reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
     1351}
     1352const PertialSchedule *CodeGenerator::op_movlpd_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    13101353    //movlpd xmm_reg,qword ptr[base_reg+offset]
    1311     __op_format(0,(char)0x66,(char)0x0F,(char)0x12,xmm_reg,base_reg,offset,mod, scheduleType );
     1354    return __op_format(0,(char)0x66,(char)0x0F,(char)0x12,xmm_reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
    13121355}
    13131356void CodeGenerator::op_movsd_RR(int xmm_reg1,int xmm_reg2){
     
    13171360    __op_format(0,(char)0xF2,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG);
    13181361}
    1319 void CodeGenerator::op_movsd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     1362const PertialSchedule *CodeGenerator::op_movsd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    13201363    //movsd qword ptr[reg+offset],xmm_reg
    13211364    //movsd qword ptr[reg],xmm_reg
    1322     __op_format(0,(char)0xF2,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType );
     1365    return __op_format(0,(char)0xF2,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
    13231366}
    13241367void CodeGenerator::op_movss_RR(int xmm_reg1,int xmm_reg2){
     
    13281371    __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG);
    13291372}
    1330 void CodeGenerator::op_movss_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     1373const PertialSchedule *CodeGenerator::op_movss_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    13311374    //movss xmm_reg,dword ptr[base_reg+offset]
    1332     __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg,base_reg,offset,mod, scheduleType );
    1333 }
    1334 void CodeGenerator::op_movss_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
     1375    return __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
     1376}
     1377const PertialSchedule *CodeGenerator::op_movss_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType, bool isPertialSchedule ){
    13351378    //movss dword ptr[reg+offset],xmm_reg
    13361379    //movss dword ptr[reg],xmm_reg
    1337     __op_format(0,(char)0xF3,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType );
     1380    return __op_format(0,(char)0xF3,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType, isPertialSchedule );
    13381381}
    13391382
  • trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp

    r242 r254  
    3232                (char)0x1C
    3333            );
    34             compiler.codeGenerator.PutOld(
    35                 (long)pRelativeVar->offset,
    36                 Schedule::LocalVar
     34            compiler.codeGenerator.localVarPertialSchedules.push_back(
     35                compiler.codeGenerator.PutOld( (long)pRelativeVar->offset, true )
    3736            );
    3837        }
    3938        else{
    4039            //movlpd xmm_reg,qword ptr[rsp+offset]
    41             compiler.codeGenerator.op_movlpd_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     40            compiler.codeGenerator.localVarPertialSchedules.push_back(
     41                compiler.codeGenerator.op_movlpd_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
     42            );
    4243        }
    4344    }
     
    4546        if(pRelativeVar->bOffsetOffset){
    4647            //add r11,qword ptr[rsp+offset]
    47             compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     48            compiler.codeGenerator.localVarPertialSchedules.push_back(
     49                compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     50            );
    4851        }
    4952        else{
    5053            //mov r11,qword ptr[rsp+offset]
    51             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     54            compiler.codeGenerator.localVarPertialSchedules.push_back(
     55                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     56            );
    5257        }
    5358
     
    8590                (char)0x1C
    8691            );
    87             compiler.codeGenerator.PutOld(
    88                 (long)pRelativeVar->offset,
    89                 Schedule::LocalVar
     92            compiler.codeGenerator.localVarPertialSchedules.push_back(
     93                compiler.codeGenerator.PutOld( (long)pRelativeVar->offset, true )
    9094            );
    9195        }
    9296        else{
    9397            //movss xmm_reg,dword ptr[rsp+offset]
    94             compiler.codeGenerator.op_movss_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     98            compiler.codeGenerator.localVarPertialSchedules.push_back(
     99                compiler.codeGenerator.op_movss_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
     100            );
    95101        }
    96102    }
     
    98104        if(pRelativeVar->bOffsetOffset){
    99105            //add r11,qword ptr[rsp+offset]
    100             compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     106            compiler.codeGenerator.localVarPertialSchedules.push_back(
     107                compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     108            );
    101109        }
    102110        else{
    103111            //mov r11,qword ptr[rsp+offset]
    104             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     112            compiler.codeGenerator.localVarPertialSchedules.push_back(
     113                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     114            );
    105115        }
    106116
     
    145155        if(pRelativeVar->bOffsetOffset){
    146156            //mov reg, ptr[rsp+r11+offset]
    147             compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET, Schedule::LocalVar );
     157            compiler.codeGenerator.localVarPertialSchedules.push_back(
     158                compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET, Schedule::None, true )
     159            );
    148160        }
    149161        else{
    150162            //mov reg, ptr[rsp+offset]
    151             compiler.codeGenerator.op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     163            compiler.codeGenerator.localVarPertialSchedules.push_back(
     164                compiler.codeGenerator.op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     165            );
    152166        }
    153167    }
     
    155169        if(pRelativeVar->bOffsetOffset){
    156170            //add r11,qword ptr[rsp+offset]
    157             compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     171            compiler.codeGenerator.localVarPertialSchedules.push_back(
     172                compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     173            );
    158174        }
    159175        else{
    160176            //mov r11,qword ptr[rsp+offset]
    161             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     177            compiler.codeGenerator.localVarPertialSchedules.push_back(
     178                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     179            );
    162180        }
    163181
  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r228 r254  
    77#include "../BasicCompiler_Common/common.h"
    88#include "Opcode.h"
    9 
    10 //ローカル変数アドレススケジュール
    11 DWORD *pLocalVarAddrSchedule;
    12 int LocalVarAddrScheduleNum;
    139
    1410void Call_DebugSys_SaveContext(){
     
    2723    compiler.codeGenerator.op_call(pSub_DebugSys_SaveContext);
    2824}
    29 
    30 void AddLocalVarAddrSchedule(){
    31     extern HANDLE hHeap;
    32 
    33     //ローカル変数アドレススケジュールに追加する
    34     pLocalVarAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,pLocalVarAddrSchedule,(LocalVarAddrScheduleNum+1)*sizeof(DWORD));
    35     pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
    36     LocalVarAddrScheduleNum++;
    37 }
    38 
    3925
    4026bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer){
  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r243 r254  
    173173
    174174    //mov qword ptr[rax],typeSize(オブジェクトのサイズ)
    175     compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RAX,0, Schedule::None, NON_OFFSET,typeSize);
     175    compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RAX,0, Schedule::None, false, NON_OFFSET,typeSize);
    176176
    177177    //add rax,PTR_SIZE
  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r242 r254  
    66#include <Program.h>
    77#include <Compiler.h>
    8 #include <LexicalScopingImpl.h>
    98#include <Class.h>
    109
     
    116115        UserProc::CompileStartForGlobalArea();
    117116
    118         GetLexicalScopes().CallDestructorsOfScopeEnd();
     117        compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
    119118
    120119        UserProc::CompileStartForUserProc( pBackUserProc );
     
    308307
    309308    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
    310     extern DWORD *pExitSubSchedule;
    311     extern int ExitSubScheduleNum;
    312     pExitSubSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    313     ExitSubScheduleNum=0;
     309    compiler.codeGenerator.exitSubCodePositions.clear();
     310    compiler.codeGenerator._exitSubCodePositions_ObpOld.clear();
    314311
    315312    //ラベル用のメモリを確保
     
    320317
    321318    //Gotoラベルスケジュール
    322     extern GOTOLABELSCHEDULE *pGotoLabelSchedule;
    323     extern int GotoLabelScheduleNum;
    324     pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapAlloc(hHeap,0,1);
    325     GotoLabelScheduleNum=0;
     319    compiler.codeGenerator.gotoLabelSchedules.clear();
    326320
    327321    //With情報のメモリを確保
     
    344338    AllLocalVarSize=0;
    345339
    346     //ローカル変数アドレススケジュール
    347     extern DWORD *pLocalVarAddrSchedule;
    348     extern int LocalVarAddrScheduleNum;
    349     pLocalVarAddrSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    350     LocalVarAddrScheduleNum=0;
    351 
    352340    //レキシカルスコープ情報を初期化
    353     GetLexicalScopes().Init(obp);
     341    compiler.codeGenerator.lexicalScopes.Init(obp);
    354342
    355343
     
    386374
    387375        //レキシカルスコープ情報
    388         pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
    389         pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
     376        pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
     377        pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
    390378        pVar->bLiving=TRUE;
    391379
     
    661649    HeapDefaultFree(pLabelNames);
    662650
    663     //Goto未知ラベルスケジュールを解放
    664     for(i3=0;i3<GotoLabelScheduleNum;i3++){
    665         if(pGotoLabelSchedule[i3].pName){
    666             SetError(6,pGotoLabelSchedule[i3].pName,pGotoLabelSchedule[i3].now_cp);
    667             HeapDefaultFree(pGotoLabelSchedule[i3].pName);
    668         }
    669         else{
    670             sprintf(temporary,"%d",pGotoLabelSchedule[i3].line);
    671             SetError(6,temporary,pGotoLabelSchedule[i3].now_cp);
    672         }
    673     }
    674     HeapDefaultFree(pGotoLabelSchedule);
    675 
    676651    //With情報のメモリを解放
    677652    for(i3=0;i3<WithInfo.num;i3++){
     
    683658
    684659    //ローカルオブジェクト(レキシカルスコープレベル=0)の解放処理
    685     GetLexicalScopes().CallDestructorsOfScopeEnd();
     660    compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
    686661
    687662    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
    688     for(i3=0;i3<ExitSubScheduleNum;i3++){
    689         *((long *)(OpBuffer+pExitSubSchedule[i3]))=obp-(pExitSubSchedule[i3]+sizeof(long));
    690     }
    691     HeapDefaultFree(pExitSubSchedule);
     663    compiler.codeGenerator.ResolveExitSubSchedule();
    692664
    693665    if(bDebugCompile&&bDebugSupportProc==0){
     
    739711
    740712    //ローカル変数アドレススケジュール
    741     for(i3=0;i3<LocalVarAddrScheduleNum;i3++){
    742         *((long *)(OpBuffer+pLocalVarAddrSchedule[i3])) += AllLocalVarSize + stackFrameSize;
    743     }
    744     HeapDefaultFree(pLocalVarAddrSchedule);
     713    BOOST_FOREACH( const PertialSchedule *pPertialSchedule, compiler.codeGenerator.localVarPertialSchedules )
     714    {
     715        compiler.codeGenerator.opfix_offset( pPertialSchedule, AllLocalVarSize );
     716    }
     717    compiler.codeGenerator.localVarPertialSchedules.clear();
    745718    BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
    746719        //後にデバッグで利用する
  • trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp

    r242 r254  
    126126                (char)0x1C
    127127            );
    128             compiler.codeGenerator.PutOld(
    129                 (long)pRelative->offset,
    130                 Schedule::LocalVar
     128            compiler.codeGenerator.localVarPertialSchedules.push_back(
     129                compiler.codeGenerator.PutOld( (long)pRelative->offset, true )
    131130            );
    132131        }
    133132        else{
    134133            //movsd qword ptr[rsp+offset],xmm0
    135             compiler.codeGenerator.op_movsd_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     134            compiler.codeGenerator.localVarPertialSchedules.push_back(
     135                compiler.codeGenerator.op_movsd_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::None, true )
     136            );
    136137        }
    137138    }
     
    139140        if(pRelative->bOffsetOffset){
    140141            //add r11,qword ptr[rsp+offset]
    141             compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     142            compiler.codeGenerator.localVarPertialSchedules.push_back(
     143                compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     144            );
    142145        }
    143146        else{
    144147            //mov r11,qword ptr[rsp+offset]
    145             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     148            compiler.codeGenerator.localVarPertialSchedules.push_back(
     149                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     150            );
    146151        }
    147152
     
    186191                (char)0x1C
    187192            );
    188             compiler.codeGenerator.PutOld(
    189                 (long)pRelative->offset,
    190                 Schedule::LocalVar
     193            compiler.codeGenerator.localVarPertialSchedules.push_back(
     194                compiler.codeGenerator.PutOld( (long)pRelative->offset, true )
    191195            );
    192196        }
    193197        else{
    194198            //movss dword ptr[rsp+offset],xmm0
    195             compiler.codeGenerator.op_movss_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     199            compiler.codeGenerator.localVarPertialSchedules.push_back(
     200                compiler.codeGenerator.op_movss_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::None, true )
     201            );
    196202        }
    197203    }
     
    199205        if(pRelative->bOffsetOffset){
    200206            //add r11,qword ptr[rsp+offset]
    201             compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     207            compiler.codeGenerator.localVarPertialSchedules.push_back(
     208                compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     209            );
    202210        }
    203211        else{
    204212            //mov r11,qword ptr[rsp+offset]
    205             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     213            compiler.codeGenerator.localVarPertialSchedules.push_back(
     214                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     215            );
    206216        }
    207217
     
    302312        if(pRelative->bOffsetOffset){
    303313            //mov ptr[rsp+r11+offset],rax/eax/ax/al
    304             compiler.codeGenerator.op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET, Schedule::LocalVar );
     314            compiler.codeGenerator.localVarPertialSchedules.push_back(
     315                compiler.codeGenerator.op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET, Schedule::None, true )
     316            );
    305317        }
    306318        else{
    307319            //mov ptr[rsp+offset],rax/eax/ax/al
    308             compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     320            compiler.codeGenerator.localVarPertialSchedules.push_back(
     321                compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     322            );
    309323        }
    310324    }
     
    312326        if(pRelative->bOffsetOffset){
    313327            //add r11,qword ptr[rsp+offset]
    314             compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     328            compiler.codeGenerator.localVarPertialSchedules.push_back(
     329                compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32, Schedule::None, true )
     330            );
    315331        }
    316332        else{
    317333            //mov r11,qword ptr[rsp+offset]
    318             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     334            compiler.codeGenerator.localVarPertialSchedules.push_back(
     335                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
     336            );
    319337        }
    320338
  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r243 r254  
    33#include <jenga/include/smoothie/LexicalAnalysis.h>
    44
    5 #include <LexicalScopingImpl.h>
    65#include <Compiler.h>
    76
     
    192191
    193192    //je (endif、または else まで条件ジャンプ)
    194     CodeGenerator::PertialSchedule *pIfPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
     193    const PertialSchedule *pIfPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
    195194
    196195
     
    200199
    201200    //レキシカルスコープをレベルアップ
    202     GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
     201    compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_IF );
    203202
    204203    int i2=CompileBuffer(ESC_ENDIF,0);
    205204
    206205    //レキシカルスコープをレベルダウン
    207     GetLexicalScopes().End();
     206    compiler.codeGenerator.lexicalScopes.End();
    208207
    209208
    210209    if(i2==ESC_ELSE){
    211210        //jmp (endifまで)
    212         CodeGenerator::PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
     211        const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
    213212
    214213        compiler.codeGenerator.opfix_JmpPertialSchedule( pIfPertialSchedule );
     
    221220
    222221        //レキシカルスコープをレベルアップ
    223         GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
     222        compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_IF );
    224223
    225224        CompileBuffer(ESC_ENDIF,0);
    226225
    227226        //レキシカルスコープをレベルダウン
    228         GetLexicalScopes().End();
     227        compiler.codeGenerator.lexicalScopes.End();
    229228
    230229
     
    259258void OpcodeGoto(char *Parameter){
    260259    extern HANDLE hHeap;
    261     extern GOTOLABELSCHEDULE *pGotoLabelSchedule;
    262     extern int GotoLabelScheduleNum;
    263260    int i,LineNum;
    264261
     
    266263        i=GetLabelAddress(Parameter+1,0);
    267264
    268         //jmp ...
    269         OpBuffer[obp++]=(char)0xE9;
    270         if(i==-1){
    271             pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE));
    272             pGotoLabelSchedule[GotoLabelScheduleNum].pName=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter+1)+1);
    273             lstrcpy(pGotoLabelSchedule[GotoLabelScheduleNum].pName,Parameter+1);
    274             pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp;
    275             pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp;
    276             GotoLabelScheduleNum++;
    277         }
    278         *((long *)(OpBuffer+obp))=i-(obp+sizeof(long));
    279         obp+=sizeof(long);
     265        if( i == -1 )
     266        {
     267            //jmp ...(schedule)
     268            extern int obp;
     269            compiler.codeGenerator.op_jmp_goto_schedule( (const std::string)(Parameter + 1), 0, cp );
     270        }
     271        else
     272        {
     273            //jmp ...
     274            extern int obp;
     275            compiler.codeGenerator.op_jmp( i-obp, sizeof(long), false, true );
     276        }
    280277    }
    281278    else{
     
    283280        i=GetLabelAddress(0,LineNum);
    284281
    285         //jmp ...
    286         OpBuffer[obp++]=(char)0xE9;
    287         if(i==-1){
    288             pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE));
    289             pGotoLabelSchedule[GotoLabelScheduleNum].pName=0;
    290             pGotoLabelSchedule[GotoLabelScheduleNum].line=LineNum;
    291             pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp;
    292             pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp;
    293             GotoLabelScheduleNum++;
    294         }
    295         *((long *)(OpBuffer+obp))=i-(obp+sizeof(long));
    296         obp+=sizeof(long);
     282        if( i == -1 )
     283        {
     284            //jmp ...(schedule)
     285            extern int obp;
     286            compiler.codeGenerator.op_jmp_goto_schedule( "", LineNum, cp );
     287        }
     288        else
     289        {
     290            //jmp ...
     291            extern int obp;
     292            compiler.codeGenerator.op_jmp( i-obp, sizeof(long), false, true );
     293        }
    297294    }
    298295}
     
    309306
    310307    //je (Wend まで)
    311     CodeGenerator::PertialSchedule *pWhilePertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
     308    const PertialSchedule *pWhilePertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
    312309
    313310    //レキシカルスコープをレベルアップ
    314     GetLexicalScopes().Start( obp, SCOPE_TYPE_WHILE );
     311    compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_WHILE );
    315312
    316313    //While内をコンパイル
    317314    CompileBuffer(0,COM_WEND);
    318315
    319     GetLexicalScopes().CallDestructorsOfScopeEnd();
     316    compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
    320317
    321318    //jmp ...
     
    323320
    324321    //レキシカルスコープをレベルダウン
    325     GetLexicalScopes().End();
     322    compiler.codeGenerator.lexicalScopes.End();
    326323
    327324    compiler.codeGenerator.opfix_JmpPertialSchedule( pWhilePertialSchedule );
     
    364361
    365362    //jmp ...
    366     CodeGenerator::PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
     363    const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
    367364
    368365    //Continueアドレスのバックアップとセット
     
    407404
    408405    //jmp [カウンタ減少の場合の判定を飛び越す]
    409     CodeGenerator::PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
     406    const PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
    410407
    411408    //jeジャンプ先のオフセット値
     
    430427
    431428    //レキシカルスコープをレベルアップ
    432     GetLexicalScopes().Start( obp, SCOPE_TYPE_FOR );
     429    compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_FOR );
    433430
    434431    //For内をコンパイル
    435432    CompileBuffer(0,COM_NEXT);
    436433
    437     GetLexicalScopes().CallDestructorsOfScopeEnd();
     434    compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
    438435
    439436    if(szNextVariable[0]){
     
    447444
    448445    //レキシカルスコープをレベルダウン
    449     GetLexicalScopes().End();
     446    compiler.codeGenerator.lexicalScopes.End();
    450447
    451448    //jeジャンプ先のオフセット値
     
    466463
    467464    //レキシカルスコープをレベルアップ
    468     GetLexicalScopes().Start( obp, SCOPE_TYPE_DO );
     465    compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_DO );
    469466
    470467    //Do内をコンパイル
    471468    CompileBuffer(0,COM_LOOP);
    472469
    473     GetLexicalScopes().CallDestructorsOfScopeEnd();
    474 
    475     CodeGenerator::PertialSchedule *pDoPertialSchedule = NULL;
     470    compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
     471
     472    const PertialSchedule *pDoPertialSchedule = NULL;
    476473
    477474    extern char *basbuf;
     
    522519
    523520    //jmp ...
    524     CodeGenerator::PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
     521    const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
    525522
    526523    //レキシカルスコープをレベルダウン
    527     GetLexicalScopes().End();
     524    compiler.codeGenerator.lexicalScopes.End();
    528525
    529526    //jmpジャンプ先のオフセット値
     
    539536
    540537void OpcodeExitSub(void){
    541     extern DWORD *pExitSubSchedule;
    542     extern int ExitSubScheduleNum;
    543     extern HANDLE hHeap;
    544 
    545538    if( UserProc::IsGlobalAreaCompiling() ){
    546539        SetError(12,"Exit Sub/Function",cp);
     
    549542
    550543    //未解放のローカルオブジェクトのデストラクタを呼び出す
    551     GetLexicalScopes().CallDestructorsOfReturn();
     544    compiler.codeGenerator.lexicalScopes.CallDestructorsOfReturn();
    552545
    553546    //jmp ...(End Sub/Function)
    554     OpBuffer[obp++]=(char)0xE9;
    555 
    556     pExitSubSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitSubSchedule,(ExitSubScheduleNum+1)*sizeof(DWORD));
    557     pExitSubSchedule[ExitSubScheduleNum]=obp;
    558     ExitSubScheduleNum++;
    559 
    560     obp+=sizeof(long);
    561 }
    562 
    563 void AddCaseSchedule(void){
    564     extern DWORD *pCaseSchedule;
    565     extern int CaseScheduleNum;
    566     extern HANDLE hHeap;
    567 
    568     pCaseSchedule=(DWORD *)HeapReAlloc(hHeap,0,pCaseSchedule,(CaseScheduleNum+1)*sizeof(DWORD));
    569     pCaseSchedule[CaseScheduleNum]=obp;
    570     CaseScheduleNum++;
    571 }
     547    compiler.codeGenerator.op_jmp_exitsub();
     548}
     549
     550//Caseスケジュール
     551class SelectSchedule
     552{
     553public:
     554    SelectSchedule( int typeSize )
     555        : typeSize( typeSize )
     556        , nowCaseSchedule( 0 )
     557    {
     558    }
     559
     560    PertialSchedules casePertialSchedules;
     561    int typeSize;
     562    int nowCaseSchedule;
     563};
     564std::vector<SelectSchedule> selectSchedules;
     565
    572566void OpcodeSelect( const char *lpszParms ){
    573     extern DWORD *pCaseSchedule;
    574     extern int CaseScheduleNum;
    575     extern int NowCaseSchedule;
    576567    extern HANDLE hHeap;
    577568    extern char *basbuf;
    578569    int i,i2,i3,NowCaseCp;
    579570    char temporary[VN_SIZE];
    580 
    581     DWORD *temp_pCaseSchedule;
    582     int temp_CaseScheduleNum;
    583     int temp_NowCaseSchedule;
    584 
    585     temp_pCaseSchedule=pCaseSchedule;
    586     temp_CaseScheduleNum=CaseScheduleNum;
    587     temp_NowCaseSchedule=NowCaseSchedule;
    588     pCaseSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    589     CaseScheduleNum=0;
    590     NowCaseSchedule=0;
    591 
     571   
    592572    int reg1=REG_RAX;
    593573    Type type1;
     
    596576    }
    597577
     578    selectSchedules.push_back( SelectSchedule( type1.GetSize() ) );
     579
     580    if( selectSchedules.back().typeSize < sizeof(long) ){
     581        selectSchedules.back().typeSize = sizeof(long);
     582    }
     583
    598584    if(type1.IsDouble()){
    599585        //movsd qword ptr[rsp+offset],xmm_reg       ※スタックフレームを利用
     
    613599    for(i=cp;;i++){
    614600        if(basbuf[i]=='\0'){
    615             HeapDefaultFree(pCaseSchedule);
    616             pCaseSchedule=temp_pCaseSchedule;
    617             CaseScheduleNum=temp_CaseScheduleNum;
    618             NowCaseSchedule=temp_NowCaseSchedule;
     601            selectSchedules.pop_back();
    619602            SetError(22,"Select",cp);
    620603            return;
     
    718701
    719702                    //jne ...
    720                     OpBuffer[obp++]=(char)0x0F;
    721                     OpBuffer[obp++]=(char)0x85;
     703                    selectSchedules.back().casePertialSchedules.push_back(
     704                        compiler.codeGenerator.op_jne( 0, sizeof(long), true )
     705                    );
    722706                }
    723707                else{
     
    759743
    760744                    //je ...
    761                     OpBuffer[obp++]=(char)0x0F;
    762                     OpBuffer[obp++]=(char)0x84;
     745                    selectSchedules.back().casePertialSchedules.push_back(
     746                        compiler.codeGenerator.op_je( 0, sizeof(long), true )
     747                    );
    763748                }
    764                 AddCaseSchedule();
    765                 obp+=sizeof(long);
    766749
    767750                if(basbuf[i]!=',') break;
     
    770753        if(basbuf[i]==1&&basbuf[i+1]==ESC_CASEELSE){
    771754            //jmp ...
    772             OpBuffer[obp++]=(char)0xE9;
    773             AddCaseSchedule();
    774             obp+=sizeof(long);
     755            selectSchedules.back().casePertialSchedules.push_back(
     756                compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
     757            );
    775758        }
    776759    }
     
    780763
    781764    //レキシカルスコープをレベルアップ
    782     GetLexicalScopes().Start( obp, SCOPE_TYPE_SELECT );
     765    compiler.codeGenerator.lexicalScopes.Start( obp, LexicalScope::SCOPE_TYPE_SELECT );
    783766
    784767    //Select Case内をコンパイル
     
    786769
    787770    //jmp EndSelect
    788     OpBuffer[obp++]=(char)0xE9;
    789     AddCaseSchedule();
    790     obp+=sizeof(long);
     771    selectSchedules.back().casePertialSchedules.push_back(
     772        compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
     773    );
    791774
    792775    //最終スケジュール
    793     for(i=NowCaseSchedule;i<CaseScheduleNum;i++){
    794         *(long *)(OpBuffer+pCaseSchedule[i])=obp-(pCaseSchedule[i]+sizeof(long));
    795     }
    796     HeapDefaultFree(pCaseSchedule);
     776    for(i=selectSchedules.back().nowCaseSchedule;i<(int)selectSchedules.back().casePertialSchedules.size();i++){
     777        compiler.codeGenerator.opfix_JmpPertialSchedule( selectSchedules.back().casePertialSchedules[i] );
     778    }
    797779
    798780    //レキシカルスコープをレベルダウン
    799     GetLexicalScopes().End();
    800 
    801     pCaseSchedule=temp_pCaseSchedule;
    802     CaseScheduleNum=temp_CaseScheduleNum;
    803     NowCaseSchedule=temp_NowCaseSchedule;
     781    compiler.codeGenerator.lexicalScopes.End();
     782
     783    selectSchedules.pop_back();
    804784}
    805785void OpcodeCase(char *Parameter){
    806     extern DWORD *pCaseSchedule;
    807     extern int NowCaseSchedule;
    808786    int i;
    809787
    810     if(!pCaseSchedule){
     788    if(selectSchedules.back().typeSize==-1){
    811789        SetError(30,"Case",cp);
    812790        return;
     
    814792
    815793    //jmp EndSelect
    816     OpBuffer[obp++]=(char)0xE9;
    817     AddCaseSchedule();
    818     obp+=sizeof(long);
     794    selectSchedules.back().casePertialSchedules.push_back(
     795        compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
     796    );
    819797
    820798    i=0;
    821799    while(1){
    822800        //Caseスケジュール
    823         *(long *)(OpBuffer+pCaseSchedule[NowCaseSchedule])=obp-(pCaseSchedule[NowCaseSchedule]+sizeof(long));
    824         NowCaseSchedule++;
     801        compiler.codeGenerator.opfix_JmpPertialSchedule( selectSchedules.back().casePertialSchedules[selectSchedules.back().nowCaseSchedule] );
     802        selectSchedules.back().nowCaseSchedule++;
    825803
    826804        i=JumpOneParameter(Parameter,i);
     
    830808
    831809void OpcodeGosub(char *Parameter){
    832     extern HANDLE hHeap;
    833     extern GOTOLABELSCHEDULE *pGotoLabelSchedule;
    834     extern int GotoLabelScheduleNum;
    835     int i,LineNum;
    836 
    837     //call _System_GetEip
    838     extern const UserProc *pSub_System_GetEip;
    839     compiler.codeGenerator.op_call(pSub_System_GetEip);
    840 
    841     //add rax,offset(Gosubステートメントの最終ポイント)
    842     int schedule=obp,schedule2;
    843     compiler.codeGenerator.op_add_RV(REG_RAX,0);
    844     schedule2=obp-sizeof(long);
    845 
    846     //※戻り先用のrip
    847     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    848     pobj_sf->push(REG_RAX);
    849 
    850 
    851     if(Parameter[0]=='*'){
    852         i=GetLabelAddress(Parameter+1,0);
    853 
    854         //jmp ...
    855         OpBuffer[obp++]=(char)0xE9;
    856         if(i==-1){
    857             pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE));
    858             pGotoLabelSchedule[GotoLabelScheduleNum].pName=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter+1)+1);
    859             lstrcpy(pGotoLabelSchedule[GotoLabelScheduleNum].pName,Parameter+1);
    860             pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp;
    861             pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp;
    862             GotoLabelScheduleNum++;
    863         }
    864         *((long *)(OpBuffer+obp))=i-(obp+sizeof(long));
    865         obp+=sizeof(long);
    866     }
    867     else{
    868         LineNum=atoi(Parameter);
    869         i=GetLabelAddress(0,LineNum);
    870 
    871         //jmp ...
    872         OpBuffer[obp++]=(char)0xE9;
    873         if(i==-1){
    874             pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE));
    875             pGotoLabelSchedule[GotoLabelScheduleNum].pName=0;
    876             pGotoLabelSchedule[GotoLabelScheduleNum].line=LineNum;
    877             pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp;
    878             pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp;
    879             GotoLabelScheduleNum++;
    880         }
    881         *((long *)(OpBuffer+obp))=i-(obp+sizeof(long));
    882         obp+=sizeof(long);
    883     }
    884 
    885     *((long *)(OpBuffer+schedule2))=obp-schedule;
    886 
    887     //※スタックフレームを元に戻す
    888     pobj_sf->pop(REG_NON);
    889 
    890810    SetError(-1,"Gosub ~ Returnステートメントは64ビットコンパイラで利用することはできません。",cp);
    891811}
  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r243 r254  
    44#include <jenga/include/smoothie/LexicalAnalysis.h>
    55
    6 #include <LexicalScopingImpl.h>
    76#include <CodeGenerator.h>
    87#include <Compiler.h>
     
    989988
    990989        //mov qword ptr[rsp+offset],rax
    991         compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
    992         obp-=sizeof(long);
    993         AddLocalVarAddrSchedule();
    994         obp+=sizeof(long);
     990        compiler.codeGenerator.localVarPertialSchedules.push_back(
     991            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
     992        );
    995993    }
    996994    else if( type.IsSingle() ){
     
    999997
    1000998        //mov dword ptr[rsp+offset],value
    1001         compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::LocalVar, USE_OFFSET,*(int *)&flt);
     999        compiler.codeGenerator.localVarPertialSchedules.push_back(
     1000            compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::None, true, USE_OFFSET,*(int *)&flt)
     1001        );
    10021002    }
    10031003    else if( type.Is64() || type.IsPointer() ){
     
    10141014
    10151015            //mov qword ptr[rsp+offset],rax
    1016             compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::LocalVar );
     1016            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1017                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
     1018            );
    10171019        }
    10181020        else{
     
    10221024
    10231025                //mov qword ptr[rsp+offset],rax
    1024                 compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::LocalVar );
     1026                compiler.codeGenerator.localVarPertialSchedules.push_back(
     1027                    compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
     1028                );
    10251029            }
    10261030            else{
    10271031                //mov qword ptr[rsp+offset],value
    1028                 compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RSP,offset, Schedule::LocalVar, USE_OFFSET,(int)i64data);
     1032                compiler.codeGenerator.localVarPertialSchedules.push_back(
     1033                    compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
     1034                );
    10291035            }
    10301036        }
     
    10321038    else if( type.IsDWord() || type.IsLong() ){
    10331039        //mov dword ptr[rsp+offset],value
    1034         compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::LocalVar,USE_OFFSET,(int)i64data);
     1040        compiler.codeGenerator.localVarPertialSchedules.push_back(
     1041            compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
     1042        );
    10351043    }
    10361044    else if( type.IsWord() || type.IsInteger() ){
    10371045        //mov word ptr[rsp+offset],value
    1038         compiler.codeGenerator.op_mov_MV(sizeof(short),REG_RSP,offset, Schedule::LocalVar,USE_OFFSET,(int)i64data);
     1046        compiler.codeGenerator.localVarPertialSchedules.push_back(
     1047            compiler.codeGenerator.op_mov_MV(sizeof(short),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
     1048        );
    10391049    }
    10401050    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
    10411051        //mov byte ptr[rsp+offset],value
    1042         compiler.codeGenerator.op_mov_MV(sizeof(char),REG_RSP,offset, Schedule::LocalVar,USE_OFFSET,(int)i64data);
     1052        compiler.codeGenerator.localVarPertialSchedules.push_back(
     1053            compiler.codeGenerator.op_mov_MV(sizeof(char),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
     1054        );
    10431055    }
    10441056    return true;
     
    10741086
    10751087        //レキシカルスコープ
    1076         pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
    1077         pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
     1088        pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
     1089        pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
    10781090        pVar->bLiving=TRUE;
    10791091
     
    11091121
    11101122        //レキシカルスコープ
    1111         pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
    1112         pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
     1123        pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
     1124        pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
    11131125        pVar->bLiving=TRUE;
    11141126
     
    11511163
    11521164            //add rcx, offset
    1153             compiler.codeGenerator.op_add_RV( REG_RCX, -pVar->GetOffsetAddress() );
    1154             obp-=sizeof(long);
    1155             AddLocalVarAddrSchedule();
    1156             obp+=sizeof(long);
     1165            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1166                compiler.codeGenerator.op_add_RV( REG_RCX, -pVar->GetOffsetAddress(), Schedule::None, true )
     1167            );
    11571168
    11581169            //call FillMemory
     
    12171228        if(pRelativeVar->bOffsetOffset){
    12181229            //add r11,offset
    1219             compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::LocalVar );
     1230            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1231                compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::None, true )
     1232            );
    12201233
    12211234            //add r11,rsp
     
    12301243
    12311244            //add reg,offset
    1232             compiler.codeGenerator.op_add_RV(reg,(long)pRelativeVar->offset, Schedule::LocalVar );
     1245            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1246                compiler.codeGenerator.op_add_RV(reg,(long)pRelativeVar->offset, Schedule::None, true )
     1247            );
    12331248        }
    12341249    }
     
    12361251        if(pRelativeVar->bOffsetOffset){
    12371252            //add r11,qword ptr[rsp+offset]
    1238             compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
     1253            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1254                compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
     1255            );
    12391256        }
    12401257        else{
    12411258            //mov r11,qword ptr[rsp+offset]
    1242             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
     1259            compiler.codeGenerator.localVarPertialSchedules.push_back(
     1260                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
     1261            );
    12431262        }
    12441263
  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r242 r254  
    55#include <jenga/include/smoothie/Smoothie.h>
    66
    7 #include <LexicalScopingImpl.h>
    87#include <Class.h>
    98#include <Compiler.h>
     
    334333
    335334    //レキシカルスコープ情報を初期化
    336     GetLexicalScopes().Init(obp);
     335    compiler.codeGenerator.lexicalScopes.Init(obp);
    337336
    338337
     
    369368
    370369        //Gotoラベルスケジュール
    371         extern GOTOLABELSCHEDULE *pGotoLabelSchedule;
    372         extern int GotoLabelScheduleNum;
    373         pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapAlloc(hHeap,0,1);
    374         GotoLabelScheduleNum=0;
     370        compiler.codeGenerator.gotoLabelSchedules.clear();
    375371
    376372        //With情報のメモリを確保
     
    424420        HeapDefaultFree(pLabelNames);
    425421
    426         //Goto未知ラベルスケジュールを解放
    427         for(i=0;i<GotoLabelScheduleNum;i++){
    428             if(pGotoLabelSchedule[i].pName){
    429                 SetError(6,pGotoLabelSchedule[i].pName,pGotoLabelSchedule[i].now_cp);
    430                 HeapDefaultFree(pGotoLabelSchedule[i].pName);
     422        //Goto未知ラベルスケジュールが存在したらエラーにする
     423        BOOST_FOREACH( const GotoLabelSchedule *pGotoLabelSchedule, compiler.codeGenerator.gotoLabelSchedules )
     424        {
     425            if(pGotoLabelSchedule->GetName().size()>0){
     426                SetError(6,pGotoLabelSchedule->GetName(),pGotoLabelSchedule->GetSourceCodePos());
    431427            }
    432428            else{
    433                 sprintf(temporary,"%d",pGotoLabelSchedule[i].line);
    434                 SetError(6,temporary,pGotoLabelSchedule[i].now_cp);
     429                sprintf(temporary,"%d",pGotoLabelSchedule->GetLineNum());
     430                SetError(6,temporary,pGotoLabelSchedule->GetSourceCodePos());
    435431            }
    436432        }
    437         HeapDefaultFree(pGotoLabelSchedule);
    438433
    439434
  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r242 r254  
    533533    }
    534534
    535     if(expression[0]==1&& expression[1]==ESC_NEW ){
    536         //New演算子(オブジェクト生成)
    537 
    538         if( pobj_BlockReg->check(REG_RAX) ){
    539             SetError();
    540         }
    541 
    542         //////////////////////////////////////////////////////
    543         /////    レジスタ資源のバックアップ
    544         {   BACKUP_REGISTER_RESOURCE
    545         //////////////////////////////////////////////////////
    546 
    547             if( !Operator_New( expression+2, baseType, resultType ) ){
    548                 return false;
    549             }
    550 
    551         /////////////////////////////////////////////
    552         //////   レジスタ資源を復元
    553             RESTORE_REGISTER_RESOURCE
    554         }////////////////////////////////////////////
    555 
    556         //mov reg,rax
    557         compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
    558 
    559         return true;
    560     }
    561 
    562535    if( !baseType.IsNull() && expression[0] == '[' ){
    563536        // リテラル配列の場合
     
    608581
    609582        resultType = baseType;
     583
     584        return true;
     585    }
     586
     587    bool isLiteralCalculation;
     588    if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
     589    {
     590        return false;
     591    }
     592    if( isLiteralCalculation )
     593    {
     594        //右辺値が数値の定数式の場合
     595        _int64 i64data;
     596        StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
     597
     598        if(resultType.IsReal()){
     599            if(baseType.IsReal()) resultType=baseType;
     600
     601            int xmmReg = REG_XMM0;
     602
     603            if(resultType.IsDouble()){
     604                i3 = compiler.GetDataTable().Add( i64data );
     605
     606                //movlpd xmm_reg,qword ptr[data table offset]
     607                compiler.codeGenerator.op_movlpd_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
     608            }
     609            if(resultType.IsSingle()){
     610                double dbl;
     611                memcpy(&dbl,&i64data,sizeof(_int64));
     612
     613                float flt;
     614                int i32data;
     615                flt=(float)dbl;
     616                memcpy(&i32data,&flt,sizeof(long));
     617
     618                i3 = compiler.GetDataTable().Add( i32data );
     619
     620                //movss xmm_reg,dword ptr[data table offset]
     621                compiler.codeGenerator.op_movss_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
     622            }
     623        }
     624        else{
     625            if(!resultType.Is64()){
     626                //整数(符号有り/無し)
     627
     628                i3=(long)i64data;
     629
     630                if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
     631                if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
     632
     633                i64data=(_int64)i3;
     634            }
     635
     636            //mov reg,i64data
     637            compiler.codeGenerator.op_mov_RV64(*pReg,i64data);
     638        }
     639        return true;
     640    }
     641
     642    if(expression[0]==1&& expression[1]==ESC_NEW ){
     643        //New演算子(オブジェクト生成)
     644
     645        if( pobj_BlockReg->check(REG_RAX) ){
     646            SetError();
     647        }
     648
     649        //////////////////////////////////////////////////////
     650        /////    レジスタ資源のバックアップ
     651        {   BACKUP_REGISTER_RESOURCE
     652        //////////////////////////////////////////////////////
     653
     654            if( !Operator_New( expression+2, baseType, resultType ) ){
     655                return false;
     656            }
     657
     658        /////////////////////////////////////////////
     659        //////   レジスタ資源を復元
     660            RESTORE_REGISTER_RESOURCE
     661        }////////////////////////////////////////////
     662
     663        //mov reg,rax
     664        compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
    610665
    611666        return true;
  • trunk/abdev/BasicCompiler64/Opcode.h

    r226 r254  
    2727    int line;
    2828    DWORD address;
    29 };
    30 
    31 //Goto未知ラベル
    32 struct GOTOLABELSCHEDULE{
    33     char *pName;
    34     int line;
    35     DWORD pos;
    36     DWORD now_cp;
    3729};
    3830
     
    339331
    340332//Compile_CallProc.cpp
    341 void AddLocalVarAddrSchedule();
    342333#define PROCFLAG_NEW    1
    343334bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
  • trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r206 r254  
    542542}
    543543
    544 bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
     544bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType, bool *pIsLiteralCalculation ){
    545545    extern int cp;
    546546    int i,i3;
     547
     548    //リテラル値のみの計算かどうかを判別するためのフラグ
     549    bool dummyBool;
     550    if( pIsLiteralCalculation == NULL )
     551    {
     552        pIsLiteralCalculation = &dummyBool;
     553    }
     554    *pIsLiteralCalculation = true;
    547555
    548556    if(expression[0]=='\0'){
     
    553561    if(expression[0]==1&& expression[1]==ESC_NEW ){
    554562        //New演算子(オブジェクト生成)
     563        *pIsLiteralCalculation = false;
    555564        return Operator_New_GetType(expression+2,baseType, resultType );
    556565    }
     
    590599    BOOL bError;
    591600    bError=0;
    592 
    593     //リテラル値のみの計算かどうかを判別するためのフラグ
    594     BOOL bLiteralCalculation=1;
    595601
    596602    int sp;
     
    684690                        type_stack[sp]=DEF_OBJECT;
    685691                        index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
    686                         bLiteralCalculation=0;
     692                        *pIsLiteralCalculation = false;
    687693
    688694                        sp++;
     
    691697
    692698                    type_stack[sp]=typeOfPtrChar;
    693                     bLiteralCalculation=0;
     699                    *pIsLiteralCalculation = false;
    694700                }
    695701                else if((term[0]=='e'||term[0]=='E')&&
     
    711717
    712718                        if( !isLiteral ){
    713                             bLiteralCalculation=0;
     719                            *pIsLiteralCalculation = false;
    714720                        }
    715721
     
    730736                            index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
    731737                        }
    732                         bLiteralCalculation = 0;
     738                        *pIsLiteralCalculation = false;
    733739                        sp++;
    734740                        break;
     
    784790
    785791                        index_stack[sp]=tempType.GetIndex();
    786                         bLiteralCalculation=0;
     792                        *pIsLiteralCalculation = false;
    787793
    788794                        sp++;
     
    900906    }
    901907
    902     if(bLiteralCalculation){
     908    if( *pIsLiteralCalculation ){
    903909        //右辺値が数値の定数式の場合
    904910        int base_type = 0;
  • trunk/abdev/BasicCompiler_Common/calculation.cpp

    r206 r254  
    726726                        //リテラル値
    727727                        StrPtr[pnum]=0;
    728                         type[pnum]=GetLiteralValue(Parms,&i64data,BaseType);
     728                        type[pnum]=GetLiteralValue(Parms,&i64data,BaseType, enableerror);
     729                        if( type[pnum] == -1 )
     730                        {
     731                            // エラー
     732                            return false;
     733                        }
    729734                        if(IsRealNumberType(type[pnum])){
    730735                            //実数型
     
    969974#pragma optimize("", off)
    970975#pragma warning(disable : 4748)
    971 DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType){
     976DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType, bool isNotifyError ){
    972977    extern HANDLE hHeap;
    973978    extern int cp;
     
    987992            }
    988993            if(temporary[i]){
     994                if( !isNotifyError )
     995                {
     996                    return -1;
     997                }
    989998                SetError(57,NULL,cp);
    990999                return DEF_BYTE;
     
    10091018            }
    10101019            if(temporary[i]){
     1020                if( !isNotifyError )
     1021                {
     1022                    return -1;
     1023                }
    10111024                SetError(58,NULL,cp);
    10121025                return DEF_BYTE;
     
    10211034        }
    10221035        else{
     1036            if( !isNotifyError )
     1037            {
     1038                return -1;
     1039            }
    10231040            SetError(12,"&",cp);
    10241041            return DEF_BYTE;
     
    10701087                    if(bDebugRun) return DEF_DOUBLE;
    10711088
     1089                    if( !isNotifyError )
     1090                    {
     1091                        return -1;
     1092                    }
     1093
    10721094                    SetError(3,value,cp);
    10731095                    return DEF_DOUBLE;
     
    11111133    if(bDebugRun) return DEF_DOUBLE;
    11121134
     1135    if( !isNotifyError )
     1136    {
     1137        return -1;
     1138    }
     1139
    11131140    SetError(33,NULL,cp);
    11141141    return DEF_DOUBLE;
     
    11161143#pragma optimize("", on)
    11171144
    1118 int IsStrCalculation(char *Command){
     1145int IsStrCalculation(const char *Command){
    11191146    int i,i2,i3,i4,PareNum;
    11201147    char temporary[VN_SIZE],temp2[8192];
  • trunk/abdev/BasicCompiler_Common/common.h

    r223 r254  
    343343int GetLiteralIndex(_int64 i64data);
    344344int NeutralizationType(int type1,LONG_PTR index1,int type2,LONG_PTR index2);
    345 DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType);
    346 int IsStrCalculation(char *Command);
     345DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType, bool isNotifyError = true );
     346int IsStrCalculation(const char *Command);
    347347BYTE GetCalcId(const char *Command,int *pi);
    348348BOOL GetNumOpeElements(const char *Command,int *pnum,
     
    353353BOOL CheckCalcType(int idCalc,int *type,int sp);
    354354bool GetTermType( const char *term, Type &resultType, bool &isLiteral, bool *pIsClassName = NULL );
    355 bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType );
     355bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType, bool *pIsLiteralCalculation = NULL );
    356356
    357357//Subroutine.cpp
  • trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

    r253 r254  
    288288private:
    289289    void set_rex(int op_size,int reg,int index_reg,int base_reg);
    290     void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp, Schedule::Type scheduleType = Schedule::None );
    291     void __op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None );
     290    const PertialSchedule *set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     291    const PertialSchedule *__op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
    292292public:
    293293    void op_mov_RV                  (int op_size,int reg,long i32data, Schedule::Type scheduleType = Schedule::None );
    294294    void op_mov_RV64                (int reg,_int64 i64data);
    295     void op_mov_RM                  (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None );
    296     void op_mov_RM_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None );
    297     void op_mov_MR                  (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None );
    298     void op_mov_MR_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None );
    299     void op_mov_MV                  (int op_size,int base_reg,int offset, Schedule::Type offsetScheduleType, BOOL bUseOffset,long i32data);
     295    const PertialSchedule *op_mov_RM        (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     296    const PertialSchedule *op_mov_RM_ex     (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     297    const PertialSchedule *op_mov_MR        (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     298    const PertialSchedule *op_mov_MR_ex     (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     299    const PertialSchedule *op_mov_MV        (int op_size,int base_reg,int offset, Schedule::Type offsetScheduleType, bool isPertialSchedule, BOOL bUseOffset,long i32data);
    300300    void op_mov_RR                  (int reg1,int reg2);
    301301    void op_movsxd                  (int reg64,int reg32);
     
    308308    void op_inc                     (int reg);
    309309    void op_dec                     (int reg);
    310     void op_add_RM                  (int op_size,int reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    311     void op_add_RV                  (int reg,long offset, Schedule::Type scheduleType = Schedule::None );
     310    const PertialSchedule *op_add_RM        (int op_size,int reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     311    const PertialSchedule *op_add_RV        (int reg,long offset, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
    312312    void op_add_RR              (int reg1,int reg2);
    313313    void op_add32_reg               (int reg1,int reg2);
     
    334334    void op_cmp_value               (int op_size,int reg,char byte_data);
    335335    void op_setne                   (int reg);
    336     void op_movlpd_MR               (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    337     void op_movlpd_RM               (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
     336    const PertialSchedule *op_movlpd_MR     (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     337    const PertialSchedule *op_movlpd_RM     (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
    338338    void op_movsd_RR                (int xmm_reg1,int xmm_reg2);
    339     void op_movsd_MR                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
     339    const PertialSchedule *op_movsd_MR      (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
    340340    void op_movss_RR                (int xmm_reg1,int xmm_reg2);
    341     void op_movss_RM                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    342     void op_movss_MR                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
     341    const PertialSchedule *op_movss_RM      (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
     342    const PertialSchedule *op_movss_MR      (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None, bool isPertialSchedule = false );
    343343    void op_movd_RX                 (int reg,int xmm_reg);
    344344    void op_cvtsd2ss                (int xmm_reg1,int xmm_reg2);
     
    448448        pNativeCode->Put( l, scheduleType );
    449449    }
     450    const PertialSchedule *PutOld( long l, bool isPertialSchedule )
     451    {
     452        const PertialSchedule *pPertialSchedule;
     453        if( isPertialSchedule )
     454        {
     455            pertialSchedules.push_back( new PertialSchedule( pNativeCode->GetSize(), sizeof(long) ) );
     456            pPertialSchedule = pertialSchedules.back();
     457        }
     458        pNativeCode->Put( l, Schedule::None );
     459        return pPertialSchedule;
     460    }
    450461    void PutOld( const NativeCode &nativeCode )
    451462    {
  • trunk/abdev/BasicCompiler_Common/include/Const.h

    r206 r254  
    8484public:
    8585
    86     int GetBasicType(char *Name);
    87     _int64 GetWholeData(char *Name);
    88     double GetDoubleData(char *Name);
    89     bool IsStringPtr(char *Name);
     86    int GetBasicType(const char *Name);
     87    _int64 GetWholeData(const char *Name);
     88    double GetDoubleData(const char *Name);
     89    bool IsStringPtr(const char *Name);
    9090};
    9191
  • trunk/abdev/BasicCompiler_Common/src/CommonCodeGenerator.cpp

    r253 r254  
    301301void CodeGenerator::op_jmp_continue()
    302302{
    303     //op_jmp( GetContinueCodePos()-(pNativeCode->GetSize()+sizeof(long)), sizeof(long) );
    304 
    305     // TODO: 未完成(OpBuffer/obp廃止が整ったら上記のコードを有効にすべし)
    306 
    307     if( GetContinueCodePosOld() == -1 )
     303    ////////////////////////////////////
     304    // エラー検出(必要なくなったら消す)
     305    extern int obp;
     306    if( GetContinueCodePosOld()-obp != GetContinueCodePos()-pNativeCode->GetSize() )
     307    {
     308        int continueCodePosOld = GetContinueCodePosOld();
     309        int continueCodePos = GetContinueCodePos();
     310        int size = pNativeCode->GetSize();
     311        int test=0;
     312        SetError();
     313    }
     314    ////////////////////////////////////
     315
     316
     317    if( GetContinueCodePos() == -1 )
    308318    {
    309319        SetError(12,"Continue",cp);
    310320        return;
    311321    }
    312 
    313     extern int obp;
    314     op_jmp( GetContinueCodePosOld()-obp, sizeof(long), false, true );
     322    op_jmp( GetContinueCodePos() - pNativeCode->GetSize(), sizeof(long), false, true );
    315323}
    316324void CodeGenerator::op_jmp_exitsub()
  • trunk/abdev/BasicCompiler_Common/src/Const.cpp

    r206 r254  
    9292
    9393
    94 int Consts::GetBasicType(char *Name){
     94int Consts::GetBasicType(const char *Name){
    9595    CConst *pConst = GetObjectPtr(Name);
    9696
     
    9999    return pConst->GetType().GetBasicType();
    100100}
    101 _int64 Consts::GetWholeData(char *Name){
     101_int64 Consts::GetWholeData(const char *Name){
    102102    CConst *pConst = GetObjectPtr(Name);
    103103
     
    106106    return pConst->GetWholeData();
    107107}
    108 double Consts::GetDoubleData(char *Name){
     108double Consts::GetDoubleData(const char *Name){
    109109    CConst *pConst = GetObjectPtr(Name);
    110110
     
    113113    return pConst->GetDoubleData();
    114114}
    115 bool Consts::IsStringPtr( char *Name ){
     115bool Consts::IsStringPtr( const char *Name ){
    116116    CConst *pConst = GetObjectPtr(Name);
    117117
  • trunk/abdev/BasicCompiler_Common/src/LexicalScope.cpp

    r253 r254  
    128128
    129129            //mov rcx,qword ptr[rsp+offset]
     130            compiler.codeGenerator.localVarPertialSchedules.push_back(
    130131            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
    131132                -pVar->GetOffsetAddress(),
    132133                MOD_BASE_DISP32,
    133                 Schedule::LocalVar);
     134                Schedule::None, true)
     135            );
    134136#else
    135137            //x86コード
Note: See TracChangeset for help on using the changeset viewer.