Changeset 34 in dev


Ignore:
Timestamp:
Jan 14, 2007, 6:11:23 AM (13 years ago)
Author:
dai_9181
Message:

スコープ処理を統一した。関数の途中でReturnしても、スコープにあるローカルオブジェクトを正確に破棄できるようにした。

Files:
1 added
2 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • BasicCompiler32/BasicCompiler.vcproj

    r28 r34  
    11681168                    </File>
    11691169                    <File
    1170                         RelativePath="..\BasicCompiler_Common\schedule.h"
     1170                        RelativePath="..\BasicCompiler_Common\PESchedule.h"
    11711171                        >
    11721172                    </File>
  • BasicCompiler32/Compile_ProcOp.cpp

    r31 r34  
    8888        bCompilingGlobal=1;
    8989
    90         CallDestrouctorsOfScope();
     90        obj_LexScopes.CallDestructorsOfScopeEnd();
    9191
    9292        bCompilingGlobal=bBackCompilingGlobal;
     
    658658    }
    659659
    660     //プロシージャ抜け出しスケジュール(Exit Sub/Function)
    661     for(i3=0;i3<ExitSubScheduleNum;i3++){
    662         *((long *)(OpBuffer+pExitSubSchedule[i3]))=obp-(pExitSubSchedule[i3]+sizeof(long));
    663     }
    664     HeapDefaultFree(pExitSubSchedule);
    665 
    666     if(bDebugCompile&&bDebugSupportProc==0){
    667         *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset;
    668 
    669         //call _DebugSys_EndProc
    670         extern SUBINFO *pSub_DebugSys_EndProc;
    671         op_call(pSub_DebugSys_EndProc);
    672     }
    673 
    674660    //ラベル用のメモリを解放
    675661    for(i3=0;i3<MaxLabelNum;i3++){
     
    707693
    708694    //ローカルオブジェクトの解放処理
    709     CallDestrouctorsOfScope();
     695    obj_LexScopes.CallDestructorsOfScopeEnd();
     696
     697    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
     698    for(i3=0;i3<ExitSubScheduleNum;i3++){
     699        *((long *)(OpBuffer+pExitSubSchedule[i3]))=obp-(pExitSubSchedule[i3]+sizeof(long));
     700    }
     701    HeapDefaultFree(pExitSubSchedule);
     702
     703    if(bDebugCompile&&bDebugSupportProc==0){
     704        *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset;
     705
     706        //call _DebugSys_EndProc
     707        extern SUBINFO *pSub_DebugSys_EndProc;
     708        op_call(pSub_DebugSys_EndProc);
     709    }
    710710
    711711    if(psi->ReturnType!=-1){
  • BasicCompiler32/Compile_Statement.cpp

    r31 r34  
    299299
    300300    //レキシカルスコープをレベルアップ
    301     obj_LexScopes.LevelUp(obp);
     301    obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
    302302
    303303    i2=CompileBuffer(ESC_ENDIF,0);
    304304
    305305    //レキシカルスコープをレベルダウン
    306     obj_LexScopes.LevelDown();
     306    obj_LexScopes.End();
    307307
    308308
     
    325325
    326326        //レキシカルスコープをレベルアップ
    327         obj_LexScopes.LevelUp(obp);
     327        obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
    328328
    329329        CompileBuffer(ESC_ENDIF,0);
    330330
    331331        //レキシカルスコープをレベルダウン
    332         obj_LexScopes.LevelDown();
     332        obj_LexScopes.End();
    333333
    334334
     
    402402}
    403403void OpcodeWhile(char *Parameter){
    404     extern DWORD *pExitWhileSchedule;
    405     extern int ExitWhileScheduleNum;
    406404    extern HANDLE hHeap;
    407405    int i2,i3,type;
    408     DWORD *lpdwTemp;
    409     int TempNum;
    410406
    411407    //Continueアドレスのバックアップとセット
     
    550546    }
    551547
    552     //ExitWhileスケジュールの準備
    553     lpdwTemp=pExitWhileSchedule;
    554     TempNum=ExitWhileScheduleNum;
    555     pExitWhileSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    556     ExitWhileScheduleNum=0;
    557 
    558548    //レキシカルスコープをレベルアップ
    559     obj_LexScopes.LevelUp(obp);
     549    obj_LexScopes.Start( obp, SCOPE_TYPE_WHILE );
    560550
    561551    //While内をコンパイル
    562552    CompileBuffer(0,COM_WEND);
    563553
    564     CallDestrouctorsOfScope();
     554    obj_LexScopes.CallDestructorsOfScopeEnd();
    565555
    566556    //jmp ...
     
    569559    obp+=sizeof(long);
    570560
    571     //ExitWhileスケジュール
    572     for(i2=0;i2<ExitWhileScheduleNum;i2++){
    573         *((long *)(OpBuffer+pExitWhileSchedule[i2]))=obp-(pExitWhileSchedule[i2]+sizeof(long));
    574     }
    575     HeapDefaultFree(pExitWhileSchedule);
    576     pExitWhileSchedule=lpdwTemp;
    577     ExitWhileScheduleNum=TempNum;
    578 
    579561    //レキシカルスコープをレベルダウン
    580     obj_LexScopes.LevelDown();
     562    obj_LexScopes.End();
    581563
    582564    *((long *)(OpBuffer+je_schedule-sizeof(long)))=obp-je_schedule; //jeジャンプ先のオフセット値
     
    585567    dwContinueAddress=dwTempContinue;
    586568}
    587 void OpcodeExitWhile(void){
    588     extern DWORD *pExitWhileSchedule;
    589     extern int ExitWhileScheduleNum;
    590     extern HANDLE hHeap;
    591 
    592     if(!pExitWhileSchedule){
    593         SetError(12,"Exit While",cp);
    594         return;
    595     }
    596 
    597     //jmp ...(Wend addr)
    598     OpBuffer[obp++]=(char)0xE9;
    599 
    600     pExitWhileSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitWhileSchedule,(ExitWhileScheduleNum+1)*sizeof(DWORD));
    601     pExitWhileSchedule[ExitWhileScheduleNum]=obp;
    602     ExitWhileScheduleNum++;
    603 
    604     obp+=sizeof(long);
    605 }
     569
    606570char szNextVariable[VN_SIZE];
    607571void OpcodeFor(char *Parameter){
    608     extern DWORD *pExitForSchedule;
    609     extern int ExitForScheduleNum;
    610572    extern HANDLE hHeap;
    611     DWORD *lpdwTemp;
    612     int TempNum;
    613573    int i,i2,i3;
    614574    char temporary[VN_SIZE],variable[VN_SIZE],JudgeNum[VN_SIZE],StepNum[VN_SIZE];
     
    717677    obp+=sizeof(long);
    718678
    719     //ExitForスケジュールの準備
    720     lpdwTemp=pExitForSchedule;
    721     TempNum=ExitForScheduleNum;
    722     pExitForSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    723     ExitForScheduleNum=0;
    724 
    725679    //レキシカルスコープをレベルアップ
    726     obj_LexScopes.LevelUp(obp);
     680    obj_LexScopes.Start( obp, SCOPE_TYPE_FOR );
    727681
    728682    //For内をコンパイル
    729683    CompileBuffer(0,COM_NEXT);
    730684
    731     CallDestrouctorsOfScope();
     685    obj_LexScopes.CallDestructorsOfScopeEnd();
    732686
    733687    if(szNextVariable[0]){
     
    742696    obp+=sizeof(long);
    743697
    744     //ExitForスケジュール
    745     for(i=0;i<ExitForScheduleNum;i++){
    746         *((long *)(OpBuffer+pExitForSchedule[i]))=obp-(pExitForSchedule[i]+sizeof(long));
    747     }
    748     HeapDefaultFree(pExitForSchedule);
    749     pExitForSchedule=lpdwTemp;
    750     ExitForScheduleNum=TempNum;
    751 
    752698    //レキシカルスコープをレベルダウン
    753     obj_LexScopes.LevelDown();
     699    obj_LexScopes.End();
    754700
    755701    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jeジャンプ先のオフセット値
     
    758704    dwContinueAddress=dwTempContinue;
    759705}
    760 void OpcodeExitFor(void){
    761     extern DWORD *pExitForSchedule;
    762     extern int ExitForScheduleNum;
    763     extern HANDLE hHeap;
    764 
    765     if(!pExitForSchedule){
    766         SetError(12,"Exit For",cp);
    767         return;
    768     }
    769 
    770     //jmp ...(Next addr)
    771     OpBuffer[obp++]=(char)0xE9;
    772 
    773     pExitForSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitForSchedule,(ExitForScheduleNum+1)*sizeof(DWORD));
    774     pExitForSchedule[ExitForScheduleNum]=obp;
    775     ExitForScheduleNum++;
    776 
    777     obp+=sizeof(long);
    778 }
    779706
    780707void OpcodeDo(char *Parameter){
    781     extern DWORD *pExitDoSchedule;
    782     extern int ExitDoScheduleNum;
    783708    extern HANDLE hHeap;
    784709    int i,i2,i3,i4,type;
    785     DWORD *lpdwTemp;
    786     int TempNum;
    787710
    788711    if(Parameter[0]) SetError(10,"Do",cp);
    789 
    790     //ExitDoスケジュールの準備
    791     lpdwTemp=pExitDoSchedule;
    792     TempNum=ExitDoScheduleNum;
    793     pExitDoSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    794     ExitDoScheduleNum=0;
    795712
    796713    //Continueアドレスのバックアップとセット
     
    801718
    802719    //レキシカルスコープをレベルアップ
    803     obj_LexScopes.LevelUp(obp);
     720    obj_LexScopes.Start( obp, SCOPE_TYPE_DO );
    804721
    805722    //Do内をコンパイル
    806723    CompileBuffer(0,COM_LOOP);
    807724
    808     CallDestrouctorsOfScope();
     725    obj_LexScopes.CallDestructorsOfScopeEnd();
    809726
    810727    extern char *basbuf;
     
    1007924    obp+=sizeof(long);
    1008925
    1009     //ExitDoスケジュール
    1010     for(i=0;i<ExitDoScheduleNum;i++){
    1011         *((long *)(OpBuffer+pExitDoSchedule[i]))=obp-(pExitDoSchedule[i]+sizeof(long));
    1012     }
    1013     HeapDefaultFree(pExitDoSchedule);
    1014     pExitDoSchedule=lpdwTemp;
    1015     ExitDoScheduleNum=TempNum;
    1016 
    1017926    //レキシカルスコープをレベルダウン
    1018     obj_LexScopes.LevelDown();
     927    obj_LexScopes.End();
    1019928
    1020929    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jmpジャンプ先のオフセット値
     
    1023932    //Continueアドレスを復元
    1024933    dwContinueAddress=dwTempContinue;
    1025 }
    1026 void OpcodeExitDo(void){
    1027     extern HANDLE hHeap;
    1028     extern DWORD *pExitDoSchedule;
    1029     extern int ExitDoScheduleNum;
    1030 
    1031     if(!pExitDoSchedule){
    1032         SetError(12,"Exit Do",cp);
    1033         return;
    1034     }
    1035 
    1036     //jmp ...(Loop addr)
    1037     OpBuffer[obp++]=(char)0xE9;
    1038 
    1039     pExitDoSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitDoSchedule,(ExitDoScheduleNum+1)*sizeof(DWORD));
    1040     pExitDoSchedule[ExitDoScheduleNum]=obp;
    1041     ExitDoScheduleNum++;
    1042 
    1043     obp+=sizeof(long);
    1044934}
    1045935void OpcodeContinue(void){
     
    1068958        return;
    1069959    }
     960
     961    //未解放のローカルオブジェクトのデストラクタを呼び出す
     962    obj_LexScopes.CallDestructorsOfReturn();
    1070963
    1071964    //jmp ...(End Sub/Function)
     
    13541247
    13551248    //レキシカルスコープをレベルアップ
    1356     obj_LexScopes.LevelUp(obp);
     1249    obj_LexScopes.Start( obp, SCOPE_TYPE_SELECT );
    13571250
    13581251    //Select Case内をコンパイル
     
    13711264
    13721265    //レキシカルスコープをレベルダウン
    1373     obj_LexScopes.LevelDown();
     1266    obj_LexScopes.End();
    13741267
    13751268    pCaseSchedule=temp_pCaseSchedule;
  • BasicCompiler32/Compile_Var.cpp

    r28 r34  
    381381
    382382        for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    383             if(LocalVar[i].bLiving){
    384                 if(lstrcmp(VarName,LocalVar[i].name)==0) break;
     383            if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
     384                && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     385                ){
     386                    if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    385387            }
    386388        }
     
    540542
    541543    for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    542         if(GlobalVar[i].bLiving){
    543             if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
     544        if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
     545            && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     546            ){
     547                if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    544548        }
    545549    }
  • BasicCompiler32/Opcode.h

    r31 r34  
    247247void OpcodeGoto(char *Parameter);
    248248void OpcodeWhile(char *Parameter);
    249 void OpcodeExitWhile(void);
    250249void OpcodeFor(char *Parameter);
    251 void OpcodeExitFor(void);
    252250void OpcodeDo(char *Parameter);
    253 void OpcodeExitDo(void);
    254251void OpcodeContinue(void);
    255252void OpcodeExitSub(void);
  • BasicCompiler64/BasicCompiler.vcproj

    r26 r34  
    14821482                    </File>
    14831483                    <File
    1484                         RelativePath="..\BasicCompiler_Common\schedule.h"
     1484                        RelativePath="..\BasicCompiler_Common\PESchedule.h"
     1485                        >
     1486                    </File>
     1487                    <File
     1488                        RelativePath="..\BasicCompiler_Common\Schedule.cpp"
     1489                        >
     1490                    </File>
     1491                    <File
     1492                        RelativePath="..\BasicCompiler_Common\Schedule.h"
    14851493                        >
    14861494                    </File>
  • BasicCompiler64/Compile_ProcOp.cpp

    r31 r34  
    109109        bCompilingGlobal=1;
    110110
    111         CallDestrouctorsOfScope();
     111        obj_LexScopes.CallDestructorsOfScopeEnd();
    112112
    113113        bCompilingGlobal=bBackCompilingGlobal;
     
    700700    }
    701701
    702     //プロシージャ抜け出しスケジュール(Exit Sub/Function)
    703     for(i3=0;i3<ExitSubScheduleNum;i3++){
    704         *((long *)(OpBuffer+pExitSubSchedule[i3]))=obp-(pExitSubSchedule[i3]+sizeof(long));
    705     }
    706     HeapDefaultFree(pExitSubSchedule);
    707 
    708     if(bDebugCompile&&bDebugSupportProc==0){
    709         //call _DebugSys_EndProc
    710         extern SUBINFO *pSub_DebugSys_EndProc;
    711         op_call(pSub_DebugSys_EndProc);
    712     }
    713 
    714702    //ラベル用のメモリを解放
    715703    for(i3=0;i3<MaxLabelNum;i3++){
     
    744732
    745733    //ローカルオブジェクト(レキシカルスコープレベル=0)の解放処理
    746     CallDestrouctorsOfScope();
     734    obj_LexScopes.CallDestructorsOfScopeEnd();
     735
     736    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
     737    for(i3=0;i3<ExitSubScheduleNum;i3++){
     738        *((long *)(OpBuffer+pExitSubSchedule[i3]))=obp-(pExitSubSchedule[i3]+sizeof(long));
     739    }
     740    HeapDefaultFree(pExitSubSchedule);
     741
     742    if(bDebugCompile&&bDebugSupportProc==0){
     743        //call _DebugSys_EndProc
     744        extern SUBINFO *pSub_DebugSys_EndProc;
     745        op_call(pSub_DebugSys_EndProc);
     746    }
    747747
    748748    if(psi->ReturnType!=-1){
  • BasicCompiler64/Compile_Statement.cpp

    r31 r34  
    191191
    192192    //レキシカルスコープをレベルアップ
    193     obj_LexScopes.LevelUp(obp);
     193    obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
    194194
    195195    i2=CompileBuffer(ESC_ENDIF,0);
    196196
    197197    //レキシカルスコープをレベルダウン
    198     obj_LexScopes.LevelDown();
     198    obj_LexScopes.End();
    199199
    200200
     
    215215
    216216        //レキシカルスコープをレベルアップ
    217         obj_LexScopes.LevelUp(obp);
     217        obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
    218218
    219219        CompileBuffer(ESC_ENDIF,0);
    220220
    221221        //レキシカルスコープをレベルダウン
    222         obj_LexScopes.LevelDown();
     222        obj_LexScopes.End();
    223223
    224224
     
    292292}
    293293void OpcodeWhile(char *Parameter){
    294     extern DWORD *pExitWhileSchedule;
    295     extern int ExitWhileScheduleNum;
    296294    extern HANDLE hHeap;
    297295    int i2;
    298     DWORD *lpdwTemp;
    299     int TempNum;
    300296
    301297    //Continueアドレスのバックアップとセット
     
    321317    pobj_TempSchedule->lock(&je_schedule);
    322318
    323     //ExitWhileスケジュールの準備
    324     lpdwTemp=pExitWhileSchedule;
    325     TempNum=ExitWhileScheduleNum;
    326     pExitWhileSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    327     ExitWhileScheduleNum=0;
    328 
    329319    //レキシカルスコープをレベルアップ
    330     obj_LexScopes.LevelUp(obp);
     320    obj_LexScopes.Start( obp, SCOPE_TYPE_WHILE );
    331321
    332322    //While内をコンパイル
    333323    CompileBuffer(0,COM_WEND);
    334324
    335     CallDestrouctorsOfScope();
     325    obj_LexScopes.CallDestructorsOfScopeEnd();
    336326
    337327    //jmp ...
     
    342332    pobj_TempSchedule->unlock();
    343333
    344     //ExitWhileスケジュール
    345     for(i2=0;i2<ExitWhileScheduleNum;i2++){
    346         *((long *)(OpBuffer+pExitWhileSchedule[i2]))=obp-(pExitWhileSchedule[i2]+sizeof(long));
    347     }
    348     HeapDefaultFree(pExitWhileSchedule);
    349     pExitWhileSchedule=lpdwTemp;
    350     ExitWhileScheduleNum=TempNum;
    351 
    352334    //レキシカルスコープをレベルダウン
    353     obj_LexScopes.LevelDown();
     335    obj_LexScopes.End();
    354336
    355337    *((long *)(OpBuffer+je_schedule-sizeof(long)))=obp-je_schedule; //jeジャンプ先のオフセット値
     
    359341    dwContinueAddress=dwTempContinue;
    360342}
    361 void OpcodeExitWhile(void){
    362     extern DWORD *pExitWhileSchedule;
    363     extern int ExitWhileScheduleNum;
    364     extern HANDLE hHeap;
    365 
    366     if(!pExitWhileSchedule){
    367         SetError(12,"Exit While",cp);
    368         return;
    369     }
    370 
    371     //jmp ...(Wend addr)
    372     OpBuffer[obp++]=(char)0xE9;
    373 
    374     pExitWhileSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitWhileSchedule,(ExitWhileScheduleNum+1)*sizeof(DWORD));
    375     pExitWhileSchedule[ExitWhileScheduleNum]=obp;
    376     ExitWhileScheduleNum++;
    377 
    378     obp+=sizeof(long);
    379 }
     343
    380344char szNextVariable[VN_SIZE];
    381345void OpcodeFor(char *Parameter){
    382     extern DWORD *pExitForSchedule;
    383     extern int ExitForScheduleNum;
    384346    extern HANDLE hHeap;
    385     DWORD *lpdwTemp;
    386     int TempNum;
    387347    int i,i2,i3;
    388348    char temporary[VN_SIZE],variable[VN_SIZE],JudgeNum[VN_SIZE],StepNum[VN_SIZE];
     349    bool isError = false;
    389350
    390351    //第1パラメータを取得
     
    392353    if(!Parameter[i]){
    393354        SetError(12,"For",cp);
     355        isError = true;
    394356        goto ErrorStep;
    395357    }
     
    405367        if(temporary[i2]=='\0'){
    406368            SetError(12,"For",cp);
     369            isError = true;
    407370            goto ErrorStep;
    408371        }
     
    488451    pobj_TempSchedule->lock(&je_schedule);
    489452
    490     //ExitForスケジュールの準備
    491     lpdwTemp=pExitForSchedule;
    492     TempNum=ExitForScheduleNum;
    493     pExitForSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    494     ExitForScheduleNum=0;
    495 
    496453    //レキシカルスコープをレベルアップ
    497     obj_LexScopes.LevelUp(obp);
     454    obj_LexScopes.Start( obp, SCOPE_TYPE_FOR );
    498455
    499456    //For内をコンパイル
    500457    CompileBuffer(0,COM_NEXT);
    501458
    502     CallDestrouctorsOfScope();
     459    obj_LexScopes.CallDestructorsOfScopeEnd();
    503460
    504461    if(szNextVariable[0]){
     
    512469    *((long *)(OpBuffer+obp))=dwContinueAddress-(obp+sizeof(long));
    513470    obp+=sizeof(long);
    514     pobj_TempSchedule->unlock();
    515     pobj_TempSchedule->unlock();
    516 
    517     //ExitForスケジュール
    518     for(i=0;i<ExitForScheduleNum;i++){
    519         *((long *)(OpBuffer+pExitForSchedule[i]))=obp-(pExitForSchedule[i]+sizeof(long));
    520     }
    521     HeapDefaultFree(pExitForSchedule);
    522     pExitForSchedule=lpdwTemp;
    523     ExitForScheduleNum=TempNum;
     471    if( isError == false ){
     472        pobj_TempSchedule->unlock();
     473        pobj_TempSchedule->unlock();
     474    }
    524475
    525476    //レキシカルスコープをレベルダウン
    526     obj_LexScopes.LevelDown();
     477    obj_LexScopes.End();
    527478
    528479    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jeジャンプ先のオフセット値
     
    532483    dwContinueAddress=dwTempContinue;
    533484}
    534 void OpcodeExitFor(void){
    535     extern DWORD *pExitForSchedule;
    536     extern int ExitForScheduleNum;
    537     extern HANDLE hHeap;
    538 
    539     if(!pExitForSchedule){
    540         SetError(12,"Exit For",cp);
    541         return;
    542     }
    543 
    544     //jmp ...(Next addr)
    545     OpBuffer[obp++]=(char)0xE9;
    546 
    547     pExitForSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitForSchedule,(ExitForScheduleNum+1)*sizeof(DWORD));
    548     pExitForSchedule[ExitForScheduleNum]=obp;
    549     ExitForScheduleNum++;
    550 
    551     obp+=sizeof(long);
    552 }
    553485
    554486void OpcodeDo(char *Parameter){
    555     extern DWORD *pExitDoSchedule;
    556     extern int ExitDoScheduleNum;
    557487    extern HANDLE hHeap;
    558488    int i,i2,i3;
    559     DWORD *lpdwTemp;
    560     int TempNum;
    561489
    562490    if(Parameter[0]) SetError(10,"Do",cp);
    563 
    564     //ExitDoスケジュールの準備
    565     lpdwTemp=pExitDoSchedule;
    566     TempNum=ExitDoScheduleNum;
    567     pExitDoSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
    568     ExitDoScheduleNum=0;
    569491
    570492    //Continueアドレスのバックアップとセット
     
    577499
    578500    //レキシカルスコープをレベルアップ
    579     obj_LexScopes.LevelUp(obp);
     501    obj_LexScopes.Start( obp, SCOPE_TYPE_DO );
    580502
    581503    //Do内をコンパイル
    582504    CompileBuffer(0,COM_LOOP);
    583505
    584     CallDestrouctorsOfScope();
     506    obj_LexScopes.CallDestructorsOfScopeEnd();
    585507
    586508    extern char *basbuf;
     
    637559    pobj_TempSchedule->lock(&je_schedule);
    638560
    639     //ExitDoスケジュール
    640     for(i=0;i<ExitDoScheduleNum;i++){
    641         *((long *)(OpBuffer+pExitDoSchedule[i]))=obp-(pExitDoSchedule[i]+sizeof(long));
    642     }
    643     HeapDefaultFree(pExitDoSchedule);
    644     pExitDoSchedule=lpdwTemp;
    645     ExitDoScheduleNum=TempNum;
    646 
    647561    //レキシカルスコープをレベルダウン
    648     obj_LexScopes.LevelDown();
     562    obj_LexScopes.End();
    649563
    650564    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jmpジャンプ先のオフセット値
     
    653567    //Continueアドレスを復元
    654568    dwContinueAddress=dwTempContinue;
    655 }
    656 void OpcodeExitDo(void){
    657     extern HANDLE hHeap;
    658     extern DWORD *pExitDoSchedule;
    659     extern int ExitDoScheduleNum;
    660 
    661     if(!pExitDoSchedule){
    662         SetError(12,"Exit Do",cp);
    663         return;
    664     }
    665 
    666     //jmp ...(Loop addr)
    667     OpBuffer[obp++]=(char)0xE9;
    668 
    669     pExitDoSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitDoSchedule,(ExitDoScheduleNum+1)*sizeof(DWORD));
    670     pExitDoSchedule[ExitDoScheduleNum]=obp;
    671     ExitDoScheduleNum++;
    672 
    673     obp+=sizeof(long);
    674569}
    675570void OpcodeContinue(void){
     
    698593        return;
    699594    }
     595
     596    //未解放のローカルオブジェクトのデストラクタを呼び出す
     597    obj_LexScopes.CallDestructorsOfReturn();
    700598
    701599    //jmp ...(End Sub/Function)
     
    938836
    939837    //レキシカルスコープをレベルアップ
    940     obj_LexScopes.LevelUp(obp);
     838    obj_LexScopes.Start( obp, SCOPE_TYPE_SELECT );
    941839
    942840    //Select Case内をコンパイル
     
    955853
    956854    //レキシカルスコープをレベルダウン
    957     obj_LexScopes.LevelDown();
     855    obj_LexScopes.End();
    958856
    959857    pCaseSchedule=temp_pCaseSchedule;
     
    1051949    extern BOOL bCompilingGlobal;
    1052950    if(bCompilingGlobal){
    1053         //Gosub~Returnとして扱う
    1054 
    1055         //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    1056         pobj_sf->push(REG_NON);
    1057         pobj_sf->ref(REG_RAX);
    1058         pobj_sf->pop(REG_NON);
    1059 
    1060         //jmp rax
    1061         OpBuffer[obp++]=(char)0xFF;
    1062         OpBuffer[obp++]=(char)0xE0;
     951        SetError(62,NULL,cp);
    1063952    }
    1064953    else{
  • BasicCompiler64/Compile_Var.cpp

    r28 r34  
    408408
    409409        for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    410             if(LocalVar[i].bLiving){
    411                 if(lstrcmp(VarName,LocalVar[i].name)==0) break;
     410            if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
     411                && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     412                ){
     413                    if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    412414            }
    413415        }
     
    564566
    565567    for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    566         if(GlobalVar[i].bLiving){
    567             if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
     568        if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
     569            && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     570            ){
     571                if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    568572        }
    569573    }
  • BasicCompiler64/Opcode.h

    r31 r34  
    411411void OpcodeGoto(char *Parameter);
    412412void OpcodeWhile(char *Parameter);
    413 void OpcodeExitWhile(void);
    414413void OpcodeFor(char *Parameter);
    415 void OpcodeExitFor(void);
    416414void OpcodeDo(char *Parameter);
    417 void OpcodeExitDo(void);
    418415void OpcodeContinue(void);
    419416void OpcodeExitSub(void);
  • BasicCompiler_Common/Compile.cpp

    r26 r34  
    1414LABEL *pLabelNames;
    1515int MaxLabelNum;
    16 
    17 //ループごとのスケジュール
    18 DWORD *pExitWhileSchedule;  //ExitWhileスケジュール
    19 int ExitWhileScheduleNum;
    20 DWORD *pExitForSchedule;    //ExitForスケジュール
    21 int ExitForScheduleNum;
    22 DWORD *pExitDoSchedule;     //ExitDoスケジュール
    23 int ExitDoScheduleNum;
    2416
    2517//Continueアドレス
     
    176168                break;
    177169            case ESC_EXITWHILE:
    178                 OpcodeExitWhile();
     170                obj_LexScopes.ExitWhile();
    179171                break;
    180172            case ESC_EXITFOR:
    181                 OpcodeExitFor();
     173                obj_LexScopes.ExitFor();
    182174                break;
    183175            case ESC_EXITDO:
    184                 OpcodeExitDo();
     176                obj_LexScopes.ExitDo();
    185177                break;
    186178            case ESC_CONTINUE:
  • BasicCompiler_Common/LexicalScoping.cpp

    r5 r34  
    99CLexicalScopes obj_LexScopes;
    1010
     11
     12CScope::CScope( int level, int addr, SCOPE_TYPE TypeOfStatement ){
     13    this->level = level;
     14    this->StartAddress = addr;
     15    this->TypeOfStatement = TypeOfStatement;
     16
     17    pBreakSchedule = (DWORD *)malloc( 1 );
     18    nBreakSchedule = 0;
     19}
     20CScope::~CScope(){
     21    free( pBreakSchedule );
     22}
     23
     24int CScope::GetStartAddress(){
     25    return StartAddress;
     26}
     27SCOPE_TYPE CScope::GetTypeOfStatement(){
     28    return TypeOfStatement;
     29}
     30
     31void CScope::Break(){
     32    //未解放のローカルオブジェクトを解放する
     33    obj_LexScopes.CallDestructorsOfReturn( level );
     34
     35    //jmp ...(Next addr)
     36    OpBuffer[obp++]=(char)0xE9;
     37
     38    pBreakSchedule=(DWORD *)realloc( pBreakSchedule, ( nBreakSchedule + 1 ) * sizeof(DWORD) );
     39    pBreakSchedule[nBreakSchedule]=obp;
     40    nBreakSchedule++;
     41
     42    obp+=sizeof(long);
     43}
     44void CScope::RunScheduleOfBreak(){
     45    for(int i=0;i<nBreakSchedule;i++){
     46        *((long *)(OpBuffer+pBreakSchedule[i]))=obp-(pBreakSchedule[i]+sizeof(long));
     47    }
     48}
     49
     50
     51CScope *CLexicalScopes::SearchScope( SCOPE_TYPE TypeOfStatement ){
     52    for( int i = level; i>=0; i-- ){
     53        if( ppScopes[i]->GetTypeOfStatement() == TypeOfStatement ){
     54            return ppScopes[i];
     55        }
     56    }
     57    return NULL;
     58}
     59
    1160CLexicalScopes::CLexicalScopes(){
     61    ppScopes = (CScope **)malloc( 1 );
    1262    level=0;
    1363}
    1464CLexicalScopes::~CLexicalScopes(){
     65    free( ppScopes );
    1566}
    1667void CLexicalScopes::Init(int addr){
    17     level=0;
    18     StartAddresses[level]=addr;
    19 }
    20 void CLexicalScopes::LevelUp(int addr){
     68    // TODO: エラーチェック
     69
     70    level = -1;
     71    Start( addr, SCOPE_TYPE_BASE );
     72}
     73void CLexicalScopes::Start( int addr, SCOPE_TYPE TypeOfStatement ){
    2174    level++;
    22     StartAddresses[level]=addr;
    23 }
    24 void CLexicalScopes::LevelDown(void){
    25     //デストラクタを呼ぶ
    26     CallDestrouctorsOfScope();
    27 
    28     //スコープレベルを下げる
    29     level--;
    30     if(level<0){
     75    ppScopes = (CScope **)realloc( ppScopes, ( level + 1 ) * sizeof( CScope * ) );
     76    ppScopes[level] = new CScope( level, addr, TypeOfStatement );
     77}
     78void CLexicalScopes::End(){
     79    if( level <= 0 ){
    3180        SetError(300,NULL,cp);
    3281        return;
    3382    }
     83
     84    //デストラクタを呼ぶ
     85    CallDestructorsOfScopeEnd();
    3486
    3587    extern BOOL bCompilingGlobal;
     
    51103    }
    52104
     105    //使用済みローカル変数の生存チェックを外す
    53106    for(int i=0;i<num;i++){
    54         if(pVar[i].bLiving&&pVar[i].ScopeLevel==level+1){
     107        if(pVar[i].bLiving&&pVar[i].ScopeLevel==level){
    55108            pVar[i].bLiving=0;
    56109            extern int obp;
     
    58111        }
    59112    }
    60 }
    61 
    62 int CLexicalScopes::GetNowLevel(void){
     113
     114
     115    //スコープ抜け出しスケジュール
     116    ppScopes[level]->RunScheduleOfBreak();
     117
     118
     119    //スコープレベルを下げる
     120    delete ppScopes[level];
     121    level--;
     122}
     123
     124void CLexicalScopes::ExitFor(){
     125    CScope *pScope = SearchScope( SCOPE_TYPE_FOR );
     126    if( !pScope ){
     127        SetError(12,"Exit For",cp);
     128        return;
     129    }
     130
     131    pScope->Break();
     132}
     133void CLexicalScopes::ExitWhile(){
     134    CScope *pScope = SearchScope( SCOPE_TYPE_WHILE );
     135    if( !pScope ){
     136        SetError(12,"Exit While",cp);
     137        return;
     138    }
     139
     140    pScope->Break();
     141}
     142void CLexicalScopes::ExitDo(){
     143    CScope *pScope = SearchScope( SCOPE_TYPE_DO );
     144    if( !pScope ){
     145        SetError(12,"Exit Do",cp);
     146        return;
     147    }
     148
     149    pScope->Break();
     150}
     151
     152int CLexicalScopes::GetNowLevel(){
    63153    return level;
    64154}
    65 int CLexicalScopes::GetStartAddress(void){
    66     return StartAddresses[level];
    67 }
     155void CLexicalScopes::SetNowLevel( int level ){
     156    this->level = level;
     157}
     158int CLexicalScopes::GetStartAddress(){
     159    return ppScopes[level]->GetStartAddress();
     160}
     161
     162
     163// スコープ終了時のデストラクタ呼び出し
     164void CLexicalScopes::CallDestructorsOfScopeEnd(){
     165    extern BOOL bCompilingGlobal;
     166    VARIABLE *pVar;
     167    int num;
     168    if(bCompilingGlobal){
     169        //グローバルオブジェクトの解放処理
     170        extern VARIABLE *GlobalVar;
     171        extern int MaxGlobalVarNum;
     172        pVar=GlobalVar;
     173        num=MaxGlobalVarNum;
     174    }
     175    else{
     176        //ローカルオブジェクトの解放処理
     177        extern VARIABLE *LocalVar;
     178        extern int MaxLocalVarNum;
     179        pVar=LocalVar;
     180        num=MaxLocalVarNum;
     181    }
     182
     183
     184    int i3,i4,i5;
     185    int indexSystemGC=-1;
     186    for( i3 = num - 1; i3 >= 0; i3-- ){     //確保したのと逆順序で解放するため、バックサーチにする
     187
     188        if( bCompilingGlobal && GetNowLevel() == 0 ){
     189            if(lstrcmp(pVar[i3].name,"_System_GC")==0){
     190                indexSystemGC=i3;
     191                continue;
     192            }
     193        }
     194
     195        //同一レベルのレキシカルスコープのみを検知
     196        if(!pVar[i3].bLiving) continue;
     197        if( pVar[i3].ScopeLevel != GetNowLevel() ) continue;
     198
     199        if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef&OBJECT_PARAMETER){
     200            //実態オブジェクトのパラメータを持つとき
     201
     202            //デストラクタを呼び出す
     203            i5=pVar[i3].u.pobj_c->DestructorMemberSubIndex;
     204            if(i5!=-1)
     205                Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,pVar[i3].name,DEF_OBJECT);
     206
     207            //メモリを解放する
     208
     209#ifdef _AMD64_
     210            //x64ビットコード
     211
     212            //mov rcx,qword ptr[rsp+offset]
     213            op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
     214                -pVar[i3].offset,
     215                MOD_BASE_DISP32);
     216            obp-=sizeof(long);
     217            AddLocalVarAddrSchedule();
     218            obp+=sizeof(long);
     219#else
     220            //x86コード
     221
     222            //mov ecx,dword ptr[ebp+offset]
     223            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar[i3].offset,MOD_BASE_DISP32);
     224            obp-=sizeof(long);
     225            AddLocalVarAddrSchedule();
     226            obp+=sizeof(long);
     227
     228            //push ecx
     229            op_push(REG_ECX);
     230#endif
     231
     232            //call free
     233            extern SUBINFO *pSub_free;
     234            op_call(pSub_free);
     235
     236
     237            if(bCompilingGlobal){
     238                //ここには来ないハズ
     239                SetError(300,NULL,cp);
     240            }
     241        }
     242        else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
     243            //デストラクタの呼び出し
     244            i5=pVar[i3].u.pobj_c->DestructorMemberSubIndex;
     245            if(i5!=-1){
     246                int ss[MAX_ARRAYDIM];
     247                memset(ss,0,MAX_ARRAYDIM*sizeof(int));
     248                if(pVar[i3].SubScripts[0]!=-1){
     249                    while(1){
     250                        for(i4=0;;i4++){
     251                            if(pVar[i3].SubScripts[i4]==-1) break;
     252
     253                            if(ss[i4]>pVar[i3].SubScripts[i4]){
     254                                ss[i4]=0;
     255                                ss[i4+1]++;
     256                            }
     257                            else break;
     258                        }
     259                        if(pVar[i3].SubScripts[i4]==-1) break;
     260                        char temporary[VN_SIZE];
     261                        sprintf(temporary,"%s[%d",pVar[i3].name,ss[0]);
     262                        for(i4=1;;i4++){
     263                            if(pVar[i3].SubScripts[i4]==-1) break;
     264
     265                            sprintf(temporary+lstrlen(temporary),",%d",ss[i4]);
     266                        }
     267                        lstrcat(temporary,"]");
     268                        Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,temporary,DEF_OBJECT);
     269
     270                        ss[0]++;
     271
     272
     273                        //ネイティブコードバッファの再確保
     274                        extern int obp_AllocSize;
     275                        if(obp_AllocSize<obp+8192){
     276                            obp_AllocSize+=8192;
     277                            OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
     278                        }
     279                    }
     280                }
     281                else{
     282                    Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,pVar[i3].name,DEF_OBJECT);
     283                }
     284            }
     285        }
     286    }
     287
     288    if(indexSystemGC!=-1){
     289        //_System_GCオブジェクトのデストラクタの呼び出し処理
     290        i3=pVar[indexSystemGC].u.pobj_c->DestructorMemberSubIndex;
     291        if(i3!=-1){
     292            Opcode_CallProc("",pVar[indexSystemGC].u.pobj_c->ppobj_Method[i3]->psi,0,pVar[indexSystemGC].name,DEF_OBJECT);
     293        }
     294    }
     295}
     296
     297// Returnステートメントで発行されるデストラクタを生成
     298void CLexicalScopes::CallDestructorsOfReturn( int BaseLevel ){
     299    //現在のスコープレベルを退避
     300    int backupScopeLevel = GetNowLevel();
     301
     302    for( int i = GetNowLevel(); i >= BaseLevel; i-- ){
     303        SetNowLevel( i );
     304
     305        CallDestructorsOfScopeEnd();
     306    }
     307
     308    //現在のスコープレベルを復元
     309    SetNowLevel( backupScopeLevel );
     310}
  • BasicCompiler_Common/LexicalScoping.h

    r4 r34  
    11
    22
     3enum SCOPE_TYPE{
     4    //ベース
     5    SCOPE_TYPE_BASE,
     6
     7    //分岐
     8    SCOPE_TYPE_IF,
     9
     10    //ループ
     11    SCOPE_TYPE_DO,
     12    SCOPE_TYPE_FOR,
     13    SCOPE_TYPE_WHILE,
     14
     15    //ケース分け
     16    SCOPE_TYPE_SELECT,
     17};
     18
     19class CScope{
     20    int level;
     21    int StartAddress;
     22    SCOPE_TYPE TypeOfStatement;
     23
     24    DWORD *pBreakSchedule;
     25    int nBreakSchedule;
     26
     27public:
     28    CScope( int level, int addr, SCOPE_TYPE TypeOfStatement );
     29    ~CScope();
     30
     31    int GetStartAddress();
     32    SCOPE_TYPE GetTypeOfStatement();
     33
     34    void Break();
     35    void RunScheduleOfBreak();
     36};
     37
    338class CLexicalScopes{
     39    CScope **ppScopes;
    440    int level;
    5     int StartAddresses[1024];
     41
     42    CScope *SearchScope( SCOPE_TYPE TypeOfStatement );
     43
    644public:
    745    CLexicalScopes();
    846    ~CLexicalScopes();
    947
     48    //初期化(関数コンパイルの開始時に呼び出される)
    1049    void Init(int addr);
    1150
    12     void LevelUp(int addr);
    13     void LevelDown(void);
     51    // スコープを開始
     52    void Start( int addr, SCOPE_TYPE TypeOfStatement );
     53
     54    //スコープを終了
     55    void End();
     56
     57    //スコープ抜け出しステートメント
     58    void Break();
     59    void ExitFor();
     60    void ExitWhile();
     61    void ExitDo();
    1462
    1563    int GetNowLevel(void);
     64    void SetNowLevel( int level );
    1665    int GetStartAddress(void);
     66
     67    //スコープ終了時のデストラクタ呼び出し
     68    void CallDestructorsOfScopeEnd();
     69
     70    //Returnステートメント用のデストラクタ呼び出し
     71    void CallDestructorsOfReturn( int BaseLevel = 0 );
    1772
    1873private:
  • BasicCompiler_Common/Object.cpp

    r31 r34  
    183183    }
    184184}
    185 
    186 
    187 void CallDestrouctorsOfScope(void){
    188     extern BOOL bCompilingGlobal;
    189     VARIABLE *pVar;
    190     int num;
    191     if(bCompilingGlobal){
    192         //グローバルオブジェクトの解放処理
    193         extern VARIABLE *GlobalVar;
    194         extern int MaxGlobalVarNum;
    195         pVar=GlobalVar;
    196         num=MaxGlobalVarNum;
    197     }
    198     else{
    199         //ローカルオブジェクトの解放処理
    200         extern VARIABLE *LocalVar;
    201         extern int MaxLocalVarNum;
    202         pVar=LocalVar;
    203         num=MaxLocalVarNum;
    204     }
    205 
    206 
    207     int i3,i4,i5;
    208     int indexSystemGC=-1;
    209     for(i3=0;i3<num;i3++){
    210 
    211         if(bCompilingGlobal&&obj_LexScopes.GetNowLevel()==0){
    212             if(lstrcmp(pVar[i3].name,"_System_GC")==0){
    213                 indexSystemGC=i3;
    214                 continue;
    215             }
    216         }
    217 
    218         //同一レベルのレキシカルスコープのみを検知
    219         if(!pVar[i3].bLiving) continue;
    220         if(pVar[i3].ScopeLevel!=obj_LexScopes.GetNowLevel()) continue;
    221 
    222         if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef&OBJECT_PARAMETER){
    223             //実態オブジェクトのパラメータを持つとき
    224 
    225             //デストラクタを呼び出す
    226             i5=pVar[i3].u.pobj_c->DestructorMemberSubIndex;
    227             if(i5!=-1)
    228                 Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,pVar[i3].name,DEF_OBJECT);
    229 
    230             //メモリを解放する
    231 
    232 #ifdef _AMD64_
    233             //x64ビットコード
    234 
    235             //mov rcx,qword ptr[rsp+offset]
    236             op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
    237                 -pVar[i3].offset,
    238                 MOD_BASE_DISP32);
    239             obp-=sizeof(long);
    240             AddLocalVarAddrSchedule();
    241             obp+=sizeof(long);
    242 #else
    243             //x86コード
    244 
    245             //mov ecx,dword ptr[ebp+offset]
    246             op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar[i3].offset,MOD_BASE_DISP32);
    247             obp-=sizeof(long);
    248             AddLocalVarAddrSchedule();
    249             obp+=sizeof(long);
    250 
    251             //push ecx
    252             op_push(REG_ECX);
    253 #endif
    254 
    255             //call free
    256             extern SUBINFO *pSub_free;
    257             op_call(pSub_free);
    258 
    259 
    260             if(bCompilingGlobal){
    261                 //ここには来ないハズ
    262                 SetError(300,NULL,cp);
    263             }
    264         }
    265         else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
    266             //デストラクタの呼び出し
    267             i5=pVar[i3].u.pobj_c->DestructorMemberSubIndex;
    268             if(i5!=-1){
    269                 int ss[MAX_ARRAYDIM];
    270                 memset(ss,0,MAX_ARRAYDIM*sizeof(int));
    271                 if(pVar[i3].SubScripts[0]!=-1){
    272                     while(1){
    273                         for(i4=0;;i4++){
    274                             if(pVar[i3].SubScripts[i4]==-1) break;
    275 
    276                             if(ss[i4]>pVar[i3].SubScripts[i4]){
    277                                 ss[i4]=0;
    278                                 ss[i4+1]++;
    279                             }
    280                             else break;
    281                         }
    282                         if(pVar[i3].SubScripts[i4]==-1) break;
    283                         char temporary[VN_SIZE];
    284                         sprintf(temporary,"%s[%d",pVar[i3].name,ss[0]);
    285                         for(i4=1;;i4++){
    286                             if(pVar[i3].SubScripts[i4]==-1) break;
    287 
    288                             sprintf(temporary+lstrlen(temporary),",%d",ss[i4]);
    289                         }
    290                         lstrcat(temporary,"]");
    291                         Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,temporary,DEF_OBJECT);
    292 
    293                         ss[0]++;
    294 
    295 
    296                         //ネイティブコードバッファの再確保
    297                         extern int obp_AllocSize;
    298                         if(obp_AllocSize<obp+8192){
    299                             obp_AllocSize+=8192;
    300                             OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
    301                         }
    302                     }
    303                 }
    304                 else{
    305                     Opcode_CallProc("",pVar[i3].u.pobj_c->ppobj_Method[i5]->psi,0,pVar[i3].name,DEF_OBJECT);
    306                 }
    307             }
    308         }
    309     }
    310 
    311     if(indexSystemGC!=-1){
    312         //_System_GCオブジェクトのデストラクタの呼び出し処理
    313         i3=pVar[indexSystemGC].u.pobj_c->DestructorMemberSubIndex;
    314         if(i3!=-1){
    315             Opcode_CallProc("",pVar[indexSystemGC].u.pobj_c->ppobj_Method[i3]->psi,0,pVar[indexSystemGC].name,DEF_OBJECT);
    316         }
    317     }
    318 }
    319 
  • BasicCompiler_Common/PESchedule.cpp

    r5 r34  
    265265}
    266266void CTempSchedule::unlock(){
     267    if( num <= 0 ){
     268        //エラー
     269        SetError(300,NULL,cp);
     270    }
    267271    num--;
    268272}
  • BasicCompiler_Common/Variable.cpp

    r29 r34  
    648648
    649649        for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    650             if(LocalVar[i].bLiving){
    651                 if(lstrcmp(VarName,LocalVar[i].name)==0) break;
     650            if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
     651                && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     652                ){
     653                    if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    652654            }
    653655        }
     
    766768
    767769    for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    768         if(GlobalVar[i].bLiving){
    769             if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
     770        if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
     771            && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの(Returnによる解放処理中を考慮)
     772            ){
     773                if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    770774        }
    771775    }
  • BasicCompiler_Common/common.h

    r31 r34  
    385385
    386386
    387 #include "../BasicCompiler_Common/schedule.h"
     387#include "../BasicCompiler_Common/PESchedule.h"
    388388#include "../BasicCompiler_Common/DebugSection.h"
    389389#include "../BasicCompiler_Common/LexicalScoping.h"
     
    423423void AddClassName(char *Parameter,int NowLine);
    424424void CallConstractor(char *VarName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter);
    425 void CallDestrouctorsOfScope(void);
    426425
    427426//Overload.sbp
  • BasicCompiler_Common/error.cpp

    r28 r34  
    143143    if(num==60) lstrcpy(msg,"Staticステートメントはグローバル領域では使用できません。");
    144144    if(num==61) sprintf(msg,"\"%s\" は定数です。書き込みアクセスはできません。",KeyWord);
     145    if(num==62) sprintf(msg,"グローバル領域でのReturnは禁止されています。",KeyWord);
    145146
    146147
Note: See TracChangeset for help on using the changeset viewer.