msvc_project_context.cpp

ncbi源码

    //take into account default libs from site:
    libs_list->push_back(MSVC_DEFAULT_LIBS_TAG);
    //and LIBS from Makefiles:
    ITERATE(list<string>, p, m_ProjectLibs) {
        const string& lib = *p;
        list<string> components;
        GetApp().GetSite().GetComponents(lib, &components);
        copy(components.begin(), 
             components.end(), back_inserter(*libs_list));

    }
    libs_list->sort();
    libs_list->unique();
}

const CMsvcCombinedProjectMakefile& 
CMsvcPrjProjectContext::GetMsvcProjectMakefile(void) const
{
    if ( m_MsvcCombinedProjectMakefile.get() )
        return *m_MsvcCombinedProjectMakefile;

    string rules_dir = GetApp().GetProjectTreeInfo().m_Compilers;
    rules_dir = 
            CDirEntry::ConcatPath(rules_dir, 
                                  GetApp().GetRegSettings().m_CompilersSubdir);


    // temporary fix with const_cast
    (const_cast<auto_ptr<CMsvcCombinedProjectMakefile>&>
        (m_MsvcCombinedProjectMakefile)).reset(new CMsvcCombinedProjectMakefile
                                                  (m_ProjType,
                                                   m_MsvcProjectMakefile.get(),
                                                   rules_dir,
                                                   m_Requires));

    return *m_MsvcCombinedProjectMakefile;
}


bool CMsvcPrjProjectContext::IsRequiresOk(const CProjItem& prj)
{
    ITERATE(list<string>, p, prj.m_Requires) {
        const string& requires = *p;
        if ( !GetApp().GetSite().IsProvided(requires) )
            return false;
    }
    return true;
}


bool CMsvcPrjProjectContext::IsConfigEnabled(const SConfigInfo& config) const
{
    list<string> libs_3party;
    ITERATE(list<string>, p, m_ProjectLibs) {
        const string& lib = *p;
        list<string> components;
        GetApp().GetSite().GetComponents(lib, &components);
        copy(components.begin(), 
             components.end(), back_inserter(libs_3party));
    }

    // Add requires to test : If there is such library and configuration for 
    // this library is disabled then we'll disable this config
    copy(m_Requires.begin(), m_Requires.end(), back_inserter(libs_3party));
    libs_3party.sort();
    libs_3party.unique();

    // Test third-party libs and requires:
    ITERATE(list<string>, p, libs_3party) {
        const string& requires = *p;
        SLibInfo lib_info;
        GetApp().GetSite().GetLibInfo(requires, config, &lib_info);
        
        if ( lib_info.IsEmpty() ) 
            continue;

        if ( !GetApp().GetSite().IsLibEnabledInConfig(requires, config) )
            return false;
    }

    return true;
}


const list<string> CMsvcPrjProjectContext::Defines(const SConfigInfo& cfg_info) const
{
    list<string> defines(m_Defines);

    list<string> libs_list;
    CreateLibsList(&libs_list);
    ITERATE(list<string>, p, libs_list) {
        const string& lib_id = *p;
        SLibInfo lib_info;
        GetApp().GetSite().GetLibInfo(lib_id, cfg_info, &lib_info);
        if ( !lib_info.m_LibDefines.empty() ) {
            copy(lib_info.m_LibDefines.begin(),
                 lib_info.m_LibDefines.end(),
                 back_inserter(defines));
        }
    }
    defines.sort();
    defines.unique();
    return defines;
}



//-----------------------------------------------------------------------------
CMsvcPrjGeneralContext::CMsvcPrjGeneralContext
    (const SConfigInfo&            config, 
     const CMsvcPrjProjectContext& prj_context)
     :m_Config          (config),
      m_MsvcMetaMakefile(GetApp().GetMetaMakefile())
{
    //m_Type
    switch ( prj_context.ProjectType() ) {
    case CProjKey::eLib:
        m_Type = eLib;
        break;
    case CProjKey::eApp:
        m_Type = eExe;
        break;
    case CProjKey::eDll:
        m_Type = eDll;
        break;
    default:
        //TODO - handle Dll(s)
   	    NCBI_THROW(CProjBulderAppException, eProjectType, 
                        NStr::IntToString(prj_context.ProjectType()));
    }
    

    //m_OutputDirectory;
    // /compilers/msvc7_prj/
    string output_dir_abs = GetApp().GetProjectTreeInfo().m_Compilers;
    output_dir_abs = 
            CDirEntry::ConcatPath(output_dir_abs, 
                                  GetApp().GetRegSettings().m_CompilersSubdir);
    output_dir_abs = 
            CDirEntry::ConcatPath(output_dir_abs, 
                                  GetApp().GetBuildType().GetTypeStr());
    if (m_Type == eLib)
        output_dir_abs = CDirEntry::ConcatPath(output_dir_abs, "lib");
    else if (m_Type == eExe)
        output_dir_abs = CDirEntry::ConcatPath(output_dir_abs, "bin");
    else if (m_Type == eDll) // same dir as exe 
        output_dir_abs = CDirEntry::ConcatPath(output_dir_abs, "bin"); 
    else {
        //TODO - handle Dll(s)
   	    NCBI_THROW(CProjBulderAppException, 
                   eProjectType, NStr::IntToString(m_Type));
    }

    output_dir_abs = 
        CDirEntry::ConcatPath(output_dir_abs, config.m_Name);
    m_OutputDirectory = 
        CDirEntry::CreateRelativePath(prj_context.ProjectDir(), 
                                      output_dir_abs);

#if 0

    const string project_tag(string(1,CDirEntry::GetPathSeparator()) + 
                             "compilers" +
                             CDirEntry::GetPathSeparator() + 
                             GetApp().GetRegSettings().m_CompilersSubdir +
                             CDirEntry::GetPathSeparator());
    
    string project_dir = prj_context.ProjectDir();
    string output_dir_prefix = 
        string (project_dir, 
                0, 
                project_dir.find(project_tag) + project_tag.length());
    
    output_dir_prefix = 
        CDirEntry::ConcatPath(output_dir_prefix, 
                              GetApp().GetBuildType().GetTypeStr());

    if (m_Type == eLib)
        output_dir_prefix = CDirEntry::ConcatPath(output_dir_prefix, "lib");
    else if (m_Type == eExe)
        output_dir_prefix = CDirEntry::ConcatPath(output_dir_prefix, "bin");
    else if (m_Type == eDll) // same dir as exe 
        output_dir_prefix = CDirEntry::ConcatPath(output_dir_prefix, "bin"); 
    else {
        //TODO - handle Dll(s)
   	    NCBI_THROW(CProjBulderAppException, 
                   eProjectType, NStr::IntToString(m_Type));
    }

    //output to ..static\DebugDLL or ..dll\DebugDLL
    string output_dir_abs = 
        CDirEntry::ConcatPath(output_dir_prefix, config.m_Name);
    m_OutputDirectory = 
        CDirEntry::CreateRelativePath(project_dir, output_dir_abs);
#endif
}

