Changeset 195 in dev


Ignore:
Timestamp:
Jun 26, 2007, 1:48:18 PM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
2 added
15 edited

Legend:

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

    r193 r195  
    12761276                </File>
    12771277                <File
     1278                    RelativePath="..\BasicCompiler_Common\src\NamespaceSupporter.cpp"
     1279                    >
     1280                </File>
     1281                <File
    12781282                    RelativePath="..\BasicCompiler_Common\src\ProcedureImpl.cpp"
    12791283                    >
     
    13771381                </File>
    13781382                <File
     1383                    RelativePath="..\BasicCompiler_Common\include\NamespaceSupporter.h"
     1384                    >
     1385                </File>
     1386                <File
    13791387                    RelativePath="..\BasicCompiler_Common\include\ProcedureImpl.h"
    13801388                    >
  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r193 r195  
    77#include <ClassImpl.h>
    88#include <VariableImpl.h>
     9#include <NamespaceSupporter.h>
    910
    1011#include "../BasicCompiler_Common/common.h"
     
    281282
    282283    // コンパイル中の関数が属する名前空間
    283     Smoothie::Temp::liveingNamespaceScopes = pUserProc->GetNamespaceScopes();
     284    namespaceSupporter.GetLivingNamespaceScopes() = pUserProc->GetNamespaceScopes();
    284285
    285286    // コンパイル中の関数でImportsされている名前空間
    286     compiler.SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
     287    namespaceSupporter.SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
    287288
    288289    if(pUserProc->IsSystem()){
  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r193 r195  
    66#include <ClassImpl.h>
    77#include <Compiler.h>
     8#include <NamespaceSupporter.h>
    89
    910#include "../BasicCompiler_Common/common.h"
     
    169170
    170171    // 名前空間情報を取得
    171     NamespaceScopesCollection::CollectNamespaces(
     172    NamespaceSupporter::CollectNamespaces(
    172173        Smoothie::Lexical::source.GetBuffer(),
    173174        compiler.GetMeta().GetNamespaces()
     
    370371    if(!bDll){
    371372        // 名前空間が初期化されているかをチェック
    372         if( Smoothie::Temp::liveingNamespaceScopes.size() ){
     373        if( namespaceSupporter.GetLivingNamespaceScopes().size() ){
    373374            SetError();
    374375        }
     
    470471
    471472        // 名前空間が正しく閉じられているかをチェック
    472         if( Smoothie::Temp::liveingNamespaceScopes.size() ){
     473        if( namespaceSupporter.GetLivingNamespaceScopes().size() ){
    473474            SetError(63,NULL,-1);
    474475        }
  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r193 r195  
    66#include <CodeGenerator.h>
    77#include <Compiler.h>
     8#include <NamespaceSupporter.h>
    89
    910#include "../BasicCompiler_Common/common.h"
     
    252253
    253254            case ESC_NAMESPACE:
    254                 Smoothie::Temp::liveingNamespaceScopes.push_back( Command + 2 );
     255                namespaceSupporter.GetLivingNamespaceScopes().push_back( Command + 2 );
    255256                break;
    256257            case ESC_ENDNAMESPACE:
    257                 if( Smoothie::Temp::liveingNamespaceScopes.size() <= 0 ){
     258                if( namespaceSupporter.GetLivingNamespaceScopes().size() <= 0 ){
    258259                    SetError(12,"End Namespace",cp);
    259260                }
    260                 Smoothie::Temp::liveingNamespaceScopes.pop_back();
     261                namespaceSupporter.GetLivingNamespaceScopes().pop_back();
    261262                break;
    262263            case ESC_IMPORTS:
    263                 compiler.ImportsNamespace( Command + 2 );
     264                namespaceSupporter.ImportsNamespace( Command + 2 );
    264265                break;
    265266            case ESC_CLEARNAMESPACEIMPORTED:
    266                 compiler.GetImportedNamespaces().clear();
     267                namespaceSupporter.GetImportedNamespaces().clear();
    267268                break;
    268269
  • trunk/abdev/BasicCompiler_Common/Const.cpp

    r193 r195  
    11#include <Compiler.h>
     2#include <NamespaceSupporter.h>
    23
    34#include "common.h"
     
    1415        return false;
    1516    }
    16     return compiler.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
     17    return namespaceSupporter.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
    1718}
    1819bool ConstBase::IsEqualSymbol( const string &fullName ) const
  • trunk/abdev/BasicCompiler_Common/Enum.cpp

    r182 r195  
    33#include <jenga/include/smoothie/Smoothie.h>
    44#include <jenga/include/smoothie/LexicalAnalysis.h>
     5
     6#include <NamespaceSupporter.h>
    57
    68#include "common.h"
     
    115117
    116118    // 名前空間管理
    117     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     119    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    118120    namespaceScopes.clear();
    119121
  • trunk/abdev/BasicCompiler_Common/Intermediate_Step2.cpp

    r182 r195  
    11#include <jenga/include/smoothie/Smoothie.h>
    22#include <jenga/include/smoothie/LexicalAnalysis.h>
     3
     4#include <NamespaceSupporter.h>
    35
    46#include "../BasicCompiler_Common/common.h"
     
    250252
    251253    // 名前空間管理
    252     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     254    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    253255    namespaceScopes.clear();
    254256
  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r193 r195  
    44#include <Compiler.h>
    55#include <ProcedureImpl.h>
     6#include <NamespaceSupporter.h>
    67
    78#include "../BasicCompiler_Common/common.h"
     
    628629
    629630    // 名前空間管理
    630     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     631    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    631632    namespaceScopes.clear();
    632633
    633634    // Importsされた名前空間の管理
    634     NamespaceScopesCollection &importedNamespaces = compiler.GetImportedNamespaces();
     635    NamespaceScopesCollection &importedNamespaces = namespaceSupporter.GetImportedNamespaces();
    635636    importedNamespaces.clear();
    636637
     
    686687                temporary[i2]=basbuf[i];
    687688            }
    688             if( !compiler.ImportsNamespace( temporary ) )
     689            if( !namespaceSupporter.ImportsNamespace( temporary ) )
    689690            {
    690691                SetError(64,temporary,cp );
  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r193 r195  
    55#include <LexicalScopingImpl.h>
    66#include <VariableImpl.h>
     7#include <NamespaceSupporter.h>
    78
    89#include "../BasicCompiler_Common/common.h"
     
    976977    bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
    977978
    978     Variable *pVar = new VariableImpl( Smoothie::Temp::liveingNamespaceScopes, name, type, isConst );
     979    Variable *pVar = new VariableImpl( namespaceSupporter.GetLivingNamespaceScopes(), name, type, isConst );
    979980
    980981    if( SubScripts[0] != -1 ){
  • trunk/abdev/BasicCompiler_Common/include/Compiler.h

    r193 r195  
    88    NativeCode nativeCode;
    99    MetaImpl metaImpl;
    10 
    11     NamespaceScopesCollection importedNamespaces;
    1210
    1311public:
     
    2220    }
    2321
    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 
    4422    static bool StringToType( const std::string &typeName, Type &type );
    4523    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     }
    7324};
    7425
    75 static Compiler compiler;
     26extern Compiler compiler;
  • trunk/abdev/BasicCompiler_Common/src/ClassImpl.cpp

    r193 r195  
    77#include <ClassImpl.h>
    88#include <Compiler.h>
     9#include <NamespaceSupporter.h>
    910
    1011#include "../common.h"
     
    8283    }
    8384
    84     return compiler.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
     85    return namespaceSupporter.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
    8586}
    8687
     
    517518
    518519    // 名前空間管理
    519     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     520    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    520521    namespaceScopes.clear();
    521522
    522523    // Importsされた名前空間の管理
    523     NamespaceScopesCollection &importedNamespaces = compiler.GetImportedNamespaces();
     524    NamespaceScopesCollection &importedNamespaces = namespaceSupporter.GetImportedNamespaces();
    524525    importedNamespaces.clear();
    525526
     
    558559                temporary[i2]=source[i];
    559560            }
    560             if( !compiler.ImportsNamespace( temporary ) )
     561            if( !namespaceSupporter.ImportsNamespace( temporary ) )
    561562            {
    562563                SmoothieException::Throw(64,temporary,i );
     
    653654
    654655        // 名前空間をセット
    655         Smoothie::Temp::liveingNamespaceScopes = objClass.GetNamespaceScopes();
     656        namespaceSupporter.GetLivingNamespaceScopes() = objClass.GetNamespaceScopes();
    656657
    657658        int i=0;
     
    674675    }
    675676
    676     Smoothie::Temp::liveingNamespaceScopes.clear();
     677    namespaceSupporter.GetLivingNamespaceScopes().clear();
    677678
    678679    cp=back_cp;
     
    709710
    710711    // 名前空間管理
    711     NamespaceScopes backupNamespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
    712     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     712    NamespaceScopes backupNamespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
     713    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    713714    namespaceScopes.clear();
    714715
     
    11521153
    11531154    // 名前空間を元に戻す
    1154     Smoothie::Temp::liveingNamespaceScopes = backupNamespaceScopes;
     1155    namespaceSupporter.GetLivingNamespaceScopes() = backupNamespaceScopes;
    11551156}
    11561157void ClassesImpl::GetAllClassInfo(void){
  • trunk/abdev/BasicCompiler_Common/src/Compiler.cpp

    r193 r195  
    44#include <Compiler.h>
    55
     6Compiler compiler;
    67
    78bool Compiler::StringToType( const string &typeName, Type &type ){
  • trunk/abdev/BasicCompiler_Common/src/ProcedureImpl.cpp

    r193 r195  
    44#include <Compiler.h>
    55#include <ProcedureImpl.h>
     6#include <NamespaceSupporter.h>
    67
    78#include "../common.h"
     
    388389    }
    389390
    390     return compiler.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
     391    return namespaceSupporter.IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
    391392}
    392393bool GlobalProc::IsEqualSymbol( const GlobalProc &globalProc ) const
     
    408409        return false;
    409410    }
    410     return compiler.IsSameAreaNamespace( this->GetNamespaceScopes(), namespaceScopes );
     411    return namespaceSupporter.IsSameAreaNamespace( this->GetNamespaceScopes(), namespaceScopes );
    411412}
    412413bool DllProcImpl::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
  • trunk/abdev/BasicCompiler_Common/src/TypeDef.cpp

    r193 r195  
    55#include <TypeDef.h>
    66#include <Compiler.h>
     7#include <NamespaceSupporter.h>
    78
    89TypeDef::TypeDef( const NamespaceScopes &namespaceScopes, const string &name, const string &baseName, int nowLine )
     
    2425        return false;
    2526    }
    26     return compiler.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
     27    return namespaceSupporter.IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
    2728}
    2829bool TypeDef::IsEqualSymbol( const string &fullName ) const
     
    147148
    148149    // 名前空間管理
    149     NamespaceScopes &namespaceScopes = Smoothie::Temp::liveingNamespaceScopes;
     150    NamespaceScopes &namespaceScopes = namespaceSupporter.GetLivingNamespaceScopes();
    150151    namespaceScopes.clear();
    151152
    152153    // Importsされた名前空間の管理
    153     NamespaceScopesCollection &importedNamespaces = compiler.GetImportedNamespaces();
     154    NamespaceScopesCollection &importedNamespaces = namespaceSupporter.GetImportedNamespaces();
    154155    importedNamespaces.clear();
    155156
     
    192193                temporary[i2]=basbuf[i];
    193194            }
    194             if( !compiler.ImportsNamespace( temporary ) )
     195            if( !namespaceSupporter.ImportsNamespace( temporary ) )
    195196            {
    196197                SmoothieException::Throw(64,temporary,i );
  • trunk/abdev/BasicCompiler_Common/src/VariableImpl.cpp

    r193 r195  
    11#include <Compiler.h>
    22#include <VariableImpl.h>
     3#include <NamespaceSupporter.h>
    34
    45bool VariableImpl::IsEqualSymbol( const Symbol &symbol, bool isSupportStaticMember ) const
    56{
    67    if( GetName() == symbol.GetName()
    7         && compiler.IsSameAreaNamespace( this->GetNamespaceScopes(), symbol.GetNamespaceScopes() ) )
     8        && namespaceSupporter.IsSameAreaNamespace( this->GetNamespaceScopes(), symbol.GetNamespaceScopes() ) )
    89    {
    910        return true;
Note: See TracChangeset for help on using the changeset viewer.