Changeset 182 in dev for trunk/abdev


Ignore:
Timestamp:
Jun 24, 2007, 6:49:13 PM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev/BasicCompiler_Common
Files:
29 deleted
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/abdev/BasicCompiler_Common/BasicCompiler.cpp

    r167 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include <Program.h>
    24
     
    185187    }
    186188
    187     i3=baseDirPath.size();i4=0;
     189    i3=(int)baseDirPath.size();i4=0;
    188190    while(i4<i2){
    189191        for(i3--;;i3--){
     
    550552    char temporary[1024],temp2[MAX_PATH];
    551553
    552     //MessageBox(0,"starting compiler/debugger","ActiveBasic",MB_OK);
     554    MessageBox(0,"starting compiler/debugger","ActiveBasic",MB_OK);
    553555    trace( "Start ActiveBasic Compiler!" );
    554556
     
    702704        //Unicode
    703705        else if( lstrcmp( temp2, "unicode" ) ==0 ){
    704             isUnicode = true;
     706            Smoothie::SetUnicodeMark( true );
    705707            typeOfPtrChar = MAKE_PTR_TYPE(DEF_WORD,1);
    706708            typeOfPtrUChar = MAKE_PTR_TYPE(DEF_WORD,1);
  • trunk/abdev/BasicCompiler_Common/BasicCompiler.h

    r167 r182  
    7979
    8080BOOL bDll;
    81 bool isUnicode = false;
    8281int typeOfPtrChar = MAKE_PTR_TYPE(DEF_SBYTE,1);
    8382int typeOfPtrUChar = MAKE_PTR_TYPE(DEF_BYTE,1);
  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r143 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3#include <jenga/include/smoothie/SmoothieException.h>
     4
     5#include <LexicalScopingImpl.h>
     6#include <CodeGenerator.h>
     7
    18#include "../BasicCompiler_Common/common.h"
    29
     
    714#endif
    815
     16#include <Exception.h>
     17
    918//ラベルアドレス
    1019LABEL *pLabelNames;
     
    3342WITHINFO WithInfo;
    3443
    35 
    36 int obp,obp_AllocSize;
    37 int GlobalOpBufferSize;
    38 char *OpBuffer;
    39 void ReallocNativeCodeBuffer(){
    40     if(obp_AllocSize<obp+8192){
    41         obp_AllocSize+=8192;
    42         OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
    43     }
    44 }
    4544
    4645
     
    177176                break;
    178177            case ESC_EXITWHILE:
    179                 obj_LexScopes.ExitWhile();
     178                {
     179                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_WHILE );
     180                    if( !pScope ){
     181                        SetError(12,"Exit While",cp);
     182                        return;
     183                    }
     184                    pScope->Break();
     185                }
    180186                break;
    181187            case ESC_EXITFOR:
    182                 obj_LexScopes.ExitFor();
     188                {
     189                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_FOR );
     190                    if( !pScope ){
     191                        SetError(12,"Exit For",cp);
     192                        return;
     193                    }
     194                    pScope->Break();
     195                }
    183196                break;
    184197            case ESC_EXITDO:
    185                 obj_LexScopes.ExitDo();
     198                {
     199                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_DO );
     200                    if( !pScope ){
     201                        SetError(12,"Exit Do",cp);
     202                        return;
     203                    }
     204                    pScope->Break();
     205                }
    186206                break;
    187207            case ESC_CONTINUE:
     
    231251
    232252            case ESC_NAMESPACE:
    233                 Smoothie::Lexical::liveingNamespaceScopes.push_back( Command + 2 );
     253                Smoothie::Temp::liveingNamespaceScopes.push_back( Command + 2 );
    234254                break;
    235255            case ESC_ENDNAMESPACE:
    236                 if( Smoothie::Lexical::liveingNamespaceScopes.size() <= 0 ){
     256                if( Smoothie::Temp::liveingNamespaceScopes.size() <= 0 ){
    237257                    SetError(12,"End Namespace",cp);
    238258                }
    239                 Smoothie::Lexical::liveingNamespaceScopes.pop_back();
     259                Smoothie::Temp::liveingNamespaceScopes.pop_back();
    240260                break;
    241261            case ESC_IMPORTS:
     
    641661            }
    642662
    643             ChangeOpcode(Command);
     663            try
     664            {
     665                ChangeOpcode(Command);
     666            }
     667            catch( const SmoothieException &smoothieException )
     668            {
     669                SetError(
     670                    smoothieException.GetErrorCode(),
     671                    smoothieException.GetKeyword(),
     672                    smoothieException.GetNowLine()
     673                );
     674            }
    644675
    645676#ifdef _DEBUG
     
    651682            if(bStopCompile) return 0;
    652683
    653             if(obp_AllocSize<obp+8192){
    654                 obp_AllocSize+=8192;
    655                 OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize);
    656             }
     684            ReallocNativeCodeBuffer();
    657685
    658686            if(basbuf[cp]=='\0'){
  • trunk/abdev/BasicCompiler_Common/Const.cpp

    r103 r182  
    1818    char AreaName[VN_SIZE] = "";        //オブジェクト変数
    1919    char NestName[VN_SIZE] = "";        //入れ子メンバ
    20     bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
     20    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );
    2121
    2222    return IsEqualSymbol( NamespaceScopes( AreaName ), NestName );
     
    180180    char ObjName[VN_SIZE];      //オブジェクト変数
    181181    char NestMember[VN_SIZE];   //入れ子メンバ
    182     bool isObjectMember = SplitMemberName( name.c_str(), ObjName, NestMember );
     182    bool isObjectMember = CClass::SplitName( name.c_str(), ObjName, NestMember );
    183183
    184184    //ハッシュ値を取得
  • trunk/abdev/BasicCompiler_Common/Const.h

    r103 r182  
     1#pragma once
    12
     3#include <jenga/include/smoothie/Type.h>
    24
    35//定数の基底クラス
  • trunk/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r159 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <ClassImpl.h>
     4
    15#include "../BasicCompiler_Common/common.h"
    26
     
    2832        (*p)+=lstrlen(buffer+(*p))+1;
    2933
    30         type.SetIndex( (LONG_PTR)pobj_DBClass->Find(szClassName) );
     34        type.SetIndex( (LONG_PTR)Smoothie::GetMeta().GetClasses().Find(szClassName) );
    3135    }
    3236    else{
     
    115119
    116120    //イテレータをリセット
    117     extern Classes *pobj_DBClass;
    118     pobj_DBClass->Iterator_Reset();
     121    Smoothie::GetMeta().GetClasses().Iterator_Reset();
    119122
    120123    //個数
    121     *(long *)(buffer+i2)=pobj_DBClass->Iterator_GetMaxCount();
    122     i2+=sizeof(long);
    123 
    124     while(pobj_DBClass->Iterator_HasNext()){
     124    *(long *)(buffer+i2)=Smoothie::GetMeta().GetClasses().Iterator_GetMaxCount();
     125    i2+=sizeof(long);
     126
     127    while(Smoothie::GetMeta().GetClasses().Iterator_HasNext()){
    125128        CClass *pobj_c;
    126         pobj_c=pobj_DBClass->Iterator_GetNext();
     129        pobj_c=Smoothie::GetMeta().GetClasses().Iterator_GetNext();
    127130
    128131        //クラス名
     
    136139    // TypeDef情報
    137140    //////////////////
    138     *(long *)(buffer+i2)=(int)Smoothie::meta.typeDefs.size();
    139     i2+=sizeof(long);
    140     for(i3=0;i3<(int)Smoothie::meta.typeDefs.size();i3++){
    141         lstrcpy(buffer+i2,Smoothie::meta.typeDefs[i3].GetName().c_str() );
    142         i2+=lstrlen(buffer+i2)+1;
    143 
    144         lstrcpy(buffer+i2,Smoothie::meta.typeDefs[i3].GetBaseName().c_str() );
     141    *(long *)(buffer+i2)=(int)Smoothie::GetMeta().typeDefs.size();
     142    i2+=sizeof(long);
     143    for(i3=0;i3<(int)Smoothie::GetMeta().typeDefs.size();i3++){
     144        lstrcpy(buffer+i2,Smoothie::GetMeta().typeDefs[i3].GetName().c_str() );
     145        i2+=lstrlen(buffer+i2)+1;
     146
     147        lstrcpy(buffer+i2,Smoothie::GetMeta().typeDefs[i3].GetBaseName().c_str() );
    145148        i2+=lstrlen(buffer+i2)+1;
    146149
     
    156159    *(long *)(buffer+i2)=(int)::globalVars.size();
    157160    i2+=sizeof(long);
    158     foreach( Variable *pVar, ::globalVars ){
     161    BOOST_FOREACH( Variable *pVar, ::globalVars ){
    159162        //変数名
    160163        lstrcpy(buffer+i2,pVar->GetName().c_str());
     
    245248            }
    246249
    247             foreach( Variable *pVar, pUserProc->localVars ){
     250            BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    248251                lstrcpy(buffer+i2,pVar->GetName().c_str());
    249252                i2+=lstrlen(buffer+i2)+1;
     
    304307
    305308    //イテレータをリセット
    306     pobj_DBClass->Iterator_Reset();
    307 
    308     while(pobj_DBClass->Iterator_HasNext()){
     309    Smoothie::GetMeta().GetClasses().Iterator_Reset();
     310
     311    while(Smoothie::GetMeta().GetClasses().Iterator_HasNext()){
    309312        CClass *pobj_c;
    310         pobj_c=pobj_DBClass->Iterator_GetNext();
     313        pobj_c=Smoothie::GetMeta().GetClasses().Iterator_GetNext();
    311314
    312315
     
    324327
    325328        //メンバ
    326         *(long *)(buffer+i2)=(int)pobj_c->dynamicMembers.size();
    327         i2+=sizeof(long);
    328         foreach( CMember *member, pobj_c->dynamicMembers ){
     329        *(long *)(buffer+i2)=(int)pobj_c->GetDynamicMembers().size();
     330        i2+=sizeof(long);
     331        BOOST_FOREACH( CMember *member, pobj_c->GetDynamicMembers() ){
    329332            // 名前
    330333            lstrcpy(buffer+i2,member->GetName().c_str());
     
    353356
    354357        //メソッド
    355         *(long *)(buffer+i2)=(long)pobj_c->methods.size();
    356         i2+=sizeof(long);
    357         foreach( const CMethod *pMethod, pobj_c->methods ){
     358        *(long *)(buffer+i2)=(long)pobj_c->GetMethods().size();
     359        i2+=sizeof(long);
     360        BOOST_FOREACH( const CMethod *pMethod, pobj_c->GetMethods() ){
    358361            *(Prototype::Accessibility *)(buffer+i2)=pMethod->GetAccessibility();
    359362            i2+=sizeof(Prototype::Accessibility);
     
    371374
    372375        //静的メンバ
    373         *(long *)(buffer+i2)=(long)pobj_c->staticMembers.size();
    374         i2+=sizeof(long);
    375         foreach( CMember *member, pobj_c->staticMembers ){
     376        *(long *)(buffer+i2)=(long)pobj_c->GetStaticMembers().size();
     377        i2+=sizeof(long);
     378        BOOST_FOREACH( CMember *member, pobj_c->GetStaticMembers() ){
    376379            // 名前
    377380            lstrcpy(buffer+i2,member->GetName().c_str());
     
    432435    char temp2[MAX_PATH],*temp5;
    433436
    434     pobj_CompilingClass = NULL;
     437    Smoothie::Temp::pCompilingClass = NULL;
    435438
    436439    i2=0;
     
    482485    ///////////////////////////////////////////
    483486
    484     this->pobj_DBClass=new Classes();
     487    this->pobj_DBClass=new ClassesImpl();
    485488
    486489    int iMaxClassCount;
     
    490493        //クラス名
    491494        // TODO: 名前空間が未完成
    492         pobj_DBClass->AddClass(NamespaceScopes(),NamespaceScopesCollection(),buffer+i2,0);
    493         i2+=lstrlen(buffer+i2)+1;
    494     }
    495 
    496     extern Classes *pobj_DBClass;
    497     pobj_DBClass=this->pobj_DBClass;
     495        this->pobj_DBClass->Add(NamespaceScopes(),NamespaceScopesCollection(),buffer+i2,0);
     496        i2+=lstrlen(buffer+i2)+1;
     497    }
     498
     499    Smoothie::GetMeta().SetClasses( this->pobj_DBClass );
    498500
    499501
     
    503505
    504506    //初期化
    505     Smoothie::meta.typeDefs.clear();
     507    Smoothie::GetMeta().typeDefs.clear();
    506508
    507509    //個数を取得
     
    513515
    514516        // 名前空間に未対応
    515         Smoothie::meta.typeDefs.push_back( TypeDef( NamespaceScopes(), temp5, buffer+i2 ) );
     517        Smoothie::GetMeta().typeDefs.push_back( TypeDef( NamespaceScopes(), temp5, buffer+i2, -1 ) );
    516518
    517519        i2+=lstrlen(buffer+i2)+1;
     
    590592        const CClass *pClass = NULL;
    591593        if(szParentClassName[0]){
    592             pClass=pobj_DBClass->Find(szParentClassName);
     594            pClass=Smoothie::GetMeta().GetClasses().Find(szParentClassName);
    593595        }
    594596
     
    695697        i2+=lstrlen(buffer+i2)+1;
    696698
    697         pobj_c =  const_cast<CClass *>( pobj_DBClass->Find(szClassName) );
     699        pobj_c =  const_cast<CClass *>( Smoothie::GetMeta().GetClasses().Find(szClassName) );
    698700
    699701        //仮想関数の数
     
    724726            i2+=sizeof(Prototype::Accessibility);
    725727
    726             CMember *member=new CMember( accessibility, name, type, false );
     728            CMember *member=new CMember( accessibility, name, type, false, "", "" );
    727729
    728730            memcpy(member->SubScripts,buffer+i2,sizeof(int)*MAX_ARRAYDIM);
    729731            i2+=sizeof(int)*MAX_ARRAYDIM;
    730732
    731             pobj_c->dynamicMembers.push_back( member );
     733            pobj_c->GetDynamicMembers().push_back( member );
    732734        }
    733735
     
    746748            const CClass *pobj_InheritsClass = NULL;
    747749            if(szInherits[0]){
    748                 pobj_InheritsClass=pobj_DBClass->Find(szInherits);
     750                pobj_InheritsClass=Smoothie::GetMeta().GetClasses().Find(szInherits);
    749751            }
    750752
     
    764766            CMethod *pMethod = new DynamicMethod( pUserProc, accessibility, 0,0,false, pobj_InheritsClass);
    765767
    766             pobj_c->methods.push_back( pMethod );
     768            pobj_c->GetMethods().push_back( pMethod );
    767769        }
    768770
     
    786788            i2+=sizeof(Prototype::Accessibility);
    787789
    788             CMember *member=new CMember( accessibility, name, type, false );
     790            CMember *member=new CMember( accessibility, name, type, false, "", "" );
    789791
    790792            memcpy(member->SubScripts,buffer+i2,sizeof(int)*MAX_ARRAYDIM);
    791793            i2+=sizeof(int)*MAX_ARRAYDIM;
    792794
    793             pobj_c->staticMembers.push_back( member );
     795            pobj_c->GetStaticMembers().push_back( member );
    794796        }
    795797    }
     
    943945
    944946    // クラス情報
    945     extern Classes *pobj_DBClass;
    946     pobj_DBClass=this->pobj_DBClass;
     947    Smoothie::GetMeta().SetClasses( this->pobj_DBClass );
    947948
    948949    //定数を取得
     
    979980
    980981    //クラスに関するメモリを解放
    981     delete pobj_DBClass;
    982     pobj_DBClass=0;
     982    delete this->pobj_DBClass;
     983    this->pobj_DBClass=0;
    983984
    984985    //サブルーチン情報のメモリ解放
     
    992993
    993994    //コードバッファを解放
    994     HeapDefaultFree(OpBuffer);
     995    free(OpBuffer);
    995996    OpBuffer=0;
    996997
  • trunk/abdev/BasicCompiler_Common/DebugSection.h

    r159 r182  
     1#pragma once
     2
     3#include <jenga/include/smoothie/Source.h>
     4#include <jenga/include/smoothie/Class.h>
     5
     6#include <ProcedureImpl.h>
     7
    18
    29class CDebugSection{
  • trunk/abdev/BasicCompiler_Common/Diagnose.cpp

    r167 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include <Program.h>
    24
     
    6668        // イテレータをリセット
    6769        extern Classes *pobj_DBClass;
    68         pobj_DBClass->Iterator_Reset();
     70        Smoothie::GetMeta().GetClasses().Iterator_Reset();
    6971
    70         while( pobj_DBClass->Iterator_HasNext() ){
     72        while( Smoothie::GetMeta().GetClasses().Iterator_HasNext() ){
    7173            int codeSizeOfClass = 0;
    7274
    73             CClass &objClass = *pobj_DBClass->Iterator_GetNext();
     75            CClass &objClass = *Smoothie::GetMeta().GetClasses().Iterator_GetNext();
    7476
    7577            if( !objClass.IsEnum() ){
     
    7981
    8082            // 動的メソッド
    81             foreach( const CMethod *pMethod, objClass.GetMethods() ){
     83            BOOST_FOREACH( const CMethod *pMethod, objClass.GetMethods() ){
    8284                if( pMethod->pUserProc->IsCompiled() ){
    8385                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     
    8688
    8789            // 静的メソッド
    88             foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
     90            BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
    8991                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    9092            }
     
    106108        // イテレータをリセット
    107109        extern Classes *pobj_DBClass;
    108         pobj_DBClass->Iterator_Reset();
     110        Smoothie::GetMeta().GetClasses().Iterator_Reset();
    109111
    110         while( pobj_DBClass->Iterator_HasNext() ){
     112        while( Smoothie::GetMeta().GetClasses().Iterator_HasNext() ){
    111113            int codeSizeOfClass = 0;
    112114
    113             CClass &objClass = *pobj_DBClass->Iterator_GetNext();
     115            CClass &objClass = *Smoothie::GetMeta().GetClasses().Iterator_GetNext();
    114116
    115117            // 動的メソッド
    116             foreach( const CMethod *pMethod, objClass.GetMethods() ){
     118            BOOST_FOREACH( const CMethod *pMethod, objClass.GetMethods() ){
    117119                if( pMethod->pUserProc->IsCompiled() ){
    118120                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
     
    121123
    122124            // 静的メソッド
    123             foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
     125            BOOST_FOREACH( const CMethod *pMethod, objClass.GetStaticMethods() ){
    124126                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    125127            }
  • trunk/abdev/BasicCompiler_Common/Enum.cpp

    r167 r182  
    11#include <jenga/include/common/logger.h>
     2
     3#include <jenga/include/smoothie/Smoothie.h>
     4#include <jenga/include/smoothie/LexicalAnalysis.h>
    25
    36#include "common.h"
     
    112115
    113116    // 名前空間管理
    114     NamespaceScopes &namespaceScopes = Smoothie::Lexical::liveingNamespaceScopes;
     117    NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
    115118    namespaceScopes.clear();
    116119
  • trunk/abdev/BasicCompiler_Common/Enum.h

    r103 r182  
     1#pragma once
    12
     3#include <jenga/include/smoothie/Namespace.h>
    24
    35class CEnumMember{
  • trunk/abdev/BasicCompiler_Common/Intermediate_Step1.cpp

    r112 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include "../BasicCompiler_Common/common.h"
    25
  • trunk/abdev/BasicCompiler_Common/Intermediate_Step2.cpp

    r128 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include "../BasicCompiler_Common/common.h"
    25
     
    247250
    248251    // 名前空間管理
    249     NamespaceScopes &namespaceScopes = Smoothie::Lexical::liveingNamespaceScopes;
     252    NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
    250253    namespaceScopes.clear();
    251254
  • trunk/abdev/BasicCompiler_Common/MakeExe.cpp

    r167 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "common.h"
    24
     
    202204    DeleteDeclareInfo();
    203205
    204     //関数ポインタ情報のメモリ解放
    205     DeleteProcPtrInfo();
    206 
    207206    //定数に関する情報を解放
    208207    extern CONSTINFO **ppConstHash;
  • trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r159 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
    14#include "common.h"
    25
     
    311314    char member[VN_SIZE];
    312315    CClass::RefType refType;
    313     if( SplitMemberName( termFull, termLeft, member, refType ) ){
     316    if( CClass::SplitName( termFull, termLeft, member, refType ) ){
    314317        ///////////////////////////////////////////////////////////////////
    315318        // オブジェクトとメンバに分解できるとき
     
    323326        Type leftType;
    324327        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
    325             if( isClassName == false && Smoothie::meta.blittableTypes.IsExist( leftType ) ){
     328            if( isClassName == false && Smoothie::GetMeta().blittableTypes.IsExist( leftType ) ){
    326329                // 左側のオブジェクト部分がBlittable型のとき
    327330
     
    329332                lstrcpy( temporary, termLeft );
    330333                sprintf( termLeft, "%s(%s)",
    331                     Smoothie::meta.blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
     334                    Smoothie::GetMeta().blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
    332335                    temporary );
    333336
     
    393396
    394397    if( pIsClassName ){
    395         if( pobj_DBClass->Find( termFull ) ){
     398        if( Smoothie::GetMeta().GetClasses().Find( termFull ) ){
    396399            *pIsClassName = true;
    397400            return true;
     
    408411    if(lstrcmpi(termFull,"This")==0){
    409412        //Thisオブジェクト
    410         resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     413        resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    411414        isLiteral = false;
    412415        return true;
     
    670673                        //要求タイプがオブジェクト、または未定のとき
    671674                        type_stack[sp]=DEF_OBJECT;
    672                         index_stack[sp]=(LONG_PTR)pobj_DBClass->GetStringClassPtr();
     675                        index_stack[sp]=(LONG_PTR)Smoothie::GetMeta().GetClasses().GetStringClassPtr();
    673676                        bLiteralCalculation=0;
    674677
     
    715718                        }
    716719                        else{
    717                             index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClassPtr();
     720                            index_stack[sp] = (LONG_PTR)Smoothie::GetMeta().GetClasses().GetObjectClassPtr();
    718721                        }
    719722                        bLiteralCalculation = 0;
  • trunk/abdev/BasicCompiler_Common/Object.cpp

    r131 r182  
     1#include <CodeGenerator.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24
  • trunk/abdev/BasicCompiler_Common/Overload.cpp

    r75 r182  
    2626
    2727        char MethodName[VN_SIZE];
    28         if( !SplitMemberName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
     28        if( !CClass::SplitName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
    2929/*
    3030        //メソッドの場合は静的かどうかを調べる
  • trunk/abdev/BasicCompiler_Common/PESchedule.h

    r75 r182  
     1#pragma once
    12
     3#include <jenga/include/smoothie/Procedure.h>
    24
    35///////////////////////
  • trunk/abdev/BasicCompiler_Common/ParamImpl.cpp

    r167 r182  
    7878{
    7979    ParmsNum = 0;
    80     foreach( Parameter *pParam, params ){
     80    BOOST_FOREACH( Parameter *pParam, params ){
    8181        Parms[ParmsNum]=0;
    8282        ParmsNum++;
     
    204204    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
    205205
    206         foreach( UserProc *pTempUserProc, subs ){
     206        BOOST_FOREACH( UserProc *pTempUserProc, subs ){
    207207
    208208            if(EvaluateOverloadScore( level, pTempUserProc->Params(), isEnabledReturnType?pTempUserProc->ReturnType():Type() )){
     
    237237
    238238    if(!sw){
    239         foreach( UserProc *pTempUserProc, subs ){
     239        BOOST_FOREACH( UserProc *pTempUserProc, subs ){
    240240
    241241            //エラーチェック
  • trunk/abdev/BasicCompiler_Common/Resource.cpp

    r75 r182  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
    13#include "common.h"
    24
  • trunk/abdev/BasicCompiler_Common/StrOperation.cpp

    r77 r182  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24
     
    167169    free(temp);
    168170}
    169 _int8 IsCommandDelimitation(char c){
    170     if(c=='\n'||c==':'||c=='\0') return 1;
    171     return 0;
    172 }
    173 BOOL IsBlank(char c){
    174     if(c==' '||c=='\t') return 1;
    175     return 0;
    176 }
    177 int GetOneParameter(const char *Parameter,int pos,char *retAns){
    178     int i,i2,i3,IsStr;
    179     for(i=pos,i2=0,IsStr=0;;i++,i2++){
    180         if(Parameter[i]=='\"') IsStr^=1;
    181         else if(Parameter[i]=='('&&IsStr==0){
    182             i3=GetStringInPare(retAns+i2,Parameter+i);
    183             i+=i3-1;
    184             i2+=i3-1;
    185             continue;
    186         }
    187         else if(Parameter[i]=='['&&IsStr==0){
    188             i3=GetStringInBracket(retAns+i2,Parameter+i);
    189             i+=i3-1;
    190             i2+=i3-1;
    191             continue;
    192         }
    193         else if(Parameter[i]==','&&IsStr==0){
    194             retAns[i2]=0;
    195             i++;
    196             break;
    197         }
    198 
    199         if(IsCommandDelimitation(Parameter[i])&&IsStr==0
    200             || Parameter[i] == ')' && IsStr == 0 ){
    201                 retAns[i2]=0;
    202                 break;
    203         }
    204 
    205         retAns[i2]=Parameter[i];
    206     }
    207     return i;
    208 }
    209 int JumpOneParameter(char *Parameter,int i){
    210     int i2,IsStr;
    211     for(i2=0,IsStr=0;;i++,i2++){
    212         if(Parameter[i]=='\"') IsStr^=1;
    213         else if(Parameter[i]=='('&&IsStr==0){
    214             i=JumpStringInPare(Parameter,i+1);
    215             continue;
    216         }
    217         else if(Parameter[i]=='['&&IsStr==0){
    218             i=JumpStringInBracket(Parameter,i+1);
    219             continue;
    220         }
    221         else if(Parameter[i]==','&&IsStr==0){
    222             i++;
    223             break;
    224         }
    225         if(IsCommandDelimitation(Parameter[i])) break;
    226     }
    227     return i;
    228 }
    229 int GetStringInQuotation(char *buffer,char *ReadBuffer){
    230     int i;
    231 
    232     if(ReadBuffer[0]=='\"'){
    233         buffer[0]=ReadBuffer[0];
    234         i=1;
    235     }
    236     else i=0;
    237 
    238     for(;;i++){
    239         buffer[i]=ReadBuffer[i];
    240         if(IsDBCSLeadByte(ReadBuffer[i])){
    241             i++;
    242             buffer[i]=ReadBuffer[i];
    243             continue;
    244         }
    245         if(ReadBuffer[i]=='\"'){
    246             i++;
    247             buffer[i]=0;
    248             break;
    249         }
    250         if(ReadBuffer[i]=='\0') return 0;
    251     }
    252     return i;
    253 }
    254 int GetStringInPare(char *buffer,const char *ReadBuffer){
    255     int i,IsStr,PareNum;
    256     for(i=0,IsStr=0,PareNum=0;;i++){
    257         buffer[i]=ReadBuffer[i];
    258         if(IsDBCSLeadByte(ReadBuffer[i])){
    259             i++;
    260             buffer[i]=ReadBuffer[i];
    261             continue;
    262         }
    263         if(ReadBuffer[i]=='\"') IsStr^=1;
    264         else if(ReadBuffer[i]=='('&&IsStr==0) PareNum++;
    265         else if(ReadBuffer[i]==')'&&IsStr==0){
    266             PareNum--;
    267             if(PareNum==0){
    268                 i++;
    269                 buffer[i]=0;
    270                 break;
    271             }
    272         }
    273         else if(ReadBuffer[i]=='\0') return 0;
    274     }
    275     return i;
    276 }
    277 int GetStringInPare_RemovePare(char *buffer,char *ReadBuffer){
    278     int i,IsStr,PareNum;
    279     for(i=0,IsStr=0,PareNum=1;;i++){
    280         buffer[i]=ReadBuffer[i];
    281         if(IsDBCSLeadByte(ReadBuffer[i])){
    282             i++;
    283             buffer[i]=ReadBuffer[i];
    284             continue;
    285         }
    286         if(ReadBuffer[i]=='\"') IsStr^=1;
    287         else if(ReadBuffer[i]=='('&&IsStr==0) PareNum++;
    288         else if(ReadBuffer[i]==')'&&IsStr==0){
    289             PareNum--;
    290             if(PareNum==0){
    291                 buffer[i]=0;
    292                 break;
    293             }
    294         }
    295         else if(ReadBuffer[i]=='\0') return 0;
    296     }
    297     return i;
    298 }
    299 int GetStringInBracket(char *buffer,const char *ReadBuffer){
    300     int i,IsStr,PareNum;
    301     for(i=0,IsStr=0,PareNum=0;;i++){
    302         buffer[i]=ReadBuffer[i];
    303         if(IsDBCSLeadByte(ReadBuffer[i])){
    304             i++;
    305             buffer[i]=ReadBuffer[i];
    306             continue;
    307         }
    308         if(ReadBuffer[i]=='\"') IsStr^=1;
    309         else if(ReadBuffer[i]=='['&&IsStr==0) PareNum++;
    310         else if(ReadBuffer[i]==']'&&IsStr==0){
    311             PareNum--;
    312             if(PareNum==0){
    313                 i++;
    314                 buffer[i]=0;
    315                 break;
    316             }
    317         }
    318         else if(ReadBuffer[i]=='\0') return 0;
    319     }
    320     return i;
    321 }
    322 int JumpStringInPare(const char *buffer,int pos){
    323     int PareNum;
    324     for(PareNum=1;;pos++){
    325         if(buffer[pos]=='\"'){
    326             for(pos++;;pos++){
    327                 if(buffer[pos]=='\"') break;
    328             }
    329             continue;
    330         }
    331         else if(buffer[pos]=='(') PareNum++;
    332         else if(buffer[pos]==')'){
    333             PareNum--;
    334             if(PareNum==0) return pos;
    335         }
    336         else if(buffer[pos]=='\0') break;
    337     }
    338     return 0;
    339 }
    340 int JumpStringInBracket(const char *buffer,int pos){
    341     int PareNum;
    342     for(PareNum=1;;pos++){
    343         if(buffer[pos]=='\"'){
    344             for(pos++;;pos++){
    345                 if(buffer[pos]=='\"') break;
    346             }
    347             continue;
    348         }
    349         else if(buffer[pos]=='[') PareNum++;
    350         else if(buffer[pos]==']'){
    351             PareNum--;
    352             if(PareNum==0) return pos;
    353         }
    354         else if(buffer[pos]=='\0') break;
    355     }
    356     return 0;
    357 }
    358171
    359172int GetCpFromLine(int LineNum){
  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r169 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <ProcedureImpl.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27
     
    8388    }
    8489}
    85 bool SplitMemberName( const char *desc, char *object, char *member, CClass::RefType &refType ){
    86     int lastIndex = -1;
    87     for( int i=0; desc[i]; i++ ){
    88         if( desc[i] == '(' ){
    89             i=JumpStringInPare(desc,i+1);
    90             continue;
    91         }
    92         else if( desc[i] == '[' ){
    93             i=JumpStringInBracket(desc,i+1);
    94             continue;
    95         }
    96         else if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM)){
    97             lastIndex = i;
    98         }
    99     }
    100     if( lastIndex == -1 ){
    101         lstrcpy( member, desc );
    102         return false;
    103     }
    104 
    105     if(desc[lastIndex]=='.'){
    106         lstrcpy(member,desc+lastIndex+1);
    107         refType = CClass::Dot;
    108     }
    109     else{
    110         lstrcpy(member,desc+lastIndex+2);
    111         refType = CClass::Pointer;
    112     }
    113 
    114     if( object ){
    115         lstrcpy( object, desc );
    116         object[lastIndex]=0;
    117     }
    118 
    119     return true;
    120 }
    121 bool SplitMemberName( const char *desc, char *object, char *member ){
    122     CClass::RefType dummyRefType;
    123     return SplitMemberName( desc, object, member, dummyRefType );
    124 }
    12590
    12691bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn ){
     
    199164        GetVarType(fullCallName,type,false);
    200165
    201         ProcPointer *pProcPtr = Smoothie::meta.procPointers[type.GetIndex()];
     166        ProcPointer *pProcPtr = Smoothie::GetMeta().GetProcPointers()[type.GetIndex()];
    202167        resultType = pProcPtr->ReturnType();
    203168
     
    402367
    403368    // オブジェクトを生成
    404     DllProc *pDllProc = new DllProc( namespaceScopes, procName, kind, isCdecl, dllFileName, alias );
     369    DllProc *pDllProc = new DllProcImpl( namespaceScopes, procName, kind, isCdecl, dllFileName, alias );
    405370
    406371    // パラメータを解析
     
    409374
    410375    // パラメータのエラーチェック
    411     foreach( const Parameter *pParam, pDllProc->Params() ){
     376    BOOST_FOREACH( const Parameter *pParam, pDllProc->Params() ){
    412377        if( pParam->IsObject() ){
    413378            SetError(25,pParam->GetVarName(),nowLine);
     
    662627
    663628    // 名前空間管理
    664     NamespaceScopes &namespaceScopes = Smoothie::Lexical::liveingNamespaceScopes;
     629    NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
    665630    namespaceScopes.clear();
    666631
     
    852817}
    853818
    854 
    855 
    856 ///////////////////////
    857 // 関数ポインタの管理
    858 ///////////////////////
    859 
    860 int AddProcPtrInfo( const string &typeExpression, int nowLine ){
    861     DWORD dwProcType = (DWORD)typeExpression[2];
    862     const string &paramStr = typeExpression.substr( 3 );
    863 
    864     Procedure::Kind kind = Procedure::Sub;
    865     if( dwProcType == ESC_FUNCTION ){
    866         kind = Procedure::Function;
    867     }
    868 
    869     ProcPointer *pProcPointer = new ProcPointer( kind );
    870 
    871     //buffer[0]は'('となっている
    872     pProcPointer->SetParamsAndReturnType( paramStr.c_str(), nowLine );
    873 
    874     Smoothie::meta.procPointers.push_back( pProcPointer );
    875 
    876     return (int)Smoothie::meta.procPointers.size()-1;
    877 }
    878 void DeleteProcPtrInfo(void){
    879     BOOST_FOREACH( ProcPointer *pProcPointer, Smoothie::meta.procPointers ){
    880         delete pProcPointer;
    881     }
    882 
    883     Smoothie::meta.procPointers.clear();
    884 }
    885 
    886 
    887 
    888819bool IsNeedProcCompile(){
    889820    for(int i2=0;i2<MAX_HASH;i2++){
  • trunk/abdev/BasicCompiler_Common/VarList.cpp

    r140 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24
     
    266268    extern int MemPos_RWSection;
    267269
    268     foreach( Variable *pVar, globalVars ){
     270    BOOST_FOREACH( Variable *pVar, globalVars ){
    269271
    270272        //スコープ外の場合は無視
     
    362364    if(!pUserProc) return;
    363365
    364     foreach( Variable *pVar, pUserProc->localVars ){
     366    BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    365367
    366368        //スコープ外の場合は無視
     
    725727
    726728        if(pUserProc){
    727             pobj_CompilingClass = pUserProc->GetParentClassPtr();
     729            Smoothie::Temp::pCompilingClass = pUserProc->GetParentClassPtr();
    728730            UserProc::CompileStartForUserProc( pUserProc );
    729731        }
  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r159 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <LexicalScopingImpl.h>
     5
    16#include "../BasicCompiler_Common/common.h"
    27
     
    712#endif
    813
    9 BOOL IsVariableTopChar(char c){
    10     if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||c=='_') return 1;
    11     return 0;
    12 }
    13 BOOL IsVariableChar(char c){
    14     if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9')||
    15         c=='%'||c=='!'||c=='#'||c=='$'||
    16         c=='_'||c=='.') return 1;
    17     return 0;
    18 }
    1914BOOL IsPtrType(int type){
    2015    if(type==-1) return 0;
     
    119114            return DEF_QWORD;
    120115        case DEF_CHAR:
    121             if( isUnicode ) return DEF_WORD;
     116            if( Smoothie::IsUnicode() ) return DEF_WORD;
    122117            return DEF_BYTE;
    123118    }
     
    150145    //文字型
    151146    else if( type == DEF_CHAR ){
    152         if( isUnicode ) return sizeof( WORD );
     147        if( Smoothie::IsUnicode() ) return sizeof( WORD );
    153148        return sizeof( BYTE );
    154149    }
     
    220215        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
    221216        else{
    222             if( Smoothie::meta.procPointers[lpIndex]->ReturnType().IsNull() )
     217            if( Smoothie::GetMeta().GetProcPointers()[lpIndex]->ReturnType().IsNull() )
    223218                lstrcpy(name,"*Sub");
    224219            else lstrcpy(name,"*Function");
     
    235230
    236231Type GetStringTypeInfo(){
    237     Type type( DEF_OBJECT, *pobj_DBClass->GetStringClassPtr() );
     232    Type type( DEF_OBJECT, *Smoothie::GetMeta().GetClasses().GetStringClassPtr() );
    238233    return type;
    239234}
     
    248243}
    249244
    250 /*TODO: 消す
    251 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
    252     int p1 = 0, p2 = 0;
    253 
    254     for( int i=0; term[i]!='\0' ; i++ ){
    255 
    256         if( term[i] == '[' ){
    257             i = JumpStringInBracket( term, i + 1 );
    258             if( term[i] == '\0' ) break;
    259             continue;
    260         }
    261         if( term[i] == '(' ){
    262             int temp_p = i;
    263             i = JumpStringInPare( term, i + 1 ) + 1;
    264             if( term[i] == '\0' ) break;
    265             if( term[i] == '.'
    266                 || term[i] == 1 && term[i] == ESC_PSMEM ){
    267                     p1 = temp_p;
    268                     p2 = i;
    269             }
    270             continue;
    271         }
    272     }
    273     if( !p1 ) return false;
    274 
    275     //メソッド名
    276     memcpy( procName, term, p1 );
    277     procName[p1] = 0;
    278 
    279     //パラメータ
    280     memcpy( parameter, term + p1 + 1, p2 - p1 - 2 );
    281     parameter[ p2 - p1 - 2 ] = 0;
    282 
    283     //参照タイプ
    284     if( term[p2] == '.' ){
    285         refType = CClass::Dot;
    286     }
    287     else{
    288         refType = CClass::Pointer;
    289         p2++;
    290     }
    291 
    292     //メンバ
    293     lstrcpy( member, term + p2 + 1 );
    294 
    295     return true;
    296 }*/
     245
     246void GetArrange(char *variable,char *variAnswer,int *SubScripts){
     247    extern int cp;
     248    int i,i2,i3,i4;
     249    double dbl;
     250    _int64 i64data;
     251    BOOL bBracket;
     252    char temporary[VN_SIZE];
     253
     254    for(i=0;;i++){
     255        if(variable[i]=='('||variable[i]=='['){
     256            if(variable[i]=='[') bBracket=1;
     257            else bBracket=0;
     258
     259            variAnswer[i]=0;
     260            for(i++,i2=0,i3=0;;i++,i2++){
     261                if(variable[i]==','){
     262                    temporary[i2]=0;
     263
     264                    Type resultType;
     265                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
     266                        return;
     267                    }
     268                    if(resultType.IsReal()){
     269                        memcpy(&dbl,&i64data,sizeof(double));
     270                        i64data=(_int64)dbl;
     271                    }
     272
     273                    if(i64data<0){
     274                        //error
     275                        SubScripts[i3]=0;
     276                    }
     277                    else SubScripts[i3]=(int)i64data;
     278                    i3++;
     279                    i2=-1;
     280                    continue;
     281                }
     282                if(variable[i]=='('){
     283                    i4=GetStringInPare(temporary+i2,variable+i);
     284                    i2+=i4-1;
     285                    i+=i4-1;
     286                    continue;
     287                }
     288                if(variable[i]=='['){
     289                    i4=GetStringInBracket(temporary+i2,variable+i);
     290                    i2+=i4-1;
     291                    i+=i4-1;
     292                    continue;
     293                }
     294                if(variable[i]==')'&&bBracket==0||
     295                    variable[i]==']'&&bBracket){
     296                    temporary[i2]=0;
     297                    if(i2==0){
     298                        SubScripts[i3]=-2;
     299                        break;
     300                    }
     301
     302                    Type resultType;
     303                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
     304                        return;
     305                    }
     306                    if(resultType.IsReal()){
     307                        memcpy(&dbl,&i64data,sizeof(double));
     308                        i64data=(_int64)dbl;
     309                    }
     310
     311                    if(i64data<0){
     312                        //error
     313                        SubScripts[i3]=0;
     314                    }
     315                    else SubScripts[i3]=(int)i64data;
     316                    SubScripts[i3+1]=-1;
     317                    break;
     318                }
     319                if(variable[i]=='\"'){
     320                    SetError(1,NULL,cp);
     321                    return;
     322                }
     323                temporary[i2]=variable[i];
     324            }
     325            break;
     326        }
     327        variAnswer[i]=variable[i];
     328        if(variable[i]=='\0'){
     329            SubScripts[0]=-1;
     330            break;
     331        }
     332    }
     333}
     334
    297335
    298336BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,CClass::RefType &refType){
     
    427465    return i2;
    428466}
    429 void GetArrange(char *variable,char *variAnswer,int *SubScripts){
    430     extern int cp;
    431     int i,i2,i3,i4;
    432     double dbl;
    433     _int64 i64data;
    434     BOOL bBracket;
    435     char temporary[VN_SIZE];
    436 
    437     for(i=0;;i++){
    438         if(variable[i]=='('||variable[i]=='['){
    439             if(variable[i]=='[') bBracket=1;
    440             else bBracket=0;
    441 
    442             variAnswer[i]=0;
    443             for(i++,i2=0,i3=0;;i++,i2++){
    444                 if(variable[i]==','){
    445                     temporary[i2]=0;
    446 
    447                     Type resultType;
    448                     if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
    449                         return;
    450                     }
    451                     if(resultType.IsReal()){
    452                         memcpy(&dbl,&i64data,sizeof(double));
    453                         i64data=(_int64)dbl;
    454                     }
    455 
    456                     if(i64data<0){
    457                         //error
    458                         SubScripts[i3]=0;
    459                     }
    460                     else SubScripts[i3]=(int)i64data;
    461                     i3++;
    462                     i2=-1;
    463                     continue;
    464                 }
    465                 if(variable[i]=='('){
    466                     i4=GetStringInPare(temporary+i2,variable+i);
    467                     i2+=i4-1;
    468                     i+=i4-1;
    469                     continue;
    470                 }
    471                 if(variable[i]=='['){
    472                     i4=GetStringInBracket(temporary+i2,variable+i);
    473                     i2+=i4-1;
    474                     i+=i4-1;
    475                     continue;
    476                 }
    477                 if(variable[i]==')'&&bBracket==0||
    478                     variable[i]==']'&&bBracket){
    479                     temporary[i2]=0;
    480                     if(i2==0){
    481                         SubScripts[i3]=-2;
    482                         break;
    483                     }
    484 
    485                     Type resultType;
    486                     if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
    487                         return;
    488                     }
    489                     if(resultType.IsReal()){
    490                         memcpy(&dbl,&i64data,sizeof(double));
    491                         i64data=(_int64)dbl;
    492                     }
    493 
    494                     if(i64data<0){
    495                         //error
    496                         SubScripts[i3]=0;
    497                     }
    498                     else SubScripts[i3]=(int)i64data;
    499                     SubScripts[i3+1]=-1;
    500                     break;
    501                 }
    502                 if(variable[i]=='\"'){
    503                     SetError(1,NULL,cp);
    504                     return;
    505                 }
    506                 temporary[i2]=variable[i];
    507             }
    508             break;
    509         }
    510         variAnswer[i]=variable[i];
    511         if(variable[i]=='\0'){
    512             SubScripts[0]=-1;
    513             break;
    514         }
    515     }
    516 }
    517 
    518 int GetTypeFromSimpleName(char *variable){
    519     extern char DefIntVari[26],DefSngVari[26],DefStrVari[26],divNum,dsvNum,dStrvNum;
    520     int i;
    521     char name[VN_SIZE];
    522 
    523     //構造体メンバの場合を考慮
    524     for(i=lstrlen(variable);i>0;i--){
    525         if(variable[i]=='.'){
    526             i++;
    527             break;
    528         }
    529     }
    530 
    531     for(;;i++){
    532         if(variable[i]=='('||variable[i]=='\0'){
    533             name[i]=0;
    534             break;
    535         }
    536         name[i]=variable[i];
    537     }
    538     //変数名から選択
    539     i--;
    540     if(name[i]=='#') return DEF_DOUBLE;
    541     if(name[i]=='!') return DEF_SINGLE;
    542     if(name[i]=='%') return DEF_INTEGER;
    543     return DEF_DOUBLE;
    544 }
    545467
    546468
     
    571493
    572494    //アクセシビリティをチェック
    573     if( &objClass == pobj_CompilingClass ){
     495    if( &objClass == Smoothie::Temp::pCompilingClass ){
    574496        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    575497        if( pMember->IsNoneAccess() ){
     
    645567    // 名前空間を分離
    646568    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    647     Smoothie::meta.namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
     569    Smoothie::GetMeta().namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
    648570
    649571    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
     
    675597    }
    676598
    677     if(pobj_CompilingClass){
     599    if(Smoothie::Temp::pCompilingClass){
    678600        ///////////////////////
    679601        // クラスメンバの参照
     
    682604        if(lstrcmpi(variable,"This")==0){
    683605            //Thisオブジェクト
    684             resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     606            resultType.SetType( DEF_OBJECT, Smoothie::Temp::pCompilingClass );
    685607            return true;
    686608        }
     
    695617
    696618            bool isFound = false;
    697             BOOST_FOREACH( CMember *pMember, pobj_CompilingClass->GetDynamicMembers() ){
     619            BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
    698620                if( pMember->GetName() == VarName ){
    699621                    isFound = true;
     
    704626        }
    705627
    706         return GetMemberType(*pobj_CompilingClass,variable,resultType,1,isErrorEnabled);
     628        return GetMemberType(*Smoothie::Temp::pCompilingClass,variable,resultType,1,isErrorEnabled);
    707629    }
    708630
     
    738660        }
    739661
    740         int typeDefIndex = Smoothie::meta.typeDefs.GetIndex( VarName );
     662        int typeDefIndex = Smoothie::GetMeta().typeDefs.GetIndex( VarName );
    741663        if( typeDefIndex != -1 ){
    742664            // TypeDef後の型名だったとき
    743             lstrcpy( VarName, Smoothie::meta.typeDefs[typeDefIndex].GetBaseName().c_str() );
     665            lstrcpy( VarName, Smoothie::GetMeta().typeDefs[typeDefIndex].GetBaseName().c_str() );
    744666        }
    745667
     
    755677    }
    756678
    757     if(pobj_CompilingClass){
     679    if(Smoothie::Temp::pCompilingClass){
    758680        //自身のクラスから静的メンバを参照する場合
    759681        char temp2[VN_SIZE];
    760         sprintf(temp2,"%s.%s",pobj_CompilingClass->GetName().c_str(),VarName);
     682        sprintf(temp2,"%s.%s",Smoothie::Temp::pCompilingClass->GetName().c_str(),VarName);
    761683
    762684        pVar = globalVars.Find( Symbol( temp2 ) );
     
    972894        if( InitBuf[0] == '\0' ){
    973895            //As指定も、初期値指定もない場合
    974             type.SetBasicType( GetTypeFromSimpleName(variable) );
     896            type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
    975897
    976898            i2=lstrlen(variable)-1;
     
    1015937
    1016938    //クラス名
    1017     if(pobj_CompilingClass){
    1018         lstrcat(FullName,pobj_CompilingClass->GetName().c_str());
     939    if(Smoothie::Temp::pCompilingClass){
     940        lstrcat(FullName,Smoothie::Temp::pCompilingClass->GetName().c_str());
    1019941        lstrcat(FullName,"%");
    1020942    }
     
    1052974    bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
    1053975
    1054     Variable *pVar = new Variable( Smoothie::Lexical::liveingNamespaceScopes, name, type, isConst );
     976    Variable *pVar = new Variable( Smoothie::Temp::liveingNamespaceScopes, name, type, isConst );
    1055977
    1056978    if( SubScripts[0] != -1 ){
     
    1063985
    1064986    //レキシカルスコープ
    1065     pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1066     pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     987    pVar->ScopeLevel=GetLexicalScopes().GetNowLevel();
     988    pVar->ScopeStartAddress=GetLexicalScopes().GetStartAddress();
    1067989    pVar->bLiving=TRUE;
    1068990
  • trunk/abdev/BasicCompiler_Common/VariableOpe.h

    r138 r182  
    11
    22
    3 BOOL IsVariableTopChar(char c);
    4 BOOL IsVariableChar(char c);
    53BOOL IsPtrType(int type);
    64BOOL IsSignedType(int type);
     
    1917BOOL CheckVarNameError(char *name,int nowLine);
    2018int JumpSubScripts(const int *ss);
    21 void GetArrange(char *variable,char *variAnswer,int *SubScripts);
    22 int GetTypeFromSimpleName(char *variable);
    2319bool GetMemberType( const CClass &objClass, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled);
    2420bool GetVarType( const char *nameBuffer, Type &resultType, bool isError);
  • trunk/abdev/BasicCompiler_Common/WatchList.cpp

    r140 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "common.h"
    24
     
    316318    GlobalProc *pUserProc = GetSubFromObp(obp_Rip);
    317319
    318     foreach( Variable *pVar, pUserProc->localVars ){
     320    BOOST_FOREACH( Variable *pVar, pUserProc->localVars ){
    319321        if( pVar->GetName() == "_System_LocalThis" ){
    320322            return pVar->offset;
     
    369371    }
    370372
    371     if(pobj_CompilingClass){
     373    if(Smoothie::Temp::pCompilingClass){
    372374        ///////////////////////
    373375        // クラスメンバの参照
     
    383385
    384386            bool isFound = false;
    385             BOOST_FOREACH( CMember *pMember, pobj_CompilingClass->GetDynamicMembers() ){
     387            BOOST_FOREACH( CMember *pMember, Smoothie::Temp::pCompilingClass->GetDynamicMembers() ){
    386388                if( pMember->GetName() == VarName ){
    387389                    isFound = true;
     
    412414        pRelativeVar->dwKind=VAR_DIRECTMEM;
    413415
    414         i3=Debugging_GetMember(*pobj_CompilingClass,variable,pRelativeVar,resultType,1);
     416        i3=Debugging_GetMember(*Smoothie::Temp::pCompilingClass,variable,pRelativeVar,resultType,1);
    415417        if(i3==0){
    416418            //式エラー
  • trunk/abdev/BasicCompiler_Common/calculation.cpp

    r128 r182  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24
  • trunk/abdev/BasicCompiler_Common/common.h

    r167 r182  
    1919#include <boost/foreach.hpp>
    2020
    21 #define foreach BOOST_FOREACH
    22 
    2321using namespace std;
    2422
     
    3937#include "../BasicCompiler_Common/psapi.h"
    4038#include "../BasicCompiler_Common/BreakPoint.h"
    41 #include "../BasicCompiler_Common/LexicalScoping.h"
    4239
    4340
     
    5653
    5754#define MAX_LEN         65535
    58 #define VN_SIZE         512
    5955#define DIGIT_SIZE      128
    6056#define MAX_PARMS       64
     
    9187extern HANDLE hHeap;
    9288extern int cp;
    93 extern bool isUnicode;
    9489extern int typeOfPtrChar;
    9590extern int typeOfPtrUChar;
     
    144139
    145140
    146 // クラス管理用のクラス
    147 #include "Class.h"
    148 
    149141// 列挙体管理用のクラス
    150142#include "Enum.h"
     
    152144// 定数管理用のクラス
    153145#include "Const.h"
    154 
    155 // 変数管理用のクラス
    156 #include "Variable.h"
    157 
    158 // パラメータ管理用のクラス
    159 #include "Parameter.h"
    160 
    161 // プロシージャ管理用のクラス
    162 #include "Procedure.h"
    163 
    164 // コンパイラが必要とするデータハウス
    165 #include <Smoothie.h>
    166146
    167147
     
    170150    char *FileName;
    171151    int line;
    172 };
    173 struct INCLUDEFILEINFO{
    174     char **ppFileNames;
    175     int FilesNum;
    176     int LineOfFile[MAX_LEN];
    177152};
    178153
     
    272247#include "../BasicCompiler_Common/DebugSection.h"
    273248#include "../BasicCompiler_Common/VariableOpe.h"
    274 #include <Exception.h>
    275249
    276250
     
    388362void SlideString(char *str,int slide);
    389363void SlideBuffer(char *buffer,int length,int slide);
    390 _int8 IsCommandDelimitation(char c);
    391 BOOL IsBlank(char c);
    392 int GetOneParameter(const char *Parameter,int pos,char *retAns);
    393 int JumpOneParameter(char *Parameter,int i);
    394 int GetStringInQuotation(char *buffer,char *ReadBuffer);
    395 int GetStringInPare(char *buffer,const char *ReadBuffer);
    396 int GetStringInPare_RemovePare(char *buffer,char *ReadBuffer);
    397 int GetStringInBracket(char *buffer,const char *ReadBuffer);
    398 int JumpStringInPare(const char *buffer,int pos);
    399 int JumpStringInBracket(const char *buffer,int pos);
    400364int GetCpFromLine(int LineNum);
    401365BOOL GetLineNum(int pos,int *pLine,char *FileName);
     
    435399int GetProc(char *name,void **ppInfo);
    436400void SplitObjectName(const char *name,char *ObjectName,int *pRefType);
    437 bool SplitMemberName( const char *desc, char *object, char *member, CClass::RefType &refType );
    438 bool SplitMemberName( const char *desc, char *object, char *member );
    439401bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn = true );
    440402bool CallPropertyMethod( const char *variable, const char *rightSide, Type &resultType);
     
    446408void DeleteDeclareInfo(void);
    447409int AddProcPtrInfo( const string &typeExpression, int nowLine );
    448 void DeleteProcPtrInfo(void);
    449410bool IsNeedProcCompile();
    450411
     
    452413void Opcode_Input(const char *Parameter);
    453414void Opcode_Print(const char *Parameter,BOOL bWrite);
    454 
    455 //LoopRefCheck.cpp
    456 class CLoopRefCheck{
    457     char **names;
    458     int num;
    459     void init();
    460 public:
    461     CLoopRefCheck();
    462     ~CLoopRefCheck();
    463     void add(const char *lpszInheritsClass);
    464     void del(const char *lpszInheritsClass);
    465     BOOL check(const CClass &inheritsClass) const;
    466 };
    467 extern CLoopRefCheck *pobj_LoopRefCheck;
    468 
    469 //DataTable.cpp
    470 class DataTable{
    471     void *pdata;
    472     int size;
    473 
    474 public:
    475     DataTable();
    476     ~DataTable();
    477     void Init();
    478 
    479     int AddBinary( const void *pdata, int size );
    480     int Add( _int64 i64data );
    481     int Add( int i32data );
    482     int Add( double dbl );
    483     int Add( float flt );
    484     int AddString( const char *str, int length );
    485     int AddString( const char *str );
    486 
    487     const void *GetPtr() const;
    488     int GetSize() const;
    489 };
    490 extern DataTable dataTable;
    491415
    492416//error.cpp
     
    499423
    500424//Compile.cpp
    501 void ReallocNativeCodeBuffer();
    502425void GetIdentifierToken( char *token, const char *source, int &pos );
    503426int JumpStatement(const char *source, int &pos);
  • trunk/abdev/BasicCompiler_Common/error.cpp

    r167 r182  
     1#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
    13#include <Program.h>
    24
  • trunk/abdev/BasicCompiler_Common/hash.cpp

    r136 r182  
     1#include <jenga/include/smoothie/Smoothie.h>
     2
    13#include "../BasicCompiler_Common/common.h"
    24
     
    3840    char ObjName[VN_SIZE];      //オブジェクト変数
    3941    char NestMember[VN_SIZE];   //入れ子メンバ
    40     bool isObjectMember = SplitMemberName( fullName, ObjName, NestMember );
     42    bool isObjectMember = CClass::SplitName( fullName, ObjName, NestMember );
    4143
    4244    //ハッシュ値を取得
     
    7173    char ObjName[VN_SIZE];      //オブジェクト変数
    7274    char NestMember[VN_SIZE];   //入れ子メンバ
    73     bool isObjectMember = SplitMemberName( name, ObjName, NestMember );
     75    bool isObjectMember = CClass::SplitName( name, ObjName, NestMember );
    7476
    7577    if(isObjectMember){
     
    8082        if(lstrcmpi(ObjName,"Super")==0){
    8183            //クラスメンバ関数内から基底クラスの呼び出し
    82             pobj_c=pobj_CompilingClass;
     84            pobj_c=Smoothie::Temp::pCompilingClass;
    8385        }
    8486        else{
     
    8991            }
    9092            else{
    91                 pobj_c=pobj_DBClass->Find(ObjName);
     93                pobj_c=Smoothie::GetMeta().GetClasses().Find(ObjName);
    9294                if( pobj_c ){
    9395                    isStatic = true;
     
    110112
    111113
    112     if(pobj_CompilingClass){
     114    if(Smoothie::Temp::pCompilingClass){
    113115        //自身のオブジェクトのメンバ関数を検索
    114116
    115117        // 静的メソッド
    116         pobj_CompilingClass->GetStaticMethods().Enum( name, subs );
     118        Smoothie::Temp::pCompilingClass->GetStaticMethods().Enum( name, subs );
    117119
    118120        // 動的メソッド
    119         pobj_CompilingClass->GetMethods().Enum( name, subs );
     121        Smoothie::Temp::pCompilingClass->GetMethods().Enum( name, subs );
    120122    }
    121123
     
    187189
    188190UserProc *GetClassMethod( const char *className, const char *methodName ){
    189     const CClass *pClass = pobj_DBClass->Find( className );
     191    const CClass *pClass = Smoothie::GetMeta().GetClasses().Find( className );
    190192    if( pClass ){
    191193        vector<UserProc *> userProcs;
  • trunk/abdev/BasicCompiler_Common/include/option.h

    r167 r182  
    2323
    2424// ログ生成しない場合はこの下の行をコメントアウトする
    25 #define USE_TRACE
     25//#define USE_TRACE
    2626
    2727// オーバーロードに関するログを生成する
Note: See TracChangeset for help on using the changeset viewer.