Changeset 193 in dev for trunk/abdev/BasicCompiler_Common


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

Legend:

Unmodified
Added
Removed

  • 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.