//------------------------------------------------------------------------------
static IConfiguration* s_CreateConfiguration
    (const CMsvcPrjGeneralContext& general_context,
     const CMsvcPrjProjectContext& project_context);

static ICompilerTool* s_CreateCompilerTool
    (const CMsvcPrjGeneralContext& general_context,
     const CMsvcPrjProjectContext& project_context);

static ILinkerTool* s_CreateLinkerTool
    (const CMsvcPrjGeneralContext& general_context,
     const CMsvcPrjProjectContext& project_context);

static ILibrarianTool* s_CreateLibrarianTool
    (const CMsvcPrjGeneralContext& general_context,
     const CMsvcPrjProjectContext& project_context);

static IResourceCompilerTool* s_CreateResourceCompilerTool
    (const CMsvcPrjGeneralContext& general_context,
     const CMsvcPrjProjectContext& project_context);

//-----------------------------------------------------------------------------
CMsvcTools::CMsvcTools(const CMsvcPrjGeneralContext& general_context,
                       const CMsvcPrjProjectContext& project_context)
{
    //configuration
    m_Configuration.reset
        (s_CreateConfiguration(general_context, project_context));
    //compiler
    m_Compiler.reset
        (s_CreateCompilerTool(general_context, project_context));
    //Linker:
    m_Linker.reset(s_CreateLinkerTool(general_context, project_context));
    //Librarian
    m_Librarian.reset(s_CreateLibrarianTool
                                     (general_context, project_context));
    //Dummies
    m_CustomBuid.reset    (new CCustomBuildToolDummyImpl());
    m_MIDL.reset          (new CMIDLToolDummyImpl());
    m_PostBuildEvent.reset(new CPostBuildEventToolDummyImpl());

    //Pre-build event - special case for LIB projects
    if (project_context.ProjectType() == CProjKey::eLib) {
        m_PreBuildEvent.reset(new CPreBuildEventToolLibImpl
                                                (project_context.PreBuilds()));
    } else {
        m_PreBuildEvent.reset(new CPreBuildEventToolDummyImpl());
    }
    m_PreLinkEvent.reset(new CPreLinkEventToolDummyImpl());

    //Resource Compiler
    m_ResourceCompiler.reset(s_CreateResourceCompilerTool
                                     (general_context,project_context));

    //Dummies
    m_WebServiceProxyGenerator.reset
        (new CWebServiceProxyGeneratorToolDummyImpl());

    m_XMLDataGenerator.reset
        (new CXMLDataGeneratorToolDummyImpl());

    m_ManagedWrapperGenerator.reset
        (new CManagedWrapperGeneratorToolDummyImpl());

    m_AuxiliaryManagedWrapperGenerator.reset
        (new CAuxiliaryManagedWrapperGeneratorToolDummyImpl());
}


IConfiguration* CMsvcTools::Configuration(void) const
{
    return m_Configuration.get();
}


ICompilerTool* CMsvcTools::Compiler(void) const
{
    return m_Compiler.get();
}


ILinkerTool* CMsvcTools::Linker(void) const
{
    return m_Linker.get();
}


ILibrarianTool* CMsvcTools::Librarian(void) const
{
    return m_Librarian.get();
}


ICustomBuildTool* CMsvcTools::CustomBuid(void) const
{
    return m_CustomBuid.get();
}


IMIDLTool* CMsvcTools::MIDL(void) const
{
    return m_MIDL.get();
}


IPostBuildEventTool* CMsvcTools::PostBuildEvent(void) const
{
    return m_PostBuildEvent.get();
}


IPreBuildEventTool* CMsvcTools::PreBuildEvent(void) const
{
    return m_PreBuildEvent.get();
}


IPreLinkEventTool* CMsvcTools::PreLinkEvent(void) const
{
    return m_PreLinkEvent.get();
}


IResourceCompilerTool* CMsvcTools::ResourceCompiler(void) const
{
    return m_ResourceCompiler.get();