Changeset 206 in dev


Ignore:
Timestamp:
Jul 12, 2007, 2:58:26 AM (17 years ago)
Author:
dai_9181
Message:

コード全体のリファクタリングを実施

Location:
trunk/abdev
Files:
13 added
3 deleted
96 edited
6 moved

Legend:

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

    r195 r206  
    5353                BasicRuntimeChecks="3"
    5454                RuntimeLibrary="1"
     55                UsePrecompiledHeader="2"
    5556                PrecompiledHeaderFile=".\Debug/BasicCompiler.pch"
    5657                AssemblerListingLocation=".\Debug/"
    5758                ObjectFile=".\Debug/"
    5859                ProgramDataBaseFileName=".\Debug/"
    59                 BrowseInformation="1"
     60                BrowseInformation="0"
    6061                WarningLevel="3"
    6162                SuppressStartupBanner="true"
     
    155156                EnableFunctionLevelLinking="true"
    156157                RuntimeTypeInfo="true"
     158                UsePrecompiledHeader="2"
    157159                PrecompiledHeaderFile=".\Release/BasicCompiler.pch"
    158160                AssemblerListingLocation=".\Release/"
     
    242244                </FileConfiguration>
    243245            </File>
     246            <File
     247                RelativePath=".\stdafx.cpp"
     248                >
     249                <FileConfiguration
     250                    Name="Debug|Win32"
     251                    >
     252                    <Tool
     253                        Name="VCCLCompilerTool"
     254                        UsePrecompiledHeader="1"
     255                    />
     256                </FileConfiguration>
     257                <FileConfiguration
     258                    Name="Release|Win32"
     259                    >
     260                    <Tool
     261                        Name="VCCLCompilerTool"
     262                        UsePrecompiledHeader="1"
     263                    />
     264                </FileConfiguration>
     265            </File>
    244266            <Filter
    245267                Name="32及び64共通"
     
    776798                    <File
    777799                        RelativePath="..\BasicCompiler_Common\PESchedule.h"
    778                         >
    779                     </File>
    780                 </Filter>
    781                 <Filter
    782                     Name="Constant"
    783                     >
    784                     <File
    785                         RelativePath="..\BasicCompiler_Common\Const.cpp"
    786                         >
    787                         <FileConfiguration
    788                             Name="Debug|Win32"
    789                             >
    790                             <Tool
    791                                 Name="VCCLCompilerTool"
    792                                 PreprocessorDefinitions=""
    793                             />
    794                         </FileConfiguration>
    795                         <FileConfiguration
    796                             Name="Release|Win32"
    797                             >
    798                             <Tool
    799                                 Name="VCCLCompilerTool"
    800                                 PreprocessorDefinitions=""
    801                             />
    802                         </FileConfiguration>
    803                     </File>
    804                     <File
    805                         RelativePath="..\BasicCompiler_Common\Const.h"
    806800                        >
    807801                    </File>
     
    12521246                >
    12531247                <File
    1254                     RelativePath="..\BasicCompiler_Common\src\ClassImpl.cpp"
     1248                    RelativePath="..\BasicCompiler_Common\src\Class.cpp"
    12551249                    >
    12561250                </File>
     
    12641258                </File>
    12651259                <File
     1260                    RelativePath="..\BasicCompiler_Common\src\Const.cpp"
     1261                    >
     1262                </File>
     1263                <File
    12661264                    RelativePath="..\BasicCompiler_Common\src\DataTable.cpp"
    12671265                    >
     
    12761274                </File>
    12771275                <File
     1276                    RelativePath="..\BasicCompiler_Common\src\Method.cpp"
     1277                    >
     1278                </File>
     1279                <File
    12781280                    RelativePath="..\BasicCompiler_Common\src\NamespaceSupporter.cpp"
    12791281                    >
    12801282                </File>
    12811283                <File
    1282                     RelativePath="..\BasicCompiler_Common\src\ProcedureImpl.cpp"
     1284                    RelativePath="..\BasicCompiler_Common\src\Procedure.cpp"
    12831285                    >
    12841286                </File>
     
    12921294                </File>
    12931295                <File
     1296                    RelativePath="..\BasicCompiler_Common\src\Symbol.cpp"
     1297                    >
     1298                </File>
     1299                <File
     1300                    RelativePath="..\BasicCompiler_Common\src\Type.cpp"
     1301                    >
     1302                </File>
     1303                <File
    12941304                    RelativePath="..\BasicCompiler_Common\src\TypeDef.cpp"
    12951305                    >
    12961306                </File>
    12971307                <File
    1298                     RelativePath="..\BasicCompiler_Common\src\VariableImpl.cpp"
     1308                    RelativePath="..\BasicCompiler_Common\src\Variable.cpp"
    12991309                    >
    13001310                </File>
     
    13101320            </File>
    13111321            <File
    1312                 RelativePath="..\BasicCompiler_Common\BasicFixed.h"
    1313                 >
    1314             </File>
    1315             <File
    13161322                RelativePath="CommandValue.h"
    13171323                >
     
    13271333            <File
    13281334                RelativePath="..\BasicCompiler_Common\include\option.h"
     1335                >
     1336            </File>
     1337            <File
     1338                RelativePath=".\stdafx.h"
    13291339                >
    13301340            </File>
     
    13531363                >
    13541364                <File
    1355                     RelativePath="..\BasicCompiler_Common\include\ClassImpl.h"
     1365                    RelativePath="..\BasicCompiler_Common\include\Class.h"
    13561366                    >
    13571367                </File>
     
    13651375                </File>
    13661376                <File
     1377                    RelativePath="..\BasicCompiler_Common\include\Const.h"
     1378                    >
     1379                </File>
     1380                <File
    13671381                    RelativePath="..\BasicCompiler_Common\include\DataTable.h"
    13681382                    >
     
    13771391                </File>
    13781392                <File
     1393                    RelativePath="..\BasicCompiler_Common\include\Member.h"
     1394                    >
     1395                </File>
     1396                <File
    13791397                    RelativePath="..\BasicCompiler_Common\include\MetaImpl.h"
    13801398                    >
    13811399                </File>
    13821400                <File
     1401                    RelativePath="..\BasicCompiler_Common\include\Method.h"
     1402                    >
     1403                </File>
     1404                <File
    13831405                    RelativePath="..\BasicCompiler_Common\include\NamespaceSupporter.h"
    13841406                    >
    13851407                </File>
    13861408                <File
    1387                     RelativePath="..\BasicCompiler_Common\include\ProcedureImpl.h"
     1409                    RelativePath="..\BasicCompiler_Common\include\Parameter.h"
     1410                    >
     1411                </File>
     1412                <File
     1413                    RelativePath="..\BasicCompiler_Common\include\Procedure.h"
    13881414                    >
    13891415                </File>
     
    13931419                </File>
    13941420                <File
     1421                    RelativePath="..\BasicCompiler_Common\include\Prototype.h"
     1422                    >
     1423                </File>
     1424                <File
    13951425                    RelativePath="..\BasicCompiler_Common\include\SmoothieImpl.h"
    13961426                    >
    13971427                </File>
    13981428                <File
     1429                    RelativePath="..\BasicCompiler_Common\include\Symbol.h"
     1430                    >
     1431                </File>
     1432                <File
     1433                    RelativePath="..\BasicCompiler_Common\include\Type.h"
     1434                    >
     1435                </File>
     1436                <File
    13991437                    RelativePath="..\BasicCompiler_Common\include\TypeDef.h"
    14001438                    >
    14011439                </File>
    14021440                <File
    1403                     RelativePath="..\BasicCompiler_Common\include\VariableImpl.h"
     1441                    RelativePath="..\BasicCompiler_Common\include\Variable.h"
    14041442                    >
    14051443                </File>
  • trunk/abdev/BasicCompiler32/CParameter.cpp

    r76 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
     
    108110
    109111                //call free
    110                 extern UserProc *pSub_free;
     112                extern const UserProc *pSub_free;
    111113                op_call(pSub_free);
    112114            }
     
    135137
    136138    //call calloc
    137     extern UserProc *pSub_calloc;
     139    extern const UserProc *pSub_calloc;
    138140    op_call(pSub_calloc);
    139141
  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    481483            }
    482484            else{
    483                 if(GetConstHash(variable)){
     485                if( compiler.GetMeta().GetGlobalConsts().IsExist(variable)
     486                    || compiler.GetMeta().GetGlobalConstMacros().IsExist(variable) )
     487                {
    484488                    //定数リストに該当したとき
    485489                    SetError(1,NULL,cp);
     
    626630    if( varType.IsObject() && compiler.GetMeta().GetBlittableTypes().IsExist( calcType ) ){
    627631        // Blittable型をオブジェクトとして扱う
    628         vector<UserProc *> userProcs;
     632        vector<const UserProc *> userProcs;
    629633        compiler.GetMeta().GetBlittableTypes().GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
    630634        if( userProcs.size() != 1 ){
     
    632636            return;
    633637        }
    634         UserProc *pUserProc = userProcs[0];
     638        const UserProc *pUserProc = userProcs[0];
    635639
    636640        // call System.[TypeClass]._Create
  • trunk/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp

    r97 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    1214void Call_DebugSys_SaveContext(){
    1315    //call _System_GetEip
    14     extern UserProc *pSub_System_GetEip;
     16    extern const UserProc *pSub_System_GetEip;
    1517    op_call(pSub_System_GetEip);
    1618
     
    2224
    2325    //call _DebugSys_SaveContext
    24     extern UserProc *pSub_DebugSys_SaveContext;
     26    extern const UserProc *pSub_DebugSys_SaveContext;
    2527    op_call(pSub_DebugSys_SaveContext);
    2628}
     
    9597}
    9698
    97 bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
     99bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
    98100    int i2;
    99101
     
    123125            if(lstrcmpi(ObjectName,"Super")==0){
    124126                //クラスメンバ関数内から基底クラスの呼び出し
    125                 pobj_c=Smoothie::Temp::pCompilingClass;
     127                pobj_c=compiler.pCompilingClass;
    126128            }
    127129            else{
     
    148150            else{
    149151                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
    150                 pobj_c=Smoothie::Temp::pCompilingClass;
     152                pobj_c=compiler.pCompilingClass;
    151153            }
    152154        }
     
    177179        if(ObjectName[0]){
    178180            //外部からの呼び出し
    179             if(pobj_c==Smoothie::Temp::pCompilingClass){
     181            if(pobj_c==compiler.pCompilingClass){
    180182                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    181183                if( pMethod->IsNoneAccess() ){
     
    261263
    262264        //call calloc
    263         extern UserProc *pSub_calloc;
     265        extern const UserProc *pSub_calloc;
    264266        op_call(pSub_calloc);
    265267
  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    196198    }
    197199
    198     int SubScripts[MAX_ARRAYDIM];
     200    Subscripts subscripts;
    199201    RELATIVE_VAR RelativeVar;
    200     if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,SubScripts)) return;
     202    if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
    201203
    202204    if(type.GetBasicType()&FLAG_PTR){
     
    209211    int typeSize = type.GetSize();
    210212
    211     if(bArrayHead) typeSize*=JumpSubScripts(SubScripts);
     213    if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
    212214
    213215    //mov eax,TypeSize
     
    218220void Opcode_Func_AddressOf( const char *name ){
    219221    extern int cp;
    220     UserProc *pUserProc;
     222    const UserProc *pUserProc;
    221223
    222224    extern LONG_PTR ProcPtr_BaseIndex;
     
    224226        //左辺の型にのっとり、オーバーロードを解決
    225227
    226         std::vector<UserProc *> subs;
     228        std::vector<const UserProc *> subs;
    227229        GetOverloadSubHash( name, subs );
    228230        if( subs.size() == 0 ){
     
    284286            SetThisPtrToReg(REG_RCX);
    285287
    286             pobj_c=Smoothie::Temp::pCompilingClass;
     288            pobj_c=compiler.pCompilingClass;
    287289        }
    288290
  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r140 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
     
    3537    ////////////////////////
    3638
    37     std::vector<UserProc *> subs;
     39    std::vector<const UserProc *> subs;
    3840    pobj_c->GetMethods().Enum( pobj_c->GetName().c_str(), subs );
    3941
    40     UserProc *pUserProc;
     42    const UserProc *pUserProc;
    4143    if( subs.size() > 0 ){
    4244        //オーバーロードを解決
     
    161163
    162164        //call _System_GC_malloc_ForObject
    163         extern UserProc *pSub_System_GC_malloc_ForObject;
     165        extern const UserProc *pSub_System_GC_malloc_ForObject;
    164166        op_call(pSub_System_GC_malloc_ForObject);
    165167    }
     
    169171
    170172        //call _System_GC_malloc_ForObjectPtr
    171         extern UserProc *pSub_System_GC_malloc_ForObjectPtr;
     173        extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
    172174        op_call(pSub_System_GC_malloc_ForObjectPtr);
    173175    }
     
    213215    //mov ecx,DestructorProcAddr
    214216    OpBuffer[obp++]=(char)0xB9;
    215     pobj_SubAddrSchedule->add(method->pUserProc,0);
    216     method->pUserProc->Using();
     217    pobj_SubAddrSchedule->add(&method->GetUserProc(),0);
     218    method->GetUserProc().Using();
    217219    obp+=sizeof(long);
    218220
     
    351353    if( isSweeping ){
    352354        //call _System_GC_free_for_SweepingDelete
    353         extern UserProc *pSub_System_GC_free_for_SweepingDelete;
     355        extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
    354356        op_call(pSub_System_GC_free_for_SweepingDelete);
    355357    }
    356358    else{
    357359        //call free
    358         extern UserProc *pSub_free;
     360        extern const UserProc *pSub_free;
    359361        op_call(pSub_free);
    360362    }
  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r204 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    57#include <Compiler.h>
    68#include <LexicalScopingImpl.h>
    7 #include <ClassImpl.h>
    8 #include <VariableImpl.h>
     9#include <Class.h>
     10#include <Variable.h>
    911#include <NamespaceSupporter.h>
    1012
     
    3638        }
    3739
    38         UserProc *pBackUserProc;
     40        const UserProc *pBackUserProc;
    3941        pBackUserProc = &UserProc::CompilingUserProc();
    4042        UserProc::CompileStartForGlobalArea();
     
    5456
    5557        //_System_StartupProgramの呼び出し
    56         extern UserProc *pSub_System_StartupProgram;
     58        extern const UserProc *pSub_System_StartupProgram;
    5759        op_call(pSub_System_StartupProgram);
    5860
     
    7173        //静的ローカルオブジェクトのコンストラクタ呼び出し
    7274
    73         BOOST_FOREACH( Variable *pVar, globalVars ){
     75        BOOST_FOREACH( Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
    7476            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
    7577                //コンストラクタ呼び出し
    76                 if( pVar->IsObject() ){
     78                if( pVar->GetType().IsObject() ){
    7779
    7880                    //エラー用
     
    8183                    CallConstructor(
    8284                        pVar->GetName().c_str(),
    83                         pVar->GetSubScriptsPtr(),
    84                         *pVar,
    85                         pVar->paramStrForConstructor.c_str());
     85                        pVar->GetSubscripts(),
     86                        pVar->GetType(),
     87                        pVar->GetParamStrForConstructor().c_str());
    8688                }
    8789            }
     
    9395    else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){
    9496
    95         UserProc *pBackUserProc;
     97        const UserProc *pBackUserProc;
    9698        pBackUserProc = &UserProc::CompilingUserProc();
    9799        UserProc::CompileStartForGlobalArea();
     
    222224    }
    223225}
    224 void AutoGeneration(UserProc &userProc){
     226void AutoGeneration( const UserProc &userProc){
    225227    if( userProc.GetName() == "InitializeUserTypes"
    226228        && userProc.HasParentClass()
     
    240242}
    241243
    242 void _compile_proc(UserProc *pUserProc){
     244void _compile_proc(const UserProc *pUserProc){
    243245    extern char *basbuf;
    244246    extern HANDLE hHeap;
    245     extern GlobalProc **ppSubHash;
    246247    extern BOOL bDebugCompile;
    247248    int i3,i4,LocalVarSchedule,EspOffsetSchedule,BaseOffset;
     
    250251    if( pUserProc->IsUsing() == false || pUserProc->IsCompiled() ) return;
    251252
    252     if( pUserProc->localVars.size() ){
     253    if( pUserProc->GetLocalVars().size() ){
    253254        SetError();
    254255        return;
    255256    }
     257
     258    trace_for_sourcecodestep( "★★★ " << pUserProc->GetFullName() << "のコンパイルを開始" );
    256259
    257260    pUserProc->CompleteCompile();
     
    270273    else bDebugSupportProc=0;
    271274
    272     pUserProc->beginOpAddress=obp;
     275    pUserProc->SetBeginOpAddress( obp );
    273276
    274277    //コンパイル中の関数が属するクラス
    275     Smoothie::Temp::pCompilingClass=pUserProc->GetParentClassPtr();
     278    compiler.pCompilingClass=pUserProc->GetParentClassPtr();
    276279
    277280    //コンパイルスタートをクラス管理クラスに追加
     
    297300        SystemProc(*pUserProc);
    298301
    299         pUserProc->endOpAddress=obp;
     302        pUserProc->SetEndOpAddress( obp );
    300303        return;
    301304    }
     
    321324        Parameter &param = *pUserProc->RealParams()[i3];
    322325
    323         Variable *pVar = new VariableImpl( param.GetVarName(), param, false, param.IsRef() );
     326        Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef(), "" );
    324327
    325328        if( param.IsArray() ){
    326             pVar->SetArray( param.GetSubScriptsPtr() );
     329            pVar->SetArray( param.GetSubscripts() );
    327330        }
    328331
     
    342345        }
    343346        AllLocalVarSize+=varSize;
    344         pVar->offset=AllLocalVarSize;
     347        pVar->SetOffsetAddress( AllLocalVarSize );
    345348
    346349        //レキシカルスコープ情報
    347         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    348         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     350        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     351        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    349352        pVar->bLiving=TRUE;
    350353
    351         pUserProc->localVars.push_back( pVar );
     354        pUserProc->GetLocalVars().push_back( pVar );
    352355    }
    353356
     
    456459
    457460        //call _DebugSys_StartProc
    458         extern UserProc *pSub_DebugSys_StartProc;
     461        extern const UserProc *pSub_DebugSys_StartProc;
    459462        op_call(pSub_DebugSys_StartProc);
    460463    }
    461464
    462     if(Smoothie::Temp::pCompilingClass){
    463         if( pUserProc->GetName() == Smoothie::Temp::pCompilingClass->GetName() ){
     465    if(compiler.pCompilingClass){
     466        if( pUserProc->GetName() == compiler.pCompilingClass->GetName() ){
    464467            ////////////////////////////////////
    465468            // コンストラクタをコンパイルするとき
     
    467470
    468471            //コンストラクタのコンパイル開始を通知
    469             Smoothie::Temp::pCompilingClass->NotifyStartConstructorCompile();
     472            compiler.pCompilingClass->NotifyStartConstructorCompile();
    470473
    471474            //基底クラスかどうかの識別
    472475            //(継承元がインターフェイスの場合も基底クラスと見なす)
    473476            BOOL bThisIsSuperClass;
    474             if( !Smoothie::Temp::pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
    475             else if( Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
     477            if( !compiler.pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
     478            else if( compiler.pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
    476479                //インターフェイスを継承したときはコンストラクタを持たない
    477480                bThisIsSuperClass=1;
     
    492495                    temporary[i4]=basbuf[i3];
    493496                }
    494                 if( Smoothie::Temp::pCompilingClass->GetSuperClass().GetName() == temporary ){
     497                if( compiler.pCompilingClass->GetSuperClass().GetName() == temporary ){
    495498                    //基底クラスのコンストラクタを呼び出す
    496499                    cp=i3;
     
    509512                    Type dummyType;
    510513                    CallProc( PROC_DEFAULT
    511                         , Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc
    512                         , Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc->GetName().c_str()
     514                        , &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc()
     515                        , compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc().GetName().c_str()
    513516                        , temporary
    514517                        , dummyType );
     
    517520                    //基底クラスのコンストラクタを暗黙的に呼び出す
    518521                    Opcode_CallProc("",
    519                         Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc,
     522                        &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
    520523                        0,
    521524                        "",
     
    525528
    526529            //仮想関数テーブルを初期化
    527             if( Smoothie::Temp::pCompilingClass->IsExistVirtualFunctions()
    528                 && !Smoothie::Temp::pCompilingClass->IsAbstract() ){
     530            if( compiler.pCompilingClass->IsExistVirtualFunctions()
     531                && !compiler.pCompilingClass->IsAbstract() ){
    529532                    //関数テーブルに値をセット
    530                     int offset = (int)Smoothie::Temp::pCompilingClass->GetVtblGlobalOffset();
     533                    int offset = (int)compiler.pCompilingClass->GetVtblGlobalOffset();
    531534
    532535                    //mov eax,offset
     
    548551
    549552            //デストラクタのコンパイル開始を通知
    550             Smoothie::Temp::pCompilingClass->NotifyStartDestructorCompile();
     553            compiler.pCompilingClass->NotifyStartDestructorCompile();
    551554        }
    552555    }
     
    574577    //////////////////////////////////////////
    575578
    576     if( Smoothie::Temp::pCompilingClass ){
    577 
    578         if( Smoothie::Temp::pCompilingClass->IsCompilingConstructor() ){
     579    if( compiler.pCompilingClass ){
     580
     581        if( compiler.pCompilingClass->IsCompilingConstructor() ){
    579582            // コンストラクタをコンパイルしていたとき
    580583
    581584            // コンストラクタのコンパイルが完了したことを通知
    582             Smoothie::Temp::pCompilingClass->NotifyFinishConstructorCompile();
     585            compiler.pCompilingClass->NotifyFinishConstructorCompile();
    583586        }
    584587        else if( pUserProc->IsDestructor() ){
     
    588591
    589592            // デストラクタのコンパイルが完了したことを通知
    590             Smoothie::Temp::pCompilingClass->NotifyFinishDestructorCompile();
    591 
    592             if( Smoothie::Temp::pCompilingClass->HasSuperClass() ){
     593            compiler.pCompilingClass->NotifyFinishDestructorCompile();
     594
     595            if( compiler.pCompilingClass->HasSuperClass() ){
    593596                /* サブクラスのデストラクタをコンパイルしているときは、
    594597                    基底クラスのデストラクタを呼び出す */
    595598
    596                 const CMethod *method = Smoothie::Temp::pCompilingClass->GetSuperClass().GetDestructorMethod();
     599                const CMethod *method = compiler.pCompilingClass->GetSuperClass().GetDestructorMethod();
    597600                if( method ){
    598601                    Opcode_CallProc("",
    599                         method->pUserProc,
     602                        &method->GetUserProc(),
    600603                        0,
    601604                        "",
     
    649652
    650653        //call _DebugSys_EndProc
    651         extern UserProc *pSub_DebugSys_EndProc;
     654        extern const UserProc *pSub_DebugSys_EndProc;
    652655        op_call(pSub_DebugSys_EndProc);
    653656    }
     
    742745    }
    743746    HeapDefaultFree(pLocalVarAddrSchedule);
    744     BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
     747    BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
    745748        //後にデバッグで利用する
    746         pVar->offset = AllLocalVarSize - pVar->offset;
     749        pVar->SetOffsetAddress( AllLocalVarSize - pVar->GetOffsetAddress() );
    747750    }
    748751
     
    771774
    772775        //call _esp_error
    773         extern UserProc *pSub_esp_error;
     776        extern const UserProc *pSub_esp_error;
    774777        op_call( pSub_esp_error );
    775778
     
    799802
    800803
    801     pUserProc->endOpAddress=obp;
     804    pUserProc->SetEndOpAddress( obp );
    802805
    803806
     
    811814}
    812815
    813 void CompileBufferInProcedure( UserProc &userProc ){
     816void CompileBufferInProcedure( const UserProc &userProc ){
    814817    if( userProc.IsUsing() == false || userProc.IsCompiled() ) return;
    815818
     
    827830}
    828831void CompileLocal(){
    829     extern GlobalProc **ppSubHash;
    830     int i2;
    831 
    832832    extern BOOL bDll;
    833833    if(bDll){
    834834        //DLLの場合はグローバル変数を初期化するための関数を一番初めにコンパイルする
    835         UserProc *pUserProc=GetSubHash("_System_InitDllGlobalVariables");
     835        const UserProc *pUserProc=GetSubHash("_System_InitDllGlobalVariables");
    836836        if(pUserProc){
    837837            CompileBufferInProcedure( *pUserProc );
     
    841841
    842842    //_System_TypeBase_InitializeUserTypesは一番最後にコンパイル
    843     extern UserProc *pSubStaticMethod_System_TypeBase_InitializeUserTypes;
     843    extern const UserProc *pSubStaticMethod_System_TypeBase_InitializeUserTypes;
    844844    pSubStaticMethod_System_TypeBase_InitializeUserTypes->CompleteCompile();
    845845
    846846    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    847847    //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
    848     extern UserProc *pSub_System_InitStaticLocalVariables;
     848    extern const UserProc *pSub_System_InitStaticLocalVariables;
    849849    pSub_System_InitStaticLocalVariables->CompleteCompile();
    850850
    851851    //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
    852     extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
     852    extern const UserProc *pSub_System_Call_Destructor_of_GlobalObject;
    853853    pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile();
    854854
    855855repeat:
    856     GlobalProc *pGlobalProc;
    857     for(i2=0;i2<MAX_HASH;i2++){
    858         pGlobalProc=ppSubHash[i2];
    859         while(pGlobalProc){
    860             CompileBufferInProcedure( *pGlobalProc );
    861             pGlobalProc=pGlobalProc->pNextData;
    862         }
     856    compiler.GetMeta().GetUserProcs().Iterator_Reset();
     857    while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     858    {
     859        UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     860        CompileBufferInProcedure( *pUserProc );
    863861    }
    864862
     
    874872    if( IsNeedProcCompile() ){
    875873        //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合
    876         for(i2=0;i2<MAX_HASH;i2++){
    877             pGlobalProc=ppSubHash[i2];
    878             while(pGlobalProc){
    879                 CompileBufferInProcedure( *pGlobalProc );
    880                 pGlobalProc=pGlobalProc->pNextData;
    881             }
     874
     875        compiler.GetMeta().GetUserProcs().Iterator_Reset();
     876        while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     877        {
     878            UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     879            CompileBufferInProcedure( *pUserProc );
    882880        }
    883881    }
  • trunk/abdev/BasicCompiler32/Compile_Set_Var.cpp

    r183 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    4042
    4143                    //call free
    42                     extern UserProc *pSub_free;
     44                    extern const UserProc *pSub_free;
    4345                    op_call(pSub_free);
    4446                }
  • trunk/abdev/BasicCompiler32/Compile_Statement.cpp

    r183 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/LexicalAnalysis.h>
    24
     
    911void OpcodeOthers( const char *Command ){
    1012    int i,i2;
    11     UserProc *pUserProc;
    1213
    1314    char leftTerm[8192];
     
    5960        //////////////////////////////
    6061
    61         pUserProc=GetSubHash(Command);
     62        const UserProc *pUserProc = GetSubHash(Command);
    6263
    6364        //GetSubHash内でエラー提示が行われた場合
     
    10791080
    10801081                if(type1.IsObject()){
    1081                     std::vector<UserProc *> subs;
     1082                    std::vector<const UserProc *> subs;
    10821083                    type1.GetClass().GetMethods().Enum( CALC_EQUAL, subs );
    10831084                    if( subs.size() == 0 ){
     
    10891090
    10901091                    //オーバーロードを解決
    1091                     UserProc *pUserProc;
    1092                     pUserProc=OverloadSolution("==",subs, params, NULL);
     1092                    const UserProc *pUserProc = OverloadSolution("==",subs, params, NULL);
    10931093
    10941094                    delete params[0];
     
    13261326        //戻り値をセット
    13271327        if(Parameter[0]){
    1328             UserProc &proc = UserProc::CompilingUserProc();
     1328            const UserProc &proc = UserProc::CompilingUserProc();
    13291329
    13301330            const char *temp = "_System_ReturnValue";
  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    57#include <CodeGenerator.h>
    68#include <Compiler.h>
    7 #include <VariableImpl.h>
     9#include <Variable.h>
    810
    911#include "../BasicCompiler_Common/common.h"
     
    1113
    1214//変数
    13 Variables globalVars;
     15// TODO: xml未完成
    1416int AllGlobalVarSize;
    1517int AllInitGlobalVarSize;
     
    6466    }
    6567}
    66 bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){
     68bool GetArrayOffset(const Subscripts &subscripts,char *array, const Type &type){
    6769    extern HANDLE hHeap;
    6870    int i,i2,i3,i4;
     
    8385        }
    8486        if(array[i]==','||array[i]=='\0'){
    85             if(SubScripts[i3]==-1){
     87            if( i3 >= (int)subscripts.size() )
     88            {
    8689                for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    8790                return 0;
     
    9699
    97100            if(array[i]=='\0'){
    98                 if(SubScripts[i3]!=-1){
     101                if( i3 < (int)subscripts.size() )
     102                {
    99103                    for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    100104                    return 0;
     
    131135        op_pop(REG_EAX);
    132136
    133         for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;
     137        for(i2=i+1,i4=1;i2<i3;i2++) i4*=subscripts[i2]+1;
    134138
    135139        //imul eax,i4
     
    175179    char lpPtrOffset[VN_SIZE];  //第2次配列
    176180    char NestMember[VN_SIZE];   //入れ子メンバ
    177     CClass::RefType refType;
     181    ReferenceKind refType;
    178182    lstrcpy(VarName,member);
    179183    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
     
    195199
    196200    //アクセシビリティをチェック
    197     if(&objClass==Smoothie::Temp::pCompilingClass){
     201    if(&objClass==compiler.pCompilingClass){
    198202        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    199203        if(pMember->IsNoneAccess()){
     
    228232    //ポインタ変数の場合
    229233    if( resultType.IsPointer() ){
    230         if(pMember->SubScripts[0]==-1){
     234        if( pMember->GetSubscripts().size() == 0 ){
    231235            lstrcpy(lpPtrOffset,array);
    232236            array[0]=0;
     
    250254    if(array[0]){
    251255        //配列オフセット
    252         if(!GetArrayOffset(pMember->SubScripts,array,pMember->GetType())){
     256        if(!GetArrayOffset(pMember->GetSubscripts(),array,pMember->GetType())){
    253257            if(isErrorEnabled) SetError(14,member,cp);
    254258        }
    255259    }
    256     else if(pMember->SubScripts[0]!=-1){
     260    else if( pMember->GetSubscripts().size() > 0 ){
    257261        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    258262    }
     
    262266
    263267        if( resultType.IsObject() || resultType.IsStruct() ){
    264             if( refType != CClass::Dot ){
     268            if( refType != RefDot ){
    265269                if(isErrorEnabled) SetError(104,member,cp);
    266270                return false;
     
    278282                //pObj[n].member
    279283                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
    280                     && refType != CClass::Dot ){
     284                    && refType != RefDot ){
    281285                        if(isErrorEnabled) SetError(104,member,cp);
    282286                        return false;
     
    292296                //pObj->member
    293297                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
    294                     && refType != CClass::Pointer ){
     298                    && refType != RefPointer ){
    295299                        if(isErrorEnabled) SetError(104,member,cp);
    296300                        return false;
     
    306310            if(lpPtrOffset[0]){
    307311                //ppObj[n]->member
    308                 if( refType != CClass::Pointer ){
     312                if( refType != RefPointer ){
    309313                    if(isErrorEnabled) SetError(104,member,cp);
    310314                    return false;
     
    357361}
    358362
    359 bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){
     363bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts ){
    360364    char variable[VN_SIZE];
    361365
     
    371375
    372376    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
    373     CClass::RefType refType;
     377    ReferenceKind refType;
    374378    char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    375379    GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
     
    384388    }
    385389
    386     const int *pSubScripts;
     390    const Subscripts *pSubscripts;
    387391    bool bConst = false;
    388392
     
    393397        //////////////////
    394398
    395         const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( Symbol( VarName ) );
     399        const Variable *pVar = UserProc::CompilingUserProc().GetLocalVars().BackSearch( Symbol( VarName ) );
    396400        if( pVar ){
    397401            //ポインタ変数の場合
    398             if( pVar->IsPointer() ){
     402            if( pVar->GetType().IsPointer() ){
    399403                if( !pVar->IsArray() ){
    400404                    lstrcpy(lpPtrOffset,array);
     
    410414            }
    411415
    412             pRelativeVar->offset=-pVar->offset;
     416            pRelativeVar->offset=-pVar->GetOffsetAddress();
    413417            pRelativeVar->bOffsetOffset=0;
    414418            if( pVar->IsRef() ){
     
    417421            }
    418422            else pRelativeVar->dwKind=VAR_LOCAL;
    419             resultType = *pVar;
    420             pSubScripts=pVar->GetSubScriptsPtr();
     423            resultType = pVar->GetType();
     424            pSubscripts = &pVar->GetSubscripts();
    421425            bConst = pVar->IsConst();
    422426
     
    425429    }
    426430
    427     if(Smoothie::Temp::pCompilingClass){
     431    if(compiler.pCompilingClass){
    428432        //////////////////////
    429433        // クラスメンバの参照
     
    438442            pRelativeVar->dwKind=VAR_DIRECTMEM;
    439443
    440             resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
     444            resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
    441445            return true;
    442446        }
     
    451455
    452456            bool isFound = false;
    453             BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
     457            BOOST_FOREACH( CMember *pMember, compiler.pCompilingClass->GetDynamicMembers() ){
    454458                if( pMember->GetName() == VarName ){
    455459                    isFound = true;
     
    465469        if( isWriteAccess &&
    466470            pMethod->IsConst() &&
    467             Smoothie::Temp::pCompilingClass->IsCompilingConstructor() == false &&
    468             Smoothie::Temp::pCompilingClass->IsCompilingDestructor() == false
     471            compiler.pCompilingClass->IsCompilingConstructor() == false &&
     472            compiler.pCompilingClass->IsCompilingDestructor() == false
    469473            ){
    470474                SetError(131, NULL, cp );
     
    481485            isErrorEnabled,
    482486            isWriteAccess,
    483             *Smoothie::Temp::pCompilingClass,
     487            *compiler.pCompilingClass,
    484488            variable,
    485489            pRelativeVar,
     
    502506            GetNowStaticVarFullName(VarName,temporary);
    503507
    504             pVar = globalVars.Find( Symbol( temporary ) );
     508            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temporary ) );
    505509            if( pVar ){
    506510                goto GlobalOk;
     
    521525            char tempArray[VN_SIZE];
    522526            {
    523                 CClass::RefType refType;
     527                ReferenceKind refType;
    524528                GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
    525529            }
     
    533537            char temp2[VN_SIZE];
    534538            sprintf(temp2,"%s.%s",VarName,temporary);
    535             pVar = globalVars.Find( Symbol( temp2 ) );
     539            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temp2 ) );
    536540            if( pVar ){
    537541                lstrcpy(member,tempMember);
     
    541545        }
    542546
    543         if(Smoothie::Temp::pCompilingClass){
     547        if(compiler.pCompilingClass){
    544548            //自身のクラスから静的メンバを参照する場合
    545549            char temp2[VN_SIZE];
    546             sprintf(temp2,"%s.%s",Smoothie::Temp::pCompilingClass->GetName().c_str(),VarName);
    547             pVar = globalVars.Find( Symbol( temp2 ) );
     550            sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
     551            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temp2 ) );
    548552            if( pVar ){
    549553                goto GlobalOk;
     
    555559        /////////////////////
    556560
    557         pVar = globalVars.BackSearch( Symbol( VarName ) );
     561        pVar = compiler.GetMeta().GetGlobalVars().BackSearch( Symbol( VarName ) );
    558562        if( pVar ){
    559563            goto GlobalOk;
     
    568572GlobalOk:
    569573        //ポインタ変数の場合
    570         if( pVar->IsPointer() ){
     574        if( pVar->GetType().IsPointer() ){
    571575            if( !pVar->IsArray() ){
    572576                lstrcpy(lpPtrOffset,array);
     
    582586        }
    583587
    584         pRelativeVar->offset=pVar->offset;
     588        pRelativeVar->offset=pVar->GetOffsetAddress();
    585589        pRelativeVar->bOffsetOffset=0;
    586590        if( pVar->IsRef() ){
     
    589593        }
    590594        else pRelativeVar->dwKind=VAR_GLOBAL;
    591         resultType = *pVar;
    592         pSubScripts=pVar->GetSubScriptsPtr();
     595        resultType = pVar->GetType();
     596        pSubscripts=&pVar->GetSubscripts();
    593597        bConst = pVar->IsConst();
    594598    }
     
    610614    }
    611615
    612     if(array[0]==0&&pSubScripts[0]!=-1){
     616    if( array[0] == 0 && pSubscripts->size() > 0 ){
    613617        //配列の先頭ポインタを示す場合
    614618        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    615         if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
     619
     620        if( pResultSubscripts )
     621        {
     622            (*pResultSubscripts) = *pSubscripts;
     623        }
    616624        return true;
    617625    }
     
    625633    }
    626634    if(array[0]){
    627         if(!GetArrayOffset(pSubScripts,array,resultType)){
     635        if(!GetArrayOffset(*pSubscripts,array,resultType)){
    628636            SetError(14,variable,cp);
    629637            pRelativeVar->dwKind=NON_VAR;
     
    634642        if( resultType.IsObject() || resultType.IsStruct() ){
    635643            //実態オブジェクトのメンバを参照(obj.member)
    636             if( refType != CClass::Dot ){
     644            if( refType != RefDot ){
    637645                SetError(104,VarName,cp);
    638646                pRelativeVar->dwKind=NON_VAR;
     
    649657            if(lpPtrOffset[0]){
    650658                //pObj[n].member
    651                 if( refType != CClass::Dot ){
     659                if( refType != RefDot ){
    652660                    SetError(104,VarName,cp);
    653661                    pRelativeVar->dwKind=NON_VAR;
     
    659667            else{
    660668                //pObj->member
    661                 if( refType != CClass::Pointer ){
     669                if( refType != RefPointer ){
    662670                    SetError(104,VarName,cp);
    663671                    pRelativeVar->dwKind=NON_VAR;
     
    677685            if(lpPtrOffset[0]){
    678686                //ppObj[n]->member
    679                 if( refType != CClass::Pointer ){
     687                if( refType != RefPointer ){
    680688                    SetError(104,VarName,cp);
    681689                    pRelativeVar->dwKind=NON_VAR;
     
    722730}
    723731
    724 bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){
     732bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
    725733    extern BYTE *initGlobalBuf;
    726734    int i2,i3;
     
    735743        int typeSize = type.GetSize();
    736744
    737         if(SubScripts[0]!=-1){
    738             typeSize*=JumpSubScripts(SubScripts+1);
    739             int i=0;
    740             i2=0;
    741             while(1){
    742                 if(SubScripts[0]<i2){
    743                     SetError(41,0,cp);
    744                     return 0;
    745                 }
    746                 i=GetOneParameter(InitBuf,i,temporary);
    747                 if(!SetInitGlobalData(
    748                     offset+i2*typeSize,
    749                     type,
    750                     SubScripts+1,
    751                     temporary)) return false;
    752                 i2++;
    753                 if(InitBuf[i]=='\0') break;
     745        if( subscripts.size() > 0 ){
     746            Subscripts nestSubscripts;
     747            for( int i=1; i<(int)subscripts.size(); i++ )
     748            {
     749                nestSubscripts.push_back( subscripts[i] );
     750            }
     751
     752            typeSize*=JumpSubScripts( nestSubscripts );
     753            {
     754                int i=0;
     755                i2=0;
     756                while(1){
     757                    if( subscripts[0] < i2 ){
     758                        SetError(41,0,cp);
     759                        return 0;
     760                    }
     761                    i=GetOneParameter(InitBuf,i,temporary);
     762                    if(!SetInitGlobalData(
     763                        offset+i2*typeSize,
     764                        type,
     765                        nestSubscripts,
     766                        temporary)) return false;
     767                    i2++;
     768                    if(InitBuf[i]=='\0') break;
     769                }
    754770            }
    755771            return true;
     
    772788                if(!SetInitGlobalData(offset+i3,
    773789                    pMember->GetType(),
    774                     pMember->SubScripts,
     790                    pMember->GetSubscripts(),
    775791                    temporary)) return false;
    776792            }
     
    793809    }
    794810
    795     if(SubScripts[0]!=-1){
     811    if( subscripts.size() > 0 ){
    796812        SetError(41,0,cp);
    797813        return false;
     
    861877    return true;
    862878}
    863 bool InitLocalVar(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){
    864     int i,i2,i3;
     879bool InitLocalVar(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
     880    int i2,i3;
    865881    char temporary[VN_SIZE];
    866882    char InitBuf[VN_SIZE];
     
    873889        int typeSize = type.GetSize();
    874890
    875         if(SubScripts[0]!=-1){
    876             typeSize*=JumpSubScripts(SubScripts+1);
    877             i=0;
    878             i2=0;
    879             while(1){
    880                 if(SubScripts[0]<i2){
    881                     SetError(41,0,cp);
    882                     return false;
    883                 }
    884                 i=GetOneParameter(InitBuf,i,temporary);
    885                 if(!InitLocalVar(
    886                     offset+i2*typeSize,
    887                     type,
    888                     SubScripts+1,
    889                     temporary)) return false;
    890                 i2++;
    891                 if(InitBuf[i]=='\0') break;
     891        if( subscripts.size() > 0 ){
     892            Subscripts nestSubscripts;
     893            for( int i=1; i<(int)subscripts.size(); i++ )
     894            {
     895                nestSubscripts.push_back( subscripts[i] );
     896            }
     897
     898            typeSize*=JumpSubScripts( nestSubscripts );
     899            {
     900                int i=0;
     901                i2=0;
     902                while(1){
     903                    if( subscripts[0] < i2 ){
     904                        SetError(41,0,cp);
     905                        return 0;
     906                    }
     907                    i=GetOneParameter(InitBuf,i,temporary);
     908                    if(!InitLocalVar(
     909                        offset+i2*typeSize,
     910                        type,
     911                        nestSubscripts,
     912                        temporary)) return false;
     913                    i2++;
     914                    if(InitBuf[i]=='\0') break;
     915                }
    892916            }
    893917            return true;
     
    910934                if(!InitLocalVar(offset+i3,
    911935                    pMember->GetType(),
    912                     pMember->SubScripts,
     936                    pMember->GetSubscripts(),
    913937                    temporary)) return false;
    914938
     
    927951    ///////////////////////////////////////
    928952
    929     if(SubScripts[0]!=-1){
     953    if( subscripts.size() > 0 ){
    930954        SetError(41,0,cp);
    931955        return false;
     
    10751099}
    10761100
    1077 void dim( char *VarName,int *SubScripts,Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
     1101void dim( char *VarName, const Subscripts &subscripts, Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
    10781102    if( UserProc::IsGlobalAreaCompiling() ){
    10791103        /////////////////////////
     
    10811105        /////////////////////////
    10821106
    1083         AddGlobalVariable(VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
     1107        AddGlobalVariable(VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags);
    10841108    }
    10851109    else{
     
    10881112        /////////////////
    10891113
    1090         if( UserProc::CompilingUserProc().localVars.DuplicateCheck( Symbol( VarName ) ) ){
     1114        if( UserProc::CompilingUserProc().GetLocalVars().DuplicateCheck( Symbol( VarName ) ) ){
    10911115            //2重定義のエラー
    10921116            SetError(15,VarName,cp);
     
    10961120        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
    10971121
    1098         Variable *pVar = new VariableImpl( VarName, type, isConst );
    1099 
    1100         if( SubScripts[0] != -1 ){
     1122        Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter );
     1123
     1124        if( subscripts.size() > 0 ){
    11011125            //配列あり
    1102             pVar->SetArray( SubScripts );
    1103         }
    1104 
    1105         //コンストラクタ用パラメータ
    1106         pVar->paramStrForConstructor = ConstractParameter;
     1126            pVar->SetArray( subscripts );
     1127        }
    11071128
    11081129        //レキシカルスコープ
    1109         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    1110         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     1130        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     1131        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    11111132        pVar->bLiving=TRUE;
    11121133
     
    11151136
    11161137        // 変数を追加
    1117         UserProc::CompilingUserProc().localVars.push_back( pVar );
     1138        UserProc::CompilingUserProc().GetLocalVars().push_back( pVar );
    11181139
    11191140        //アラインメントを考慮
    1120         if( pVar->IsStruct() ){
    1121             int alignment = pVar->GetClass().iAlign;
     1141        if( pVar->GetType().IsStruct() ){
     1142            int alignment = pVar->GetType().GetClass().iAlign;
    11221143
    11231144            if( alignment ){
     
    11391160
    11401161        AllLocalVarSize += pVar->GetMemorySize();
    1141         pVar->offset = AllLocalVarSize;
     1162        pVar->SetOffsetAddress( AllLocalVarSize );
    11421163
    11431164        //レキシカルスコープ
    1144         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    1145         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     1165        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     1166        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    11461167        pVar->bLiving=TRUE;
    11471168
     
    11531174
    11541175            int result = 0;
    1155             if( !pVar->IsObject() ){
    1156                 result = InitLocalVar(-pVar->offset,
    1157                     *pVar,
    1158                     pVar->GetSubScriptsPtr(),
     1176            if( !pVar->GetType().IsObject() ){
     1177                result = InitLocalVar(-pVar->GetOffsetAddress(),
     1178                    pVar->GetType(),
     1179                    pVar->GetSubscripts(),
    11591180                    InitBuf);
    11601181            }
     
    11841205            //add eax,offset
    11851206            OpBuffer[obp++]=(char)0x05;
    1186             *((long *)(OpBuffer+obp))=-pVar->offset;
     1207            *((long *)(OpBuffer+obp))=-pVar->GetOffsetAddress();
    11871208            AddLocalVarAddrSchedule();
    11881209            obp+=sizeof(long);
     
    12041225    if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
    12051226        char objectSize[255];
    1206         if( SubScripts[0] == -1 ){
     1227        if( subscripts.size() == 0 ){
    12071228            objectSize[0] = 0;
    12081229        }
    12091230        else{
    1210             if( SubScripts[1] != -1 ){
     1231            if( subscripts.size() > 1 ){
    12111232                SetError(300,NULL,cp);
    12121233            }
    1213             sprintf( objectSize, "%d", SubScripts[0] );
     1234            sprintf( objectSize, "%d", subscripts[0] );
    12141235        }
    12151236        Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
     
    13231344
    13241345bool Compile_AddGlobalRootsForGc(){
    1325     UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
     1346    const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
    13261347    if( !pUserProc_AddGlobalRootPtr ){
    13271348        SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
     
    13291350    }
    13301351
    1331     BOOST_FOREACH( const Variable *pVar, globalVars ){
    1332         if( pVar->IsObject() || pVar->IsPointer() || pVar->IsStruct() ){
     1352    BOOST_FOREACH( const Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
     1353        if( pVar->GetType().IsObject() || pVar->GetType().IsPointer() || pVar->GetType().IsStruct() ){
    13331354            // オブジェクトまたはポインタだったとき
    13341355            // ※構造体も含む(暫定対応)
     
    13421363
    13431364            //mov eax,offset
    1344             op_mov_RV(REG_EAX,(int)pVar->offset);
     1365            op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress());
    13451366            obp-=sizeof(long);
    13461367            pobj_GlobalVarSchedule->add();
  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r201 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/common/Environment.h>
    24
     
    46
    57#include <LexicalScopingImpl.h>
    6 #include <ClassImpl.h>
     8#include <Class.h>
    79#include <Compiler.h>
    810#include <NamespaceSupporter.h>
    911
     12#include <../Enum.h>
     13
    1014#include "../BasicCompiler_Common/common.h"
     15#include "../BasicCompiler_Common/DebugSection.h"
    1116#include "Opcode.h"
    1217
     
    1924
    2025// グローバル関数、静的メソッド
    21 UserProc
     26const UserProc
    2227    *pSub_System_StartupProgram,
    2328    *pSub_DebugSys_StartProc,
     
    5156
    5257// 動的メソッド
    53 UserProc
     58const UserProc
    5459    *pUserProc_System_CGarbageCollection_RegisterGlobalRoots;
    5560
     
    176181
    177182    //クラス名を取得(詳細情報はGetAllClassInfoで取得)
    178     //   GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。
     183    //   CollectUserProcs関数の中で参照されるオブジェクト名を事前に取得する。
    179184    //     ※オブジェクトの内容までは取得しない
    180185    compiler.GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
     
    186191    GetConstInfo();
    187192
    188     //サブルーチン(ユーザー定義、DLL関数)の識別子、アドレスを取得
    189     Smoothie::Temp::pCompilingClass=0;
    190     GetSubInfo();
    191 
    192     //クラス情報を取得(※注 - GetSubInfoの後に呼び出す)
     193    // サブルーチン(ユーザー定義、DLL関数)の識別子、アドレスを取得
     194    compiler.pCompilingClass=0;
     195    UserProcs::CollectUserProcs( Smoothie::Lexical::source, compiler.GetMeta().GetUserProcs() );
     196
     197    // クラス情報を取得(※注 - CollectUserProcsの後に呼び出す)
    193198    compiler.GetMeta().GetClasses().GetAllClassInfo();
     199
     200    // サブルーチン(ユーザー定義、DLL関数)のイテレータの準備
     201    compiler.GetMeta().GetUserProcs().Iterator_Init();
    194202
    195203    if( !compiler.GetMeta().Write( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
     
    197205        MessageBox(0,"XML書き込みに失敗","test",0);
    198206    }
    199     MetaImpl tempMeta;
    200     if( !tempMeta.Read( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
     207    MetaImpl *pTempMeta = new MetaImpl();
     208    if( !pTempMeta->Read( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
    201209    {
    202210        MessageBox(0,"XML読み込みに失敗","test",0);
    203211    }
     212    compiler.GetMeta() = (*pTempMeta);
    204213
    205214    //コードと行番号の関係
     
    401410        extern DWORD dwContinueAddress;
    402411        dwContinueAddress=-1;
     412
     413        trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" );
    403414
    404415
     
    451462
    452463        //call _System_End
    453         extern UserProc *pSub_System_End;
     464        extern const UserProc *pSub_System_End;
    454465        op_call(pSub_System_End);
    455466
     
    593604        ExportNamesLength=lstrlen(lpExportNames)+1;
    594605
    595         extern GlobalProc **ppSubHash;
    596         GlobalProc *pUserProc,*psi2;
     606        UserProc *pUserProc,*psi2;
    597607        while(1){
    598608            //辞書順にサーチ
    599609            temporary[0]=0;
    600             for(i=0,psi2=0;i<MAX_HASH;i++){
    601                 pUserProc=ppSubHash[i];
    602                 while(pUserProc){
    603                     if(pUserProc->IsExport()){
    604                         if(temporary[0]=='\0'){
     610            compiler.GetMeta().GetUserProcs().Iterator_Reset();
     611            while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     612            {
     613                pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     614                if(pUserProc->IsExport()){
     615                    if(temporary[0]=='\0'){
     616                        lstrcpy(temporary,pUserProc->GetName().c_str());
     617                        psi2=pUserProc;
     618                    }
     619                    else{
     620                        i3=lstrlen(temporary);
     621                        i4=(int)pUserProc->GetName().size();
     622                        if(i3<i4) i3=i4;
     623                        if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
    605624                            lstrcpy(temporary,pUserProc->GetName().c_str());
    606625                            psi2=pUserProc;
    607626                        }
    608                         else{
    609                             i3=lstrlen(temporary);
    610                             i4=(int)pUserProc->GetName().size();
    611                             if(i3<i4) i3=i4;
    612                             if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
    613                                 lstrcpy(temporary,pUserProc->GetName().c_str());
    614                                 psi2=pUserProc;
    615                             }
    616                         }
    617627                    }
    618                     pUserProc=pUserProc->pNextData;
    619628                }
    620629            }
     
    625634
    626635            if( pUserProc->GetName() == "DllMain" ){
    627                 DllMain_EntryPoint=pUserProc->beginOpAddress;
     636                DllMain_EntryPoint=pUserProc->GetBeginOpAddress();
    628637            }
    629638
    630639            lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
    631             lpdwExportAddressTable[ExportNum]=pUserProc->beginOpAddress;
     640            lpdwExportAddressTable[ExportNum]=pUserProc->GetBeginOpAddress();
    632641
    633642            lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
     
    808817    //(デバッグ情報で利用される)
    809818    extern int AllInitGlobalVarSize;
    810     BOOST_FOREACH( Variable *pVar, globalVars ){
    811         if(pVar->offset&0x80000000){
    812             pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
     819    BOOST_FOREACH( Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
     820        if(pVar->GetOffsetAddress()&0x80000000){
     821            pVar->SetOffsetAddress( (pVar->GetOffsetAddress()&0x7FFFFFFF)+AllInitGlobalVarSize );
    813822        }
    814823    }
     
    11101119    // プロシージャポインタスケジュール
    11111120    for(i=0;i<pobj_SubAddrSchedule->num;i++){
    1112         if(pobj_SubAddrSchedule->ppsi[i]->beginOpAddress==0
    1113             &&pobj_SubAddrSchedule->ppsi[i]->endOpAddress==0){
     1121        if(pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()==0
     1122            &&pobj_SubAddrSchedule->ppsi[i]->GetEndOpAddress()==0){
    11141123            SetError(300,NULL,-1);
    11151124        }
     
    11171126        if(pobj_SubAddrSchedule->pbCall[i]){
    11181127            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1119                 pobj_SubAddrSchedule->ppsi[i]->beginOpAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
     1128                pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
    11201129        }
    11211130        else{
    11221131            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1123                 pobj_SubAddrSchedule->ppsi[i]->beginOpAddress+ImageBase+MemPos_CodeSection;
     1132                pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()+ImageBase+MemPos_CodeSection;
    11241133        }
    11251134    }
  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    179181    // 動的メソッドを検索
    180182    ///////////////////////////////////////////////////////////////////
    181     vector<UserProc *> userProcs;
     183    vector<const UserProc *> userProcs;
    182184
    183185    char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
    184     CClass::RefType refType;
     186    ReferenceKind refType;
    185187    lstrcpy( methodName, member );
    186188    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
    187189
    188190    objClass.GetMethods().Enum( methodName, userProcs );
    189     UserProc *pUserProc;
    190191    if(userProcs.size()){
    191192        //オーバーロードを解決
    192         pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
     193        const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
    193194
    194195        if( pUserProc ){
     
    248249    // パース
    249250    char member[VN_SIZE];
    250     CClass::RefType refType;
    251     if( CClass::SplitName( termFull, termLeft, member, refType ) ){
     251    ReferenceKind refType;
     252    if( SplitMemberName( termFull, termLeft, member, refType ) ){
    252253        ///////////////////////////////////////////////////////////////////
    253254        // オブジェクトとメンバに分解できるとき
     
    312313    if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
    313314        //Thisオブジェクト
    314         resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
     315        resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
    315316
    316317        SetThisPtrToReg( useReg );
     
    386387            return true;
    387388        }
    388         else if(GetConstCalcBuffer(procName,parameter,temporary)){
    389             /////////////////////////
    390             // マクロ関数
    391             /////////////////////////
    392 
    393             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    394             if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
    395 
    396             //マクロ関数の場合
    397             NumOpe(useReg, temporary,Type(),resultType);
    398 
    399             if(!IS_LITERAL(resultType.GetIndex())){
    400                 //リテラル値ではなかったとき
    401                 isLiteral = false;
     389        ConstMacro *pConstMacro = compiler.GetMeta().GetGlobalConstMacros().Find( procName );
     390        if( pConstMacro )
     391        {
     392            if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
     393            {
     394                /////////////////////////
     395                // マクロ関数
     396                /////////////////////////
     397
     398                //閉じカッコ")"に続く文字がNULLでないときはエラーにする
     399                if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     400
     401                //マクロ関数の場合
     402                NumOpe(useReg, temporary,Type(),resultType);
     403
     404                if(!IS_LITERAL(resultType.GetIndex())){
     405                    //リテラル値ではなかったとき
     406                    isLiteral = false;
     407                }
     408
     409                return true;
    402410            }
    403 
    404             return true;
    405411        }
    406412    }
     
    855861                    //////////////
    856862
    857                     i3 = CDBConst::obj.GetBasicType(term);
     863                    i3 = compiler.GetMeta().GetGlobalConsts().GetBasicType(term);
    858864                    if(i3){
    859                         if( CDBConst::obj.IsStringPtr( term ) ){
     865                        if( compiler.GetMeta().GetGlobalConsts().IsStringPtr( term ) ){
    860866                            //リテラル文字列
    861867
    862                             double dbl = CDBConst::obj.GetDoubleData(term);
     868                            double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
    863869                            memcpy(&i64data,&dbl,sizeof(double));
    864870
     
    874880                        if(IsRealNumberType(i3)){
    875881                            //実数
    876                             double dbl = CDBConst::obj.GetDoubleData(term);
     882                            double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
    877883                            memcpy(&i64data,&dbl,sizeof(double));
    878884                            goto Literal;
     
    880886                        else if(IsWholeNumberType(i3)){
    881887                            //整数
    882                             i64data = CDBConst::obj.GetWholeData(term);
     888                            i64data = compiler.GetMeta().GetGlobalConsts().GetWholeData(term);
    883889                            goto Literal;
    884890                        }
  • trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp

    r75 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    270272
    271273            //call _allmul
    272             extern UserProc *pSub_allmul;
     274            extern const UserProc *pSub_allmul;
    273275            op_call(pSub_allmul);
    274276
     
    460462
    461463            //call _aullrem
    462             extern UserProc *pSub_aullrem;
     464            extern const UserProc *pSub_aullrem;
    463465            op_call(pSub_aullrem);
    464466        }
     
    467469
    468470            //call _allrem
    469             extern UserProc *pSub_allrem;
     471            extern const UserProc *pSub_allrem;
    470472            op_call(pSub_allrem);
    471473        }
     
    720722
    721723            //call _aulldiv
    722             extern UserProc *pSub_aulldiv;
     724            extern const UserProc *pSub_aulldiv;
    723725            op_call(pSub_aulldiv);
    724726        }
     
    727729
    728730            //call _alldiv
    729             extern UserProc *pSub_alldiv;
     731            extern const UserProc *pSub_alldiv;
    730732            op_call(pSub_alldiv);
    731733        }
     
    10001002
    10011003    //call pow
    1002     extern UserProc *pSub_pow;
     1004    extern const UserProc *pSub_pow;
    10031005    op_call(pSub_pow);
    10041006
     
    11561158
    11571159        //call _allshl
    1158         extern UserProc *pSub_allshl;
     1160        extern const UserProc *pSub_allshl;
    11591161        op_call(pSub_allshl);
    11601162
     
    13611363
    13621364            //call _aullshr
    1363             extern UserProc *pSub_aullshr;
     1365            extern const UserProc *pSub_aullshr;
    13641366            op_call(pSub_aullshr);
    13651367        }
     
    13681370
    13691371            //call _allshr
    1370             extern UserProc *pSub_allshr;
     1372            extern const UserProc *pSub_allshr;
    13711373            op_call(pSub_allshr);
    13721374        }
  • trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp

    r36 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler32/NumOpe_Relation.cpp

    r97 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp

    r183 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
  • trunk/abdev/BasicCompiler32/Opcode.h

    r142 r206  
    1 //Opcode.h
     1#pragma once
     2
     3#include <Type.h>
     4#include <Procedure.h>
     5
    26
    37//未定義の定数情報
     
    201205bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
    202206void SetThisPtrToReg(int reg);
    203 bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = 0);
    204 bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *InitBuf);
     207bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts = NULL );
     208bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *InitBuf);
    205209#define DIMFLAG_INITDEBUGVAR            1
    206210#define DIMFLAG_NONCALL_CONSTRACTOR     2
    207211#define DIMFLAG_STATIC                  4
    208212#define DIMFLAG_CONST                   8
    209 void dim( char *VarName,int *SubScripts,Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
     213void dim( char *VarName, const Subscripts &subscripts, Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
    210214void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
    211215void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
     
    234238    bool EvaluateOverloadScore( int level, const Parameters &targetParms, const Type &targetResultType );
    235239public:
    236     UserProc *_OverloadSolution( const char *name, std::vector<UserProc *> &subs, bool isEnabledReturnType = false );
    237     UserProc *OverloadSolution( const char *name, std::vector<UserProc *> &subs, bool isEnabledReturnType = false );
     240    const UserProc *_OverloadSolution( const char *name, std::vector<const UserProc *> &subs, bool isEnabledReturnType = false );
     241    const UserProc *OverloadSolution( const char *name, std::vector<const UserProc *> &subs, bool isEnabledReturnType = false );
    238242
    239243    void ApplyDefaultParameters( const Parameters &params );
     
    252256#define PROCFLAG_NEW    1
    253257bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
    254 bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
     258bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
    255259bool Opcode_CallDllProc( const char *lpszParms, DllProc *pDllProc );
    256260
     
    351355void fpu_cast_end();
    352356
    353 void op_call(UserProc *pUserProc);
     357void op_call(const UserProc *pUserProc);
    354358void op_ret();
  • trunk/abdev/BasicCompiler32/OperatorProc.cpp

    r135 r206  
     1#include "stdafx.h"
     2
     3#include <jenga/include/smoothie/LexicalAnalysis.h>
     4
    15#include "../BasicCompiler_Common/common.h"
    26#include "Opcode.h"
     
    1115
    1216        //call DestructorProcAddr
    13         op_call( method->pUserProc );
     17        op_call( &method->GetUserProc() );
    1418    }
    1519
     
    1822
    1923    //call free
    20     extern UserProc *pSub_free;
     24    extern const UserProc *pSub_free;
    2125    op_call(pSub_free);
    2226}
     
    2731    pobj_c=(CClass *)index_stack[sp-2];
    2832
    29     std::vector<UserProc *> subs;
     33    std::vector<const UserProc *> subs;
    3034    pobj_c->GetMethods().Enum( idCalc, subs );
    3135    if( subs.size() == 0 ){
     
    5357    if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
    5458    else GetCalcName(idCalc,temporary);
    55     UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
     59    const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
    5660
    5761    if(!pUserProc){
     
    107111
    108112        //call calloc
    109         extern UserProc *pSub_calloc;
     113        extern const UserProc *pSub_calloc;
    110114        op_call(pSub_calloc);
    111115
     
    249253}
    250254void CallIndexerGetterProc(const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType){
    251     std::vector<UserProc *> subs;
     255    std::vector<const UserProc *> subs;
    252256    pobj_Class->GetMethods().Enum( CALC_ARRAY_GET, subs );
    253257    if( subs.size() == 0 ){
  • trunk/abdev/BasicCompiler32/increment.cpp

    r129 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler32/op32_main.cpp

    r142 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    980982/////////////////////////////
    981983
    982 void op_call(UserProc *pUserProc){
     984void op_call(const UserProc *pUserProc){
    983985    OpBuffer[obp++]=(char)0xE8;
    984986    pobj_SubAddrSchedule->add(pUserProc,1);
  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r198 r206  
    5555                RuntimeLibrary="1"
    5656                RuntimeTypeInfo="true"
    57                 UsePrecompiledHeader="0"
     57                UsePrecompiledHeader="2"
    5858                PrecompiledHeaderFile=".\Debug/BasicCompiler.pch"
    5959                AssemblerListingLocation=".\Debug/"
     
    167167                RuntimeLibrary="1"
    168168                RuntimeTypeInfo="true"
    169                 UsePrecompiledHeader="0"
     169                UsePrecompiledHeader="2"
    170170                PrecompiledHeaderFile=".\Release/BasicCompiler.pch"
    171171                AssemblerListingLocation=".\Release/"
     
    246246            </File>
    247247            <File
    248                 RelativePath="..\BasicCompiler_Common\BasicFixed.h"
    249                 >
    250             </File>
    251             <File
    252248                RelativePath="CommandValue.h"
    253249                >
     
    263259            <File
    264260                RelativePath="..\BasicCompiler_Common\include\option.h"
     261                >
     262            </File>
     263            <File
     264                RelativePath=".\stdafx.h"
    265265                >
    266266            </File>
     
    289289                >
    290290                <File
    291                     RelativePath="..\BasicCompiler_Common\include\ClassImpl.h"
     291                    RelativePath="..\BasicCompiler_Common\include\Class.h"
    292292                    >
    293293                </File>
     
    301301                </File>
    302302                <File
     303                    RelativePath="..\BasicCompiler_Common\include\Const.h"
     304                    >
     305                </File>
     306                <File
    303307                    RelativePath="..\BasicCompiler_Common\include\DataTable.h"
    304308                    >
     
    313317                </File>
    314318                <File
     319                    RelativePath="..\BasicCompiler_Common\include\Member.h"
     320                    >
     321                </File>
     322                <File
    315323                    RelativePath="..\BasicCompiler_Common\include\MetaImpl.h"
    316324                    >
    317325                </File>
    318326                <File
     327                    RelativePath="..\BasicCompiler_Common\include\Method.h"
     328                    >
     329                </File>
     330                <File
    319331                    RelativePath="..\BasicCompiler_Common\include\NamespaceSupporter.h"
    320332                    >
    321333                </File>
    322334                <File
    323                     RelativePath="..\BasicCompiler_Common\include\ProcedureImpl.h"
     335                    RelativePath="..\BasicCompiler_Common\include\Parameter.h"
     336                    >
     337                </File>
     338                <File
     339                    RelativePath="..\BasicCompiler_Common\include\Procedure.h"
    324340                    >
    325341                </File>
     
    329345                </File>
    330346                <File
     347                    RelativePath="..\BasicCompiler_Common\include\Prototype.h"
     348                    >
     349                </File>
     350                <File
    331351                    RelativePath="..\BasicCompiler_Common\include\SmoothieImpl.h"
    332352                    >
    333353                </File>
    334354                <File
     355                    RelativePath="..\BasicCompiler_Common\include\Symbol.h"
     356                    >
     357                </File>
     358                <File
     359                    RelativePath="..\BasicCompiler_Common\include\Type.h"
     360                    >
     361                </File>
     362                <File
    335363                    RelativePath="..\BasicCompiler_Common\include\TypeDef.h"
    336364                    >
    337365                </File>
    338366                <File
    339                     RelativePath="..\BasicCompiler_Common\include\VariableImpl.h"
     367                    RelativePath="..\BasicCompiler_Common\include\Variable.h"
    340368                    >
    341369                </File>
     
    396424                        Name="VCResourceCompilerTool"
    397425                        PreprocessorDefinitions="_DEBUG;JPN;$(NoInherit)"
     426                    />
     427                </FileConfiguration>
     428            </File>
     429            <File
     430                RelativePath=".\stdafx.cpp"
     431                >
     432                <FileConfiguration
     433                    Name="Debug|Win32"
     434                    >
     435                    <Tool
     436                        Name="VCCLCompilerTool"
     437                        UsePrecompiledHeader="1"
     438                    />
     439                </FileConfiguration>
     440                <FileConfiguration
     441                    Name="Release|Win32"
     442                    >
     443                    <Tool
     444                        Name="VCCLCompilerTool"
     445                        UsePrecompiledHeader="1"
    398446                    />
    399447                </FileConfiguration>
     
    9811029                </Filter>
    9821030                <Filter
    983                     Name="Constant"
    984                     >
    985                     <File
    986                         RelativePath="..\BasicCompiler_Common\Const.cpp"
    987                         >
    988                     </File>
    989                     <File
    990                         RelativePath="..\BasicCompiler_Common\Const.h"
    991                         >
    992                     </File>
    993                 </Filter>
    994                 <Filter
    9951031                    Name="Variable"
    9961032                    >
     
    10211057                >
    10221058                <File
    1023                     RelativePath="..\BasicCompiler_Common\src\ClassImpl.cpp"
     1059                    RelativePath="..\BasicCompiler_Common\src\Class.cpp"
    10241060                    >
    10251061                </File>
     
    10331069                </File>
    10341070                <File
     1071                    RelativePath="..\BasicCompiler_Common\src\Const.cpp"
     1072                    >
     1073                </File>
     1074                <File
    10351075                    RelativePath="..\BasicCompiler_Common\src\DataTable.cpp"
    10361076                    >
     
    10451085                </File>
    10461086                <File
     1087                    RelativePath="..\BasicCompiler_Common\src\Method.cpp"
     1088                    >
     1089                </File>
     1090                <File
    10471091                    RelativePath="..\BasicCompiler_Common\src\NamespaceSupporter.cpp"
    10481092                    >
    10491093                </File>
    10501094                <File
    1051                     RelativePath="..\BasicCompiler_Common\src\ProcedureImpl.cpp"
     1095                    RelativePath="..\BasicCompiler_Common\src\Procedure.cpp"
    10521096                    >
    10531097                </File>
     
    10611105                </File>
    10621106                <File
     1107                    RelativePath="..\BasicCompiler_Common\src\Symbol.cpp"
     1108                    >
     1109                </File>
     1110                <File
     1111                    RelativePath="..\BasicCompiler_Common\src\Type.cpp"
     1112                    >
     1113                </File>
     1114                <File
    10631115                    RelativePath="..\BasicCompiler_Common\src\TypeDef.cpp"
    10641116                    >
    10651117                </File>
    10661118                <File
    1067                     RelativePath="..\BasicCompiler_Common\src\VariableImpl.cpp"
     1119                    RelativePath="..\BasicCompiler_Common\src\Variable.cpp"
    10681120                    >
    10691121                </File>
  • trunk/abdev/BasicCompiler64/CLockParameter.cpp

    r3 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
  • trunk/abdev/BasicCompiler64/CParameter.cpp

    r75 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
     
    110112
    111113                //call free
    112                 extern UserProc *pSub_free;
     114                extern const UserProc *pSub_free;
    113115                op_call(pSub_free);
    114116            }
     
    133135
    134136        //call calloc
    135         extern UserProc *pSub_calloc;
     137        extern const UserProc *pSub_calloc;
    136138        op_call(pSub_calloc);
    137139
  • trunk/abdev/BasicCompiler64/Compile_Calc.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    9496            }
    9597            else{
    96                 if(GetConstHash(variable)){
     98                if( compiler.GetMeta().GetGlobalConsts().IsExist(variable)
     99                    || compiler.GetMeta().GetGlobalConstMacros().IsExist(variable) )
     100                {
    97101                    //定数リストに該当したとき
    98102                    SetError(1,NULL,cp);
     
    234238    if( varType.IsObject() && compiler.GetMeta().GetBlittableTypes().IsExist( calcType ) ){
    235239        // Blittable型をオブジェクトとして扱う
    236         vector<UserProc *> userProcs;
     240        vector<const UserProc *> userProcs;
    237241        compiler.GetMeta().GetBlittableTypes().GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
    238242        if( userProcs.size() != 1 ){
     
    240244            return;
    241245        }
    242         UserProc *pUserProc = userProcs[0];
     246        const UserProc *pUserProc = userProcs[0];
    243247
    244248        // mov rcx, rax
  • trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp

    r66 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    1214void Call_DebugSys_SaveContext(){
    1315    //call _System_GetEip
    14     extern UserProc *pSub_System_GetEip;
     16    extern const UserProc *pSub_System_GetEip;
    1517    op_call(pSub_System_GetEip);
    1618
     
    2224
    2325    //call _DebugSys_SaveContext
    24     extern UserProc *pSub_DebugSys_SaveContext;
     26    extern const UserProc *pSub_DebugSys_SaveContext;
    2527    op_call(pSub_DebugSys_SaveContext);
    2628}
     
    99101}
    100102
    101 bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
     103bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
    102104    // TODO: RefTypeは不必要なので削除する
    103105    int i2;
     
    128130            if(lstrcmpi(ObjectName,"Super")==0){
    129131                //クラスメンバ関数内から基底クラスの呼び出し
    130                 pobj_c=Smoothie::Temp::pCompilingClass;
     132                pobj_c=compiler.pCompilingClass;
    131133            }
    132134            else{
     
    153155            else{
    154156                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
    155                 pobj_c=Smoothie::Temp::pCompilingClass;
     157                pobj_c=compiler.pCompilingClass;
    156158            }
    157159        }
     
    182184        if(ObjectName[0]){
    183185            //外部からの呼び出し
    184             if(pobj_c==Smoothie::Temp::pCompilingClass){
     186            if(pobj_c==compiler.pCompilingClass){
    185187                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    186188                if( pMethod->IsNoneAccess() ){
     
    279281
    280282            //call calloc
    281             extern UserProc *pSub_calloc;
     283            extern const UserProc *pSub_calloc;
    282284            op_call(pSub_calloc);
    283285
  • trunk/abdev/BasicCompiler64/Compile_Func.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    4648    }
    4749
    48     int SubScripts[MAX_ARRAYDIM];
     50    Subscripts subscripts;
    4951    RELATIVE_VAR RelativeVar;
    50     if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,SubScripts)) return;
     52    if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
    5153
    5254    if(type.GetBasicType()&FLAG_PTR){
     
    5961    int typeSize = type.GetSize();
    6062
    61     if(bArrayHead) typeSize*=JumpSubScripts(SubScripts);
     63    if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
    6264
    6365    //mov rax,TypeSize
     
    6870void Opcode_Func_AddressOf( const char *name ){
    6971    extern int cp;
    70     UserProc *pUserProc;
     72    const UserProc *pUserProc;
    7173
    7274    extern LONG_PTR ProcPtr_BaseIndex;
     
    7476        //左辺の型にのっとり、オーバーロードを解決
    7577
    76         std::vector<UserProc *> subs;
     78        std::vector<const UserProc *> subs;
    7779        GetOverloadSubHash( name, subs );
    7880        if( subs.size() == 0 ){
     
    131133            SetThisPtrToReg(REG_RCX);
    132134
    133             pobj_c=Smoothie::Temp::pCompilingClass;
     135            pobj_c=compiler.pCompilingClass;
    134136        }
    135137
  • trunk/abdev/BasicCompiler64/Compile_Interface.cpp

    r132 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r140 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "opcode.h"
     
    3335    ////////////////////////
    3436
    35     std::vector<UserProc *> subs;
     37    std::vector<const UserProc *> subs;
    3638    pobj_c->GetMethods().Enum( pobj_c->GetName().c_str(), subs );
    3739
    38     UserProc *pUserProc;
     40    const UserProc *pUserProc;
    3941    if( subs.size() > 0 ){
    4042        //オーバーロードを解決
     
    142144
    143145        //call _System_GC_malloc_ForObject
    144         extern UserProc *pSub_System_GC_malloc_ForObject;
     146        extern const UserProc *pSub_System_GC_malloc_ForObject;
    145147        op_call(pSub_System_GC_malloc_ForObject);
    146148    }
     
    150152
    151153        //call _System_GC_malloc_ForObjectPtr
    152         extern UserProc *pSub_System_GC_malloc_ForObjectPtr;
     154        extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
    153155        op_call(pSub_System_GC_malloc_ForObjectPtr);
    154156    }
     
    185187    op_mov_RV(sizeof(_int64),REG_RCX,0);
    186188    obp-=sizeof(long);
    187     pobj_SubAddrSchedule->add(method->pUserProc,0);
    188     method->pUserProc->Using();
     189    pobj_SubAddrSchedule->add(&method->GetUserProc(),0);
     190    method->GetUserProc().Using();
    189191    obp+=sizeof(long);
    190192
     
    299301    if( isSweeping ){
    300302        //call _System_GC_free_for_SweepingDelete
    301         extern UserProc *pSub_System_GC_free_for_SweepingDelete;
     303        extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
    302304        op_call(pSub_System_GC_free_for_SweepingDelete);
    303305    }
    304306    else{
    305307        //call free
    306         extern UserProc *pSub_free;
     308        extern const UserProc *pSub_free;
    307309        op_call(pSub_free);
    308310    }
  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r204 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    57#include <Compiler.h>
    68#include <LexicalScopingImpl.h>
    7 #include <ClassImpl.h>
    8 #include <VariableImpl.h>
     9#include <Class.h>
    910
    1011#include "../BasicCompiler_Common/common.h"
     
    3132        }
    3233
    33         UserProc *pBackUserProc;
    34         pBackUserProc = &UserProc::CompilingUserProc();
     34        const UserProc *pBackUserProc = &UserProc::CompilingUserProc();
    3535        UserProc::CompileStartForGlobalArea();
    3636
     
    5454
    5555        //_System_StartupProgramの呼び出し
    56         extern UserProc *pSub_System_StartupProgram;
     56        extern const UserProc *pSub_System_StartupProgram;
    5757        op_call(pSub_System_StartupProgram);
    5858
     
    8282        StackFrameSchedule=obp-sizeof(long);
    8383
    84         BOOST_FOREACH( Variable *pVar, globalVars ){
     84        BOOST_FOREACH( Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
    8585            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
    8686                //コンストラクタ呼び出し
    87                 if( pVar->IsObject() ){
     87                if( pVar->GetType().IsObject() ){
    8888
    8989                    //エラー用
     
    9292                    CallConstructor(
    9393                        pVar->GetName().c_str(),
    94                         pVar->GetSubScriptsPtr(),
    95                         *pVar,
    96                         pVar->paramStrForConstructor.c_str());
     94                        pVar->GetSubscripts(),
     95                        pVar->GetType(),
     96                        pVar->GetParamStrForConstructor().c_str());
    9797                }
    9898            }
     
    113113
    114114
    115         UserProc *pBackUserProc;
    116         pBackUserProc = &UserProc::CompilingUserProc();
     115        const UserProc *pBackUserProc = &UserProc::CompilingUserProc();
    117116        UserProc::CompileStartForGlobalArea();
    118117
     
    212211    }
    213212}
    214 void AutoGeneration(UserProc &userProc){
     213void AutoGeneration(const UserProc &userProc){
    215214    if( userProc.GetName() == "InitializeUserTypes"
    216215        && userProc.HasParentClass()
     
    229228    }
    230229}
    231 void _compile_proc(UserProc *pUserProc){
     230void _compile_proc(const UserProc *pUserProc){
    232231    extern char *basbuf;
    233232    extern HANDLE hHeap;
    234     extern GlobalProc **ppSubHash;
    235233    extern BOOL bDebugCompile;
    236234    int i3,i4;
     
    239237    if( pUserProc->IsUsing() == false || pUserProc->IsCompiled() ) return;
    240238
    241     if( pUserProc->localVars.size() ){
     239    if( pUserProc->GetLocalVars().size() ){
    242240        SetError();
    243241        return;
    244242    }
     243
     244    trace_for_sourcecodestep( "★★★ " << pUserProc->GetFullName() << "のコンパイルを開始" );
    245245
    246246    pUserProc->CompleteCompile();
     
    259259    else bDebugSupportProc=0;
    260260
    261     pUserProc->beginOpAddress=obp;
     261    pUserProc->SetBeginOpAddress( obp );
    262262
    263263    //コンパイル中の関数が属するクラス
    264     Smoothie::Temp::pCompilingClass=pUserProc->GetParentClassPtr();
     264    compiler.pCompilingClass=pUserProc->GetParentClassPtr();
    265265
    266266    //コンパイルスタートをクラス管理クラスに追加
     
    294294        pobj_sf=0;
    295295
    296         pUserProc->endOpAddress=obp;
     296        pUserProc->SetEndOpAddress( obp );
    297297        return;
    298298    }
     
    360360        Parameter &param = *pUserProc->RealParams()[i3];
    361361
    362         Variable *pVar = new VariableImpl( param.GetVarName(), param, false, param.IsRef() );
     362        Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef(), "" );
    363363
    364364        if( param.IsArray() ){
    365             pVar->SetArray( param.GetSubScriptsPtr() );
     365            pVar->SetArray( param.GetSubscripts() );
    366366        }
    367367
     
    381381        }
    382382        AllLocalVarSize+=varSize;
    383         pVar->offset=AllLocalVarSize;
     383        pVar->SetOffsetAddress( AllLocalVarSize );
    384384
    385385        //レキシカルスコープ情報
    386         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    387         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     386        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     387        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    388388        pVar->bLiving=TRUE;
    389389
    390         pUserProc->localVars.push_back( pVar );
     390        pUserProc->GetLocalVars().push_back( pVar );
    391391    }
    392392
     
    507507
    508508        //call _DebugSys_StartProc
    509         extern UserProc *pSub_DebugSys_StartProc;
     509        extern const UserProc *pSub_DebugSys_StartProc;
    510510        op_call(pSub_DebugSys_StartProc);
    511511    }
    512512
    513     if(Smoothie::Temp::pCompilingClass){
    514         if( pUserProc->GetName() == Smoothie::Temp::pCompilingClass->GetName() ){
     513    if(compiler.pCompilingClass){
     514        if( pUserProc->GetName() == compiler.pCompilingClass->GetName() ){
    515515            ////////////////////////////////////
    516516            // コンストラクタをコンパイルするとき
     
    518518
    519519            //コンストラクタのコンパイル開始を通知
    520             Smoothie::Temp::pCompilingClass->NotifyStartConstructorCompile();
     520            compiler.pCompilingClass->NotifyStartConstructorCompile();
    521521
    522522            //基底クラスかどうかの識別
    523523            //(継承元がインターフェイスの場合も基底クラスと見なす)
    524524            BOOL bThisIsSuperClass;
    525             if( !Smoothie::Temp::pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
    526             else if( Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
     525            if( !compiler.pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
     526            else if( compiler.pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
    527527                //インターフェイスを継承したときはコンストラクタを持たない
    528528                bThisIsSuperClass=1;
     
    543543                    temporary[i4]=basbuf[i3];
    544544                }
    545                 if( Smoothie::Temp::pCompilingClass->GetSuperClass().GetName() == temporary ){
     545                if( compiler.pCompilingClass->GetSuperClass().GetName() == temporary ){
    546546                    //基底クラスのコンストラクタを呼び出す
    547547                    cp=i3;
     
    560560                    Type dummyType;
    561561                    CallProc( PROC_DEFAULT
    562                         , Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc
    563                         , Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc->GetName().c_str()
     562                        , &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc()
     563                        , compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc().GetName().c_str()
    564564                        , temporary
    565565                        , dummyType );
     
    568568                    //基底クラスのコンストラクタを暗黙的に呼び出す
    569569                    Opcode_CallProc("",
    570                         Smoothie::Temp::pCompilingClass->GetSuperClass().GetConstructorMethod()->pUserProc,
     570                        &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
    571571                        0,
    572572                        "",
     
    576576
    577577            //仮想関数テーブルを初期化
    578             if( Smoothie::Temp::pCompilingClass->IsExistVirtualFunctions()
    579                 && !Smoothie::Temp::pCompilingClass->IsAbstract() ){
     578            if( compiler.pCompilingClass->IsExistVirtualFunctions()
     579                && !compiler.pCompilingClass->IsAbstract() ){
    580580                    //関数テーブルに値をセット
    581                     int offset = (int)Smoothie::Temp::pCompilingClass->GetVtblGlobalOffset();
     581                    int offset = (int)compiler.pCompilingClass->GetVtblGlobalOffset();
    582582
    583583                    //mov rax,offset
     
    598598
    599599            //デストラクタのコンパイル開始を通知
    600             Smoothie::Temp::pCompilingClass->NotifyStartDestructorCompile();
     600            compiler.pCompilingClass->NotifyStartDestructorCompile();
    601601        }
    602602    }
     
    624624    //////////////////////////////////////////
    625625
    626     if( Smoothie::Temp::pCompilingClass ){
    627 
    628         if( Smoothie::Temp::pCompilingClass->IsCompilingConstructor() ){
     626    if( compiler.pCompilingClass ){
     627
     628        if( compiler.pCompilingClass->IsCompilingConstructor() ){
    629629            // コンストラクタをコンパイルしていたとき
    630630
    631631            // コンストラクタのコンパイルが完了したことを通知
    632             Smoothie::Temp::pCompilingClass->NotifyFinishConstructorCompile();
     632            compiler.pCompilingClass->NotifyFinishConstructorCompile();
    633633        }
    634634        else if( pUserProc->IsDestructor() ){
     
    638638
    639639            // デストラクタのコンパイルが完了したことを通知
    640             Smoothie::Temp::pCompilingClass->NotifyFinishDestructorCompile();
    641 
    642             if( Smoothie::Temp::pCompilingClass->HasSuperClass() ){
     640            compiler.pCompilingClass->NotifyFinishDestructorCompile();
     641
     642            if( compiler.pCompilingClass->HasSuperClass() ){
    643643                /* サブクラスのデストラクタをコンパイルしているときは、
    644644                    基底クラスのデストラクタを呼び出す */
    645645
    646                 const CMethod *method = Smoothie::Temp::pCompilingClass->GetSuperClass().GetDestructorMethod();
     646                const CMethod *method = compiler.pCompilingClass->GetSuperClass().GetDestructorMethod();
    647647                if( method ){
    648648                    Opcode_CallProc("",
    649                         method->pUserProc,
     649                        &method->GetUserProc(),
    650650                        0,
    651651                        "",
     
    694694    if(bDebugCompile&&bDebugSupportProc==0){
    695695        //call _DebugSys_EndProc
    696         extern UserProc *pSub_DebugSys_EndProc;
     696        extern const UserProc *pSub_DebugSys_EndProc;
    697697        op_call(pSub_DebugSys_EndProc);
    698698    }
     
    745745    }
    746746    HeapDefaultFree(pLocalVarAddrSchedule);
    747     BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
     747    BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
    748748        //後にデバッグで利用する
    749         pVar->offset = AllLocalVarSize + pobj_sf->GetFrameSize() - pVar->offset;
     749        pVar->SetOffsetAddress(
     750            AllLocalVarSize + pobj_sf->GetFrameSize() - pVar->GetOffsetAddress()
     751        );
    750752    }
    751753
     
    785787
    786788
    787     pUserProc->endOpAddress=obp;
     789    pUserProc->SetEndOpAddress( obp );
    788790
    789791
     
    793795}
    794796
    795 void CompileBufferInProcedure( UserProc &userProc ){
     797void CompileBufferInProcedure( const UserProc &userProc ){
    796798    if( userProc.IsUsing() == false || userProc.IsCompiled() ) return;
    797799
     
    809811}
    810812void CompileLocal(){
    811     extern GlobalProc **ppSubHash;
    812     int i2;
    813 
    814813    extern BOOL bDll;
    815814    if(bDll){
    816815        //DLLの場合はグローバル変数を初期化するための関数を一番初めにコンパイルする
    817         UserProc *pUserProc=GetSubHash("_System_InitDllGlobalVariables");
     816        const UserProc *pUserProc = GetSubHash("_System_InitDllGlobalVariables");
    818817        if(pUserProc){
    819818            CompileBufferInProcedure( *pUserProc );
     
    823822
    824823    //_System_TypeBase_InitializeUserTypesは一番最後にコンパイル
    825     extern UserProc *pSubStaticMethod_System_TypeBase_InitializeUserTypes;
     824    extern const UserProc *pSubStaticMethod_System_TypeBase_InitializeUserTypes;
    826825    pSubStaticMethod_System_TypeBase_InitializeUserTypes->CompleteCompile();
    827826
    828827    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    829828    //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
    830     extern UserProc *pSub_System_InitStaticLocalVariables;
     829    extern const UserProc *pSub_System_InitStaticLocalVariables;
    831830    pSub_System_InitStaticLocalVariables->CompleteCompile();
    832831
    833832    //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
    834     extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
     833    extern const UserProc *pSub_System_Call_Destructor_of_GlobalObject;
    835834    pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile();
    836835
    837836repeat:
    838     GlobalProc *pGlobalProc;
    839     for(i2=0;i2<MAX_HASH;i2++){
    840         pGlobalProc=ppSubHash[i2];
    841         while(pGlobalProc){
    842             CompileBufferInProcedure( *pGlobalProc );
    843             pGlobalProc=pGlobalProc->pNextData;
    844         }
     837    compiler.GetMeta().GetUserProcs().Iterator_Reset();
     838    while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     839    {
     840        UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     841        CompileBufferInProcedure( *pUserProc );
    845842    }
    846843
     
    856853    if( IsNeedProcCompile() ){
    857854        //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合
    858         for(i2=0;i2<MAX_HASH;i2++){
    859             pGlobalProc=ppSubHash[i2];
    860             while(pGlobalProc){
    861                 CompileBufferInProcedure( *pGlobalProc );
    862                 pGlobalProc=pGlobalProc->pNextData;
    863             }
     855
     856        compiler.GetMeta().GetUserProcs().Iterator_Reset();
     857        while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     858        {
     859            UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     860            CompileBufferInProcedure( *pUserProc );
    864861        }
    865862    }
  • trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp

    r96 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    7880
    7981                    //call free
    80                     extern UserProc *pSub_free;
     82                    extern const UserProc *pSub_free;
    8183                    op_call(pSub_free);
    8284                }
  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/LexicalAnalysis.h>
    24
     
    911void OpcodeOthers(const char *Command){
    1012    int i,i2;
    11     UserProc *pUserProc;
    1213
    1314    char leftTerm[8192];
     
    5960        //////////////////////////////
    6061
    61         pUserProc=GetSubHash(Command);
     62        const UserProc *pUserProc=GetSubHash(Command);
    6263
    6364        //GetSubHash内でエラー提示が行われた場合
     
    737738
    738739                if(type1.IsObject()){
    739                     std::vector<UserProc *> subs;
     740                    std::vector<const UserProc *> subs;
    740741                    type1.GetClass().GetMethods().Enum( CALC_EQUAL, subs );
    741742                    if( subs.size() == 0 ){
     
    747748
    748749                    //オーバーロードを解決
    749                     UserProc *pUserProc;
    750                     pUserProc=OverloadSolution("==",subs, params, NULL);
     750                    const UserProc *pUserProc = OverloadSolution("==",subs, params, NULL);
    751751
    752752                    delete params[0];
     
    892892
    893893    //call _System_GetEip
    894     extern UserProc *pSub_System_GetEip;
     894    extern const UserProc *pSub_System_GetEip;
    895895    op_call(pSub_System_GetEip);
    896896
     
    953953        //戻り値をセット
    954954        if(Parameter[0]){
    955             UserProc &proc = UserProc::CompilingUserProc();
     955            const UserProc &proc = UserProc::CompilingUserProc();
    956956
    957957            const char *temp = "_System_ReturnValue";
  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    57#include <CodeGenerator.h>
    68#include <Compiler.h>
    7 #include <VariableImpl.h>
     9#include <Variable.h>
    810
    911#include "../BasicCompiler_Common/common.h"
     
    1113
    1214//変数
    13 Variables globalVars;
     15// TODO: xml未完成
    1416int AllGlobalVarSize;
    1517int AllInitGlobalVarSize;
     
    8688    }
    8789}
    88 bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){
     90bool GetArrayOffset(const Subscripts &subscripts,char *array, const Type &type){
    8991    extern HANDLE hHeap;
    9092    int i,i2,i3,i4;
     
    105107        }
    106108        if(array[i]==','||array[i]=='\0'){
    107             if(SubScripts[i3]==-1){
     109            if( i3 >= (int)subscripts.size() )
     110            {
    108111                for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    109112                return false;
     
    118121
    119122            if(array[i]=='\0'){
    120                 if(SubScripts[i3]!=-1){
     123                if( i3 < (int)subscripts.size() )
     124                {
    121125                    for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
    122126                    return false;
     
    166170        pobj_sf->pop(REG_R12);
    167171
    168         for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;
     172        for(i2=i+1,i4=1;i2<i3;i2++) i4*=subscripts[i2]+1;
    169173
    170174        //imul reg,i4
     
    204208    char lpPtrOffset[VN_SIZE];  //第2次配列
    205209    char NestMember[VN_SIZE];   //入れ子メンバ
    206     CClass::RefType refType;
     210    ReferenceKind refType;
    207211    lstrcpy(VarName,member);
    208212    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
     
    224228
    225229    //アクセシビリティをチェック
    226     if(&objClass==Smoothie::Temp::pCompilingClass){
     230    if(&objClass==compiler.pCompilingClass){
    227231        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    228232        if(pMember->IsNoneAccess()){
     
    257261    //ポインタ変数の場合
    258262    if( resultType.IsPointer() ){
    259         if(pMember->SubScripts[0]==-1){
     263        if( pMember->GetSubscripts().size() == 0 ){
    260264            lstrcpy(lpPtrOffset,array);
    261265            array[0]=0;
     
    280284    if(array[0]){
    281285        //配列オフセット
    282         if(!GetArrayOffset(pMember->SubScripts,array,pMember->GetType())){
     286        if(!GetArrayOffset(pMember->GetSubscripts(),array,pMember->GetType())){
    283287            if(isErrorEnabled) SetError(14,member,cp);
    284288        }
    285289    }
    286     else if(pMember->SubScripts[0]!=-1){
     290    else if( pMember->GetSubscripts().size() > 0 ){
    287291        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    288292    }
     
    292296
    293297        if( resultType.IsObject() || resultType.IsStruct() ){
    294             if( refType != CClass::Dot ){
     298            if( refType != RefDot ){
    295299                if(isErrorEnabled) SetError(104,member,cp);
    296300                return false;
     
    308312                //pObj[n].member
    309313                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
    310                     && refType != CClass::Dot ){
     314                    && refType != RefDot ){
    311315                        if(isErrorEnabled) SetError(104,member,cp);
    312316                        return false;
     
    322326                //pObj->member
    323327                if( (resultType.IsObjectPtr() || resultType.IsStructPtr() )
    324                     && refType != CClass::Pointer ){
     328                    && refType != RefPointer ){
    325329                        if(isErrorEnabled) SetError(104,member,cp);
    326330                        return false;
     
    336340            if(lpPtrOffset[0]){
    337341                //ppObj[n]->member
    338                 if( refType != CClass::Pointer ){
     342                if( refType != RefPointer ){
    339343                    if(isErrorEnabled) SetError(104,member,cp);
    340344                    return false;
     
    385389    SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
    386390}
    387 bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){
     391bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts ){
    388392    char variable[VN_SIZE];
    389393
     
    399403
    400404    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
    401     CClass::RefType refType;
     405    ReferenceKind refType;
    402406    char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    403407    GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
     
    412416    }
    413417
    414     const int *pSubScripts;
     418    const Subscripts *pSubscripts;
    415419    bool bConst = false;
    416420
     
    421425        //////////////////
    422426
    423         const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
     427        const Variable *pVar = UserProc::CompilingUserProc().GetLocalVars().BackSearch( Symbol( VarName ) );
    424428        if( pVar ){
    425429            //ポインタ変数の場合
    426             if( pVar->IsPointer() ){
     430            if( pVar->GetType().IsPointer() ){
    427431                if( !pVar->IsArray() ){
    428432                    lstrcpy(lpPtrOffset,array);
     
    438442            }
    439443
    440             pRelativeVar->offset=-pVar->offset;
     444            pRelativeVar->offset=-pVar->GetOffsetAddress();
    441445            pRelativeVar->bOffsetOffset=0;
    442446            if( pVar->IsRef() ){
     
    445449            }
    446450            else pRelativeVar->dwKind=VAR_LOCAL;
    447             resultType = *pVar;
    448             pSubScripts=pVar->GetSubScriptsPtr();
     451            resultType = pVar->GetType();
     452            pSubscripts = &pVar->GetSubscripts();
    449453            bConst = pVar->IsConst();
    450454
     
    454458
    455459
    456     if(Smoothie::Temp::pCompilingClass){
     460    if(compiler.pCompilingClass){
    457461        //////////////////////
    458462        // クラスメンバの参照
     
    465469            pRelativeVar->dwKind=VAR_DIRECTMEM;
    466470
    467             resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
     471            resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
    468472            return true;
    469473        }
     
    478482
    479483            bool isFound = false;
    480             BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
     484            BOOST_FOREACH( CMember *pMember, compiler.pCompilingClass->GetDynamicMembers() ){
    481485                if( pMember->GetName() == VarName ){
    482486                    isFound = true;
     
    492496        if( isWriteAccess &&
    493497            pMethod->IsConst() &&
    494             Smoothie::Temp::pCompilingClass->IsCompilingConstructor() == false &&
    495             Smoothie::Temp::pCompilingClass->IsCompilingDestructor() == false
     498            compiler.pCompilingClass->IsCompilingConstructor() == false &&
     499            compiler.pCompilingClass->IsCompilingDestructor() == false
    496500            ){
    497501                SetError(131, NULL, cp );
     
    505509            isErrorEnabled,
    506510            isWriteAccess,
    507             *Smoothie::Temp::pCompilingClass,
     511            *compiler.pCompilingClass,
    508512            variable,
    509513            pRelativeVar,
     
    526530            GetNowStaticVarFullName(VarName,temporary);
    527531
    528             pVar = globalVars.Find( temporary );
     532            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temporary ) );
    529533            if( pVar ){
    530534                goto GlobalOk;
     
    545549            char tempArray[VN_SIZE];
    546550            {
    547                 CClass::RefType refType;
     551                ReferenceKind refType;
    548552                GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
    549553            }
     
    557561            char temp2[VN_SIZE];
    558562            sprintf(temp2,"%s.%s",VarName,temporary);
    559             pVar = globalVars.Find( temp2 );
     563            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temp2 ) );
    560564            if( pVar ){
    561565                lstrcpy(member,tempMember);
     
    565569        }
    566570
    567         if(Smoothie::Temp::pCompilingClass){
     571        if(compiler.pCompilingClass){
    568572            //自身のクラスから静的メンバを参照する場合
    569573            char temp2[VN_SIZE];
    570             sprintf(temp2,"%s.%s",Smoothie::Temp::pCompilingClass->GetName().c_str(),VarName);
    571             pVar = globalVars.Find( temp2 );
     574            sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
     575            pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temp2 ) );
    572576            if( pVar ){
    573577                goto GlobalOk;
     
    579583        /////////////////////
    580584
    581         pVar = globalVars.BackSearch( VarName );
     585        pVar = compiler.GetMeta().GetGlobalVars().BackSearch( Symbol( VarName ) );
    582586        if( pVar ){
    583587            goto GlobalOk;
     
    592596GlobalOk:
    593597        //ポインタ変数の場合
    594         if( pVar->IsPointer() ){
     598        if( pVar->GetType().IsPointer() ){
    595599            if( !pVar->IsArray() ){
    596600                lstrcpy(lpPtrOffset,array);
     
    606610        }
    607611
    608         pRelativeVar->offset=pVar->offset;
     612        pRelativeVar->offset=pVar->GetOffsetAddress();
    609613        pRelativeVar->bOffsetOffset=0;
    610614        if( pVar->IsRef() ){
     
    613617        }
    614618        else pRelativeVar->dwKind=VAR_GLOBAL;
    615         resultType = *pVar;
    616         pSubScripts=pVar->GetSubScriptsPtr();
     619        resultType = pVar->GetType();
     620        pSubscripts=&pVar->GetSubscripts();
    617621        bConst = pVar->IsConst();
    618622    }
     
    634638    }
    635639
    636     if(array[0]==0&&pSubScripts[0]!=-1){
     640    if( array[0] == 0 && pSubscripts->size() > 0 ){
    637641        //配列の先頭ポインタを示す場合
    638642        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    639         if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
     643
     644        if( pResultSubscripts )
     645        {
     646            (*pResultSubscripts) = *pSubscripts;
     647        }
    640648        return true;
    641649    }
     
    649657    }
    650658    if(array[0]){
    651         if(!GetArrayOffset(pSubScripts,array,resultType)){
     659        if(!GetArrayOffset(*pSubscripts,array,resultType)){
    652660            SetError(14,variable,cp);
    653661            pRelativeVar->dwKind=NON_VAR;
     
    658666        if( resultType.IsObject() || resultType.IsStruct() ){
    659667            //実態オブジェクトのメンバを参照(obj.member)
    660             if( refType != CClass::Dot ){
     668            if( refType != RefDot ){
    661669                SetError(104,VarName,cp);
    662670                pRelativeVar->dwKind=NON_VAR;
     
    673681            if(lpPtrOffset[0]){
    674682                //pObj[n].member
    675                 if( refType != CClass::Dot ){
     683                if( refType != RefDot ){
    676684                    SetError(104,VarName,cp);
    677685                    pRelativeVar->dwKind=NON_VAR;
     
    683691            else{
    684692                //pObj->member
    685                 if( refType != CClass::Pointer ){
     693                if( refType != RefPointer ){
    686694                    SetError(104,VarName,cp);
    687695                    pRelativeVar->dwKind=NON_VAR;
     
    700708            if(lpPtrOffset[0]){
    701709                //ppObj[n]->member
    702                 if( refType != CClass::Pointer ){
     710                if( refType != RefPointer ){
    703711                    SetError(104,VarName,cp);
    704712                    pRelativeVar->dwKind=NON_VAR;
     
    744752}
    745753
    746 bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){
     754bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
    747755    extern BYTE *initGlobalBuf;
    748     int i,i2,i3;
     756    int i2,i3;
    749757    char temporary[VN_SIZE];
    750758    char InitBuf[VN_SIZE];
     
    757765        int typeSize = type.GetSize();
    758766
    759         if(SubScripts[0]!=-1){
    760             typeSize*=JumpSubScripts(SubScripts+1);
    761             i=0;
    762             i2=0;
    763             while(1){
    764                 if(SubScripts[0]<i2){
    765                     SetError(41,0,cp);
    766                     return 0;
    767                 }
    768                 i=GetOneParameter(InitBuf,i,temporary);
    769                 if(!SetInitGlobalData(
    770                     offset+i2*typeSize,
    771                     type,
    772                     SubScripts+1,
    773                     temporary)) return false;
    774                 i2++;
    775                 if(InitBuf[i]=='\0') break;
     767        if( subscripts.size() > 0 ){
     768            Subscripts nestSubscripts;
     769            for( int i=1; i<(int)subscripts.size(); i++ )
     770            {
     771                nestSubscripts.push_back( subscripts[i] );
     772            }
     773
     774            typeSize*=JumpSubScripts( nestSubscripts );
     775            {
     776                int i=0;
     777                i2=0;
     778                while(1){
     779                    if( subscripts[0] < i2 ){
     780                        SetError(41,0,cp);
     781                        return 0;
     782                    }
     783                    i=GetOneParameter(InitBuf,i,temporary);
     784                    if(!SetInitGlobalData(
     785                        offset+i2*typeSize,
     786                        type,
     787                        nestSubscripts,
     788                        temporary)) return false;
     789                    i2++;
     790                    if(InitBuf[i]=='\0') break;
     791                }
    776792            }
    777793            return true;
     
    794810                if(!SetInitGlobalData(offset+i3,
    795811                    pMember->GetType(),
    796                     pMember->SubScripts,
     812                    pMember->GetSubscripts(),
    797813                    temporary)) return false;
    798814            }
     
    815831    }
    816832
    817     if(SubScripts[0]!=-1){
     833    if( subscripts.size() > 0 ){
    818834        SetError(41,0,cp);
    819835        return false;
     
    883899    return true;
    884900}
    885 bool InitLocalVar(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){
    886     int i,i2,i3;
     901bool InitLocalVar(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
     902    int i2,i3;
    887903    char temporary[VN_SIZE];
    888904    char InitBuf[VN_SIZE];
     
    895911        int typeSize = type.GetSize();
    896912
    897         if(SubScripts[0]!=-1){
    898             typeSize*=JumpSubScripts(SubScripts+1);
    899             i=0;
    900             i2=0;
    901             while(1){
    902                 if(SubScripts[0]<i2){
    903                     SetError(41,0,cp);
    904                     return false;
    905                 }
    906                 i=GetOneParameter(InitBuf,i,temporary);
    907                 if(!InitLocalVar(
    908                     offset+i2*typeSize,
    909                     type,
    910                     SubScripts+1,
    911                     temporary)) return false;
    912                 i2++;
    913                 if(InitBuf[i]=='\0') break;
     913        if( subscripts.size() > 0 ){
     914            Subscripts nestSubscripts;
     915            for( int i=1; i<(int)subscripts.size(); i++ )
     916            {
     917                nestSubscripts.push_back( subscripts[i] );
     918            }
     919
     920            typeSize*=JumpSubScripts( nestSubscripts );
     921            {
     922                int i=0;
     923                i2=0;
     924                while(1){
     925                    if( subscripts[0] < i2 ){
     926                        SetError(41,0,cp);
     927                        return 0;
     928                    }
     929                    i=GetOneParameter(InitBuf,i,temporary);
     930                    if(!InitLocalVar(
     931                        offset+i2*typeSize,
     932                        type,
     933                        nestSubscripts,
     934                        temporary)) return false;
     935                    i2++;
     936                    if(InitBuf[i]=='\0') break;
     937                }
    914938            }
    915939            return true;
     
    932956                if(!InitLocalVar(offset+i3,
    933957                    pMember->GetType(),
    934                     pMember->SubScripts,
     958                    pMember->GetSubscripts(),
    935959                    temporary)) return false;
    936960
     
    949973    ///////////////////////////////////////
    950974
    951     if(SubScripts[0]!=-1){
     975    if( subscripts.size() > 0 ){
    952976        SetError(41,0,cp);
    953977        return false;
     
    10611085}
    10621086
    1063 void dim( char *VarName,int *SubScripts,Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
     1087void dim( char *VarName, const Subscripts &subscripts, Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
    10641088    if( UserProc::IsGlobalAreaCompiling() ){
    10651089        /////////////////////////
     
    10671091        /////////////////////////
    10681092
    1069         //OpcodeOthers( ( (string)"OutputDebugString(Ex\"" + VarName + "\r\n\")" ).c_str() );
    1070         AddGlobalVariable(VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
     1093        AddGlobalVariable(VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags);
    10711094    }
    10721095    else{
     
    10751098        /////////////////
    10761099
    1077         if( UserProc::CompilingUserProc().localVars.DuplicateCheck( VarName ) ){
     1100        if( UserProc::CompilingUserProc().GetLocalVars().DuplicateCheck( VarName ) ){
    10781101            //2重定義のエラー
    10791102            SetError(15,VarName,cp);
     
    10831106        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
    10841107
    1085         Variable *pVar = new VariableImpl( VarName, type, isConst );
    1086 
    1087         if( SubScripts[0] != -1 ){
     1108        Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter );
     1109
     1110        if( subscripts.size() > 0 ){
    10881111            //配列あり
    1089             pVar->SetArray( SubScripts );
    1090         }
    1091 
    1092         //コンストラクタ用パラメータ
    1093         pVar->paramStrForConstructor = ConstractParameter;
     1112            pVar->SetArray( subscripts );
     1113        }
    10941114
    10951115        //レキシカルスコープ
    1096         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    1097         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     1116        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     1117        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    10981118        pVar->bLiving=TRUE;
    10991119
     
    11021122
    11031123        // 変数を追加
    1104         UserProc::CompilingUserProc().localVars.push_back( pVar );
     1124        UserProc::CompilingUserProc().GetLocalVars().push_back( pVar );
    11051125
    11061126        //アラインメントを考慮
    1107         if( pVar->IsStruct() ){
    1108             int alignment = pVar->GetClass().iAlign;
     1127        if( pVar->GetType().IsStruct() ){
     1128            int alignment = pVar->GetType().GetClass().iAlign;
    11091129
    11101130            if( alignment ){
     
    11261146
    11271147        AllLocalVarSize += pVar->GetMemorySize();
    1128         pVar->offset = AllLocalVarSize;
     1148        pVar->SetOffsetAddress( AllLocalVarSize );
    11291149
    11301150        //レキシカルスコープ
    1131         pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
    1132         pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
     1151        pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
     1152        pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
    11331153        pVar->bLiving=TRUE;
    11341154
     
    11401160
    11411161            int result = 0;
    1142             if( !pVar->IsObject() ){
    1143                 result = InitLocalVar(-pVar->offset,
    1144                     *pVar,
    1145                     pVar->GetSubScriptsPtr(),
     1162            if( !pVar->GetType().IsObject() ){
     1163                result = InitLocalVar(-pVar->GetOffsetAddress(),
     1164                    pVar->GetType(),
     1165                    pVar->GetSubscripts(),
    11461166                    InitBuf);
    11471167            }
     
    11711191
    11721192            //add rcx, offset
    1173             op_add_RV( REG_RCX, -pVar->offset );
     1193            op_add_RV( REG_RCX, -pVar->GetOffsetAddress() );
    11741194            obp-=sizeof(long);
    11751195            AddLocalVarAddrSchedule();
     
    11861206    if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
    11871207        char objectSize[255];
    1188         if( SubScripts[0] == -1 ){
     1208        if( subscripts.size() == 0 ){
    11891209            objectSize[0] = 0;
    11901210        }
    11911211        else{
    1192             if( SubScripts[1] != -1 ){
     1212            if( subscripts.size() > 1 ){
    11931213                SetError(300,NULL,cp);
    11941214            }
    1195             sprintf( objectSize, "%d", SubScripts[0] );
     1215            sprintf( objectSize, "%d", subscripts[0] );
    11961216        }
    11971217        Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
     
    13041324
    13051325bool Compile_AddGlobalRootsForGc(){
    1306     UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
     1326    const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
    13071327    if( !pUserProc_AddGlobalRootPtr ){
    13081328        SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
     
    13101330    }
    13111331
    1312     BOOST_FOREACH( const Variable *pVar, globalVars ){
    1313         if( pVar->IsObject() || pVar->IsPointer() || pVar->IsStruct() ){
     1332    BOOST_FOREACH( const Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
     1333        if( pVar->GetType().IsObject() || pVar->GetType().IsPointer() || pVar->GetType().IsStruct() ){
    13141334            // オブジェクトまたはポインタだったとき
    13151335            // ※構造体も含む(暫定対応)
     
    13211341            // ルートポインタを引き渡す
    13221342            //mov rdx,offset
    1323             op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->offset);
     1343            op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress());
    13241344            obp-=sizeof(long);
    13251345            pobj_GlobalVarSchedule->add();
  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r202 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/common/Environment.h>
    24
     
    46
    57#include <LexicalScopingImpl.h>
    6 #include <ClassImpl.h>
     8#include <Class.h>
    79#include <Compiler.h>
    810
     11#include <../Enum.h>
     12
    913#include "../BasicCompiler_Common/common.h"
     14#include "../BasicCompiler_Common/DebugSection.h"
    1015#include "Opcode.h"
    1116
     
    1621
    1722// グローバル関数、静的メソッド
    18 UserProc
     23const UserProc
    1924    *pSub_System_StartupProgram,
    2025    *pSub_DebugSys_StartProc,
     
    3641
    3742// 動的メソッド
    38 UserProc
     43const UserProc
    3944    *pUserProc_System_CGarbageCollection_RegisterGlobalRoots;
    4045
     
    160165
    161166    //クラス名を取得(詳細情報はGetAllClassInfoで取得)
    162     //   GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。
     167    //   CollectUserProcs関数の中で参照されるオブジェクト名を事前に取得する。
    163168    //     ※オブジェクトの内容までは取得しない
    164169    compiler.GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
     
    171176
    172177    //サブルーチン(ユーザー定義、DLL関数)の識別子、アドレスを取得
    173     Smoothie::Temp::pCompilingClass = NULL;
    174     GetSubInfo();
    175 
    176     //クラス情報を取得(※注 - GetSubInfoの後に呼び出す)
     178    compiler.pCompilingClass = NULL;
     179    UserProcs::CollectUserProcs( Smoothie::Lexical::source, compiler.GetMeta().GetUserProcs() );
     180
     181    // クラス情報を取得(※注 - CollectUserProcsの後に呼び出す)
    177182    compiler.GetMeta().GetClasses().GetAllClassInfo();
    178183
    179     compiler.GetMeta().AutoWrite( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" );
     184    // サブルーチン(ユーザー定義、DLL関数)のイテレータの準備
     185    compiler.GetMeta().GetUserProcs().Iterator_Init();
     186
     187    /*
     188    if( !compiler.GetMeta().Write( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
     189    {
     190        MessageBox(0,"XML書き込みに失敗","test",0);
     191    }
     192    MetaImpl *pTempMeta = new MetaImpl();
     193    if( !pTempMeta->Read( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
     194    {
     195        MessageBox(0,"XML読み込みに失敗","test",0);
     196    }
     197    compiler.GetMeta() = (*pTempMeta);
     198    */
    180199
    181200    //コードと行番号の関係
     
    347366        extern CStackFrame *pobj_sf;
    348367        pobj_sf=new CStackFrame();
     368
     369        trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" );
    349370
    350371
     
    399420
    400421        //call _System_Call_Destructor_of_GlobalObject
    401         extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
     422        extern const UserProc *pSub_System_Call_Destructor_of_GlobalObject;
    402423        op_call(pSub_System_Call_Destructor_of_GlobalObject);
    403424
     
    557578        ExportNamesLength=lstrlen(lpExportNames)+1;
    558579
    559         extern GlobalProc **ppSubHash;
    560         GlobalProc *pUserProc,*psi2;
     580        UserProc *pUserProc,*psi2;
    561581        while(1){
    562582            //辞書順にサーチ
    563583            temporary[0]=0;
    564             for(i=0,psi2=0;i<MAX_HASH;i++){
    565                 pUserProc=ppSubHash[i];
    566                 while(pUserProc){
    567                     if(pUserProc->IsExport()){
    568                         if(temporary[0]=='\0'){
     584            compiler.GetMeta().GetUserProcs().Iterator_Reset();
     585            while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     586            {
     587                pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     588                if(pUserProc->IsExport()){
     589                    if(temporary[0]=='\0'){
     590                        lstrcpy(temporary,pUserProc->GetName().c_str());
     591                        psi2=pUserProc;
     592                    }
     593                    else{
     594                        i3=lstrlen(temporary);
     595                        i4=(int)pUserProc->GetName().size();
     596                        if(i3<i4) i3=i4;
     597                        if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
    569598                            lstrcpy(temporary,pUserProc->GetName().c_str());
    570599                            psi2=pUserProc;
    571600                        }
    572                         else{
    573                             i3=lstrlen(temporary);
    574                             i4=(int)pUserProc->GetName().size();
    575                             if(i3<i4) i3=i4;
    576                             if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
    577                                 lstrcpy(temporary,pUserProc->GetName().c_str());
    578                                 psi2=pUserProc;
    579                             }
    580                         }
    581601                    }
    582                     pUserProc=pUserProc->pNextData;
    583602                }
    584603            }
     
    589608
    590609            if( pUserProc->GetName() == "DllMain" ){
    591                 DllMain_EntryPoint=pUserProc->beginOpAddress;
     610                DllMain_EntryPoint=pUserProc->GetBeginOpAddress();
    592611            }
    593612
    594613            lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
    595             lpdwExportAddressTable[ExportNum]=pUserProc->beginOpAddress;
     614            lpdwExportAddressTable[ExportNum]=pUserProc->GetBeginOpAddress();
    596615
    597616            lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
     
    800819    //(デバッグ情報で利用される)
    801820    extern int AllInitGlobalVarSize;
    802     BOOST_FOREACH( Variable *pVar, globalVars ){
    803         if(pVar->offset&0x80000000){
    804             pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
     821    BOOST_FOREACH( Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
     822        if(pVar->GetOffsetAddress()&0x80000000){
     823            pVar->SetOffsetAddress(
     824                (pVar->GetOffsetAddress()&0x7FFFFFFF)+AllInitGlobalVarSize
     825            );
    805826        }
    806827    }
     
    10881109    // ※x86はRVAからのオフセット。x64はRPI(実行中アドレス)からのオフセット
    10891110    for(i=0;i<pobj_ImportAddrSchedule->num;i++){
    1090         DllProc *pDllProc;
    1091         pDllProc=pobj_ImportAddrSchedule->ppdi[i];
     1111        const DllProc *pDllProc = pobj_ImportAddrSchedule->ppdi[i];
    10921112        *((long *)(OpBuffer+pobj_ImportAddrSchedule->pObpValues[i]))=
    10931113            MemPos_ImportSection+
     
    11011121    // プロシージャポインタスケジュール
    11021122    for(i=0;i<pobj_SubAddrSchedule->num;i++){
    1103         if(pobj_SubAddrSchedule->ppsi[i]->beginOpAddress==0
    1104             &&pobj_SubAddrSchedule->ppsi[i]->endOpAddress==0){
     1123        if(pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()==0
     1124            &&pobj_SubAddrSchedule->ppsi[i]->GetEndOpAddress()==0){
    11051125            SetError(300,NULL,-1);
    11061126        }
     
    11081128        if(pobj_SubAddrSchedule->pbCall[i]){
    11091129            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1110                 pobj_SubAddrSchedule->ppsi[i]->beginOpAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
     1130                pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
    11111131        }
    11121132        else{
    11131133            *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
    1114                 pobj_SubAddrSchedule->ppsi[i]->beginOpAddress+ImageBase+MemPos_CodeSection;
     1134                pobj_SubAddrSchedule->ppsi[i]->GetBeginOpAddress()+ImageBase+MemPos_CodeSection;
    11151135        }
    11161136    }
  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    164166    // 動的メソッドを検索
    165167    ///////////////////////////////////////////////////////////////////
    166     vector<UserProc *> userProcs;
     168    vector<const UserProc *> userProcs;
    167169
    168170    char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
    169     CClass::RefType refType;
     171    ReferenceKind refType;
    170172    lstrcpy( methodName, member );
    171173    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
    172174
    173175    objClass.GetMethods().Enum( methodName, userProcs );
    174     UserProc *pUserProc;
    175176    if(userProcs.size()){
    176177        //オーバーロードを解決
    177         pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
     178        const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
    178179
    179180        if( pUserProc ){
     
    245246    // パース
    246247    char member[VN_SIZE];
    247     CClass::RefType refType;
    248     if( CClass::SplitName( termFull, termLeft, member, refType ) ){
     248    ReferenceKind refType;
     249    if( SplitMemberName( termFull, termLeft, member, refType ) ){
    249250        ///////////////////////////////////////////////////////////////////
    250251        // オブジェクトとメンバに分解できるとき
     
    309310    if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
    310311        //Thisオブジェクト
    311         resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
     312        resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
    312313
    313314        SetThisPtrToReg( UseReg );
     
    385386            return true;
    386387        }
    387         else if(GetConstCalcBuffer(procName,parameter,temporary)){
    388             /////////////////////////
    389             // マクロ関数
    390             /////////////////////////
    391 
    392             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    393             if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
    394 
    395             //マクロ関数の場合
    396             NumOpe(&UseReg,temporary,Type(),resultType);
    397 
    398             if(!IS_LITERAL(resultType.GetIndex())){
    399                 //リテラル値ではなかったとき
    400                 isLiteral = false;
    401             }
    402 
    403             return true;
     388
     389        ConstMacro *pConstMacro = compiler.GetMeta().GetGlobalConstMacros().Find( procName );
     390        if( pConstMacro )
     391        {
     392            if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
     393            {
     394                /////////////////////////
     395                // マクロ関数
     396                /////////////////////////
     397
     398                //閉じカッコ")"に続く文字がNULLでないときはエラーにする
     399                if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     400
     401                //マクロ関数の場合
     402                NumOpe(&UseReg, temporary,Type(),resultType);
     403
     404                if(!IS_LITERAL(resultType.GetIndex())){
     405                    //リテラル値ではなかったとき
     406                    isLiteral = false;
     407                }
     408
     409                return true;
     410            }
    404411        }
    405412    }
     
    905912                    //////////////
    906913
    907                     i3 = CDBConst::obj.GetBasicType(term);
     914                    i3 = compiler.GetMeta().GetGlobalConsts().GetBasicType(term);
    908915                    if(i3){
    909                         if( CDBConst::obj.IsStringPtr( term ) ){
     916                        if( compiler.GetMeta().GetGlobalConsts().IsStringPtr( term ) ){
    910917                            //リテラル文字列
    911918
    912                             double dbl = CDBConst::obj.GetDoubleData(term);
     919                            double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
    913920                            memcpy(&i64data,&dbl,sizeof(double));
    914921
     
    924931                        if(IsRealNumberType(i3)){
    925932                            //実数
    926                             double dbl = CDBConst::obj.GetDoubleData(term);
     933                            double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
    927934                            memcpy(&i64data,&dbl,sizeof(double));
    928935                            goto Literal;
     
    930937                        else if(IsWholeNumberType(i3)){
    931938                            //整数
    932                             i64data = CDBConst::obj.GetWholeData(term);
     939                            i64data = compiler.GetMeta().GetGlobalConsts().GetWholeData(term);
    933940                            goto Literal;
    934941                        }
  • trunk/abdev/BasicCompiler64/NumOpe_Arithmetic.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <Compiler.h>
    24
     
    561563
    562564        //call pow
    563         extern UserProc *pSub_pow;
     565        extern const UserProc *pSub_pow;
    564566        op_call(pSub_pow);
    565567
  • trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp

    r64 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler64/NumOpe_Relation.cpp

    r36 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp

    r198 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
  • trunk/abdev/BasicCompiler64/Opcode.h

    r142 r206  
    1 //Opcode.h
     1#pragma once
     2
     3#include <Type.h>
     4#include <Procedure.h>
    25
    36
     
    323326bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
    324327void SetThisPtrToReg(int reg);
    325 bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = NULL);
    326 bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *InitBuf);
     328bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts = NULL );
     329bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *InitBuf);
    327330#define DIMFLAG_INITDEBUGVAR            0x01
    328331#define DIMFLAG_NONCALL_CONSTRACTOR     0x02
    329332#define DIMFLAG_STATIC                  0x04
    330333#define DIMFLAG_CONST                   0x08
    331 void dim( char *VarName,int *SubScripts,Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
     334void dim( char *VarName, const Subscripts &subscripts, Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
    332335void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
    333336bool Compile_AddGlobalRootsForGc();
     
    356359
    357360public:
    358     UserProc *_OverloadSolution( const char *name, std::vector<UserProc *> &subs, bool isEnabledReturnType = false );
    359     UserProc *OverloadSolution( const char *name, std::vector<UserProc *> &subs, bool isEnabledReturnType = false );
     361    const UserProc *_OverloadSolution( const char *name, std::vector<const UserProc *> &subs, bool isEnabledReturnType = false );
     362    const UserProc *OverloadSolution( const char *name, std::vector<const UserProc *> &subs, bool isEnabledReturnType = false );
    360363
    361364    void ApplyDefaultParameters( const Parameters &params );
     
    389392#define PROCFLAG_NEW    1
    390393bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
    391 bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
     394bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
    392395bool Opcode_CallDllProc( const char *lpszParms,DllProc *pDllProc);
    393396
     
    401404//OperatorProc.cpp
    402405void FreeTempObject(int reg,const CClass *pobj_c);
    403 int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
     406int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
    404407void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType);
    405408void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType);
     
    512515void op_fld_ptr_esp(int type);
    513516void op_zero_reg(int reg);
    514 void op_call( UserProc *pUserProc );
    515 void op_call( DllProc *pDllProc );
     517void op_call( const UserProc *pUserProc );
     518void op_call( const DllProc *pDllProc );
    516519void op_ret();
  • trunk/abdev/BasicCompiler64/OperatorProc.cpp

    r135 r206  
     1#include "stdafx.h"
     2
     3#include <jenga/include/smoothie/LexicalAnalysis.h>
     4
    15#include "../BasicCompiler_Common/common.h"
    26#include "Opcode.h"
     
    1620
    1721        //call DestructorProcAddr
    18         op_call( method->pUserProc );
     22        op_call( &method->GetUserProc() );
    1923    }
    2024
     
    2327
    2428    //call free
    25     extern UserProc *pSub_free;
     29    extern const UserProc *pSub_free;
    2630    op_call(pSub_free);
    2731}
    2832
    29 int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
     33int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
    3034    //オーバーロードされたオペレータ関数を呼び出す
    3135    CClass *pobj_c;
    3236    pobj_c=(CClass *)index_stack[sp-2];
    3337
    34     std::vector<UserProc *> subs;
     38    std::vector<const UserProc *> subs;
    3539    pobj_c->GetMethods().Enum( idCalc, subs );
    3640    if( subs.size() == 0 ){
     
    5862    if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
    5963    else GetCalcName(idCalc,temporary);
    60     UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
     64    const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
    6165
    6266    if(!pUserProc){
     
    118122
    119123            //call calloc
    120             extern UserProc *pSub_calloc;
     124            extern const UserProc *pSub_calloc;
    121125            op_call(pSub_calloc);
    122126
     
    319323void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType ){
    320324
    321     std::vector<UserProc *> subs;
     325    std::vector<const UserProc *> subs;
    322326    pobj_Class->GetMethods().Enum( CALC_ARRAY_GET, subs );
    323327    if( subs.size() == 0 ){
  • trunk/abdev/BasicCompiler64/Register.cpp

    r131 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler64/amd64_main.cpp

    r142 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
     
    17911793/////////////////////////////
    17921794
    1793 void op_call( UserProc *pUserProc ){
     1795void op_call( const UserProc *pUserProc ){
    17941796    OpBuffer[obp++] = (char)0xE8;
    17951797    pobj_SubAddrSchedule->add( pUserProc, 1 );
     
    17971799    obp += sizeof(long);
    17981800}
    1799 void op_call( DllProc *pDllProc ){
     1801void op_call( const DllProc *pDllProc ){
    18001802    OpBuffer[obp++] = (char)0xFF;
    18011803    OpBuffer[obp++] = (char)0x15;
  • trunk/abdev/BasicCompiler64/increment.cpp

    r129 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler64/stack_frame.cpp

    r66 r206  
     1#include "stdafx.h"
     2
    13#include "../BasicCompiler_Common/common.h"
    24#include "Opcode.h"
  • trunk/abdev/BasicCompiler_Common/BasicCompiler.cpp

    r188 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    548550}
    549551
     552void _Test()
     553{
     554    Jenga::Common::LoggerSetting loggerSetting;
     555    bool result = loggerSetting.Read( Jenga::Common::Environment::GetAppDir() + "\\logger.setting.xml" );
     556
     557    MessageBeep(0);
     558}
     559
    550560int PASCAL WinMain(HINSTANCE hThisInst,HINSTANCE hPrevInst,LPSTR lpCmdLine,int nShowCmd){
    551561    int i,i2;
    552562    char temporary[1024],temp2[MAX_PATH];
     563
     564    //_Test();
    553565
    554566    //MessageBox(0,"starting compiler/debugger","ActiveBasic",MB_OK);
  • trunk/abdev/BasicCompiler_Common/BasicCompiler.h

    r182 r206  
    2323DWORD ImageBase;
    2424INCLUDEFILEINFO IncludeFileInfo;
    25 GlobalProc **ppSubHash;
    26 int SubNum;
    27 char **ppMacroNames;
    28 int MacroNum;
    2925DllProc **ppDeclareHash;
    30 CONSTINFO **ppConstHash;
    3126
    3227ERRORINFO *pErrorInfo;
  • trunk/abdev/BasicCompiler_Common/BreakPoint.cpp

    r165 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/common/Environment.h>
     4#include <jenga/include/smoothie/Source.h>
    25
    36#include "common.h"
  • trunk/abdev/BasicCompiler_Common/CDebugThreadInfo.cpp

    r4 r206  
     1#include "stdafx.h"
     2
    13#include "common.h"
     4#include "DebugSection.h"
    25
    36
  • trunk/abdev/BasicCompiler_Common/CommandFormat.cpp

    r75 r206  
     1#include "stdafx.h"
     2
    13#include "common.h"
    24
  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r199 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    126128    int i,i2;
    127129
    128     if(Command[0]=='\0') return;
     130    if(Command[0]=='\0')
     131    {
     132        return;
     133    }
     134
     135    trace_for_sourcecodestep( FormatEscapeSequenceStringToDefaultString(Command) );
     136
    129137    if(Command[0]=='*'&&IsVariableTopChar(Command[1])){
    130138        //Goto先ラベル
  • trunk/abdev/BasicCompiler_Common/Debug.cpp

    r165 r206  
     1#include "stdafx.h"
     2
     3#include <Compiler.h>
     4
    15#include "../BasicCompiler_Common/common.h"
     6#include "../BasicCompiler_Common/DebugSection.h"
    27
    38//デバッグ用
     
    224229    SendDlgItemMessage(hMainDlg,IDC_DEBUGLIST,EM_REPLACESEL,0,(LPARAM)buffer);
    225230}
    226 GlobalProc *GetSubFromObp(ULONG_PTR pos){
    227     extern GlobalProc **ppSubHash;
    228     GlobalProc *pUserProc;
    229     int i2;
    230 
    231     for(i2=0;i2<MAX_HASH;i2++){
    232         pUserProc=ppSubHash[i2];
    233         while(pUserProc){
    234             if(rva_to_real(pUserProc->beginOpAddress) <= pos  &&
    235                 pos < rva_to_real(pUserProc->endOpAddress))
    236                 return pUserProc;
    237 
    238             pUserProc=pUserProc->pNextData;
    239         }
    240     }
    241     return 0;
     231UserProc *GetSubFromObp(ULONG_PTR pos){
     232    compiler.GetMeta().GetUserProcs().Iterator_Reset();
     233    while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     234    {
     235        UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     236
     237        if(rva_to_real(pUserProc->GetBeginOpAddress()) <= pos  &&
     238            pos < rva_to_real(pUserProc->GetEndOpAddress()))
     239        {
     240            return pUserProc;
     241        }
     242    }
     243    return NULL;
    242244}
    243245void ReleaseSingleStep(DWORD dwBeforeStepRun,HANDLE hThread,CONTEXT *pContext){
     
    447449    pobj_dti=new CDebugThreadInfo();
    448450
    449     GlobalProc *pUserProc;
     451    UserProc *pUserProc;
    450452
    451453    extern DWORD dwStepRun;
     
    681683                        if(!bRet) MessageBox(hMainDlg,"プロセスメモリーの読み込みに失敗","error",MB_OK);
    682684
    683                         extern UserProc *pSub_DebugSys_EndProc;
     685                        extern const UserProc *pSub_DebugSys_EndProc;
    684686                        if((BYTE)temporary[0]==0xE8&&
    685                             *((long *)(temporary+1))+5==(long)rva_to_real(pSub_DebugSys_EndProc->beginOpAddress)-(long)EIP_RIP(Context)){
     687                            *((long *)(temporary+1))+5==(long)rva_to_real(pSub_DebugSys_EndProc->GetBeginOpAddress())-(long)EIP_RIP(Context)){
    686688                            //プロシージャの終端位置の場合はステップインを行う
    687689                            goto StepIn;
     
    704706                            //シングルステップON
    705707                            WriteProcessMemory(hDebugProcess,
    706                                 (void *)rva_to_real(pUserProc->beginOpAddress),
    707                                 pobj_DBDebugSection->pobj_now->SingleStepCodeBuffer+pUserProc->beginOpAddress,
    708                                 pUserProc->endOpAddress-pUserProc->beginOpAddress,
     708                                (void *)rva_to_real(pUserProc->GetBeginOpAddress()),
     709                                pobj_DBDebugSection->pobj_now->SingleStepCodeBuffer+pUserProc->GetBeginOpAddress(),
     710                                pUserProc->GetEndOpAddress()-pUserProc->GetBeginOpAddress(),
    709711                                &lpAccBytes);
    710712                        }
  • trunk/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r201 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
    35#include <Compiler.h>
    4 #include <ClassImpl.h>
    5 #include <VariableImpl.h>
     6#include <Class.h>
     7#include <Variable.h>
    68
    79#include "../BasicCompiler_Common/common.h"
     10#include "../BasicCompiler_Common/DebugSection.h"
    811
    912#ifdef _AMD64_
     
    4447
    4548
    46 CDebugSection::CDebugSection(){
    47     memset(this,0,sizeof(CDebugSection));
    48 }
    4949CDebugSection::~CDebugSection(){
    5050    if(pobj_DBClass) DeleteDebugInfo();
     
    5656void CDebugSection::make(void){
    5757    extern INCLUDEFILEINFO IncludeFileInfo;
    58     int i2,i3,i5,BufferSize;
     58    int i2,i3,BufferSize;
    5959
    6060    if(buffer){
     
    159159
    160160    //グローバル変数情報
    161     *(long *)(buffer+i2)=(int)::globalVars.size();
    162     i2+=sizeof(long);
    163     BOOST_FOREACH( Variable *pVar, ::globalVars ){
     161    *(long *)(buffer+i2)=(int)compiler.GetMeta().GetGlobalVars().size();
     162    i2+=sizeof(long);
     163    BOOST_FOREACH( Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
    164164        //変数名
    165165        lstrcpy(buffer+i2,pVar->GetName().c_str());
     
    167167
    168168        //型
    169         *(long *)(buffer+i2)=pVar->GetBasicType();
     169        *(long *)(buffer+i2)=pVar->GetType().GetBasicType();
    170170        i2+=sizeof(long);
    171171
    172172        //型の拡張情報
    173         SetLpIndex_DebugFile(buffer,&i2,*pVar);
     173        SetLpIndex_DebugFile(buffer,&i2,pVar->GetType());
    174174
    175175        buffer[i2++] = pVar->IsRef() ? 1 : 0;
     
    178178
    179179        if(pVar->IsArray()){
    180             for(i5=0;;i5++){
    181                 *(long *)(buffer+i2)=pVar->GetSubScriptsPtr()[i5];
     180            *(long *)(buffer+i2)=(int)pVar->GetSubscripts().size();
     181            i2+=sizeof(long);
     182            BOOST_FOREACH( int indexMax, pVar->GetSubscripts() )
     183            {
     184                *(long *)(buffer+i2)=indexMax;
    182185                i2+=sizeof(long);
    183                 if(pVar->GetSubScriptsPtr()[i5]==-1) break;
    184186            }
    185187        }
    186188
    187189        //レキシカルスコープ情報
    188         *(long *)(buffer+i2)=pVar->ScopeStartAddress;
    189         i2+=sizeof(long);
    190         *(long *)(buffer+i2)=pVar->ScopeEndAddress;
    191         i2+=sizeof(long);
    192         *(long *)(buffer+i2)=pVar->ScopeLevel;
     190        *(long *)(buffer+i2)=pVar->GetScopeStartAddress();
     191        i2+=sizeof(long);
     192        *(long *)(buffer+i2)=pVar->GetScopeEndAddress();
     193        i2+=sizeof(long);
     194        *(long *)(buffer+i2)=pVar->GetScopeLevel();
    193195        i2+=sizeof(long);
    194196
    195197        //メモリ位置
    196         *(long *)(buffer+i2)=pVar->offset;
     198        *(long *)(buffer+i2)=pVar->GetOffsetAddress();
    197199        i2+=sizeof(long);
    198200
     
    210212
    211213    //プロシージャ情報
    212     extern GlobalProc **ppSubHash;
    213     extern int SubNum;
    214     GlobalProc *pUserProc;
    215     *(long *)(buffer+i2)=SubNum;
    216     i2+=sizeof(long);
    217     for(i3=0;i3<MAX_HASH;i3++){
    218         pUserProc=ppSubHash[i3];
    219         while(pUserProc){
    220             if(pUserProc->GetParentClassPtr()){
    221                 lstrcpy(buffer+i2,pUserProc->GetParentClassPtr()->GetName().c_str());
    222                 i2+=lstrlen(buffer+i2)+1;
    223             }
    224             else{
    225                 lstrcpy(buffer+i2,"");
    226                 i2+=lstrlen(buffer+i2)+1;
    227             }
    228 
    229             //ID
    230             *(long *)(buffer+i2)=pUserProc->id;
    231             i2+=sizeof(long);
    232 
    233             //関数名
    234             lstrcpy(buffer+i2,pUserProc->GetName().c_str());
     214    *(long *)(buffer+i2) = compiler.GetMeta().GetUserProcs().Iterator_GetMaxCount();
     215    i2+=sizeof(long);
     216    compiler.GetMeta().GetUserProcs().Iterator_Reset();
     217    while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     218    {
     219        UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     220
     221        if(pUserProc->GetParentClassPtr()){
     222            lstrcpy(buffer+i2,pUserProc->GetParentClassPtr()->GetName().c_str());
    235223            i2+=lstrlen(buffer+i2)+1;
    236 
    237             *(long *)(buffer+i2)=pUserProc->beginOpAddress;
    238             i2+=sizeof(long);
    239             *(long *)(buffer+i2)=pUserProc->endOpAddress;
    240             i2+=sizeof(long);
    241 
    242             //ローカル変数情報
    243             *(long *)(buffer+i2)=(int)pUserProc->localVars.size();
    244             i2+=sizeof(long);
     224        }
     225        else{
     226            lstrcpy(buffer+i2,"");
     227            i2+=lstrlen(buffer+i2)+1;
     228        }
     229
     230        //ID
     231        *(long *)(buffer+i2)=pUserProc->GetId();
     232        i2+=sizeof(long);
     233
     234        //関数名
     235        lstrcpy(buffer+i2,pUserProc->GetName().c_str());
     236        i2+=lstrlen(buffer+i2)+1;
     237
     238        *(long *)(buffer+i2)=pUserProc->GetBeginOpAddress();
     239        i2+=sizeof(long);
     240        *(long *)(buffer+i2)=pUserProc->GetEndOpAddress();
     241        i2+=sizeof(long);
     242
     243        //ローカル変数情報
     244        *(long *)(buffer+i2)=(int)pUserProc->GetLocalVars().size();
     245        i2+=sizeof(long);
     246
     247        //バッファが足りない場合は再確保
     248        if(BufferSize<i2+32768){
     249            BufferSize+=32768;
     250            buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
     251        }
     252
     253        BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
     254            lstrcpy(buffer+i2,pVar->GetName().c_str());
     255            i2+=lstrlen(buffer+i2)+1;
     256
     257            //型
     258            *(long *)(buffer+i2)=pVar->GetType().GetBasicType();
     259            i2+=sizeof(long);
     260
     261            //型の拡張情報
     262            SetLpIndex_DebugFile(buffer,&i2,pVar->GetType());
     263
     264            //参照型パラメータかどうか
     265            buffer[i2++] = pVar->IsRef() ? 1 : 0;
     266
     267            //配列かどうか
     268            buffer[i2++] = pVar->IsArray() ? 1 : 0;
     269
     270            //配列要素
     271            if(pVar->IsArray()){
     272                *(long *)(buffer+i2)=(int)pVar->GetSubscripts().size();
     273                i2+=sizeof(long);
     274                BOOST_FOREACH( int indexMax, pVar->GetSubscripts() )
     275                {
     276                    *(long *)(buffer+i2)=indexMax;
     277                    i2+=sizeof(long);
     278                }
     279            }
     280
     281            //レキシカルスコープ情報
     282            *(long *)(buffer+i2)=pVar->GetScopeStartAddress();
     283            i2+=sizeof(long);
     284            *(long *)(buffer+i2)=pVar->GetScopeEndAddress();
     285            i2+=sizeof(long);
     286            *(long *)(buffer+i2)=pVar->GetScopeLevel();
     287            i2+=sizeof(long);
     288
     289            //メモリ位置
     290            *(long *)(buffer+i2)=pVar->GetOffsetAddress();
     291            i2+=sizeof(long);
     292
     293
     294
    245295
    246296            //バッファが足りない場合は再確保
     
    249299                buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
    250300            }
    251 
    252             BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    253                 lstrcpy(buffer+i2,pVar->GetName().c_str());
    254                 i2+=lstrlen(buffer+i2)+1;
    255 
    256                 //型
    257                 *(long *)(buffer+i2)=pVar->GetBasicType();
    258                 i2+=sizeof(long);
    259 
    260                 //型の拡張情報
    261                 SetLpIndex_DebugFile(buffer,&i2,*pVar);
    262 
    263                 //参照型パラメータかどうか
    264                 buffer[i2++] = pVar->IsRef() ? 1 : 0;
    265 
    266                 //配列かどうか
    267                 buffer[i2++] = pVar->IsArray() ? 1 : 0;
    268 
    269                 //配列要素
    270                 if(pVar->IsArray()){
    271                     for(i5=0;;i5++){
    272                         *(long *)(buffer+i2)=pVar->GetSubScriptsPtr()[i5];
    273                         i2+=sizeof(long);
    274                         if(pVar->GetSubScriptsPtr()[i5]==-1) break;
    275                     }
    276                 }
    277 
    278                 //レキシカルスコープ情報
    279                 *(long *)(buffer+i2)=pVar->ScopeStartAddress;
    280                 i2+=sizeof(long);
    281                 *(long *)(buffer+i2)=pVar->ScopeEndAddress;
    282                 i2+=sizeof(long);
    283                 *(long *)(buffer+i2)=pVar->ScopeLevel;
    284                 i2+=sizeof(long);
    285 
    286                 //メモリ位置
    287                 *(long *)(buffer+i2)=pVar->offset;
    288                 i2+=sizeof(long);
    289 
    290 
    291 
    292 
    293                 //バッファが足りない場合は再確保
    294                 if(BufferSize<i2+32768){
    295                     BufferSize+=32768;
    296                     buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
    297                 }
    298             }
    299 
    300             pUserProc=pUserProc->pNextData;
    301301        }
    302302    }
     
    328328        i2+=sizeof(long);
    329329
    330         //メンバ
     330        // 動的メンバ
    331331        *(long *)(buffer+i2)=(int)pobj_c->GetDynamicMembers().size();
    332332        i2+=sizeof(long);
     
    347347            i2+=sizeof(Prototype::Accessibility);
    348348
    349             memcpy(buffer+i2,member->SubScripts,sizeof(int)*MAX_ARRAYDIM);
    350             i2+=sizeof(int)*MAX_ARRAYDIM;
     349            *(long *)(buffer+i2)=(int)member->GetSubscripts().size();
     350            i2+=sizeof(long);
     351            BOOST_FOREACH( int indexMax, member->GetSubscripts() )
     352            {
     353                *(long *)(buffer+i2)=indexMax;
     354                i2+=sizeof(long);
     355            }
    351356
    352357            //バッファが足りない場合は再確保
     
    357362        }
    358363
    359         //メソッド
     364        // 動的メソッド
    360365        *(long *)(buffer+i2)=(long)pobj_c->GetMethods().size();
    361366        i2+=sizeof(long);
     
    371376                i2+=lstrlen(buffer+i2)+1;
    372377            }
    373             lstrcpy(buffer+i2,pMethod->pUserProc->GetName().c_str());
     378            lstrcpy(buffer+i2,pMethod->GetUserProc().GetName().c_str());
    374379            i2+=lstrlen(buffer+i2)+1;
    375380        }
     
    394399            i2+=sizeof(Prototype::Accessibility);
    395400
    396             memcpy(buffer+i2,member->SubScripts,sizeof(int)*MAX_ARRAYDIM);
    397             i2+=sizeof(int)*MAX_ARRAYDIM;
     401            // 配列
     402            *(long *)(buffer+i2)=(int)member->GetSubscripts().size();
     403            i2+=sizeof(long);
     404            BOOST_FOREACH( int indexMax, member->GetSubscripts() )
     405            {
     406                *(long *)(buffer+i2)=indexMax;
     407                i2+=sizeof(long);
     408            }
    398409
    399410            //バッファが足りない場合は再確保
     
    434445}
    435446BOOL CDebugSection::__load(void){
    436     int i2,i3,i4,i5,num;
     447    int i2,i3,i4,num;
    437448    char temp2[MAX_PATH],*temp5;
    438449
    439     Smoothie::Temp::pCompilingClass = NULL;
     450    compiler.pCompilingClass = NULL;
    440451
    441452    i2=0;
     
    487498    ///////////////////////////////////////////
    488499
    489     this->pobj_DBClass=new ClassesImpl();
     500    this->pobj_DBClass=new Classes();
    490501
    491502    int iMaxClassCount;
     
    524535    //定数を取得
    525536    GetConstInfo();
    526     extern CONSTINFO **ppConstHash;
    527     this->ppConstHash=ppConstHash;
    528 
     537    this->globalConsts = compiler.GetMeta().GetGlobalConsts();
     538    this->globalConstMacros = compiler.GetMeta().GetGlobalConstMacros();
    529539
    530540    //グローバル変数情報
    531     globalVars.clear();
     541    compiler.GetMeta().GetGlobalVars().clear();
    532542    int maxGlobalVars=*(long *)(buffer+i2);
    533543    i2+=sizeof(long);
     
    548558        bool isArray = (buffer[i2++]) ? true:false;
    549559
    550         Variable *pVar = new VariableImpl( name, type, false, isRef );
     560        Variable *pVar = new Variable( name, type, false, isRef, "" );
    551561
    552562        if(isArray){
    553             int SubScripts[MAX_ARRAYDIM];
    554             for(i4=0;;i4++){
    555                 SubScripts[i4]=*(long *)(buffer+i2);
     563            Subscripts subscripts;
     564            int nSubScriptsNum = *(long *)(buffer+i2);
     565            i2+=sizeof(long);
     566            for( int i=0; i<nSubScriptsNum; i++ )
     567            {
     568                subscripts.push_back( *(long *)(buffer+i2) );
    556569                i2+=sizeof(long);
    557 
    558                 if(SubScripts[i4]==-1) break;
    559             }
    560 
    561             pVar->SetArray( SubScripts );
     570            }
     571
     572            pVar->SetArray( subscripts );
    562573        }
    563574
    564575        //レキシカルスコープ情報
    565         pVar->ScopeStartAddress=*(long *)(buffer+i2);
    566         i2+=sizeof(long);
    567         pVar->ScopeEndAddress=*(long *)(buffer+i2);
    568         i2+=sizeof(long);
    569         pVar->ScopeLevel=*(long *)(buffer+i2);
     576        pVar->SetScopeStartAddress( *(long *)(buffer+i2) );
     577        i2+=sizeof(long);
     578        pVar->SetScopeEndAddress( *(long *)(buffer+i2) );
     579        i2+=sizeof(long);
     580        pVar->SetScopeLevel( *(long *)(buffer+i2) );
    570581        i2+=sizeof(long);
    571582
    572583        //メモリ位置
    573         pVar->offset=*(long *)(buffer+i2);
     584        pVar->SetOffsetAddress( *(long *)(buffer+i2) );
    574585        i2+=sizeof(long);
    575586
    576587        //変数を追加
    577         globalVars.push_back( pVar );
     588        compiler.GetMeta().GetGlobalVars().push_back( pVar );
    578589    }
    579590
     
    583594
    584595    //プロシージャ情報
    585     GlobalProc *pUserProc;
    586     SubNum=*(long *)(buffer+i2);
    587     i2+=sizeof(long);
    588     ppSubHash=(GlobalProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(GlobalProc *));
    589     for(int i6=0;i6<SubNum;i6++){
     596    userProcs.Clear();
     597    int subNum = *(long *)(buffer+i2);
     598    i2+=sizeof(long);
     599    for(int i6=0;i6<subNum;i6++){
    590600        char szParentClassName[VN_SIZE];
    591601        lstrcpy(szParentClassName,buffer+i2);
     
    607617        // オブジェクトを生成
    608618        // TODO: 名前空間が未完成
    609         pUserProc = new GlobalProc( NamespaceScopes(), NamespaceScopesCollection(), name, Procedure::Function, false, false, false );
    610         pUserProc->pNextData=0;
    611         pUserProc->id=id;
     619        UserProc *pUserProc = new UserProc( NamespaceScopes(), NamespaceScopesCollection(), name, Procedure::Function, false, false, false, id );
    612620        pUserProc->SetParentClass( pClass );
    613621
    614         pUserProc->beginOpAddress=*(long *)(buffer+i2);
    615         i2+=sizeof(long);
    616         pUserProc->endOpAddress=*(long *)(buffer+i2);
     622        pUserProc->SetBeginOpAddress( *(long *)(buffer+i2) );
     623        i2+=sizeof(long);
     624        pUserProc->SetEndOpAddress( *(long *)(buffer+i2) );
    617625        i2+=sizeof(long);
    618626
     
    620628
    621629        //ローカル変数情報
    622         pUserProc->localVars.clear();
     630        pUserProc->GetLocalVars().clear();
    623631        int maxLocalVar=*(long *)(buffer+i2);
    624632        i2+=sizeof(long);
     
    638646            bool isArray = (buffer[i2++]) ? true:false;
    639647
    640             Variable *pVar = new VariableImpl( name, type, false, isRef );
     648            Variable *pVar = new Variable( name, type, false, isRef, "" );
    641649
    642650            if(isArray){
    643                 int SubScripts[MAX_ARRAYDIM];
    644                 for(i4=0;;i4++){
    645                     SubScripts[i4]=*(long *)(buffer+i2);
     651                Subscripts subscripts;
     652                int nSubScriptsNum = *(long *)(buffer+i2);
     653                i2+=sizeof(long);
     654                for( int i=0; i<nSubScriptsNum; i++ )
     655                {
     656                    subscripts.push_back( *(long *)(buffer+i2) );
    646657                    i2+=sizeof(long);
    647 
    648                     if(SubScripts[i4]==-1) break;
    649658                }
    650659
    651                 pVar->SetArray( SubScripts );
     660                pVar->SetArray( subscripts );
    652661            }
    653662
    654663            //レキシカルスコープ情報
    655             pVar->ScopeStartAddress=*(long *)(buffer+i2);
    656             i2+=sizeof(long);
    657             pVar->ScopeEndAddress=*(long *)(buffer+i2);
    658             i2+=sizeof(long);
    659             pVar->ScopeLevel=*(long *)(buffer+i2);
     664            pVar->SetScopeStartAddress( *(long *)(buffer+i2) );
     665            i2+=sizeof(long);
     666            pVar->SetScopeEndAddress( *(long *)(buffer+i2) );
     667            i2+=sizeof(long);
     668            pVar->SetScopeLevel( *(long *)(buffer+i2) );
    660669            i2+=sizeof(long);
    661670
    662671            //メモリ位置
    663             pVar->offset=*(long *)(buffer+i2);
     672            pVar->SetOffsetAddress( *(long *)(buffer+i2) );
    664673            i2+=sizeof(long);
    665674
    666675            //変数を追加
    667             pUserProc->localVars.push_back( pVar );
     676            pUserProc->GetLocalVars().push_back( pVar );
    668677        }
    669678
     
    673682        /////////////////////////////////
    674683
    675         i4=hash_default(pUserProc->GetName().c_str());
    676 
    677         GlobalProc *psi2;
    678         if(ppSubHash[i4]){
    679             psi2=ppSubHash[i4];
    680             while(1){
    681                 if(psi2->pNextData==0){
    682                     psi2->pNextData=pUserProc;
    683                     break;
    684                 }
    685                 psi2=psi2->pNextData;
    686             }
    687         }
    688         else{
    689             ppSubHash[i4]=pUserProc;
    690         }
    691     }
     684        // ハッシュに追加
     685        if( !userProcs.Insert( pUserProc, -1 ) )
     686        {
     687            //return NULL;
     688        }
     689    }
     690    userProcs.Iterator_Init();
    692691
    693692    //クラス情報
     
    709708        i2+=sizeof(long);
    710709
    711         //的メンバ
     710        // 動的メンバ
    712711        int nDynamicMember = *(long *)(buffer+i2);
    713712        i2+=sizeof(long);
     
    728727            i2+=sizeof(Prototype::Accessibility);
    729728
    730             CMember *member=new CMember( accessibility, name, type, false, "", "" );
    731 
    732             memcpy(member->SubScripts,buffer+i2,sizeof(int)*MAX_ARRAYDIM);
    733             i2+=sizeof(int)*MAX_ARRAYDIM;
     729            Subscripts subscripts;
     730            int nSubScriptsNum = *(long *)(buffer+i2);
     731            i2+=sizeof(long);
     732            for( int i=0; i<nSubScriptsNum; i++ )
     733            {
     734                subscripts.push_back( *(long *)(buffer+i2) );
     735                i2+=sizeof(long);
     736            }
     737
     738            CMember *member=new CMember( accessibility, name, type, false, subscripts, "", "" );
    734739
    735740            pobj_c->GetDynamicMembers().push_back( member );
    736741        }
    737742
    738         //メソッド
     743        // 動的メソッド
    739744        int nMethod = *(long *)(buffer+i2);
    740745        i2+=sizeof(long);
     
    759764            pobj_temp_c=pobj_InheritsClass;
    760765            if(pobj_temp_c==0) pobj_temp_c=pobj_c;
    761             i5=hash_default(temp2);
    762             pUserProc=ppSubHash[i5];
    763             while(1){
    764                 if( pUserProc->GetName() == temp2 &&pUserProc->GetParentClassPtr()==pobj_temp_c) break;
    765                 pUserProc=pUserProc->pNextData;
     766
     767            UserProc *pUserProc = compiler.GetMeta().GetUserProcs().GetHashArrayElement( temp2 );
     768            while(pUserProc){
     769                if( pUserProc->GetName() == temp2 &&pUserProc->GetParentClassPtr()==pobj_temp_c)
     770                {
     771                    break;
     772                }
     773
     774                pUserProc=pUserProc->GetChainNext();
    766775            }
    767776
     
    790799            i2+=sizeof(Prototype::Accessibility);
    791800
    792             CMember *member=new CMember( accessibility, name, type, false, "", "" );
    793 
    794             memcpy(member->SubScripts,buffer+i2,sizeof(int)*MAX_ARRAYDIM);
    795             i2+=sizeof(int)*MAX_ARRAYDIM;
     801            // 配列
     802            Subscripts subscripts;
     803            int nSubScriptsNum = *(long *)(buffer+i2);
     804            i2+=sizeof(long);
     805            for( int i=0; i<nSubScriptsNum; i++ )
     806            {
     807                subscripts.push_back( *(long *)(buffer+i2) );
     808                i2+=sizeof(long);
     809            }
     810
     811            CMember *member=new CMember( accessibility, name, type, false, subscripts, "", "" );
    796812
    797813            pobj_c->GetStaticMembers().push_back( member );
     
    805821
    806822
    807     extern GlobalProc **ppSubHash;
    808     ppSubHash=this->ppSubHash;
     823    compiler.GetMeta().GetUserProcs() = userProcs;
    809824    pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc");
    810825
     
    950965
    951966    //定数を取得
    952     extern CONSTINFO **ppConstHash;
    953     ppConstHash=this->ppConstHash;
     967    compiler.GetMeta().GetGlobalConsts() = this->globalConsts;
     968    compiler.GetMeta().GetGlobalConstMacros() = this->globalConstMacros;
    954969
    955970    //グローバル実行領域のサイズ
     
    958973
    959974    //プロシージャ
    960     extern char **ppMacroNames;
    961     ppMacroNames=0;
    962     extern GlobalProc **ppSubHash;
    963     extern int SubNum;
    964     ppSubHash=this->ppSubHash;
    965     SubNum=this->SubNum;
    966 
    967     extern UserProc *pSub_DebugSys_EndProc;
     975    compiler.GetMeta().GetUserProcs() = userProcs;
     976
     977    extern const UserProc *pSub_DebugSys_EndProc;
    968978    pSub_DebugSys_EndProc=this->pSub_DebugSys_EndProc;
    969979
     
    986996    delete this->pobj_DBClass;
    987997    this->pobj_DBClass=0;
    988 
    989     //サブルーチン情報のメモリ解放
    990     DeleteSubInfo(ppSubHash,0,0);
    991 
    992     //定数に関する情報を解放
    993     DeleteConstInfo(ppConstHash);
    994998
    995999    //コードと行番号の関係を解放
  • trunk/abdev/BasicCompiler_Common/DebugSection.h

    r182 r206  
    22
    33#include <jenga/include/smoothie/Source.h>
    4 #include <jenga/include/smoothie/Class.h>
    54
    6 #include <ProcedureImpl.h>
     5#include <Class.h>
     6#include <Procedure.h>
     7#include <Const.h>
    78
    89
     
    4243
    4344    //定数を取得
    44     CONSTINFO **ppConstHash;
     45    Consts globalConsts;
     46    ConstMacros globalConstMacros;
    4547
    4648    //グローバル実行領域のサイズ
     
    4850
    4951    //プロシージャ
    50     GlobalProc **ppSubHash;
    51     int SubNum;
     52    UserProcs userProcs;
    5253
    53     UserProc *pSub_DebugSys_EndProc;
     54    const UserProc *pSub_DebugSys_EndProc;
    5455
    5556    //ネイティブコードバッファ
     
    6667
    6768
    68     CDebugSection();
     69    CDebugSection()
     70        : buffer( NULL )
     71        , length( 0 )
     72        , dwImageBase( 0 )
     73        , dwRVA_RWSection( 0 )
     74        , dwRVA_CodeSection( 0 )
     75        , SizeOf_CodeSection( 0 )
     76        , pobj_DBClass( NULL )
     77        , GlobalOpBufferSize( 0 )
     78        , pSub_DebugSys_EndProc( NULL )
     79        , OpBuffer( NULL )
     80        , SingleStepCodeBuffer( NULL )
     81        , BreakStepCodeBuffer( NULL )
     82    {
     83        szNowFilePath[0]=0;
     84    }
    6985    ~CDebugSection();
    7086
  • trunk/abdev/BasicCompiler_Common/Diagnose.cpp

    r193 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24
     
    3840        int codeSizeOfGlobalProc = 0;
    3941        int codeSizeOfClassMethod = 0;
    40         for(int i2=0;i2<MAX_HASH;i2++){
    41             extern GlobalProc **ppSubHash;
    42             GlobalProc *pUserProc = ppSubHash[i2];
    43             while(pUserProc){
    44                 if( pUserProc->IsCompiled() ){
    45                     if( pUserProc->HasParentClass() ){
    46                         codeSizeOfClassMethod += pUserProc->GetCodeSize();
    47                     }
    48                     else{
    49                         codeSizeOfGlobalProc += pUserProc->GetCodeSize();
    50                     }
     42        compiler.GetMeta().GetUserProcs().Iterator_Reset();
     43        while( compiler.GetMeta().GetUserProcs().Iterator_HasNext() )
     44        {
     45            UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Iterator_GetNext();
     46            if( pUserProc->IsCompiled() ){
     47                if( pUserProc->HasParentClass() ){
     48                    codeSizeOfClassMethod += pUserProc->GetCodeSize();
    5149                }
    52 
    53                 pUserProc=pUserProc->pNextData;
     50                else{
     51                    codeSizeOfGlobalProc += pUserProc->GetCodeSize();
     52                }
    5453            }
    5554        }
     
    8382            // 動的メソッド
    8483            BOOST_FOREACH( const CMethod *pMethod, objClass.GetMethods() ){
    85                 if( pMethod->pUserProc->IsCompiled() ){
    86                     codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     84                if( pMethod->GetUserProc().IsCompiled() ){
     85                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    8786                }
    8887            }
     
    9089            // 静的メソッド
    9190            BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
    92                     codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     91                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    9392            }
    9493
     
    118117            // 動的メソッド
    119118            BOOST_FOREACH( const CMethod *pMethod, objClass.GetMethods() ){
    120                 if( pMethod->pUserProc->IsCompiled() ){
    121                     codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     119                if( pMethod->GetUserProc().IsCompiled() ){
     120                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    122121                }
    123122            }
     
    125124            // 静的メソッド
    126125            BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
    127                     codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     126                    codeSizeOfClass += pMethod->GetUserProc().GetCodeSize();
    128127            }
    129128
  • trunk/abdev/BasicCompiler_Common/Enum.cpp

    r199 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/common/logger.h>
    24
     
    57
    68#include <Compiler.h>
     9#include <../Enum.h>
    710
    811#include "common.h"
     
    293296
    294297    // ログを生成
    295     Jenga::Common::Logger logger( Jenga::Common::Environment::GetAppDir() + "\\enum_generated.log" );
     298    Jenga::Common::Logger logger( Jenga::Common::Environment::GetAppDir() + "\\enum_generated.log", false );
    296299    logger << buffer << endl;
    297300
  • trunk/abdev/BasicCompiler_Common/Intermediate_Step1.cpp

    r182 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
  • trunk/abdev/BasicCompiler_Common/Intermediate_Step2.cpp

    r199 r206  
     1#include "stdafx.h"
     2
    13#include <jenga/include/smoothie/Smoothie.h>
    24#include <jenga/include/smoothie/LexicalAnalysis.h>
     
    68#include "../BasicCompiler_Common/common.h"
    79
    8 CONSTINFO *GetNewConstHash(char *name){
    9     extern int cp;
    10     CONSTINFO *pci;
    11 
    12     int key;
    13     key=hash_default(name);
    14 
    15     extern CONSTINFO **ppConstHash;
    16     if(ppConstHash[key]){
    17         pci=ppConstHash[key];
    18         while(1){
    19             if(lstrcmp(pci->name,name)==0){
    20                 //重複エラー
    21                 SetError(15,name,cp);
    22                 return 0;
    23             }
    24 
    25             if(pci->pNextData==0){
    26                 pci->pNextData=(CONSTINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(CONSTINFO));
    27                 break;
    28             }
    29             pci=pci->pNextData;
    30         }
    31         pci=pci->pNextData;
    32     }
    33     else{
    34         ppConstHash[key]=(CONSTINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(CONSTINFO));
    35         pci=ppConstHash[key];
    36     }
    37 
    38     return pci;
    39 }
    40 
    41 // マクロ定数を追加するための関数
    42 void AddConstData(char *Command){
    43     extern HANDLE hHeap;
    44     extern int cp;
    45     int i,i2;
    46     char temporary[VN_SIZE];
    47 
    48     for(i=0;;i++){
    49         if(Command[i]=='\0'){
    50             SetError(10,"Const",cp);
    51             return;
    52         }
    53         if(Command[i]=='=' ||  Command[i] == 1 && Command[i+1] == ESC_AS ){
    54             //定数定義は新しいクラスモジュール(CDBConst)へ移行
    55             // ※この関数はマクロ定数のみを扱う
    56             return;
    57         }
    58         if(Command[i]=='('){
    59             temporary[i]=0;
    60             break;
    61         }
    62         temporary[i]=Command[i];
    63     }
    64 
    65 
    66     /////////////////////////////////
    67     // 格納位置を計算してpciにセット
    68     /////////////////////////////////
    69 
    70     CONSTINFO *pci;
    71     pci=GetNewConstHash(temporary);
    72     if(!pci) return;
    73 
    74 
    75 
    76     ////////////////////
    77     // 定数情報を取得
    78     ////////////////////
    79 
    80     //定数名
    81     pci->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
    82     lstrcpy(pci->name,temporary);
    83 
    84     if(Command[i]=='('){
    85         pci->ppParm=(char **)HeapAlloc