Changeset 193 in dev for trunk/abdev


Ignore:
Timestamp:
Jun 26, 2007, 5:04:50 AM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
4 added
30 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/BasicCompiler.vcproj

    r191 r193  
    12871287                    >
    12881288                </File>
     1289                <File
     1290                    RelativePath="..\BasicCompiler_Common\src\TypeDef.cpp"
     1291                    >
     1292                </File>
     1293                <File
     1294                    RelativePath="..\BasicCompiler_Common\src\VariableImpl.cpp"
     1295                    >
     1296                </File>
    12891297            </Filter>
    12901298        </Filter>
    … …  
    13801388                    >
    13811389                </File>
     1390                <File
     1391                    RelativePath="..\BasicCompiler_Common\include\TypeDef.h"
     1392                    >
     1393                </File>
     1394                <File
     1395                    RelativePath="..\BasicCompiler_Common\include\VariableImpl.h"
     1396                    >
     1397                </File>
    13821398            </Filter>
    13831399        </Filter>

  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r183 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <Compiler.h>
    35
    46#include "../BasicCompiler_Common/common.h"
    … …  
    622624
    623625
    624     if( varType.IsObject() && Smoothie::GetMeta().blittableTypes.IsExist( calcType ) ){
     626    if( varType.IsObject() && compiler.GetMeta().GetBlittableTypes().IsExist( calcType ) ){
    625627        // Blittable型をオブジェクトとして扱う
    626628        vector<UserProc *> userProcs;
    627         Smoothie::GetMeta().blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
     629        compiler.GetMeta().GetBlittableTypes().GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
    628630        if( userProcs.size() != 1 ){
    629631            SetError();

  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r183 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    129131                pobj_c = &varType.GetClass();
    130132                if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
    131                     pobj_c=Smoothie::GetMeta().GetClasses().Find(ObjectName);
     133                    pobj_c=compiler.GetMeta().GetClasses().Find(ObjectName);
    132134                    if( pobj_c ){
    133135                        isStatic = true;

  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r183 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    178180        tempParm=temp2;
    179181
    180         type.SetType( DEF_OBJECT, Smoothie::GetMeta().GetClasses().GetStringClassPtr() );
     182        type.SetType( DEF_OBJECT, compiler.GetMeta().GetClasses().GetStringClassPtr() );
    181183    }
    182184
    … …  
    230232
    231233        //オーバーロードを解決
    232         pUserProc=OverloadSolution(name,subs,Smoothie::GetMeta().GetProcPointers()[ProcPtr_BaseIndex]->Params(), Type() );
     234        pUserProc=OverloadSolution(name,subs,compiler.GetMeta().GetProcPointers()[ProcPtr_BaseIndex]->Params(), Type() );
    233235
    234236        if(!pUserProc){
    … …  
    318320void Opcode_Func_SizeOf( const string &typeName ){
    319321    Type tempType;
    320     if( !Type::StringToType( typeName, tempType ) ){
     322    if( !Compiler::StringToType( typeName, tempType ) ){
    321323        SetError(3,typeName,cp);
    322324        return;

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r183 r193  
    33
    44#include <Program.h>
     5#include <Compiler.h>
    56#include <LexicalScopingImpl.h>
    67#include <ClassImpl.h>
     8#include <VariableImpl.h>
    79
    810#include "../BasicCompiler_Common/common.h"
    … …  
    5557
    5658        //クラスに属する静的メンバを定義
    57         Smoothie::GetMeta().GetClasses().InitStaticMember();
     59        compiler.GetMeta().GetClasses().InitStaticMember();
    5860
    5961        GetGlobalDataForDll();
    … …  
    224226        && userProc.GetParentClass().GetName() == "_System_TypeBase" ){
    225227
    226             Smoothie::GetMeta().GetClasses().Compile_System_InitializeUserTypes();
     228            compiler.GetMeta().GetClasses().Compile_System_InitializeUserTypes();
    227229    }
    228230    else if( userProc.GetName() == "RegisterGlobalRoots"
    … …  
    273275
    274276    //コンパイルスタートをクラス管理クラスに追加
    275     Smoothie::GetMeta().GetClasses().StartCompile( pUserProc );
     277    compiler.GetMeta().GetClasses().StartCompile( pUserProc );
    276278
    277279    //コンパイル中の関数
    … …  
    282284
    283285    // コンパイル中の関数でImportsされている名前空間
    284     Smoothie::Temp::importedNamespaces = pUserProc->GetImportedNamespaces();
     286    compiler.SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
    285287
    286288    if(pUserProc->IsSystem()){
    … …  
    318320        Parameter &param = *pUserProc->RealParams()[i3];
    319321
    320         Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef() );
     322        Variable *pVar = new VariableImpl( param.GetVarName(), param, false, param.IsRef() );
    321323
    322324        if( param.IsArray() ){
    … …  
    395397        else{
    396398            if( pUserProc->ReturnType().IsObject() ){
    397                 sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() );
     399                sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
    398400            }
    399401            else{
    400402                //戻り値用の変数の定義
    401                 sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() );
     403                sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
    402404            }
    403405

  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r183 r193  
    55#include <CodeGenerator.h>
    66#include <Compiler.h>
     7#include <VariableImpl.h>
    78
    89#include "../BasicCompiler_Common/common.h"
    … …  
    367368    // 名前空間を分離
    368369    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    369     Smoothie::GetMeta().namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
     370    compiler.GetMeta().GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
    370371
    371372    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
    … …  
    461462        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
    462463        //（コンストラクタ、デストラクタ内を除く）
    463         const CMethod *pMethod = Smoothie::GetMeta().GetClasses().GetNowCompilingMethodInfo();
     464        const CMethod *pMethod = compiler.GetMeta().GetClasses().GetNowCompilingMethodInfo();
    464465        if( isWriteAccess &&
    465466            pMethod->IsConst() &&
    … …  
    524525            }
    525526
    526             int typeDefIndex = Smoothie::GetMeta().typeDefs.GetIndex( VarName );
     527            int typeDefIndex = compiler.GetMeta().GetTypeDefs().GetIndex( VarName );
    527528            if( typeDefIndex != -1 ){
    528529                // TypeDef後の型名だったとき
    529                 lstrcpy( VarName, Smoothie::GetMeta().typeDefs[typeDefIndex].GetBaseName().c_str() );
     530                lstrcpy( VarName, compiler.GetMeta().GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
    530531            }
    531532
    … …  
    832833            char *temp;
    833834            temp=(char *)i64data;
    834             i2=Compiler::GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
     835            i2=compiler.GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
    835836            HeapDefaultFree(temp);
    836837
    … …  
    10221023            char *temp;
    10231024            temp=(char *)i64data;
    1024             i2=Compiler::GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
     1025            i2=compiler.GetNativeCode().GetDataTable().AddString(temp,lstrlen(temp));
    10251026            HeapDefaultFree(temp);
    10261027
    … …  
    10951096        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
    10961097
    1097         Variable *pVar = new Variable( VarName, type, isConst );
     1098        Variable *pVar = new VariableImpl( VarName, type, isConst );
    10981099
    10991100        if( SubScripts[0] != -1 ){

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r191 r193  
    140140    //////////////////
    141141    // データテーブル
    142     Compiler::GetNativeCode().GetDataTable().Init();
     142    compiler.GetNativeCode().GetDataTable().Init();
    143143    if(bDebugCompile){
    144         Compiler::GetNativeCode().GetDataTable().Add( (long)0x00000002 );
     144        compiler.GetNativeCode().GetDataTable().Add( (long)0x00000002 );
    145145    }
    146146
    … …  
    166166
    167167    //関数ポインタ情報を初期化
    168     Smoothie::GetMeta().GetProcPointers().clear();
     168    compiler.GetMeta().GetProcPointers().clear();
    169169
    170170    // 名前空間情報を取得
    171171    NamespaceScopesCollection::CollectNamespaces(
    172172        Smoothie::Lexical::source.GetBuffer(),
    173         Smoothie::GetMeta().namespaceScopesCollection
     173        compiler.GetMeta().GetNamespaces()
    174174    );
    175175
    … …  
    177177    //   GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。
    178178    //     ※オブジェクトの内容までは取得しない
    179     Smoothie::GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
     179    compiler.GetMeta().GetClasses().CollectClassesForNameOnly( Smoothie::Lexical::source );
    180180
    181181    //TypeDef情報を初期化
    182     Smoothie::GetMeta().typeDefs.Init();
     182    compiler.GetMeta().GetTypeDefs().Init();
    183183
    184184    //定数情報を取得
    … …  
    190190
    191191    //クラス情報を取得（※注 - GetSubInfoの後に呼び出す）
    192     Smoothie::GetMeta().GetClasses().GetAllClassInfo();
    193 
    194     if( !Smoothie::GetMeta().AutoWrite( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
     192    compiler.GetMeta().GetClasses().GetAllClassInfo();
     193
     194    if( !compiler.GetMeta().AutoWrite( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" ) )
    195195    {
    196196        ts(0);
    … …  
    415415
    416416        //クラスに属する静的メンバを定義
    417         Smoothie::GetMeta().GetClasses().InitStaticMember();
     417        compiler.GetMeta().GetClasses().InitStaticMember();
    418418
    419419        //グローバル実行領域をコンパイル開始
    … …  
    884884
    885885    //データセクションのファイル上のサイズ
    886     if(Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT) FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize()+(FILE_ALIGNMENT-Compiler::GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT);
    887     else FileSize_DataSection=Compiler::GetNativeCode().GetDataTable().GetSize();
     886    if(compiler.GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT) FileSize_DataSection=compiler.GetNativeCode().GetDataTable().GetSize()+(FILE_ALIGNMENT-compiler.GetNativeCode().GetDataTable().GetSize()%FILE_ALIGNMENT);
     887    else FileSize_DataSection=compiler.GetNativeCode().GetDataTable().GetSize();
    888888    if(FileSize_DataSection) bUse_DataSection=1;
    889889    else bUse_DataSection=0;
    … …  
    10761076    ////////////////////////////////////////
    10771077    //仮想関数データテーブルスケジュール
    1078     Smoothie::GetMeta().GetClasses().ActionVtblSchedule(ImageBase,MemPos_CodeSection);
     1078    compiler.GetMeta().GetClasses().ActionVtblSchedule(ImageBase,MemPos_CodeSection);
    10791079
    10801080
    … …  
    16111611    if(bUse_DataSection){
    16121612        //データ テーブル
    1613         WriteFile(hFile,Compiler::GetNativeCode().GetDataTable().GetPtr(),Compiler::GetNativeCode().GetDataTable().GetSize(),(DWORD *)&i2,NULL);
     1613        WriteFile(hFile,compiler.GetNativeCode().GetDataTable().GetPtr(),compiler.GetNativeCode().GetDataTable().GetSize(),(DWORD *)&i2,NULL);
    16141614        i+=i2;
    16151615    }
    … …  
    17231723
    17241724    //クラスに関するメモリを解放
    1725     Smoothie::GetMeta().GetClasses().Clear();
     1725    compiler.GetMeta().GetClasses().Clear();
    17261726}

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r183 r193  
    8282    SetStringQuotes( parameter );
    8383
    84     Operator_New( *Smoothie::GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *Smoothie::GetMeta().GetClasses().GetStringClassPtr() ) );
     84    Operator_New( *compiler.GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *compiler.GetMeta().GetClasses().GetStringClassPtr() ) );
    8585
    8686    free( parameter );
    … …  
    261261        Type leftType;
    262262        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
    263             if( isClassName == false && Smoothie::GetMeta().blittableTypes.IsExist( leftType ) ){
     263            if( isClassName == false && compiler.GetMeta().GetBlittableTypes().IsExist( leftType ) ){
    264264                // 左側のオブジェクト部分がBlittable型のとき
    265265
    … …  
    267267                lstrcpy( temporary, termLeft );
    268268                sprintf( termLeft, "%s(%s)",
    269                     Smoothie::GetMeta().blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
     269                    compiler.GetMeta().GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
    270270                    temporary );
    271271            }
    … …  
    296296
    297297    if( pIsClassName ){
    298         if( Smoothie::GetMeta().GetClasses().Find( termFull ) ){
     298        if( compiler.GetMeta().GetClasses().Find( termFull ) ){
    299299            *pIsClassName = true;
    300300            return true;
    … …  
    593593        }
    594594
    595         i2 = Compiler::GetNativeCode().GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
     595        i2 = compiler.GetNativeCode().GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
    596596
    597597        //mov eax,i2
    … …  
    709709                    // As演算子の右辺値
    710710                    //型名
    711                     if( Type::StringToType( term, resultType ) ){
     711                    if( Compiler::StringToType( term, resultType ) ){
    712712                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
    713713                    }
    … …  
    740740
    741741                        type_stack[sp]=DEF_OBJECT;
    742                         index_stack[sp]=(LONG_PTR)Smoothie::GetMeta().GetClasses().GetStringClassPtr();
     742                        index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
    743743                        bLiteralCalculation=0;
    744744
    … …  
    751751                    bLiteralCalculation=0;
    752752
    753                     i2=Compiler::GetNativeCode().GetDataTable().AddString(term,i3);
     753                    i2=compiler.GetNativeCode().GetDataTable().AddString(term,i3);
    754754
    755755                    //push DataSize
    … …  
    838838                        }
    839839                        else{
    840                             index_stack[sp] = (LONG_PTR)Smoothie::GetMeta().GetClasses().GetObjectClassPtr();
     840                            index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
    841841                        }
    842842

  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r188 r193  
    313313                    >
    314314                </File>
     315                <File
     316                    RelativePath="..\BasicCompiler_Common\include\SmoothieImpl.h"
     317                    >
     318                </File>
    315319            </Filter>
    316320        </Filter>

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r188 r193  
    177177    Smoothie::GetMeta().GetClasses().GetAllClassInfo();
    178178
    179     Smoothie::GetMeta().Write( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" );
     179    Smoothie::GetMeta().AutoWrite( Jenga::Common::Environment::GetAppDir() + "\\meta_test.xml" );
    180180
    181181    //コードと行番号の関係

  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r182 r193  
    55#include <LexicalScopingImpl.h>
    66#include <CodeGenerator.h>
     7#include <Compiler.h>
    78
    89#include "../BasicCompiler_Common/common.h"
    … …  
    260261                break;
    261262            case ESC_IMPORTS:
    262                 Smoothie::Temp::importedNamespaces.Imports( Command + 2 );
     263                compiler.ImportsNamespace( Command + 2 );
    263264                break;
    264265            case ESC_CLEARNAMESPACEIMPORTED:
    265                 Smoothie::Temp::importedNamespaces.clear();
     266                compiler.GetImportedNamespaces().clear();
    266267                break;
    267268

  • trunk/abdev/BasicCompiler_Common/Const.cpp

    r188 r193  
     1#include <Compiler.h>
     2
    13#include "common.h"
    24#include OPCODE_H_PATH  //opcode.h
    … …  
    1214        return false;
    1315    }
    14     return NamespaceScopes::IsSameArea( this->namespaceScopes, namespaceScopes );
     16    return compiler.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
    1517}
    1618bool ConstBase::IsEqualSymbol( const string &fullName ) const

  • trunk/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r191 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
    22
     3#include <Compiler.h>
    34#include <ClassImpl.h>
     5#include <VariableImpl.h>
    46
    57#include "../BasicCompiler_Common/common.h"
    … …  
    3234        (*p)+=lstrlen(buffer+(*p))+1;
    3335
    34         type.SetIndex( (LONG_PTR)Smoothie::GetMeta().GetClasses().Find(szClassName) );
     36        type.SetIndex( (LONG_PTR)compiler.GetMeta().GetClasses().Find(szClassName) );
    3537    }
    3638    else{
    … …  
    119121
    120122    //イテレータをリセット
    121     Smoothie::GetMeta().GetClasses().Iterator_Reset();
     123    compiler.GetMeta().GetClasses().Iterator_Reset();
    122124
    123125    //個数
    124     *(long *)(buffer+i2)=Smoothie::GetMeta().GetClasses().Iterator_GetMaxCount();
    125     i2+=sizeof(long);
    126 
    127     while(Smoothie::GetMeta().GetClasses().Iterator_HasNext()){
     126    *(long *)(buffer+i2)=compiler.GetMeta().GetClasses().Iterator_GetMaxCount();
     127    i2+=sizeof(long);
     128
     129    while(compiler.GetMeta().GetClasses().Iterator_HasNext()){
    128130        CClass *pobj_c;
    129         pobj_c=Smoothie::GetMeta().GetClasses().Iterator_GetNext();
     131        pobj_c=compiler.GetMeta().GetClasses().Iterator_GetNext();
    130132
    131133        //クラス名
    … …  
    139141    // TypeDef情報
    140142    //////////////////
    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() );
     143    *(long *)(buffer+i2)=(int)compiler.GetMeta().GetTypeDefs().size();
     144    i2+=sizeof(long);
     145    for(i3=0;i3<(int)compiler.GetMeta().GetTypeDefs().size();i3++){
     146        lstrcpy(buffer+i2,compiler.GetMeta().GetTypeDefs()[i3].GetName().c_str() );
     147        i2+=lstrlen(buffer+i2)+1;
     148
     149        lstrcpy(buffer+i2,compiler.GetMeta().GetTypeDefs()[i3].GetBaseName().c_str() );
    148150        i2+=lstrlen(buffer+i2)+1;
    149151
    … …  
    307309
    308310    //イテレータをリセット
    309     Smoothie::GetMeta().GetClasses().Iterator_Reset();
    310 
    311     while(Smoothie::GetMeta().GetClasses().Iterator_HasNext()){
     311    compiler.GetMeta().GetClasses().Iterator_Reset();
     312
     313    while(compiler.GetMeta().GetClasses().Iterator_HasNext()){
    312314        CClass *pobj_c;
    313         pobj_c=Smoothie::GetMeta().GetClasses().Iterator_GetNext();
     315        pobj_c=compiler.GetMeta().GetClasses().Iterator_GetNext();
    314316
    315317
    … …  
    497499    }
    498500
    499     Smoothie::GetMeta().SetClasses( this->pobj_DBClass );
     501    compiler.GetMeta().SetClasses( this->pobj_DBClass );
    500502
    501503
    … …  
    505507
    506508    //初期化
    507     Smoothie::GetMeta().typeDefs.clear();
     509    compiler.GetMeta().GetTypeDefs().clear();
    508510
    509511    //個数を取得
    … …  
    515517
    516518        // 名前空間に未対応
    517         Smoothie::GetMeta().typeDefs.push_back( TypeDef( NamespaceScopes(), temp5, buffer+i2, -1 ) );
     519        compiler.GetMeta().GetTypeDefs().push_back( TypeDef( NamespaceScopes(), temp5, buffer+i2, -1 ) );
    518520
    519521        i2+=lstrlen(buffer+i2)+1;
    … …  
    546548        bool isArray = (buffer[i2++]) ? true:false;
    547549
    548         Variable *pVar = new Variable( name, type, false, isRef );
     550        Variable *pVar = new VariableImpl( name, type, false, isRef );
    549551
    550552        if(isArray){
    … …  
    592594        const CClass *pClass = NULL;
    593595        if(szParentClassName[0]){
    594             pClass=Smoothie::GetMeta().GetClasses().Find(szParentClassName);
     596            pClass=compiler.GetMeta().GetClasses().Find(szParentClassName);
    595597        }
    596598
    … …  
    636638            bool isArray = (buffer[i2++]) ? true:false;
    637639
    638             Variable *pVar = new Variable( name, type, false, isRef );
     640            Variable *pVar = new VariableImpl( name, type, false, isRef );
    639641
    640642            if(isArray){
    … …  
    697699        i2+=lstrlen(buffer+i2)+1;
    698700
    699         pobj_c =  const_cast<CClass *>( Smoothie::GetMeta().GetClasses().Find(szClassName) );
     701        pobj_c =  const_cast<CClass *>( compiler.GetMeta().GetClasses().Find(szClassName) );
    700702
    701703        //仮想関数の数
    … …  
    748750            const CClass *pobj_InheritsClass = NULL;
    749751            if(szInherits[0]){
    750                 pobj_InheritsClass=Smoothie::GetMeta().GetClasses().Find(szInherits);
     752                pobj_InheritsClass=compiler.GetMeta().GetClasses().Find(szInherits);
    751753            }
    752754
    … …  
    945947
    946948    // クラス情報
    947     Smoothie::GetMeta().SetClasses( this->pobj_DBClass );
     949    compiler.GetMeta().SetClasses( this->pobj_DBClass );
    948950
    949951    //定数を取得

  • trunk/abdev/BasicCompiler_Common/Diagnose.cpp

    r182 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
    22
     3#include <Compiler.h>
    34#include <Program.h>
    45
    … …  
    6869        // イテレータをリセット
    6970        extern Classes *pobj_DBClass;
    70         Smoothie::GetMeta().GetClasses().Iterator_Reset();
     71        compiler.GetMeta().GetClasses().Iterator_Reset();
    7172
    72         while( Smoothie::GetMeta().GetClasses().Iterator_HasNext() ){
     73        while( compiler.GetMeta().GetClasses().Iterator_HasNext() ){
    7374            int codeSizeOfClass = 0;
    7475
    75             CClass &objClass = *Smoothie::GetMeta().GetClasses().Iterator_GetNext();
     76            CClass &objClass = *compiler.GetMeta().GetClasses().Iterator_GetNext();
    7677
    7778            if( !objClass.IsEnum() ){
    … …  
    108109        // イテレータをリセット
    109110        extern Classes *pobj_DBClass;
    110         Smoothie::GetMeta().GetClasses().Iterator_Reset();
     111        compiler.GetMeta().GetClasses().Iterator_Reset();
    111112
    112         while( Smoothie::GetMeta().GetClasses().Iterator_HasNext() ){
     113        while( compiler.GetMeta().GetClasses().Iterator_HasNext() ){
    113114            int codeSizeOfClass = 0;
    114115
    115             CClass &objClass = *Smoothie::GetMeta().GetClasses().Iterator_GetNext();
     116            CClass &objClass = *compiler.GetMeta().GetClasses().Iterator_GetNext();
    116117
    117118            // 動的メソッド

  • trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r182 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <Compiler.h>
    35
    46#include "common.h"
    … …  
    284286    }
    285287
    286     if( !Type::StringToType( TypeName, resultType ) ){
     288    if( !Compiler::StringToType( TypeName, resultType ) ){
    287289        return false;
    288290    }
    … …  
    326328        Type leftType;
    327329        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
    328             if( isClassName == false && Smoothie::GetMeta().blittableTypes.IsExist( leftType ) ){
     330            if( isClassName == false && compiler.GetMeta().GetBlittableTypes().IsExist( leftType ) ){
    329331                // 左側のオブジェクト部分がBlittable型のとき
    330332
    … …  
    332334                lstrcpy( temporary, termLeft );
    333335                sprintf( termLeft, "%s(%s)",
    334                     Smoothie::GetMeta().blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
     336                    compiler.GetMeta().GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
    335337                    temporary );
    336338
    … …  
    396398
    397399    if( pIsClassName ){
    398         if( Smoothie::GetMeta().GetClasses().Find( termFull ) ){
     400        if( compiler.GetMeta().GetClasses().Find( termFull ) ){
    399401            *pIsClassName = true;
    400402            return true;
    … …  
    635637                    // As演算子の右辺値
    636638                    //型名
    637                     if( Type::StringToType( term, resultType ) ){
     639                    if( Compiler::StringToType( term, resultType ) ){
    638640
    639641                        if( resultType.IsObject() ){
    … …  
    673675                        //要求タイプがオブジェクト、または未定のとき
    674676                        type_stack[sp]=DEF_OBJECT;
    675                         index_stack[sp]=(LONG_PTR)Smoothie::GetMeta().GetClasses().GetStringClassPtr();
     677                        index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
    676678                        bLiteralCalculation=0;
    677679
    … …  
    718720                        }
    719721                        else{
    720                             index_stack[sp] = (LONG_PTR)Smoothie::GetMeta().GetClasses().GetObjectClassPtr();
     722                            index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
    721723                        }
    722724                        bLiteralCalculation = 0;

  • trunk/abdev/BasicCompiler_Common/Object.cpp

    r182 r193  
    1 #include <CodeGenerator.h>
     1#include <Compiler.h>
    22
    33#include "../BasicCompiler_Common/common.h"
    … …  
    116116    }
    117117
    118     if( !Type::StringToType( typeName, resultType ) ){
     118    if( !Compiler::StringToType( typeName, resultType ) ){
    119119        SetError(3,typeName,cp);
    120120        return false;

  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r182 r193  
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
    33
     4#include <Compiler.h>
    45#include <ProcedureImpl.h>
    56
    … …  
    164165        GetVarType(fullCallName,type,false);
    165166
    166         ProcPointer *pProcPtr = Smoothie::GetMeta().GetProcPointers()[type.GetIndex()];
     167        ProcPointer *pProcPtr = compiler.GetMeta().GetProcPointers()[type.GetIndex()];
    167168        resultType = pProcPtr->ReturnType();
    168169
    … …  
    631632
    632633    // Importsされた名前空間の管理
    633     NamespaceScopesCollection &importedNamespaces = Smoothie::Temp::importedNamespaces;
     634    NamespaceScopesCollection &importedNamespaces = compiler.GetImportedNamespaces();
    634635    importedNamespaces.clear();
    635636
    … …  
    685686                temporary[i2]=basbuf[i];
    686687            }
    687             if( !importedNamespaces.Imports( temporary ) )
     688            if( !compiler.ImportsNamespace( temporary ) )
    688689            {
    689690                SetError(64,temporary,cp );

  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r182 r193  
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
    33
     4#include <Compiler.h>
    45#include <LexicalScopingImpl.h>
     6#include <VariableImpl.h>
    57
    68#include "../BasicCompiler_Common/common.h"
    … …  
    215217        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
    216218        else{
    217             if( Smoothie::GetMeta().GetProcPointers()[lpIndex]->ReturnType().IsNull() )
     219            if( compiler.GetMeta().GetProcPointers()[lpIndex]->ReturnType().IsNull() )
    218220                lstrcpy(name,"*Sub");
    219221            else lstrcpy(name,"*Function");
    … …  
    230232
    231233Type GetStringTypeInfo(){
    232     Type type( DEF_OBJECT, *Smoothie::GetMeta().GetClasses().GetStringClassPtr() );
     234    Type type( DEF_OBJECT, *compiler.GetMeta().GetClasses().GetStringClassPtr() );
    233235    return type;
    234236}
    … …  
    567569    // 名前空間を分離
    568570    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
    569     Smoothie::GetMeta().namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
     571    compiler.GetMeta().GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
    570572
    571573    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
    … …  
    660662        }
    661663
    662         int typeDefIndex = Smoothie::GetMeta().typeDefs.GetIndex( VarName );
     664        int typeDefIndex = compiler.GetMeta().GetTypeDefs().GetIndex( VarName );
    663665        if( typeDefIndex != -1 ){
    664666            // TypeDef後の型名だったとき
    665             lstrcpy( VarName, Smoothie::GetMeta().typeDefs[typeDefIndex].GetBaseName().c_str() );
     667            lstrcpy( VarName, compiler.GetMeta().GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
    666668        }
    667669
    … …  
    870872        }
    871873
    872         if( !Type::StringToType( temporary, type ) ){
     874        if( !Compiler::StringToType( temporary, type ) ){
    873875            SetError(3,temporary,cp);
    874876            type.SetBasicType( DEF_LONG );
    … …  
    974976    bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
    975977
    976     Variable *pVar = new Variable( Smoothie::Temp::liveingNamespaceScopes, name, type, isConst );
     978    Variable *pVar = new VariableImpl( Smoothie::Temp::liveingNamespaceScopes, name, type, isConst );
    977979
    978980    if( SubScripts[0] != -1 ){

  • trunk/abdev/BasicCompiler_Common/VariableOpe.h

    r182 r193  
    1212int GetPtrType(int type);
    1313BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
     14Type GetStringTypeInfo();
    1415void GetWithName(char *buffer);
    1516BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember, CClass::RefType &refType );

  • trunk/abdev/BasicCompiler_Common/calculation.cpp

    r182 r193  
    11#include <jenga/include/smoothie/LexicalAnalysis.h>
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    486488
    487489                        Type tempType;
    488                         if( !Type::StringToType( temp2, tempType ) ){
     490                        if( !Compiler::StringToType( temp2, tempType ) ){
    489491                            if(enableerror) SetError(3,temp2,cp);
    490492                            return false;
    … …  
    690692                        {
    691693                            Type tempType;
    692                             if( !Type::StringToType( Parms, tempType ) ){
     694                            if( !Compiler::StringToType( Parms, tempType ) ){
    693695                                if(bDebuggingWatchList){
    694696                                    if( pIsMemoryAccessError ) *pIsMemoryAccessError = true;

  • trunk/abdev/BasicCompiler_Common/hash.cpp

    r182 r193  
    11#include <jenga/include/smoothie/Smoothie.h>
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    9193            }
    9294            else{
    93                 pobj_c=Smoothie::GetMeta().GetClasses().Find(ObjName);
     95                pobj_c=compiler.GetMeta().GetClasses().Find(ObjName);
    9496                if( pobj_c ){
    9597                    isStatic = true;
    … …  
    189191
    190192UserProc *GetClassMethod( const char *className, const char *methodName ){
    191     const CClass *pClass = Smoothie::GetMeta().GetClasses().Find( className );
     193    const CClass *pClass = compiler.GetMeta().GetClasses().Find( className );
    192194    if( pClass ){
    193195        vector<UserProc *> userProcs;

  • trunk/abdev/BasicCompiler_Common/include/ClassImpl.h

    r191 r193  
    1414    {
    1515    }
     16
     17    virtual bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;
    1618
    1719    //継承させる
    … …  
    6264    virtual void Compile_System_InitializeUserTypes();
    6365
     66    virtual const CClass *Find( const NamespaceScopes &namespaceScopes, const string &name ) const;
     67
    6468
    6569    // XMLシリアライズ用

  • trunk/abdev/BasicCompiler_Common/include/Compiler.h

    r184 r193  
    22
    33#include <CodeGenerator.h>
     4#include <MetaImpl.h>
     5
    46class Compiler
    57{
    6     static NativeCode nativeCode;
     8    NativeCode nativeCode;
     9    MetaImpl metaImpl;
     10
     11    NamespaceScopesCollection importedNamespaces;
     12
    713public:
    8     static NativeCode &GetNativeCode()
     14    NativeCode &GetNativeCode()
    915    {
    1016        return nativeCode;
    1117    }
     18
     19    MetaImpl &GetMeta()
     20    {
     21        return metaImpl;
     22    }
     23
     24    NamespaceScopesCollection &GetImportedNamespaces()
     25    {
     26        return importedNamespaces;
     27    }
     28    void SetImportedNamespaces( const NamespaceScopesCollection &namespaces )
     29    {
     30        this->importedNamespaces = namespaces;
     31    }
     32    bool ImportsNamespace( const std::string &namespaceStr )
     33    {
     34        NamespaceScopes namespaceScopes( namespaceStr );
     35        if( !this->GetMeta().GetNamespaces().IsExist( namespaceScopes ) ){
     36            return false;
     37        }
     38
     39        this->importedNamespaces.push_back( namespaceScopes );
     40
     41        return true;
     42    }
     43
     44    static bool StringToType( const std::string &typeName, Type &type );
     45    static const std::string TypeToString( const Type &type );
     46
     47    // 指定された名前空間が同一エリアと見なされるかどうかをチェック
     48    bool IsSameAreaNamespace( const NamespaceScopes &baseNamespaceScopes, const NamespaceScopes &entryNamespaceScopes ){
     49        if( entryNamespaceScopes.size() ){
     50            if( baseNamespaceScopes.IsCoverd( entryNamespaceScopes ) ){
     51                // 包括しているときは同一と見なす
     52                return true;
     53            }
     54        }
     55        else{
     56            if( baseNamespaceScopes.size() ){
     57                // 名前空間の判断が必要なとき
     58                if( this->importedNamespaces.IsImported( baseNamespaceScopes )
     59                    || baseNamespaceScopes.IsLiving() ){
     60                    // Using指定があるとき
     61                    // または
     62                    // 指定された名前空間が現在の名前空間スコープと同一のとき
     63                    return true;
     64                }
     65            }
     66            else{
     67                return true;
     68            }
     69        }
     70
     71        return false;
     72    }
    1273};
     74
     75static Compiler compiler;

  • trunk/abdev/BasicCompiler_Common/include/MetaImpl.h

    r191 r193  
    77#include <ClassImpl.h>
    88#include <ProcedureImpl.h>
     9#include <TypeDef.h>
    910
    1011class MetaImpl : public Meta
    1112{
     13    // 名前空間
     14    NamespaceScopesCollection namespaceScopesCollection;
     15
     16    // クラス
    1217    ClassesImpl classesImpl;
    1318    Classes *pNowClassesForDebugger;
    1419
     20    // blittable型
     21    BlittableTypes blittableTypes;
     22
     23    // TypeDef
     24    TypeDefCollection typeDefs;
     25
    1526public:
    16     MetaImpl( ClassesImpl *pClasses )
     27    MetaImpl()
    1728        : Meta( new ProcPointersImpl() )
    1829        , classesImpl()
    … …  
    2031    {
    2132    }
    22     MetaImpl()
    23         : Meta()
     33
     34    const NamespaceScopesCollection &GetNamespaces() const
    2435    {
     36        return namespaceScopesCollection;
    2537    }
    26 
     38    NamespaceScopesCollection &GetNamespaces()
     39    {
     40        return namespaceScopesCollection;
     41    }
    2742
    2843    virtual Classes &GetClasses()
    … …  
    3348    {
    3449        this->pNowClassesForDebugger = pClasses;
     50    }
     51
     52    BlittableTypes &GetBlittableTypes()
     53    {
     54        return blittableTypes;
     55    }
     56
     57    TypeDefCollection &GetTypeDefs()
     58    {
     59        return typeDefs;
    3560    }
    3661

  • trunk/abdev/BasicCompiler_Common/include/ProcedureImpl.h

    r184 r193  
    4949    }
    5050
     51    virtual bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;
     52
    5153    virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
    5254};

  • trunk/abdev/BasicCompiler_Common/include/SmoothieImpl.h

    r191 r193  
    99{
    1010    friend Smoothie;
    11     static MetaImpl metaImpl;
     11
    1212public:
    1313    SmoothieImpl()
    … …  
    1515    {
    1616    }
     17
     18    // blittable型
     19    BlittableTypes blittableTypes;
    1720};

  • trunk/abdev/BasicCompiler_Common/src/ClassImpl.cpp

    r185 r193  
    7676
    7777
     78bool ClassImpl::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
     79{
     80    if( GetName() != name ){
     81        return false;
     82    }
     83
     84    return compiler.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
     85}
     86
    7887bool ClassImpl::Inherits( const char *inheritNames, int nowLine ){
    7988    int i = 0;
    … …  
    91100
    92101        //継承元クラスを取得
    93         const CClass *pInheritsClass = Smoothie::GetMeta().GetClasses().Find(temporary);
     102        const CClass *pInheritsClass = compiler.GetMeta().GetClasses().Find(temporary);
    94103        if( !pInheritsClass ){
    95104            SmoothieException::Throw(106,temporary,nowLine);
    … …  
    121130    if( !isInheritsClass ){
    122131        // クラスを一つも継承していないとき
    123         const CClass *pObjectClass = Smoothie::GetMeta().GetClasses().Find("Object");
     132        const CClass *pObjectClass = compiler.GetMeta().GetClasses().Find("Object");
    124133        if( !pObjectClass ){
    125134            SmoothieException::Throw(106,"Object",i);
    … …  
    145154
    146155        //継承元クラスを取得
    147         const CClass *pInheritsClass = Smoothie::GetMeta().GetClasses().Find(temporary);
     156        const CClass *pInheritsClass = compiler.GetMeta().GetClasses().Find(temporary);
    148157        if( !pInheritsClass ){
    149158            SmoothieException::Throw(106,temporary,nowLine);
    … …  
    184193        //継承先が読み取られていないとき
    185194        pobj_LoopRefCheck->add(this->GetName().c_str());
    186         Smoothie::GetMeta().GetClasses().GetClass_recur(inheritsClass.GetName().c_str());
     195        compiler.GetMeta().GetClasses().GetClass_recur(inheritsClass.GetName().c_str());
    187196        pobj_LoopRefCheck->del(this->GetName().c_str());
    188197    }
    … …  
    246255        //継承先が読み取られていないとき
    247256        pobj_LoopRefCheck->add(this->GetName().c_str());
    248         Smoothie::GetMeta().GetClasses().GetClass_recur(inheritsInterface.GetName().c_str());
     257        compiler.GetMeta().GetClasses().GetClass_recur(inheritsInterface.GetName().c_str());
    249258        pobj_LoopRefCheck->del(this->GetName().c_str());
    250259    }
    … …  
    470479    }
    471480
    472     vtbl_offset=Compiler::GetNativeCode().GetDataTable().AddBinary((void *)ppsi,GetVtblNum()*sizeof(LONG_PTR));
     481    vtbl_offset=compiler.GetNativeCode().GetDataTable().AddBinary((void *)ppsi,GetVtblNum()*sizeof(LONG_PTR));
    473482
    474483    for( int i=0; i < GetVtblNum(); i++ ){
    … …  
    484493
    485494    LONG_PTR *pVtbl;
    486     pVtbl=(LONG_PTR *)((char *)Compiler::GetNativeCode().GetDataTable().GetPtr()+vtbl_offset);
     495    pVtbl=(LONG_PTR *)((char *)compiler.GetNativeCode().GetDataTable().GetPtr()+vtbl_offset);
    487496
    488497    int i;
    … …  
    505514
    506515    // Blittable型管理オブジェクトを初期化
    507     Smoothie::GetMeta().blittableTypes.clear();
     516    compiler.GetMeta().GetBlittableTypes().clear();
    508517
    509518    // 名前空間管理
    … …  
    512521
    513522    // Importsされた名前空間の管理
    514     NamespaceScopesCollection &importedNamespaces = Smoothie::Temp::importedNamespaces;
     523    NamespaceScopesCollection &importedNamespaces = compiler.GetImportedNamespaces();
    515524    importedNamespaces.clear();
    516525
    … …  
    549558                temporary[i2]=source[i];
    550559            }
    551             if( !importedNamespaces.Imports( temporary ) )
     560            if( !compiler.ImportsNamespace( temporary ) )
    552561            {
    553562                SmoothieException::Throw(64,temporary,i );
    … …  
    580589                    i+=10;
    581590                    i+=GetStringInPare_RemovePare(temporary,source.GetBuffer()+i)+1;
    582                     Type::StringToType( temporary, blittableType );
     591                    Compiler::StringToType( temporary, blittableType );
    583592                }
    584593
    … …  
    625634
    626635                    // Blittable型として登録
    627                     Smoothie::GetMeta().blittableTypes.push_back( BlittableType( blittableType, pClass ) );
     636                    compiler.GetMeta().GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
    628637                }
    629638        }
    … …  
    783792
    784793                //継承元クラスを取得
    785                 const CClass *pInheritsClass = Find(temporary);
     794                const Classes &classes = *this;
     795                const CClass *pInheritsClass = classes.Find(temporary);
    786796                if( !pInheritsClass ){
    787797                    SetError(106,temporary,i);
    … …  
    12831293    }*/
    12841294}
     1295
     1296const CClass *ClassesImpl::Find( const NamespaceScopes &namespaceScopes, const string &name ) const
     1297{
     1298    int key;
     1299    key=GetHashCode(name.c_str());
     1300
     1301    if( namespaceScopes.size() == 0 && name == "Object" ){
     1302        return GetObjectClassPtr();
     1303    }
     1304    else if( namespaceScopes.size() == 0 && name == "String" ){
     1305        return GetStringClassPtr();
     1306    }
     1307
     1308    if(pobj_ClassHash[key]){
     1309        CClass *pobj_c;
     1310        pobj_c=pobj_ClassHash[key];
     1311        while(1){
     1312            if( pobj_c->IsEqualSymbol( namespaceScopes, name ) ){
     1313                //名前空間とクラス名が一致した
     1314                return pobj_c;
     1315            }
     1316
     1317            if(pobj_c->pobj_NextClass==0) break;
     1318            pobj_c=pobj_c->pobj_NextClass;
     1319        }
     1320    }
     1321
     1322    // TypeDefも見る
     1323    int index = compiler.GetMeta().GetTypeDefs().GetIndex( namespaceScopes, name );
     1324    if( index != -1 ){
     1325        Type type = compiler.GetMeta().GetTypeDefs()[index].GetBaseType();
     1326        if( type.IsObject() ){
     1327            return &type.GetClass();
     1328        }
     1329    }
     1330
     1331    return NULL;
     1332}

  • trunk/abdev/BasicCompiler_Common/src/Compiler.cpp

    r184 r193  
     1#include <jenga/include/smoothie/Type.h>
     2#include <jenga/include/smoothie/SmoothieException.h>
     3
    14#include <Compiler.h>
    25
    3 NativeCode Compiler::nativeCode;
     6
     7bool Compiler::StringToType( const string &typeName, Type &type ){
     8    type.SetIndex( -1 );
     9
     10    if( typeName[0] == '*' ){
     11        if( typeName.size() >= 3
     12            && typeName[1] == 1 && ( typeName[2] == ESC_FUNCTION || typeName[2] == ESC_SUB ) ){
     13                //関数ポインタ（*Function）
     14                type.SetBasicType( DEF_PTR_PROC );
     15                type.SetIndex( compiler.GetMeta().GetProcPointers().Add( typeName ) );
     16                return true;
     17        }
     18
     19        const string &nextTypeName = typeName.substr( 1 );
     20
     21        if( !StringToType( nextTypeName, type ) ){
     22            return false;
     23        }
     24
     25        type.PtrLevelUp();
     26
     27        return true;
     28    }
     29
     30    {
     31        int basicType;
     32        if( Type::StringToBasicType( typeName, basicType ) ){
     33            // 基本型だったとき
     34            type.SetBasicType( basicType );
     35            return true;
     36        }
     37    }
     38
     39    // Object型だったとき
     40    if( typeName == "Object" ){
     41        type.SetType( DEF_OBJECT, compiler.GetMeta().GetClasses().GetObjectClassPtr() );
     42        return true;
     43    }
     44
     45    // String型だったとき
     46    if( typeName == "String" ){
     47        type.SetType( DEF_OBJECT, compiler.GetMeta().GetClasses().GetStringClassPtr() );
     48        return true;
     49    }
     50
     51
     52    ////////////////////
     53    // TypeDefされた型
     54    ////////////////////
     55    int i=compiler.GetMeta().GetTypeDefs().GetIndex( typeName );
     56    if(i!=-1){
     57        type = compiler.GetMeta().GetTypeDefs()[i].GetBaseType();
     58        return true;
     59    }
     60
     61    //クラス
     62    const CClass *pobj_c = compiler.GetMeta().GetClasses().Find( typeName );
     63    if(pobj_c){
     64        type.SetClassPtr( pobj_c );
     65
     66        if( pobj_c->IsStructure() ){
     67            type.SetBasicType( DEF_STRUCT );
     68        }
     69        else{
     70            type.SetBasicType( DEF_OBJECT );
     71        }
     72        return true;
     73    }
     74
     75    return false;
     76}
     77
     78const string Compiler::TypeToString( const Type &type )
     79{
     80    if( PTR_LEVEL( type.GetBasicType() ) ){
     81        //ポインタレベルが1以上の場合
     82        Type tempType( type );
     83        tempType.PtrLevelDown();
     84
     85        return (string)"*" + TypeToString( type );
     86    }
     87    else if( type.IsObject() || type.IsStruct() ){
     88        //オブジェクトまたは構造体
     89
     90        if( !( type.GetIndex() == 0 || type.GetIndex() == -1 ) ){
     91            if( type.GetClass().GetNamespaceScopes().size() >= 1 )
     92            {
     93                return type.GetClass().GetNamespaceScopes().ToString() + "." + type.GetClass().GetName();
     94            }
     95            return type.GetClass().GetName();
     96        }
     97    }
     98    else if( type.IsProcPtr() ){
     99        if( type.GetIndex() == 0 || type.GetIndex() == -1 ){
     100            return "VoidPtr";
     101        }
     102        else{
     103            if( compiler.GetMeta().GetProcPointers()[type.GetIndex()]->ReturnType().IsNull() ){
     104                return "*Sub";
     105            }
     106            return "*Function";
     107        }
     108    }
     109    else{
     110        // 基本型
     111        const char *lpszTypeName = Type::BasicTypeToCharPtr( type );
     112        if( lpszTypeName )
     113        {
     114            return (const string)lpszTypeName;
     115        }
     116    }
     117
     118    SmoothieException::Throw( 1 );
     119
     120    return (string)"(null)";
     121}

  • trunk/abdev/BasicCompiler_Common/src/ProcedureImpl.cpp

    r185 r193  
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
    33
     4#include <Compiler.h>
    45#include <ProcedureImpl.h>
    56
    … …  
    104105            //cp = nowLine;
    105106
    106             NumOpe_GetType( initValue, Type::String(), type );
     107            NumOpe_GetType( initValue, GetStringTypeInfo(), type );
    107108        }
    108109        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
    … …  
    129130            }
    130131
    131             Type::StringToType( temporary, type );
     132            Compiler::StringToType( temporary, type );
    132133
    133134            if( type.IsNull() ){
    … …  
    257258                }
    258259
    259                 Type::StringToType( temporary, type );
     260                Compiler::StringToType( temporary, type );
    260261
    261262                if( type.IsNull() ){
    … …  
    326327                    temporary[i3]=sourceOfParams[i2];
    327328                }
    328                 Type::StringToType( temporary, this->returnType );
     329                Compiler::StringToType( temporary, this->returnType );
    329330                if( this->returnType.IsNull() ) SmoothieException::Throw(3,temporary,nowLine);
    330331
    … …  
    387388    }
    388389
    389     return NamespaceScopes::IsSameArea( GetNamespaceScopes(), namespaceScopes );
     390    return compiler.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
    390391}
    391392bool GlobalProc::IsEqualSymbol( const GlobalProc &globalProc ) const
    … …  
    402403}
    403404
     405bool DllProcImpl::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
     406{
     407    if( GetName() != name ){
     408        return false;
     409    }
     410    return compiler.IsSameAreaNamespace( this->GetNamespaceScopes(), namespaceScopes );
     411}
    404412bool DllProcImpl::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
    405413    int i = 0;
    … …  
    505513            }
    506514
    507             Type::StringToType( temporary, type );
     515            Compiler::StringToType( temporary, type );
    508516
    509517            if( type.IsNull() ){
    … …  
    559567                    temporary[i3]=sourceOfParams[i2];
    560568                }
    561                 Type::StringToType( temporary, this->returnType );
     569                Compiler::StringToType( temporary, this->returnType );
    562570                if( this->returnType.IsNull() ) SmoothieException::Throw(3,temporary,nowLine);
    563571
    … …  
    676684            }
    677685
    678             Type::StringToType( temporary, type );
     686            Compiler::StringToType( temporary, type );
    679687
    680688            if( type.IsNull() ){
    … …  
    730738                    temporary[i3]=sourceOfParams[i2];
    731739                }
    732                 Type::StringToType( temporary, this->returnType );
     740                Compiler::StringToType( temporary, this->returnType );
    733741                if( this->returnType.IsNull() ) SmoothieException::Throw(3,temporary,nowLine);
    734742

  • trunk/abdev/BasicCompiler_Common/src/SmoothieImpl.cpp

    r191 r193  
    66#include <LexicalScopingImpl.h>
    77
    8 MetaImpl SmoothieImpl::metaImpl(
    9     new ClassesImpl()
    10 );
    11 
    128CLexicalScopes *Smoothie::Temp::pLexicalScopes = new LexicalScopesImpl();
    13 
    14 
    15 Meta &Smoothie::GetMeta()
    16 {
    17     return SmoothieImpl::metaImpl;
    18 }
Note: See TracChangeset for help on using the changeset viewer.