Changeset 206 in dev for trunk/abdev/BasicCompiler32


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

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

Location:
trunk/abdev/BasicCompiler32
Files:
2 added
21 edited

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            //２重定義のエラー
    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);
Note: See TracChangeset for help on using the changeset viewer.