Changeset 183 in dev for trunk


Ignore:
Timestamp:
Jun 24, 2007, 6:50:40 PM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
1 deleted
22 edited

Legend:

Unmodified
Added
Removed
  • trunk/abdev/BasicCompiler32/BasicCompiler.vcproj

    r167 r183  
    7575            <Tool
    7676                Name="VCLinkerTool"
    77                 AdditionalDependencies="comctl32.lib psapi.lib commond.lib"
     77                AdditionalDependencies="comctl32.lib psapi.lib commond.lib smoothied.lib"
    7878                OutputFile="../ActiveBasic/BasicCompiler32.exe"
    7979                LinkIncremental="2"
     
    177177            <Tool
    178178                Name="VCLinkerTool"
    179                 AdditionalDependencies="comctl32.lib psapi.lib common.lib"
     179                AdditionalDependencies="comctl32.lib psapi.lib common.lib smoothie.lib"
    180180                OutputFile="../ActiveBasic/BasicCompiler32.exe"
    181181                LinkIncremental="1"
     
    581581                    >
    582582                    <File
    583                         RelativePath="..\BasicCompiler_Common\DataTable.cpp"
    584                         >
    585                     </File>
    586                     <File
    587                         RelativePath="..\BasicCompiler_Common\LoopRefCheck.cpp"
    588                         >
    589                         <FileConfiguration
    590                             Name="Debug|Win32"
    591                             >
    592                             <Tool
    593                                 Name="VCCLCompilerTool"
    594                                 PreprocessorDefinitions=""
    595                             />
    596                         </FileConfiguration>
    597                         <FileConfiguration
    598                             Name="Release|Win32"
    599                             >
    600                             <Tool
    601                                 Name="VCCLCompilerTool"
    602                                 PreprocessorDefinitions=""
    603                             />
    604                         </FileConfiguration>
    605                     </File>
    606                     <File
    607583                        RelativePath="..\BasicCompiler_Common\NonVolatile.cpp"
    608584                        >
     
    751727                    >
    752728                    <File
    753                         RelativePath="..\BasicCompiler_Common\Class.cpp"
    754                         >
    755                         <FileConfiguration
    756                             Name="Debug|Win32"
    757                             >
    758                             <Tool
    759                                 Name="VCCLCompilerTool"
    760                                 PreprocessorDefinitions=""
    761                             />
    762                         </FileConfiguration>
    763                         <FileConfiguration
    764                             Name="Release|Win32"
    765                             >
    766                             <Tool
    767                                 Name="VCCLCompilerTool"
    768                                 PreprocessorDefinitions=""
    769                             />
    770                         </FileConfiguration>
    771                     </File>
    772                     <File
    773                         RelativePath="..\BasicCompiler_Common\Class.h"
    774                         >
    775                     </File>
    776                     <File
    777729                        RelativePath="..\BasicCompiler_Common\Enum.cpp"
    778730                        >
     
    824776                    <File
    825777                        RelativePath="..\BasicCompiler_Common\PESchedule.h"
    826                         >
    827                     </File>
    828                 </Filter>
    829                 <Filter
    830                     Name="LexicalScoping"
    831                     >
    832                     <File
    833                         RelativePath="..\BasicCompiler_Common\LexicalScoping.cpp"
    834                         >
    835                         <FileConfiguration
    836                             Name="Debug|Win32"
    837                             >
    838                             <Tool
    839                                 Name="VCCLCompilerTool"
    840                                 PreprocessorDefinitions=""
    841                             />
    842                         </FileConfiguration>
    843                         <FileConfiguration
    844                             Name="Release|Win32"
    845                             >
    846                             <Tool
    847                                 Name="VCCLCompilerTool"
    848                                 PreprocessorDefinitions=""
    849                             />
    850                         </FileConfiguration>
    851                     </File>
    852                     <File
    853                         RelativePath="..\BasicCompiler_Common\LexicalScoping.h"
    854778                        >
    855779                    </File>
     
    13251249            </Filter>
    13261250            <Filter
    1327                 Name="Common Classes"
    1328                 >
    1329                 <File
    1330                     RelativePath="..\BasicCompiler_Common\src\Smoothie.cpp"
    1331                     >
    1332                 </File>
    1333                 <Filter
    1334                     Name="Meta Parts"
    1335                     >
    1336                     <File
    1337                         RelativePath="..\BasicCompiler_Common\src\Member.cpp"
    1338                         >
    1339                     </File>
    1340                     <File
    1341                         RelativePath="..\BasicCompiler_Common\src\Method.cpp"
    1342                         >
    1343                     </File>
    1344                     <File
    1345                         RelativePath="..\BasicCompiler_Common\src\Namespace.cpp"
    1346                         >
    1347                     </File>
    1348                     <File
    1349                         RelativePath="..\BasicCompiler_Common\Procedure.cpp"
    1350                         >
    1351                     </File>
    1352                     <File
    1353                         RelativePath="..\BasicCompiler_Common\src\Prototype.cpp"
    1354                         >
    1355                     </File>
    1356                     <File
    1357                         RelativePath="..\BasicCompiler_Common\src\Symbol.cpp"
    1358                         >
    1359                     </File>
    1360                     <File
    1361                         RelativePath="..\BasicCompiler_Common\Type.cpp"
    1362                         >
    1363                     </File>
    1364                     <File
    1365                         RelativePath="..\BasicCompiler_Common\TypeDef.cpp"
    1366                         >
    1367                         <FileConfiguration
    1368                             Name="Debug|Win32"
    1369                             >
    1370                             <Tool
    1371                                 Name="VCCLCompilerTool"
    1372                                 PreprocessorDefinitions=""
    1373                             />
    1374                         </FileConfiguration>
    1375                         <FileConfiguration
    1376                             Name="Release|Win32"
    1377                             >
    1378                             <Tool
    1379                                 Name="VCCLCompilerTool"
    1380                                 PreprocessorDefinitions=""
    1381                             />
    1382                         </FileConfiguration>
    1383                     </File>
    1384                     <File
    1385                         RelativePath="..\BasicCompiler_Common\Variable.cpp"
    1386                         >
    1387                     </File>
    1388                 </Filter>
    1389                 <Filter
    1390                     Name="Lexical Parts"
    1391                     >
    1392                     <File
    1393                         RelativePath="..\BasicCompiler_Common\src\Source.cpp"
    1394                         >
    1395                     </File>
    1396                 </Filter>
    1397                 <Filter
    1398                     Name="Operation Statements"
    1399                     >
    1400                     <File
    1401                         RelativePath="..\BasicCompiler_Common\src\Exception.cpp"
    1402                         >
    1403                     </File>
    1404                 </Filter>
    1405                 <Filter
    1406                     Name="Application Classes"
    1407                     >
    1408                     <File
    1409                         RelativePath="..\BasicCompiler_Common\src\Program.cpp"
    1410                         >
    1411                     </File>
    1412                 </Filter>
     1251                Name="Application Classes"
     1252                >
     1253                <File
     1254                    RelativePath="..\BasicCompiler_Common\src\ClassImpl.cpp"
     1255                    >
     1256                </File>
     1257                <File
     1258                    RelativePath="..\BasicCompiler_Common\src\CodeGenerator.cpp"
     1259                    >
     1260                </File>
     1261                <File
     1262                    RelativePath="..\BasicCompiler_Common\src\Compiler.cpp"
     1263                    >
     1264                </File>
     1265                <File
     1266                    RelativePath="..\BasicCompiler_Common\src\DataTable.cpp"
     1267                    >
     1268                </File>
     1269                <File
     1270                    RelativePath="..\BasicCompiler_Common\src\Exception.cpp"
     1271                    >
     1272                </File>
     1273                <File
     1274                    RelativePath="..\BasicCompiler_Common\src\LexicalScopingImpl.cpp"
     1275                    >
     1276                </File>
     1277                <File
     1278                    RelativePath="..\BasicCompiler_Common\src\ProcedureImpl.cpp"
     1279                    >
     1280                </File>
     1281                <File
     1282                    RelativePath="..\BasicCompiler_Common\src\Program.cpp"
     1283                    >
     1284                </File>
     1285                <File
     1286                    RelativePath="..\BasicCompiler_Common\src\SmoothieImpl.cpp"
     1287                    >
     1288                </File>
    14131289            </Filter>
    14141290        </Filter>
     
    14371313                >
    14381314            </File>
     1315            <File
     1316                RelativePath="..\BasicCompiler_Common\include\option.h"
     1317                >
     1318            </File>
    14391319            <Filter
    14401320                Name="言語対応文字列"
     
    14611341                >
    14621342                <File
     1343                    RelativePath="..\BasicCompiler_Common\include\ClassImpl.h"
     1344                    >
     1345                </File>
     1346                <File
     1347                    RelativePath="..\BasicCompiler_Common\include\CodeGenerator.h"
     1348                    >
     1349                </File>
     1350                <File
     1351                    RelativePath="..\BasicCompiler_Common\include\Compiler.h"
     1352                    >
     1353                </File>
     1354                <File
     1355                    RelativePath="..\BasicCompiler_Common\include\DataTable.h"
     1356                    >
     1357                </File>
     1358                <File
     1359                    RelativePath="..\BasicCompiler_Common\include\Exception.h"
     1360                    >
     1361                </File>
     1362                <File
     1363                    RelativePath="..\BasicCompiler_Common\include\LexicalScopingImpl.h"
     1364                    >
     1365                </File>
     1366                <File
     1367                    RelativePath="..\BasicCompiler_Common\include\ProcedureImpl.h"
     1368                    >
     1369                </File>
     1370                <File
    14631371                    RelativePath="..\BasicCompiler_Common\include\Program.h"
    14641372                    >
    14651373                </File>
    1466             </Filter>
    1467             <Filter
    1468                 Name="Common Classes"
    1469                 >
    1470                 <File
    1471                     RelativePath="..\BasicCompiler_Common\include\option.h"
    1472                     >
    1473                 </File>
    1474                 <File
    1475                     RelativePath="..\BasicCompiler_Common\include\Smoothie.h"
    1476                     >
    1477                 </File>
    1478                 <Filter
    1479                     Name="Meta Parts"
    1480                     >
    1481                     <File
    1482                         RelativePath="..\BasicCompiler_Common\include\Namespace.h"
    1483                         >
    1484                     </File>
    1485                     <File
    1486                         RelativePath="..\BasicCompiler_Common\Parameter.h"
    1487                         >
    1488                     </File>
    1489                     <File
    1490                         RelativePath="..\BasicCompiler_Common\Procedure.h"
    1491                         >
    1492                     </File>
    1493                     <File
    1494                         RelativePath="..\BasicCompiler_Common\include\Symbol.h"
    1495                         >
    1496                     </File>
    1497                     <File
    1498                         RelativePath="..\BasicCompiler_Common\Type.h"
    1499                         >
    1500                     </File>
    1501                     <File
    1502                         RelativePath="..\BasicCompiler_Common\TypeDef.h"
    1503                         >
    1504                     </File>
    1505                     <File
    1506                         RelativePath="..\BasicCompiler_Common\Variable.h"
    1507                         >
    1508                     </File>
    1509                     <Filter
    1510                         Name="Prototype"
    1511                         >
    1512                         <File
    1513                             RelativePath="..\BasicCompiler_Common\include\Member.h"
    1514                             >
    1515                         </File>
    1516                         <File
    1517                             RelativePath="..\BasicCompiler_Common\include\Method.h"
    1518                             >
    1519                         </File>
    1520                         <File
    1521                             RelativePath="..\BasicCompiler_Common\include\Prototype.h"
    1522                             >
    1523                         </File>
    1524                     </Filter>
    1525                 </Filter>
    1526                 <Filter
    1527                     Name="Lexical Parts"
    1528                     >
    1529                     <File
    1530                         RelativePath="..\BasicCompiler_Common\include\Source.h"
    1531                         >
    1532                     </File>
    1533                 </Filter>
    1534                 <Filter
    1535                     Name="Operation Statements"
    1536                     >
    1537                     <File
    1538                         RelativePath="..\BasicCompiler_Common\include\Exception.h"
    1539                         >
    1540                     </File>
    1541                 </Filter>
    1542                 <Filter
    1543                     Name="Module"
    1544                     >
    1545                     <File
    1546                         RelativePath="..\BasicCompiler_Common\include\ObjectModule.h"
    1547                         >
    1548                     </File>
    1549                 </Filter>
    15501374            </Filter>
    15511375        </Filter>
  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r179 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include "../BasicCompiler_Common/common.h"
    25#include "Opcode.h"
     
    7881            //符号あり
    7982
    80             if(OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)){
     83            if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
    8184                //pop eax
    8285                op_pop(REG_EAX);
     
    9093                op_push(REG_EAX);
    9194            }
    92             else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
     95            else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    9396                //pop eax
    9497                op_pop(REG_EAX);
     
    170173            //符号あり
    171174
    172             if(OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)){
     175            if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
    173176                //pop eax
    174177                op_pop(REG_EAX);
     
    182185                op_push(REG_EAX);
    183186            }
    184             else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
     187            else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    185188                //pop eax
    186189                op_pop(REG_EAX);
     
    304307    if(OldType==DEF_BOOLEAN||
    305308        OldType==DEF_BYTE||
    306         OldType==DEF_WORD||OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)) return;
    307     else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
     309        OldType==DEF_WORD||OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)) return;
     310    else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    308311        //pop eax
    309312        op_pop(REG_EAX);
     
    334337void ChangeTypeToByte(int OldType){
    335338    //現在のスタックの内容をbyte型に変換する
    336     if(OldType==DEF_BYTE||OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)) return;
     339    if(OldType==DEF_BYTE||OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)) return;
    337340
    338341    ChangeTypeToLong(OldType);
     
    619622
    620623
    621     if( varType.IsObject() && Smoothie::meta.blittableTypes.IsExist( calcType ) ){
     624    if( varType.IsObject() && Smoothie::GetMeta().blittableTypes.IsExist( calcType ) ){
    622625        // Blittable型をオブジェクトとして扱う
    623626        vector<UserProc *> userProcs;
    624         Smoothie::meta.blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
     627        Smoothie::GetMeta().blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
    625628        if( userProcs.size() != 1 ){
    626629            SetError();
  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r137 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    119121            if(lstrcmpi(ObjectName,"Super")==0){
    120122                //クラスメンバ関数内から基底クラスの呼び出し
    121                 pobj_c=pobj_CompilingClass;
     123                pobj_c=Smoothie::Temp::pCompilingClass;
    122124            }
    123125            else{
     
    127129                pobj_c = &varType.GetClass();
    128130                if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
    129                     pobj_c=pobj_DBClass->Find(ObjectName);
     131                    pobj_c=Smoothie::GetMeta().GetClasses().Find(ObjectName);
    130132                    if( pobj_c ){
    131133                        isStatic = true;
     
    144146            else{
    145147                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
    146                 pobj_c=pobj_CompilingClass;
     148                pobj_c=Smoothie::Temp::pCompilingClass;
    147149            }
    148150        }
     
    173175        if(ObjectName[0]){
    174176            //外部からの呼び出し
    175             if(pobj_c==pobj_CompilingClass){
     177            if(pobj_c==Smoothie::Temp::pCompilingClass){
    176178                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    177179                if( pMethod->IsNoneAccess() ){
  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    176178        tempParm=temp2;
    177179
    178         type.SetType( DEF_OBJECT, pobj_DBClass->GetStringClassPtr() );
     180        type.SetType( DEF_OBJECT, Smoothie::GetMeta().GetClasses().GetStringClassPtr() );
    179181    }
    180182
     
    228230
    229231        //オーバーロードを解決
    230         pUserProc=OverloadSolution(name,subs,Smoothie::meta.procPointers[ProcPtr_BaseIndex]->Params(), Type() );
     232        pUserProc=OverloadSolution(name,subs,Smoothie::GetMeta().GetProcPointers()[ProcPtr_BaseIndex]->Params(), Type() );
    231233
    232234        if(!pUserProc){
     
    280282            SetThisPtrToReg(REG_RCX);
    281283
    282             pobj_c=pobj_CompilingClass;
     284            pobj_c=Smoothie::Temp::pCompilingClass;
    283285        }
    284286
  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r143 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <Program.h>
     5#include <LexicalScopingImpl.h>
     6#include <ClassImpl.h>
     7
    18#include "../BasicCompiler_Common/common.h"
    29#include "Opcode.h"
     
    4855
    4956        //クラスに属する静的メンバを定義
    50         CMember::InitStaticMember();
     57        Smoothie::GetMeta().GetClasses().InitStaticMember();
    5158
    5259        GetGlobalDataForDll();
     
    6168        //静的ローカルオブジェクトのコンストラクタ呼び出し
    6269
    63         foreach( Variable *pVar, globalVars ){
     70        BOOST_FOREACH( Variable *pVar, globalVars ){
    6471            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
    6572                //コンストラクタ呼び出し
     
    8794        UserProc::CompileStartForGlobalArea();
    8895
    89         obj_LexScopes.CallDestructorsOfScopeEnd();
     96        GetLexicalScopes().CallDestructorsOfScopeEnd();
    9097
    9198        UserProc::CompileStartForUserProc( pBackUserProc );
     
    217224        && userProc.GetParentClass().GetName() == "_System_TypeBase" ){
    218225
    219             pobj_DBClass->Compile_System_InitializeUserTypes();
     226            Smoothie::GetMeta().GetClasses().Compile_System_InitializeUserTypes();
    220227    }
    221228    else if( userProc.GetName() == "RegisterGlobalRoots"
     
    263270
    264271    //コンパイル中の関数が属するクラス
    265     pobj_CompilingClass=pUserProc->GetParentClassPtr();
     272    Smoothie::Temp::pCompilingClass=pUserProc->GetParentClassPtr();
    266273
    267274    //コンパイルスタートをクラス管理クラスに追加
    268     pobj_DBClass->StartCompile( pUserProc );
     275    Smoothie::GetMeta().GetClasses().StartCompile( pUserProc );
    269276
    270277    //コンパイル中の関数
     
    272279
    273280    // コンパイル中の関数が属する名前空間
    274     Smoothie::Lexical::liveingNamespaceScopes = pUserProc->GetNamespaceScopes();
     281    Smoothie::Temp::liveingNamespaceScopes = pUserProc->GetNamespaceScopes();
    275282
    276283    // コンパイル中の関数でImportsされている名前空間
     
    335342
    336343        //レキシカルスコープ情報
    337         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    338         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     344        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     345        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    339346        pVar->bLiving=TRUE;
    340347
     
    450457    }
    451458
    452     if(pobj_CompilingClass){
    453         if( pUserProc->GetName() == pobj_CompilingClass->GetName() ){
     459    if(Smoothie::Temp::pCompilingClass){
     460        if( pUserProc->GetName() == Smoothie::Temp::pCompilingClass->GetName() ){
    454461            ////////////////////////////////////
    455462            // コンストラクタをコンパイルするとき
     
    457464
    458465            //コンストラクタのコンパイル開始を通知
    459             pobj_CompilingClass->NotifyStartConstructorCompile();
     466            Smoothie::Temp::pCompilingClass->NotifyStartConstructorCompile();
    460467
    461468            //基底クラスかどうかの識別
    462469            //(継承元がインターフェイスの場合も基底クラスと見なす)
    463470            BOOL bThisIsSuperClass;
    464             if(pobj_CompilingClass->pobj_InheritsClass==0) bThisIsSuperClass=1;
    465             else if( pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod() == NULL ){
     471            if(Smoothie::Temp::pCompilingClass->pobj_InheritsClass==0) bThisIsSuperClass=1;
     472            else if( Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod() == NULL ){
    466473                //インターフェイスを継承したときはコンストラクタを持たない
    467474                bThisIsSuperClass=1;
     
    482489                    temporary[i4]=basbuf[i3];
    483490                }
    484                 if( pobj_CompilingClass->pobj_InheritsClass->GetName() == temporary ){
     491                if( Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetName() == temporary ){
    485492                    //基底クラスのコンストラクタを呼び出す
    486493                    cp=i3;
     
    499506                    Type dummyType;
    500507                    CallProc( PROC_DEFAULT
    501                         , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc
    502                         , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc->GetName().c_str()
     508                        , Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc
     509                        , Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc->GetName().c_str()
    503510                        , temporary
    504511                        , dummyType );
     
    507514                    //基底クラスのコンストラクタを暗黙的に呼び出す
    508515                    Opcode_CallProc("",
    509                         pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
     516                        Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
    510517                        0,
    511518                        "",
     
    515522
    516523            //仮想関数テーブルを初期化
    517             if( pobj_CompilingClass->IsExistVirtualFunctions()
    518                 && !pobj_CompilingClass->IsAbstract() ){
     524            if( Smoothie::Temp::pCompilingClass->IsExistVirtualFunctions()
     525                && !Smoothie::Temp::pCompilingClass->IsAbstract() ){
    519526                    //関数テーブルに値をセット
    520                     int offset = (int)pobj_CompilingClass->GetVtblGlobalOffset();
     527                    int offset = (int)Smoothie::Temp::pCompilingClass->GetVtblGlobalOffset();
    521528
    522529                    //mov eax,offset
     
    538545
    539546            //デストラクタのコンパイル開始を通知
    540             pobj_CompilingClass->NotifyStartDestructorCompile();
     547            Smoothie::Temp::pCompilingClass->NotifyStartDestructorCompile();
    541548        }
    542549    }
     
    564571    //////////////////////////////////////////
    565572
    566     if( pobj_CompilingClass ){
    567 
    568         if( pobj_CompilingClass->IsCompilingConstructor() ){
     573    if( Smoothie::Temp::pCompilingClass ){
     574
     575        if( Smoothie::Temp::pCompilingClass->IsCompilingConstructor() ){
    569576            // コンストラクタをコンパイルしていたとき
    570577
    571578            // コンストラクタのコンパイルが完了したことを通知
    572             pobj_CompilingClass->NotifyFinishConstructorCompile();
     579            Smoothie::Temp::pCompilingClass->NotifyFinishConstructorCompile();
    573580        }
    574581        else if( pUserProc->IsDestructor() ){
     
    578585
    579586            // デストラクタのコンパイルが完了したことを通知
    580             pobj_CompilingClass->NotifyFinishDestructorCompile();
    581 
    582             if(pobj_CompilingClass->pobj_InheritsClass){
     587            Smoothie::Temp::pCompilingClass->NotifyFinishDestructorCompile();
     588
     589            if(Smoothie::Temp::pCompilingClass->pobj_InheritsClass){
    583590                /* サブクラスのデストラクタをコンパイルしているときは、
    584591                    基底クラスのデストラクタを呼び出す */
    585592
    586                 const CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
     593                const CMethod *method = Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetDestructorMethod();
    587594                if( method ){
    588595                    Opcode_CallProc("",
     
    627634
    628635    //ローカルオブジェクトの解放処理
    629     obj_LexScopes.CallDestructorsOfScopeEnd();
     636    GetLexicalScopes().CallDestructorsOfScopeEnd();
    630637
    631638    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
     
    702709            obp+=sizeof(long);
    703710        }
    704         else if(i3==DEF_INTEGER||i3==DEF_WORD || (isUnicode&&i3==DEF_CHAR)){
     711        else if(i3==DEF_INTEGER||i3==DEF_WORD || (Smoothie::IsUnicode()&&i3==DEF_CHAR)){
    705712            //xor eax,eax(eaxを0に初期化する)
    706713            op_zero_reg(REG_EAX);
     
    714721            obp+=sizeof(long);
    715722        }
    716         else if(i3==DEF_SBYTE||i3==DEF_BYTE||i3==DEF_BOOLEAN || (isUnicode==false&&i3==DEF_CHAR)){
     723        else if(i3==DEF_SBYTE||i3==DEF_BYTE||i3==DEF_BOOLEAN || (Smoothie::IsUnicode()==false&&i3==DEF_CHAR)){
    717724            //xor eax,eax(eaxを0に初期化する)
    718725            op_zero_reg(REG_EAX);
     
    732739    }
    733740    HeapDefaultFree(pLocalVarAddrSchedule);
    734     foreach( Variable *pVar, pUserProc->localVars ){
     741    BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    735742        //後にデバッグで利用する
    736743        pVar->offset = AllLocalVarSize - pVar->offset;
  • trunk/abdev/BasicCompiler32/Compile_Set_Var.cpp

    r121 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    213215}
    214216void ExtendTypeTo32(int type,int reg){
    215     if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     217    if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    216218        //movsx reg32,reg16
    217219        op_movsx_R32R16(reg,reg);
     
    221223        op_and_RV(reg,(int)0x0000FFFF);
    222224    }
    223     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     225    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    224226        //movsx reg32,reg8
    225227        op_movsx_R32R8(reg,reg);
     
    231233}
    232234void ExtendTypeTo16(int type,int reg){
    233     if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     235    if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    234236        //movsx reg16,reg8
    235237        op_movsx_R16R8(reg,reg);
  • trunk/abdev/BasicCompiler32/Compile_Statement.cpp

    r142 r183  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
     3#include <LexicalScopingImpl.h>
     4#include <Compiler.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27#include "Opcode.h"
     
    274279
    275280    //レキシカルスコープをレベルアップ
    276     obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
     281    GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
    277282
    278283    i2=CompileBuffer(ESC_ENDIF,0);
    279284
    280285    //レキシカルスコープをレベルダウン
    281     obj_LexScopes.End();
     286    GetLexicalScopes().End();
    282287
    283288
     
    299304
    300305        //レキシカルスコープをレベルアップ
    301         obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
     306        GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
    302307
    303308        CompileBuffer(ESC_ENDIF,0);
    304309
    305310        //レキシカルスコープをレベルダウン
    306         obj_LexScopes.End();
     311        GetLexicalScopes().End();
    307312
    308313
     
    525530
    526531    //レキシカルスコープをレベルアップ
    527     obj_LexScopes.Start( obp, SCOPE_TYPE_WHILE );
     532    GetLexicalScopes().Start( obp, SCOPE_TYPE_WHILE );
    528533
    529534    //While内をコンパイル
    530535    CompileBuffer(0,COM_WEND);
    531536
    532     obj_LexScopes.CallDestructorsOfScopeEnd();
     537    GetLexicalScopes().CallDestructorsOfScopeEnd();
    533538
    534539    if( i3 == -1 ){
     
    542547
    543548    //レキシカルスコープをレベルダウン
    544     obj_LexScopes.End();
     549    GetLexicalScopes().End();
    545550
    546551    *((long *)(OpBuffer+je_schedule-sizeof(long)))=obp-je_schedule; //jeジャンプ先のオフセット値
     
    660665
    661666    //レキシカルスコープをレベルアップ
    662     obj_LexScopes.Start( obp, SCOPE_TYPE_FOR );
     667    GetLexicalScopes().Start( obp, SCOPE_TYPE_FOR );
    663668
    664669    //For内をコンパイル
    665670    CompileBuffer(0,COM_NEXT);
    666671
    667     obj_LexScopes.CallDestructorsOfScopeEnd();
     672    GetLexicalScopes().CallDestructorsOfScopeEnd();
    668673
    669674    if(szNextVariable[0]){
     
    679684
    680685    //レキシカルスコープをレベルダウン
    681     obj_LexScopes.End();
     686    GetLexicalScopes().End();
    682687
    683688    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jeジャンプ先のオフセット値
     
    700705
    701706    //レキシカルスコープをレベルアップ
    702     obj_LexScopes.Start( obp, SCOPE_TYPE_DO );
     707    GetLexicalScopes().Start( obp, SCOPE_TYPE_DO );
    703708
    704709    //Do内をコンパイル
    705710    CompileBuffer(0,COM_LOOP);
    706711
    707     obj_LexScopes.CallDestructorsOfScopeEnd();
     712    GetLexicalScopes().CallDestructorsOfScopeEnd();
    708713
    709714    extern char *basbuf;
     
    908913
    909914    //レキシカルスコープをレベルダウン
    910     obj_LexScopes.End();
     915    GetLexicalScopes().End();
    911916
    912917    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jmpジャンプ先のオフセット値
     
    942947
    943948    //未解放のローカルオブジェクトのデストラクタを呼び出す
    944     obj_LexScopes.CallDestructorsOfReturn();
     949    GetLexicalScopes().CallDestructorsOfReturn();
    945950
    946951    //jmp ...(End Sub/Function)
     
    12171222
    12181223    //レキシカルスコープをレベルアップ
    1219     obj_LexScopes.Start( obp, SCOPE_TYPE_SELECT );
     1224    GetLexicalScopes().Start( obp, SCOPE_TYPE_SELECT );
    12201225
    12211226    //Select Case内をコンパイル
     
    12341239
    12351240    //レキシカルスコープをレベルダウン
    1236     obj_LexScopes.End();
     1241    GetLexicalScopes().End();
    12371242
    12381243    pCaseSchedule=temp_pCaseSchedule;
  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <LexicalScopingImpl.h>
     5#include <CodeGenerator.h>
     6#include <Compiler.h>
     7
    18#include "../BasicCompiler_Common/common.h"
    29#include "Opcode.h"
     
    187194
    188195    //アクセシビリティをチェック
    189     if(&objClass==pobj_CompilingClass){
     196    if(&objClass==Smoothie::Temp::pCompilingClass){
    190197        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    191198        if(pMember->IsNoneAccess()){
     
    360367    // 名前空間を分離
    361368    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    362     Smoothie::meta.namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
     369    Smoothie::GetMeta().namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
    363370
    364371    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
     
    417424    }
    418425
    419     if(pobj_CompilingClass){
     426    if(Smoothie::Temp::pCompilingClass){
    420427        //////////////////////
    421428        // クラスメンバの参照
     
    430437            pRelativeVar->dwKind=VAR_DIRECTMEM;
    431438
    432             resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     439            resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    433440            return true;
    434441        }
     
    443450
    444451            bool isFound = false;
    445             BOOST_FOREACH( CMember *pMember, pobj_CompilingClass->GetDynamicMembers() ){
     452            BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
    446453                if( pMember->GetName() == VarName ){
    447454                    isFound = true;
     
    454461        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
    455462        //(コンストラクタ、デストラクタ内を除く)
    456         const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
     463        const CMethod *pMethod = Smoothie::GetMeta().GetClasses().GetNowCompilingMethodInfo();
    457464        if( isWriteAccess &&
    458465            pMethod->IsConst() &&
    459             pobj_CompilingClass->IsCompilingConstructor() == false &&
    460             pobj_CompilingClass->IsCompilingDestructor() == false
     466            Smoothie::Temp::pCompilingClass->IsCompilingConstructor() == false &&
     467            Smoothie::Temp::pCompilingClass->IsCompilingDestructor() == false
    461468            ){
    462469                SetError(131, NULL, cp );
     
    473480            isErrorEnabled,
    474481            isWriteAccess,
    475             *pobj_CompilingClass,
     482            *Smoothie::Temp::pCompilingClass,
    476483            variable,
    477484            pRelativeVar,
     
    517524            }
    518525
    519             int typeDefIndex = Smoothie::meta.typeDefs.GetIndex( VarName );
     526            int typeDefIndex = Smoothie::GetMeta().typeDefs.GetIndex( VarName );
    520527            if( typeDefIndex != -1 ){
    521528                // TypeDef後の型名だったとき
    522                 lstrcpy( VarName, Smoothie::meta.typeDefs[typeDefIndex].GetBaseName().c_str() );
     529                lstrcpy( VarName, Smoothie::GetMeta().typeDefs[typeDefIndex].GetBaseName().c_str() );
    523530            }
    524531
     
    533540        }
    534541
    535         if(pobj_CompilingClass){
     542        if(Smoothie::Temp::pCompilingClass){
    536543            //自身のクラスから静的メンバを参照する場合
    537544            char temp2[VN_SIZE];
    538             sprintf(temp2,"%s.%s",pobj_CompilingClass->GetName().c_str(),VarName);
     545            sprintf(temp2,"%s.%s",Smoothie::Temp::pCompilingClass->GetName().c_str(),VarName);
    539546            pVar = globalVars.Find( Symbol( temp2 ) );
    540547            if( pVar ){
     
    825832            char *temp;
    826833            temp=(char *)i64data;
    827             i2=dataTable.AddString(temp,lstrlen(temp));
     834            i2=Compiler::GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
    828835            HeapDefaultFree(temp);
    829836
     
    10151022            char *temp;
    10161023            temp=(char *)i64data;
    1017             i2=dataTable.AddString(temp,lstrlen(temp));
     1024            i2=Compiler::GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
    10181025            HeapDefaultFree(temp);
    10191026
     
    10991106
    11001107        //レキシカルスコープ
    1101         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1102         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1108        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     1109        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    11031110        pVar->bLiving=TRUE;
    11041111
     
    11341141
    11351142        //レキシカルスコープ
    1136         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1137         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1143        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     1144        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    11381145        pVar->bLiving=TRUE;
    11391146
  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r165 r183  
    11#include <jenga/include/common/Environment.h>
     2
     3#include <jenga/include/smoothie/Smoothie.h>
     4
     5#include <LexicalScopingImpl.h>
     6#include <ClassImpl.h>
     7#include <Compiler.h>
    28
    39#include "../BasicCompiler_Common/common.h"
     
    134140    //////////////////
    135141    // データテーブル
    136     dataTable.Init();
     142    Compiler::GetNativeCode().GetDataTable().Init();
    137143    if(bDebugCompile){
    138         dataTable.Add( (long)0x00000002 );
     144        Compiler::GetNativeCode().GetDataTable().Add( (long)0x00000002 );
    139145    }
    140146
     
    160166
    161167    //関数ポインタ情報を初期化
    162     Smoothie::meta.procPointers.clear();
     168    Smoothie::GetMeta().GetProcPointers().clear();
    163169
    164170    // 名前空間情報を取得
    165171    NamespaceScopesCollection::CollectNamespaces(
    166172        Smoothie::Lexical::source.GetBuffer(),
    167         Smoothie::meta.namespaceScopesCollection
     173        Smoothie::GetMeta().namespaceScopesCollection
    168174    );
    169175
     
    171177    //   GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。
    172178    //     ※オブジェクトの内容までは取得しない
    173     pobj_DBClass=new Classes();
    174     pobj_DBClass->InitNames();
     179    Smoothie::GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
    175180
    176181    //TypeDef情報を初期化
    177     Smoothie::meta.typeDefs.Init();
     182    Smoothie::GetMeta().typeDefs.Init();
    178183
    179184    //定数情報を取得
     
    181186
    182187    //サブルーチン(ユーザー定義、DLL関数)の識別子、アドレスを取得
    183     pobj_CompilingClass=0;
     188    Smoothie::Temp::pCompilingClass=0;
    184189    GetSubInfo();
    185190
    186191    //クラス情報を取得(※注 - GetSubInfoの後に呼び出す)
    187     pobj_DBClass->GetAllClassInfo();
     192    Smoothie::GetMeta().GetClasses().GetAllClassInfo();
    188193
    189194    //コードと行番号の関係
     
    336341
    337342    //レキシカルスコープ情報を初期化
    338     obj_LexScopes.Init(obp);
     343    GetLexicalScopes().Init(obp);
    339344
    340345
     
    360365    if(!bDll){
    361366        // 名前空間が初期化されているかをチェック
    362         if( Smoothie::Lexical::liveingNamespaceScopes.size() ){
     367        if( Smoothie::Temp::liveingNamespaceScopes.size() ){
    363368            SetError();
    364369        }
     
    405410
    406411        //クラスに属する静的メンバを定義
    407         CMember::InitStaticMember();
     412        Smoothie::GetMeta().GetClasses().InitStaticMember();
    408413
    409414        //グローバル実行領域をコンパイル開始
     
    460465
    461466        // 名前空間が正しく閉じられているかをチェック
    462         if( Smoothie::Lexical::liveingNamespaceScopes.size() ){
     467        if( Smoothie::Temp::liveingNamespaceScopes.size() ){
    463468            SetError(63,NULL,-1);
    464469        }
     
    792797    //(デバッグ情報で利用される)
    793798    extern int AllInitGlobalVarSize;
    794     foreach( Variable *pVar, globalVars ){
     799    BOOST_FOREACH( Variable *pVar, globalVars ){
    795800        if(pVar->offset&0x80000000){
    796801            pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
     
    874879
    875880    //データセクションのファイル上のサイズ
    876     if(dataTable.GetSize()%FILE_ALIGNMENT) FileSize_DataSection=dataTable.GetSize()+(FILE_ALIGNMENT-dataTable.GetSize()%FILE_ALIGNMENT);
    877     else FileSize_DataSection=dataTable.GetSize();
     881    if(Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT) FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize()+(FILE_ALIGNMENT-Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT);
     882    else FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize();
    878883    if(FileSize_DataSection) bUse_DataSection=1;
    879884    else bUse_DataSection=0;
     
    10661071    ////////////////////////////////////////
    10671072    //仮想関数データテーブルスケジュール
    1068     pobj_DBClass->ActionVtblSchedule(ImageBase,MemPos_CodeSection);
     1073    Smoothie::GetMeta().GetClasses().ActionVtblSchedule(ImageBase,MemPos_CodeSection);
    10691074
    10701075
     
    16011606    if(bUse_DataSection){
    16021607        //データ テーブル
    1603         WriteFile(hFile,dataTable.GetPtr(),dataTable.GetSize(),(DWORD *)&i2,NULL);
     1608        WriteFile(hFile,Compiler::GetNativeCode().GetDataTable().GetPtr(),Compiler::GetNativeCode().GetDataTable().GetSize(),(DWORD *)&i2,NULL);
    16041609        i+=i2;
    16051610    }
     
    17131718
    17141719    //クラスに関するメモリを解放
    1715     delete pobj_DBClass;
    1716     pobj_DBClass=0;
     1720    Smoothie::GetMeta().GetClasses().Clear();
    17171721}
  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <Compiler.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27#include "Opcode.h"
     
    3944        op_push(REG_EAX);
    4045    }
    41     else if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     46    else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    4247        //movsx ebx,ax
    4348        OpBuffer[obp++]=(char)0x0F;
     
    4853        op_push(REG_EBX);
    4954    }
    50     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     55    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    5156        //movsx ebx,al
    5257        OpBuffer[obp++]=(char)0x0F;
     
    7782    SetStringQuotes( parameter );
    7883
    79     Operator_New( *pobj_DBClass->GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *pobj_DBClass->GetStringClassPtr() ) );
     84    Operator_New( *Smoothie::GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *Smoothie::GetMeta().GetClasses().GetStringClassPtr() ) );
    8085
    8186    free( parameter );
     
    244249    char member[VN_SIZE];
    245250    CClass::RefType refType;
    246     if( SplitMemberName( termFull, termLeft, member, refType ) ){
     251    if( CClass::SplitName( termFull, termLeft, member, refType ) ){
    247252        ///////////////////////////////////////////////////////////////////
    248253        // オブジェクトとメンバに分解できるとき
     
    256261        Type leftType;
    257262        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
    258             if( isClassName == false && Smoothie::meta.blittableTypes.IsExist( leftType ) ){
     263            if( isClassName == false && Smoothie::GetMeta().blittableTypes.IsExist( leftType ) ){
    259264                // 左側のオブジェクト部分がBlittable型のとき
    260265
     
    262267                lstrcpy( temporary, termLeft );
    263268                sprintf( termLeft, "%s(%s)",
    264                     Smoothie::meta.blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
     269                    Smoothie::GetMeta().blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
    265270                    temporary );
    266271            }
     
    291296
    292297    if( pIsClassName ){
    293         if( pobj_DBClass->Find( termFull ) ){
     298        if( Smoothie::GetMeta().GetClasses().Find( termFull ) ){
    294299            *pIsClassName = true;
    295300            return true;
     
    307312    if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
    308313        //Thisオブジェクト
    309         resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     314        resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    310315
    311316        SetThisPtrToReg( useReg );
     
    588593        }
    589594
    590         i2 = dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
     595        i2 = Compiler::GetNativeCode().GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
    591596
    592597        //mov eax,i2
     
    735740
    736741                        type_stack[sp]=DEF_OBJECT;
    737                         index_stack[sp]=(LONG_PTR)pobj_DBClass->GetStringClassPtr();
     742                        index_stack[sp]=(LONG_PTR)Smoothie::GetMeta().GetClasses().GetStringClassPtr();
    738743                        bLiteralCalculation=0;
    739744
     
    746751                    bLiteralCalculation=0;
    747752
    748                     i2=dataTable.AddString(term,i3);
     753                    i2=Compiler::GetNativeCode().GetDataTable().AddString(term,i3);
    749754
    750755                    //push DataSize
     
    833838                        }
    834839                        else{
    835                             index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClassPtr();
     840                            index_stack[sp] = (LONG_PTR)Smoothie::GetMeta().GetClasses().GetObjectClassPtr();
    836841                        }
    837842
  • trunk/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp

    r67 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <Compiler.h>
     4
    15#include "../BasicCompiler_Common/common.h"
    26#include "Opcode.h"
     
    5155        op_push(REG_EAX);
    5256    }
    53     else if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     57    else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    5458        //pop eax
    5559        op_pop(REG_EAX);
     
    7579        op_push(REG_EAX);
    7680    }
    77     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     81    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    7882        //pop eax
    7983        op_pop(REG_EAX);
     
    101105}
    102106void ExtendStackTo16(int type){
    103     if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     107    if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    104108        //pop eax
    105109        op_pop(REG_EAX);
  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r169 r183  
    7979                Name="VCLinkerTool"
    8080                AdditionalOptions="/MACHINE:AMD64"
    81                 AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib commond.lib"
     81                AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib commond.lib smoothied.lib"
    8282                OutputFile="../ActiveBasic/BasicCompiler64.exe"
    8383                LinkIncremental="2"
     
    153153                Optimization="2"
    154154                InlineFunctionExpansion="2"
     155                EnableIntrinsicFunctions="true"
    155156                FavorSizeOrSpeed="1"
    156                 AdditionalIncludeDirectories="..\..\;..\..\cpplibs\boost;..\BasicCompiler_Common\include"
     157                AdditionalIncludeDirectories="..\..\;..\..\cpplibs\STLPort;..\..\cpplibs\boost;..\BasicCompiler_Common\include"
    157158                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;JPN;_AMD64_;_WIN64"
    158159                MinimalRebuild="false"
     
    187188                Name="VCLinkerTool"
    188189                AdditionalOptions="/MACHINE:AMD64"
    189                 AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib common.lib"
     190                AdditionalDependencies="comctl32.lib psapi.lib bufferoverflowu.lib common.lib smoothie.lib"
    190191                OutputFile="../ActiveBasic/BasicCompiler64.exe"
    191192                LinkIncremental="1"
     
    275276            </Filter>
    276277            <Filter
    277                 Name="Common Classes"
    278                 >
    279                 <File
    280                     RelativePath="..\BasicCompiler_Common\include\Smoothie.h"
    281                     >
    282                 </File>
    283                 <Filter
    284                     Name="Meta Parts"
    285                     >
    286                     <File
    287                         RelativePath="..\BasicCompiler_Common\include\Namespace.h"
    288                         >
    289                     </File>
    290                     <File
    291                         RelativePath="..\BasicCompiler_Common\Parameter.h"
    292                         >
    293                     </File>
    294                     <File
    295                         RelativePath="..\BasicCompiler_Common\Procedure.h"
    296                         >
    297                     </File>
    298                     <File
    299                         RelativePath="..\BasicCompiler_Common\include\Symbol.h"
    300                         >
    301                     </File>
    302                     <File
    303                         RelativePath="..\BasicCompiler_Common\Type.h"
    304                         >
    305                     </File>
    306                     <File
    307                         RelativePath="..\BasicCompiler_Common\TypeDef.h"
    308                         >
    309                     </File>
    310                     <File
    311                         RelativePath="..\BasicCompiler_Common\Variable.h"
    312                         >
    313                     </File>
    314                     <Filter
    315                         Name="Prototype"
    316                         >
    317                         <File
    318                             RelativePath="..\BasicCompiler_Common\include\Class.h"
    319                             >
    320                         </File>
    321                         <File
    322                             RelativePath="..\BasicCompiler_Common\include\Member.h"
    323                             >
    324                         </File>
    325                         <File
    326                             RelativePath="..\BasicCompiler_Common\include\Method.h"
    327                             >
    328                         </File>
    329                         <File
    330                             RelativePath="..\BasicCompiler_Common\include\Prototype.h"
    331                             >
    332                         </File>
    333                     </Filter>
    334                 </Filter>
    335                 <Filter
    336                     Name="Lexical Parts"
    337                     >
    338                     <File
    339                         RelativePath="..\BasicCompiler_Common\include\Source.h"
    340                         >
    341                     </File>
    342                 </Filter>
    343                 <Filter
    344                     Name="Operation Statements"
    345                     >
    346                     <File
    347                         RelativePath="..\BasicCompiler_Common\include\Exception.h"
    348                         >
    349                     </File>
    350                 </Filter>
    351                 <Filter
    352                     Name="Module"
    353                     >
    354                     <File
    355                         RelativePath="..\BasicCompiler_Common\include\ObjectModule.h"
    356                         >
    357                     </File>
    358                 </Filter>
    359             </Filter>
    360             <Filter
    361278                Name="Application Classes"
    362279                >
     280                <File
     281                    RelativePath="..\BasicCompiler_Common\include\ClassImpl.h"
     282                    >
     283                </File>
     284                <File
     285                    RelativePath="..\BasicCompiler_Common\include\CodeGenerator.h"
     286                    >
     287                </File>
     288                <File
     289                    RelativePath="..\BasicCompiler_Common\include\Compiler.h"
     290                    >
     291                </File>
     292                <File
     293                    RelativePath="..\BasicCompiler_Common\include\DataTable.h"
     294                    >
     295                </File>
     296                <File
     297                    RelativePath="..\BasicCompiler_Common\include\Exception.h"
     298                    >
     299                </File>
     300                <File
     301                    RelativePath="..\BasicCompiler_Common\include\LexicalScopingImpl.h"
     302                    >
     303                </File>
     304                <File
     305                    RelativePath="..\BasicCompiler_Common\include\ProcedureImpl.h"
     306                    >
     307                </File>
    363308                <File
    364309                    RelativePath="..\BasicCompiler_Common\include\Program.h"
     
    919864                    >
    920865                    <File
    921                         RelativePath="..\BasicCompiler_Common\DataTable.cpp"
    922                         >
    923                     </File>
    924                     <File
    925                         RelativePath="..\BasicCompiler_Common\LoopRefCheck.cpp"
    926                         >
    927                     </File>
    928                     <File
    929866                        RelativePath="..\BasicCompiler_Common\NonVolatile.cpp"
    930867                        >
     
    993930                    >
    994931                    <File
    995                         RelativePath="..\BasicCompiler_Common\Class.cpp"
    996                         >
    997                     </File>
    998                     <File
    999                         RelativePath="..\BasicCompiler_Common\Class.h"
    1000                         >
    1001                     </File>
    1002                     <File
    1003932                        RelativePath="..\BasicCompiler_Common\Enum.cpp"
    1004933                        >
     
    1022951                </Filter>
    1023952                <Filter
    1024                     Name="LexicalScoping"
    1025                     >
    1026                     <File
    1027                         RelativePath="..\BasicCompiler_Common\LexicalScoping.cpp"
    1028                         >
    1029                     </File>
    1030                     <File
    1031                         RelativePath="..\BasicCompiler_Common\LexicalScoping.h"
    1032                         >
    1033                     </File>
    1034                 </Filter>
    1035                 <Filter
    1036953                    Name="Constant"
    1037954                    >
     
    1066983                    <File
    1067984                        RelativePath="..\BasicCompiler_Common\Subroutine.cpp"
    1068                         >
    1069                     </File>
    1070                 </Filter>
    1071             </Filter>
    1072             <Filter
    1073                 Name="Common Classes"
    1074                 >
    1075                 <File
    1076                     RelativePath="..\BasicCompiler_Common\src\Smoothie.cpp"
    1077                     >
    1078                 </File>
    1079                 <Filter
    1080                     Name="Meta Parts"
    1081                     >
    1082                     <File
    1083                         RelativePath="..\BasicCompiler_Common\src\Member.cpp"
    1084                         >
    1085                     </File>
    1086                     <File
    1087                         RelativePath="..\BasicCompiler_Common\src\Method.cpp"
    1088                         >
    1089                     </File>
    1090                     <File
    1091                         RelativePath="..\BasicCompiler_Common\src\Namespace.cpp"
    1092                         >
    1093                     </File>
    1094                     <File
    1095                         RelativePath="..\BasicCompiler_Common\Procedure.cpp"
    1096                         >
    1097                     </File>
    1098                     <File
    1099                         RelativePath="..\BasicCompiler_Common\src\Prototype.cpp"
    1100                         >
    1101                     </File>
    1102                     <File
    1103                         RelativePath="..\BasicCompiler_Common\src\Symbol.cpp"
    1104                         >
    1105                     </File>
    1106                     <File
    1107                         RelativePath="..\BasicCompiler_Common\Type.cpp"
    1108                         >
    1109                     </File>
    1110                     <File
    1111                         RelativePath="..\BasicCompiler_Common\TypeDef.cpp"
    1112                         >
    1113                     </File>
    1114                     <File
    1115                         RelativePath="..\BasicCompiler_Common\Variable.cpp"
    1116                         >
    1117                     </File>
    1118                 </Filter>
    1119                 <Filter
    1120                     Name="Lexical Parts"
    1121                     >
    1122                     <File
    1123                         RelativePath="..\BasicCompiler_Common\src\Source.cpp"
    1124                         >
    1125                     </File>
    1126                 </Filter>
    1127                 <Filter
    1128                     Name="Operation Statements"
    1129                     >
    1130                     <File
    1131                         RelativePath="..\BasicCompiler_Common\src\Exception.cpp"
    1132985                        >
    1133986                    </File>
     
    1138991                >
    1139992                <File
     993                    RelativePath="..\BasicCompiler_Common\src\ClassImpl.cpp"
     994                    >
     995                </File>
     996                <File
     997                    RelativePath="..\BasicCompiler_Common\src\CodeGenerator.cpp"
     998                    >
     999                </File>
     1000                <File
     1001                    RelativePath="..\BasicCompiler_Common\src\Compiler.cpp"
     1002                    >
     1003                </File>
     1004                <File
     1005                    RelativePath="..\BasicCompiler_Common\src\DataTable.cpp"
     1006                    >
     1007                </File>
     1008                <File
     1009                    RelativePath="..\BasicCompiler_Common\src\Exception.cpp"
     1010                    >
     1011                </File>
     1012                <File
     1013                    RelativePath="..\BasicCompiler_Common\src\LexicalScopingImpl.cpp"
     1014                    >
     1015                </File>
     1016                <File
     1017                    RelativePath="..\BasicCompiler_Common\src\ProcedureImpl.cpp"
     1018                    >
     1019                </File>
     1020                <File
    11401021                    RelativePath="..\BasicCompiler_Common\src\Program.cpp"
     1022                    >
     1023                </File>
     1024                <File
     1025                    RelativePath="..\BasicCompiler_Common\src\SmoothieImpl.cpp"
    11411026                    >
    11421027                </File>
  • trunk/abdev/BasicCompiler64/Compile_Calc.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include "../BasicCompiler_Common/common.h"
    25#include "Opcode.h"
     
    227230    }
    228231
    229     if( varType.IsObject() && Smoothie::meta.blittableTypes.IsExist( calcType ) ){
     232    if( varType.IsObject() && Smoothie::GetMeta().blittableTypes.IsExist( calcType ) ){
    230233        // Blittable型をオブジェクトとして扱う
    231234        vector<UserProc *> userProcs;
    232         Smoothie::meta.blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
     235        Smoothie::GetMeta().blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
    233236        if( userProcs.size() != 1 ){
    234237            SetError();
  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r137 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    124126            if(lstrcmpi(ObjectName,"Super")==0){
    125127                //クラスメンバ関数内から基底クラスの呼び出し
    126                 pobj_c=pobj_CompilingClass;
     128                pobj_c=Smoothie::Temp::pCompilingClass;
    127129            }
    128130            else{
     
    132134                pobj_c = &varType.GetClass();
    133135                if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
    134                     pobj_c=pobj_DBClass->Find(ObjectName);
     136                    pobj_c=Smoothie::GetMeta().GetClasses().Find(ObjectName);
    135137                    if( pobj_c ){
    136138                        isStatic = true;
     
    149151            else{
    150152                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
    151                 pobj_c=pobj_CompilingClass;
     153                pobj_c=Smoothie::Temp::pCompilingClass;
    152154            }
    153155        }
     
    178180        if(ObjectName[0]){
    179181            //外部からの呼び出し
    180             if(pobj_c==pobj_CompilingClass){
     182            if(pobj_c==Smoothie::Temp::pCompilingClass){
    181183                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    182184                if( pMethod->IsNoneAccess() ){
  • trunk/abdev/BasicCompiler64/Compile_Func.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    3032        tempParm=temp2;
    3133
    32         type.SetType( DEF_OBJECT, pobj_DBClass->GetStringClassPtr() );
     34        type.SetType( DEF_OBJECT, Smoothie::GetMeta().GetClasses().GetStringClassPtr() );
    3335    }
    3436
     
    7880
    7981        //オーバーロードを解決
    80         pUserProc=OverloadSolution(name,subs,Smoothie::meta.procPointers[ProcPtr_BaseIndex]->Params(), Type() );
     82        pUserProc=OverloadSolution(name,subs,Smoothie::GetMeta().GetProcPointers()[ProcPtr_BaseIndex]->Params(), Type() );
    8183
    8284        if(!pUserProc){
     
    127129            SetThisPtrToReg(REG_RCX);
    128130
    129             pobj_c=pobj_CompilingClass;
     131            pobj_c=Smoothie::Temp::pCompilingClass;
    130132        }
    131133
  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r169 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include <Program.h>
     5#include <LexicalScopingImpl.h>
     6#include <ClassImpl.h>
    27
    38#include "../BasicCompiler_Common/common.h"
     
    5156
    5257        //クラスに属する静的メンバを定義
    53         CMember::InitStaticMember();
     58        Smoothie::GetMeta().GetClasses().InitStaticMember();
    5459
    5560        GetGlobalDataForDll();
     
    7580        StackFrameSchedule=obp-sizeof(long);
    7681
    77         foreach( Variable *pVar, globalVars ){
     82        BOOST_FOREACH( Variable *pVar, globalVars ){
    7883            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
    7984                //コンストラクタ呼び出し
     
    110115        UserProc::CompileStartForGlobalArea();
    111116
    112         obj_LexScopes.CallDestructorsOfScopeEnd();
     117        GetLexicalScopes().CallDestructorsOfScopeEnd();
    113118
    114119        UserProc::CompileStartForUserProc( pBackUserProc );
     
    210215        && userProc.GetParentClass().GetName() == "_System_TypeBase" ){
    211216
    212             pobj_DBClass->Compile_System_InitializeUserTypes();
     217            Smoothie::GetMeta().GetClasses().Compile_System_InitializeUserTypes();
    213218    }
    214219    else if( userProc.GetName() == "RegisterGlobalRoots"
     
    255260
    256261    //コンパイル中の関数が属するクラス
    257     pobj_CompilingClass=pUserProc->GetParentClassPtr();
     262    Smoothie::Temp::pCompilingClass=pUserProc->GetParentClassPtr();
    258263
    259264    //コンパイルスタートをクラス管理クラスに追加
    260     pobj_DBClass->StartCompile( pUserProc );
     265    Smoothie::GetMeta().GetClasses().StartCompile( pUserProc );
    261266
    262267    //コンパイル中の関数
     
    264269
    265270    // コンパイル中の関数が属する名前空間
    266     Smoothie::Lexical::liveingNamespaceScopes = pUserProc->GetNamespaceScopes();
     271    Smoothie::Temp::liveingNamespaceScopes = pUserProc->GetNamespaceScopes();
    267272
    268273    // コンパイル中の関数でImportsされている名前空間
     
    342347
    343348    //レキシカルスコープ情報を初期化
    344     obj_LexScopes.Init(obp);
     349    GetLexicalScopes().Init(obp);
    345350
    346351
     
    377382
    378383        //レキシカルスコープ情報
    379         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    380         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     384        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     385        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    381386        pVar->bLiving=TRUE;
    382387
     
    504509    }
    505510
    506     if(pobj_CompilingClass){
    507         if( pUserProc->GetName() == pobj_CompilingClass->GetName() ){
     511    if(Smoothie::Temp::pCompilingClass){
     512        if( pUserProc->GetName() == Smoothie::Temp::pCompilingClass->GetName() ){
    508513            ////////////////////////////////////
    509514            // コンストラクタをコンパイルするとき
     
    511516
    512517            //コンストラクタのコンパイル開始を通知
    513             pobj_CompilingClass->NotifyStartConstructorCompile();
     518            Smoothie::Temp::pCompilingClass->NotifyStartConstructorCompile();
    514519
    515520            //基底クラスかどうかの識別
    516521            //(継承元がインターフェイスの場合も基底クラスと見なす)
    517522            BOOL bThisIsSuperClass;
    518             if(pobj_CompilingClass->pobj_InheritsClass==0) bThisIsSuperClass=1;
    519             else if( pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod() == NULL ){
     523            if(Smoothie::Temp::pCompilingClass->pobj_InheritsClass==0) bThisIsSuperClass=1;
     524            else if( Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod() == NULL ){
    520525                //インターフェイスを継承したときはコンストラクタを持たない
    521526                bThisIsSuperClass=1;
     
    536541                    temporary[i4]=basbuf[i3];
    537542                }
    538                 if( pobj_CompilingClass->pobj_InheritsClass->GetName() == temporary ){
     543                if( Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetName() == temporary ){
    539544                    //基底クラスのコンストラクタを呼び出す
    540545                    cp=i3;
     
    553558                    Type dummyType;
    554559                    CallProc( PROC_DEFAULT
    555                         , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc
    556                         , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc->GetName().c_str()
     560                        , Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc
     561                        , Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc->GetName().c_str()
    557562                        , temporary
    558563                        , dummyType );
     
    561566                    //基底クラスのコンストラクタを暗黙的に呼び出す
    562567                    Opcode_CallProc("",
    563                         pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
     568                        Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
    564569                        0,
    565570                        "",
     
    569574
    570575            //仮想関数テーブルを初期化
    571             if( pobj_CompilingClass->IsExistVirtualFunctions()
    572                 && !pobj_CompilingClass->IsAbstract() ){
     576            if( Smoothie::Temp::pCompilingClass->IsExistVirtualFunctions()
     577                && !Smoothie::Temp::pCompilingClass->IsAbstract() ){
    573578                    //関数テーブルに値をセット
    574                     int offset = (int)pobj_CompilingClass->GetVtblGlobalOffset();
     579                    int offset = (int)Smoothie::Temp::pCompilingClass->GetVtblGlobalOffset();
    575580
    576581                    //mov rax,offset
     
    591596
    592597            //デストラクタのコンパイル開始を通知
    593             pobj_CompilingClass->NotifyStartDestructorCompile();
     598            Smoothie::Temp::pCompilingClass->NotifyStartDestructorCompile();
    594599        }
    595600    }
     
    617622    //////////////////////////////////////////
    618623
    619     if( pobj_CompilingClass ){
    620 
    621         if( pobj_CompilingClass->IsCompilingConstructor() ){
     624    if( Smoothie::Temp::pCompilingClass ){
     625
     626        if( Smoothie::Temp::pCompilingClass->IsCompilingConstructor() ){
    622627            // コンストラクタをコンパイルしていたとき
    623628
    624629            // コンストラクタのコンパイルが完了したことを通知
    625             pobj_CompilingClass->NotifyFinishConstructorCompile();
     630            Smoothie::Temp::pCompilingClass->NotifyFinishConstructorCompile();
    626631        }
    627632        else if( pUserProc->IsDestructor() ){
     
    631636
    632637            // デストラクタのコンパイルが完了したことを通知
    633             pobj_CompilingClass->NotifyFinishDestructorCompile();
    634 
    635             if(pobj_CompilingClass->pobj_InheritsClass){
     638            Smoothie::Temp::pCompilingClass->NotifyFinishDestructorCompile();
     639
     640            if(Smoothie::Temp::pCompilingClass->pobj_InheritsClass){
    636641                /* サブクラスのデストラクタをコンパイルしているときは、
    637642                    基底クラスのデストラクタを呼び出す */
    638643
    639                 const CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
     644                const CMethod *method = Smoothie::Temp::pCompilingClass->pobj_InheritsClass->GetDestructorMethod();
    640645                if( method ){
    641646                    Opcode_CallProc("",
     
    677682
    678683    //ローカルオブジェクト(レキシカルスコープレベル=0)の解放処理
    679     obj_LexScopes.CallDestructorsOfScopeEnd();
     684    GetLexicalScopes().CallDestructorsOfScopeEnd();
    680685
    681686    //プロシージャ抜け出しスケジュール(Exit Sub/Function)
     
    738743    }
    739744    HeapDefaultFree(pLocalVarAddrSchedule);
    740     foreach( Variable *pVar, pUserProc->localVars ){
     745    BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    741746        //後にデバッグで利用する
    742747        pVar->offset = AllLocalVarSize + pobj_sf->GetFrameSize() - pVar->offset;
  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r135 r183  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
     3#include <LexicalScopingImpl.h>
     4#include <Compiler.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27#include "Opcode.h"
     
    131136    if(resultType.IsDouble()){
    132137        double dbl=0;
    133         offset=dataTable.Add( dbl );
     138        offset=Compiler::GetNativeCode().GetDataTable().Add( dbl );
    134139
    135140        //comisd xmm0,qword ptr[data table offset]
     
    145150    else if(resultType.IsSingle()){
    146151        float flt=0;
    147         offset=dataTable.Add( flt );
     152        offset=Compiler::GetNativeCode().GetDataTable().Add( flt );
    148153
    149154        //comiss xmm0,dword ptr[data table offset]
     
    195200
    196201    //レキシカルスコープをレベルアップ
    197     obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
     202    GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
    198203
    199204    i2=CompileBuffer(ESC_ENDIF,0);
    200205
    201206    //レキシカルスコープをレベルダウン
    202     obj_LexScopes.End();
     207    GetLexicalScopes().End();
    203208
    204209
     
    218223
    219224        //レキシカルスコープをレベルアップ
    220         obj_LexScopes.Start( obp, SCOPE_TYPE_IF );
     225        GetLexicalScopes().Start( obp, SCOPE_TYPE_IF );
    221226
    222227        CompileBuffer(ESC_ENDIF,0);
    223228
    224229        //レキシカルスコープをレベルダウン
    225         obj_LexScopes.End();
     230        GetLexicalScopes().End();
    226231
    227232
     
    320325
    321326    //レキシカルスコープをレベルアップ
    322     obj_LexScopes.Start( obp, SCOPE_TYPE_WHILE );
     327    GetLexicalScopes().Start( obp, SCOPE_TYPE_WHILE );
    323328
    324329    //While内をコンパイル
    325330    CompileBuffer(0,COM_WEND);
    326331
    327     obj_LexScopes.CallDestructorsOfScopeEnd();
     332    GetLexicalScopes().CallDestructorsOfScopeEnd();
    328333
    329334    //jmp ...
     
    335340
    336341    //レキシカルスコープをレベルダウン
    337     obj_LexScopes.End();
     342    GetLexicalScopes().End();
    338343
    339344    *((long *)(OpBuffer+je_schedule-sizeof(long)))=obp-je_schedule; //jeジャンプ先のオフセット値
     
    457462
    458463    //レキシカルスコープをレベルアップ
    459     obj_LexScopes.Start( obp, SCOPE_TYPE_FOR );
     464    GetLexicalScopes().Start( obp, SCOPE_TYPE_FOR );
    460465
    461466    //For内をコンパイル
    462467    CompileBuffer(0,COM_NEXT);
    463468
    464     obj_LexScopes.CallDestructorsOfScopeEnd();
     469    GetLexicalScopes().CallDestructorsOfScopeEnd();
    465470
    466471    if(szNextVariable[0]){
     
    480485
    481486    //レキシカルスコープをレベルダウン
    482     obj_LexScopes.End();
     487    GetLexicalScopes().End();
    483488
    484489    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jeジャンプ先のオフセット値
     
    504509
    505510    //レキシカルスコープをレベルアップ
    506     obj_LexScopes.Start( obp, SCOPE_TYPE_DO );
     511    GetLexicalScopes().Start( obp, SCOPE_TYPE_DO );
    507512
    508513    //Do内をコンパイル
    509514    CompileBuffer(0,COM_LOOP);
    510515
    511     obj_LexScopes.CallDestructorsOfScopeEnd();
     516    GetLexicalScopes().CallDestructorsOfScopeEnd();
    512517
    513518    extern char *basbuf;
     
    565570
    566571    //レキシカルスコープをレベルダウン
    567     obj_LexScopes.End();
     572    GetLexicalScopes().End();
    568573
    569574    *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jmpジャンプ先のオフセット値
     
    599604
    600605    //未解放のローカルオブジェクトのデストラクタを呼び出す
    601     obj_LexScopes.CallDestructorsOfReturn();
     606    GetLexicalScopes().CallDestructorsOfReturn();
    602607
    603608    //jmp ...(End Sub/Function)
     
    831836
    832837    //レキシカルスコープをレベルアップ
    833     obj_LexScopes.Start( obp, SCOPE_TYPE_SELECT );
     838    GetLexicalScopes().Start( obp, SCOPE_TYPE_SELECT );
    834839
    835840    //Select Case内をコンパイル
     
    848853
    849854    //レキシカルスコープをレベルダウン
    850     obj_LexScopes.End();
     855    GetLexicalScopes().End();
    851856
    852857    pCaseSchedule=temp_pCaseSchedule;
  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <LexicalScopingImpl.h>
     5#include <CodeGenerator.h>
     6#include <Compiler.h>
     7
    18#include "../BasicCompiler_Common/common.h"
    29#include "Opcode.h"
     
    216223
    217224    //アクセシビリティをチェック
    218     if(&objClass==pobj_CompilingClass){
     225    if(&objClass==Smoothie::Temp::pCompilingClass){
    219226        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    220227        if(pMember->IsNoneAccess()){
     
    388395    // 名前空間を分離
    389396    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    390     Smoothie::meta.namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
     397    Smoothie::GetMeta().namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
    391398
    392399    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
     
    446453
    447454
    448     if(pobj_CompilingClass){
     455    if(Smoothie::Temp::pCompilingClass){
    449456        //////////////////////
    450457        // クラスメンバの参照
     
    457464            pRelativeVar->dwKind=VAR_DIRECTMEM;
    458465
    459             resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     466            resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    460467            return true;
    461468        }
     
    470477
    471478            bool isFound = false;
    472             BOOST_FOREACH( CMember *pMember, pobj_CompilingClass->GetDynamicMembers() ){
     479            BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
    473480                if( pMember->GetName() == VarName ){
    474481                    isFound = true;
     
    481488        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
    482489        //(コンストラクタ、デストラクタ内を除く)
    483         const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
     490        const CMethod *pMethod = Smoothie::GetMeta().GetClasses().GetNowCompilingMethodInfo();
    484491        if( isWriteAccess &&
    485492            pMethod->IsConst() &&
    486             pobj_CompilingClass->IsCompilingConstructor() == false &&
    487             pobj_CompilingClass->IsCompilingDestructor() == false
     493            Smoothie::Temp::pCompilingClass->IsCompilingConstructor() == false &&
     494            Smoothie::Temp::pCompilingClass->IsCompilingDestructor() == false
    488495            ){
    489496                SetError(131, NULL, cp );
     
    497504            isErrorEnabled,
    498505            isWriteAccess,
    499             *pobj_CompilingClass,
     506            *Smoothie::Temp::pCompilingClass,
    500507            variable,
    501508            pRelativeVar,
     
    541548            }
    542549
    543             int typeDefIndex = Smoothie::meta.typeDefs.GetIndex( VarName );
     550            int typeDefIndex = Smoothie::GetMeta().typeDefs.GetIndex( VarName );
    544551            if( typeDefIndex != -1 ){
    545552                // TypeDef後の型名だったとき
    546                 lstrcpy( VarName, Smoothie::meta.typeDefs[typeDefIndex].GetBaseName().c_str() );
     553                lstrcpy( VarName, Smoothie::GetMeta().typeDefs[typeDefIndex].GetBaseName().c_str() );
    547554            }
    548555
     
    557564        }
    558565
    559         if(pobj_CompilingClass){
     566        if(Smoothie::Temp::pCompilingClass){
    560567            //自身のクラスから静的メンバを参照する場合
    561568            char temp2[VN_SIZE];
    562             sprintf(temp2,"%s.%s",pobj_CompilingClass->GetName().c_str(),VarName);
     569            sprintf(temp2,"%s.%s",Smoothie::Temp::pCompilingClass->GetName().c_str(),VarName);
    563570            pVar = globalVars.Find( temp2 );
    564571            if( pVar ){
     
    844851            char *temp;
    845852            temp=(char *)i64data;
    846             i2=dataTable.AddString( temp );
     853            i2=Compiler::GetNativeCode().GetDataTable().AddString( temp );
    847854            HeapDefaultFree(temp);
    848855
     
    9941001            char *temp;
    9951002            temp=(char *)i64data;
    996             i2=dataTable.AddString( temp );
     1003            i2=Compiler::GetNativeCode().GetDataTable().AddString( temp );
    9971004            HeapDefaultFree(temp);
    9981005
     
    10861093
    10871094        //レキシカルスコープ
    1088         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1089         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1095        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     1096        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    10901097        pVar->bLiving=TRUE;
    10911098
     
    11211128
    11221129        //レキシカルスコープ
    1123         pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1124         pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1130        pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     1131        pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    11251132        pVar->bLiving=TRUE;
    11261133
  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r169 r183  
    11#include <jenga/include/common/Environment.h>
     2
     3#include <jenga/include/smoothie/Smoothie.h>
     4
     5#include <LexicalScopingImpl.h>
     6#include <ClassImpl.h>
     7#include <Compiler.h>
    28
    39#include "../BasicCompiler_Common/common.h"
     
    119125    //////////////////
    120126    // データテーブル
    121     dataTable.Init();
     127    Compiler::GetNativeCode().GetDataTable().Init();
    122128    if(bDebugCompile){
    123         dataTable.Add( (long)0x00000002 );
     129        Compiler::GetNativeCode().GetDataTable().Add( (long)0x00000002 );
    124130    }
    125131
     
    145151
    146152    //関数ポインタ情報を初期化
    147     Smoothie::meta.procPointers.clear();
     153    Smoothie::GetMeta().GetProcPointers().clear();
    148154
    149155    // 名前空間情報を取得
    150156    NamespaceScopesCollection::CollectNamespaces(
    151157        Smoothie::Lexical::source.GetBuffer(),
    152         Smoothie::meta.namespaceScopesCollection
     158        Smoothie::GetMeta().namespaceScopesCollection
    153159    );
    154160
     
    156162    //   GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。
    157163    //     ※オブジェクトの内容までは取得しない
    158     pobj_DBClass=new Classes();
    159     pobj_DBClass->InitNames();
     164    Smoothie::GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
    160165
    161166    //TypeDef情報を初期化
    162     Smoothie::meta.typeDefs.Init();
     167    Smoothie::GetMeta().typeDefs.Init();
    163168
    164169    //定数情報を取得
     
    166171
    167172    //サブルーチン(ユーザー定義、DLL関数)の識別子、アドレスを取得
    168     pobj_CompilingClass=0;
     173    Smoothie::Temp::pCompilingClass = NULL;
    169174    GetSubInfo();
    170175
    171176    //クラス情報を取得(※注 - GetSubInfoの後に呼び出す)
    172     pobj_DBClass->GetAllClassInfo();
     177    Smoothie::GetMeta().GetClasses().GetAllClassInfo();
    173178
    174179    //コードと行番号の関係
     
    280285
    281286    obp_AllocSize=8192*2;
    282     OpBuffer=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,obp_AllocSize);
     287    OpBuffer=(char *)calloc(obp_AllocSize,1);
    283288    obp=0;
    284289
     
    287292
    288293    //レキシカルスコープ情報を初期化
    289     obj_LexScopes.Init(obp);
     294    GetLexicalScopes().Init(obp);
    290295
    291296
     
    311316    if(!bDll){
    312317        // 名前空間が初期化されているかをチェック
    313         if( Smoothie::Lexical::liveingNamespaceScopes.size() ){
     318        if( Smoothie::Temp::liveingNamespaceScopes.size() ){
    314319            SetError();
    315320        }
     
    362367
    363368        //クラスに属する静的メンバを定義
    364         CMember::InitStaticMember();
     369        Smoothie::GetMeta().GetClasses().InitStaticMember();
    365370
    366371        //グローバル実行領域をコンパイル開始
     
    426431
    427432        // 名前空間が正しく閉じられているかをチェック
    428         if( Smoothie::Lexical::liveingNamespaceScopes.size() ){
     433        if( Smoothie::Temp::liveingNamespaceScopes.size() ){
    429434            SetError(63,NULL,-1);
    430435        }
     
    793798    //(デバッグ情報で利用される)
    794799    extern int AllInitGlobalVarSize;
    795     foreach( Variable *pVar, globalVars ){
     800    BOOST_FOREACH( Variable *pVar, globalVars ){
    796801        if(pVar->offset&0x80000000){
    797802            pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
     
    876881
    877882    //データセクションのファイル上のサイズ
    878     if(dataTable.GetSize()%FILE_ALIGNMENT) FileSize_DataSection=dataTable.GetSize()+(FILE_ALIGNMENT-dataTable.GetSize()%FILE_ALIGNMENT);
    879     else FileSize_DataSection=dataTable.GetSize();
     883    if(Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT) FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize()+(FILE_ALIGNMENT-Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT);
     884    else FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize();
    880885    if(FileSize_DataSection) bUse_DataSection=1;
    881886    else bUse_DataSection=0;
     
    10661071    ////////////////////////////////////////
    10671072    //仮想関数データテーブルスケジュール
    1068     pobj_DBClass->ActionVtblSchedule(ImageBase,MemPos_CodeSection);
     1073    Smoothie::GetMeta().GetClasses().ActionVtblSchedule(ImageBase,MemPos_CodeSection);
    10691074
    10701075
     
    16021607    if(bUse_DataSection){
    16031608        //データ テーブル
    1604         WriteFile(hFile,dataTable.GetPtr(),dataTable.GetSize(),(DWORD *)&i2,NULL);
     1609        WriteFile(hFile,Compiler::GetNativeCode().GetDataTable().GetPtr(),Compiler::GetNativeCode().GetDataTable().GetSize(),(DWORD *)&i2,NULL);
    16051610        i+=i2;
    16061611    }
     
    16981703
    16991704    //コードバッファを解放
    1700     HeapDefaultFree(OpBuffer);
     1705    free(OpBuffer);
    17011706    OpBuffer=0;
    17021707
     
    17141719
    17151720    //クラスに関するメモリを解放
    1716     delete pobj_DBClass;
    1717     pobj_DBClass=0;
     1721    Smoothie::GetMeta().GetClasses().Clear();
    17181722}
  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r159 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <Compiler.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27#include "Opcode.h"
     
    1823        SetStringQuotes( parameter );
    1924
    20         Operator_New( *pobj_DBClass->GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *pobj_DBClass->GetStringClassPtr() ) );
     25        Operator_New( *Smoothie::GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *Smoothie::GetMeta().GetClasses().GetStringClassPtr() ) );
    2126
    2227        free( parameter );
     
    241246    char member[VN_SIZE];
    242247    CClass::RefType refType;
    243     if( SplitMemberName( termFull, termLeft, member, refType ) ){
     248    if( CClass::SplitName( termFull, termLeft, member, refType ) ){
    244249        ///////////////////////////////////////////////////////////////////
    245250        // オブジェクトとメンバに分解できるとき
     
    253258        Type leftType;
    254259        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
    255             if( isClassName == false && Smoothie::meta.blittableTypes.IsExist( leftType ) ){
     260            if( isClassName == false && Smoothie::GetMeta().blittableTypes.IsExist( leftType ) ){
    256261                // 左側のオブジェクト部分がBlittable型のとき
    257262
     
    259264                lstrcpy( temporary, termLeft );
    260265                sprintf( termLeft, "%s(%s)",
    261                     Smoothie::meta.blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
     266                    Smoothie::GetMeta().blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
    262267                    temporary );
    263268            }
     
    287292
    288293    if( pIsClassName ){
    289         if( pobj_DBClass->Find( termFull ) ){
     294        if( Smoothie::GetMeta().GetClasses().Find( termFull ) ){
    290295            *pIsClassName = true;
    291296            return true;
     
    304309    if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
    305310        //Thisオブジェクト
    306         resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     311        resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    307312
    308313        SetThisPtrToReg( UseReg );
     
    588593        }
    589594
    590         i2 = dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
     595        i2 = Compiler::GetNativeCode().GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
    591596
    592597        //mov reg,i2
     
    768773
    769774                        type_stack[sp]=DEF_OBJECT;
    770                         index_stack[sp]=(LONG_PTR)pobj_DBClass->GetStringClassPtr();
     775                        index_stack[sp]=(LONG_PTR)Smoothie::GetMeta().GetClasses().GetStringClassPtr();
    771776                        bLiteralCalculation=0;
    772777
     
    781786                    bLiteralCalculation=0;
    782787
    783                     i2 = dataTable.AddString( term, i3 );
     788                    i2 = Compiler::GetNativeCode().GetDataTable().AddString( term, i3 );
    784789
    785790                    //mov reg,i2
     
    877882                        }
    878883                        else{
    879                             index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClassPtr();
     884                            index_stack[sp] = (LONG_PTR)Smoothie::GetMeta().GetClasses().GetObjectClassPtr();
    880885                        }
    881886
     
    966971                        }
    967972                        else{
    968                             i3 = dataTable.Add( i64data );
     973                            i3 = Compiler::GetNativeCode().GetDataTable().Add( i64data );
    969974
    970975                            //movlpd xmm_reg,qword ptr[data table offset]
     
    9951000                        }
    9961001                        else{
    997                             i3=dataTable.Add( i32data );
     1002                            i3=Compiler::GetNativeCode().GetDataTable().Add( i32data );
    9981003
    9991004                            //movss xmm_reg,dword ptr[data table offset]
     
    11341139
    11351140            if(resultType.IsDouble()){
    1136                 i3 = dataTable.Add( i64data );
     1141                i3 = Compiler::GetNativeCode().GetDataTable().Add( i64data );
    11371142
    11381143                //movlpd xmm_reg,qword ptr[data table offset]
     
    11541159                memcpy(&i32data,&flt,sizeof(long));
    11551160
    1156                 i3 = dataTable.Add( i32data );
     1161                i3 = Compiler::GetNativeCode().GetDataTable().Add( i32data );
    11571162
    11581163                //movss xmm_reg,dword ptr[data table offset]
  • trunk/abdev/BasicCompiler64/NumOpe_Arithmetic.cpp

    r75 r183  
     1#include <Compiler.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    452454        double dbl;
    453455        dbl=-1;
    454         i32data = dataTable.Add( dbl );
     456        i32data = Compiler::GetNativeCode().GetDataTable().Add( dbl );
    455457
    456458        //mulsd xmm_reg,qword ptr[data table offset]   ※data = -1
     
    474476        float flt;
    475477        flt=-1;
    476         i32data = dataTable.Add( flt );
     478        i32data = Compiler::GetNativeCode().GetDataTable().Add( flt );
    477479
    478480        //mulss xmm_reg,dword ptr[data table offset]   ※data = -1
  • trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp

    r56 r183  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <Compiler.h>
     4
    15#include "../BasicCompiler_Common/common.h"
    26#include "Opcode.h"
     
    1014        //and reg,00000000FFFFFFFFh
    1115    }
    12     else if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     16    else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    1317        //movsx reg64,reg16
    1418        op_movsx64_FromReg16(reg,reg);
     
    1822        op_and64_value(reg,(int)0xFFFF);
    1923    }
    20     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     24    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    2125        //movsx reg64,reg8
    2226        op_movsx64_FromReg8(reg,reg);
     
    2832}
    2933void ExtendTypeTo32(int type,int reg){
    30     if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     34    if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    3135        //movsx reg32,reg16
    3236        op_movsx32_FromReg16(reg,reg);
     
    3640        op_and32_value(reg,(int)0xFFFF);
    3741    }
    38     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     42    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    3943        //movsx reg32,reg8
    4044        op_movsx32_FromReg8(reg,reg);
     
    4650}
    4751void ExtendTypeTo16(int type,int reg){
    48     if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     52    if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    4953        //movsx reg16,reg8
    5054        op_movsx16_FromReg8(reg,reg);
     
    8589            int temp;
    8690            _int64 i64data=0x43f0000000000000;
    87             temp=dataTable.Add( i64data );
     91            temp=Compiler::GetNativeCode().GetDataTable().Add( i64data );
    8892            OpBuffer[obp++]=(char)0xF2;
    8993            OpBuffer[obp++]=(char)0x0F;
     
    144148            int temp;
    145149            long i32data=0x5f800000;
    146             temp=dataTable.Add( i32data );
     150            temp=Compiler::GetNativeCode().GetDataTable().Add( i32data );
    147151            OpBuffer[obp++]=(char)0xF3;
    148152            OpBuffer[obp++]=(char)0x0F;
Note: See TracChangeset for help on using the changeset viewer.