开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
proj_tree_builder.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：48k
源码类别：

生物技术

开发平台：

C/C++

proj_tree_builder.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: proj_tree_builder.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/16 17:02:39  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: proj_tree_builder.cpp,v 1000.3 2004/06/16 17:02:39 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Viatcheslav Gorelenkov
  36.  *
  37.  */
  39. #include <ncbi_pch.hpp>
  40. #include <app/project_tree_builder/proj_tree_builder.hpp>
  41. #include <app/project_tree_builder/proj_builder_app.hpp>
  42. #include <app/project_tree_builder/proj_src_resolver.hpp>
  43. #include <app/project_tree_builder/msvc_prj_defines.hpp>
  45. #include <app/project_tree_builder/proj_projects.hpp>
  47. BEGIN_NCBI_SCOPE
  50. struct PLibExclude
  51. {
  52.     PLibExclude(const list<string>& excluded_lib_ids)
  53.     {
  54.         copy(excluded_lib_ids.begin(), excluded_lib_ids.end(), 
  55.              inserter(m_ExcludedLib, m_ExcludedLib.end()) );
  56.     }
  58.     bool operator() (const string& lib_id) const
  59.     {
  60.         return m_ExcludedLib.find(lib_id) != m_ExcludedLib.end();
  61.     }
  63. private:
  64.     set<string> m_ExcludedLib;
  65. };
  68. //-----------------------------------------------------------------------------
  69. CProjItem::TProjType SMakeProjectT::GetProjType(const string& base_dir,
  70.                                                 const string& projname)
  71. {
  72.     string fname = "Makefile." + projname;
  73.     
  74.     if ( CDirEntry(CDirEntry::ConcatPath
  75.                (base_dir, fname + ".lib")).Exists() )
  76.         return CProjKey::eLib;
  77.     else if (CDirEntry(CDirEntry::ConcatPath
  78.                (base_dir, fname + ".app")).Exists() )
  79.         return CProjKey::eApp;
  80.     else if (CDirEntry(CDirEntry::ConcatPath
  81.                (base_dir, fname + ".msvcproj")).Exists() )
  82.         return CProjKey::eMsvc;
  84.     LOG_POST(Error << "No .lib or .app projects for : " + projname +
  85.                       " in directory: " + base_dir);
  86.     return CProjKey::eNoProj;
  87. }
  90. bool SMakeProjectT::IsMakeInFile(const string& name)
  91. {
  92.     return name == "Makefile.in";
  93. }
  96. bool SMakeProjectT::IsMakeLibFile(const string& name)
  97. {
  98.     return NStr::StartsWith(name, "Makefile")  &&  
  99.        NStr::EndsWith(name, ".lib");
  100. }
  103. bool SMakeProjectT::IsMakeAppFile(const string& name)
  104. {
  105.     return NStr::StartsWith(name, "Makefile")  &&  
  106.        NStr::EndsWith(name, ".app");
  107. }
  110. bool SMakeProjectT::IsUserProjFile(const string& name)
  111. {
  112.     return NStr::StartsWith(name, "Makefile")  &&  
  113.        NStr::EndsWith(name, ".msvcproj");
  114. }
  117. void SMakeProjectT::DoResolveDefs(CSymResolver& resolver, 
  118.                                   TFiles& files,
  119.                                   const set<string>& keys)
  120. {
  121.     NON_CONST_ITERATE(CProjectTreeBuilder::TFiles, p, files) {
  122.     NON_CONST_ITERATE(CSimpleMakeFileContents::TContents, 
  123.                           n, 
  124.                           p->second.m_Contents) {
  125.             
  126.             const string& key    = n->first;
  127.             list<string>& values = n->second;
  128.     if (keys.find(key) != keys.end()) {
  129.                 list<string> new_vals;
  130.                 bool modified = false;
  131.                 NON_CONST_ITERATE(list<string>, k, values) {
  132.                     //iterate all values and try to resolve 
  133.                     const string& val = *k;
  134.                     if( !CSymResolver::IsDefine(val) ) {
  135.                         new_vals.push_back(val);
  136.                     } else {
  137.                         list<string> resolved_def;
  138.                         string val_define = FilterDefine(val);
  139.                     resolver.Resolve(val_define, &resolved_def);
  140.                     if ( resolved_def.empty() )
  141.                     new_vals.push_back(val); //not resolved - keep old val
  142.                         else {
  143.                             //was resolved
  144.                             ITERATE(list<string>, l, resolved_def) {
  145.                                 const string& define = *l;
  146.                                 if ( IsConfigurableDefine(define) ) {
  147.                                     string resolved_def_str = 
  148.                                         GetApp().GetSite().ResolveDefine
  149.                                                      (StripConfigurableDefine
  150.                                                                      (define));
  151.                                     if ( !resolved_def_str.empty() ) {
  152.                                         list<string> resolved_defs;
  153.                                         NStr::Split(resolved_def_str, 
  154.                                                     LIST_SEPARATOR, 
  155.                                                     resolved_defs);
  156.                                         copy(resolved_defs.begin(),
  157.                                              resolved_defs.end(),
  158.                                              back_inserter(new_vals));
  159.                                     } else {
  160.                                         new_vals.push_back(define);
  161.                                     }
  163.                                 } else {
  164.                                     new_vals.push_back(define);
  165.                                 }
  166.                             }
  167.                     modified = true;
  168.                         }
  169.                     }
  170.                 }
  171.                 if (modified)
  172.                     values = new_vals; // by ref!
  173.     }
  174.         }
  175.     }
  176. }
  179. string SMakeProjectT::GetOneIncludeDir(const string& flag, const string& token)
  180. {
  181.     size_t token_pos = flag.find(token);
  182.     if (token_pos != NPOS && 
  183.         token_pos + token.length() < flag.length()) {
  184.         return flag.substr(token_pos + token.length()); 
  185.     }
  186.     return "";
  187. }
  190. void SMakeProjectT::CreateIncludeDirs(const list<string>& cpp_flags,
  191.                                       const string&       source_base_dir,
  192.                                       list<string>*       include_dirs)
  193. {
  194.     include_dirs->clear();
  195.     ITERATE(list<string>, p, cpp_flags) {
  196.         const string& flag = *p;
  197.         const string token("-I$(includedir)");
  199.         // process -I$(includedir)
  200.         string token_val;
  201.         token_val = SMakeProjectT::GetOneIncludeDir(flag, "-I$(includedir)");
  202.         if ( !token_val.empty() ) {
  203.             string dir = 
  204.                 CDirEntry::ConcatPath(GetApp().GetProjectTreeInfo().m_Include,
  205.                                       token_val);
  206.             dir = CDirEntry::NormalizePath(dir);
  207.             dir = CDirEntry::AddTrailingPathSeparator(dir);
  209.             include_dirs->push_back(dir);
  210.         }
  212.         // process -I$(srcdir)
  213.         token_val = SMakeProjectT::GetOneIncludeDir(flag, "-I$(srcdir)");
  214.         if ( !token_val.empty() )  {
  215.             string dir = 
  216.                 CDirEntry::ConcatPath(source_base_dir,
  217.                                       token_val);
  218.             dir = CDirEntry::NormalizePath(dir);
  219.             dir = CDirEntry::AddTrailingPathSeparator(dir);
  221.             include_dirs->push_back(dir);
  222.         }
  223.         
  224.         // process defines like NCBI_C_INCLUDE
  225.         if(CSymResolver::IsDefine(flag)) {
  226.             string dir = GetApp().GetSite().ResolveDefine
  227.                                              (CSymResolver::StripDefine(flag));
  228.             if ( !dir.empty() && CDirEntry(dir).IsDir() ) {
  229.                 include_dirs->push_back(dir);    
  230.             }
  231.         }
  233.         // process additional include dirs for LibChoices
  234.         if(CSymResolver::IsDefine(flag)) {
  235.             string sflag = CSymResolver::StripDefine(flag);
  236.             list<string> libchoices_abs_includes ;
  237.             GetApp().GetSite().GetLibChoiceIncludes(sflag, 
  238.                                                     &libchoices_abs_includes);
  240.             ITERATE(list<string>, n, libchoices_abs_includes) {
  241.                 const string& dir = *n;
  243.                 if ( !dir.empty() && CDirEntry(dir).IsDir() ) {
  244.                     include_dirs->push_back(dir);    
  245.                 }
  246.             }
  247.         }
  248.     }
  249.     include_dirs->sort();
  250.     include_dirs->unique();
  251. }
  254. void SMakeProjectT::CreateDefines(const list<string>& cpp_flags,
  255.                                   list<string>*       defines)
  256. {
  257.     defines->clear();
  259.     ITERATE(list<string>, p, cpp_flags) {
  260.         const string& flag = *p;
  261.         if ( NStr::StartsWith(flag, "-D") ) {
  262.             defines->push_back(flag.substr(2));
  263.         }
  264.     }
  265. }
  268. void SMakeProjectT::Create3PartyLibs(const list<string>& libs_flags, 
  269.                                      list<string>*       libs_list)
  270. {
  271.     libs_list->clear();
  272.     ITERATE(list<string>, p, libs_flags) {
  273.         const string& flag = *p;
  274.         if ( IsConfigurableDefine(flag) ) {
  275.             libs_list->push_back(StripConfigurableDefine(flag));    
  276.         }
  277.     }
  278. }
  281. void SMakeProjectT::AnalyzeMakeIn
  282.     (const CSimpleMakeFileContents& makein_contents,
  283.      TMakeInInfoList*               info)
  284. {
  285.     info->clear();
  287.     CSimpleMakeFileContents::TContents::const_iterator p = 
  288.         makein_contents.m_Contents.find("LIB_PROJ");
  290.     if (p != makein_contents.m_Contents.end()) {
  292.         info->push_back(SMakeInInfo(SMakeInInfo::eLib, p->second)); 
  293.     }
  295.     p = makein_contents.m_Contents.find("APP_PROJ");
  296.     if (p != makein_contents.m_Contents.end()) {
  298.         info->push_back(SMakeInInfo(SMakeInInfo::eApp, p->second)); 
  299.     }
  301.     p = makein_contents.m_Contents.find("ASN_PROJ");
  302.     if (p != makein_contents.m_Contents.end()) {
  304.         info->push_back(SMakeInInfo(SMakeInInfo::eAsn, p->second)); 
  305.     }
  307.     p = makein_contents.m_Contents.find("MSVC_PROJ");
  308.     if (p != makein_contents.m_Contents.end()) {
  310.         info->push_back(SMakeInInfo(SMakeInInfo::eMsvc, p->second)); 
  311.     }
  313.     //TODO - DLL_PROJ
  314. }
  317. string SMakeProjectT::CreateMakeAppLibFileName
  318.                 (const string&            base_dir,
  319.                  const string&            projname)
  320. {
  321.     CProjItem::TProjType proj_type = 
  322.             SMakeProjectT::GetProjType(base_dir, projname);
  324.     string fname = "Makefile." + projname;
  325.     
  326.     if (proj_type==CProjKey::eLib)
  327.         return fname + ".lib";
  329.     if (proj_type==CProjKey::eApp)
  330.         return fname + ".app";
  332.     if (proj_type==CProjKey::eMsvc)
  333.         return fname + ".msvcproj";
  335.     return "";
  336. }
  339. void SMakeProjectT::CreateFullPathes(const string&      dir, 
  340.                                      const list<string> files,
  341.                                      list<string>*      full_pathes)
  342. {
  343.     ITERATE(list<string>, p, files) {
  344.         string full_path = CDirEntry::ConcatPath(dir, *p);
  345.         full_pathes->push_back(full_path);
  346.     }
  347. }
  350. void SMakeProjectT::ConvertLibDepends(const list<string>& depends_libs, 
  351.                                       list<CProjKey>*     depends_ids)
  352. {
  353.     depends_ids->clear();
  354.     ITERATE(list<string>, p, depends_libs)
  355.     {
  356.         const string& id = *p;
  357.         depends_ids->push_back(CProjKey(CProjKey::eLib, id));
  358.     }
  359. }
  362. bool SMakeProjectT::IsConfigurableDefine(const string& define)
  363. {
  364.     return  NStr::StartsWith(define, "@")  &&
  365.             NStr::EndsWith  (define, "@");
  367. }
  370. string SMakeProjectT::StripConfigurableDefine(const string& define)
  371. {
  372.     return IsConfigurableDefine(define) ? 
  373.                 define.substr(1, define.length() - 2): "";
  374. }
  377. //-----------------------------------------------------------------------------
  378. void SAppProjectT::CreateNcbiCToolkitLibs(const CSimpleMakeFileContents& makefile,
  379.                                           list<string>* libs_list)
  380. {
  381.     CSimpleMakeFileContents::TContents::const_iterator k = 
  382.     makefile.m_Contents.find("NCBI_C_LIBS");
  383.     if (k == makefile.m_Contents.end()) {
  384.         return;
  385.     }
  386.     const list<string>& values = k->second;
  388.     ITERATE(list<string>, p, values) {
  389.         const string& val = *p;
  390.         if ( NStr::StartsWith(val, "-l") ) {
  391.             string lib_id = val.substr(2);
  392.             libs_list->push_back(lib_id);
  393.         } else {
  394.             libs_list->push_back(val);
  395.         }
  396.     }
  398.     libs_list->sort();
  399.     libs_list->unique();
  400. }
  402. CProjKey SAppProjectT::DoCreate(const string& source_base_dir,
  403.                                 const string& proj_name,
  404.                                 const string& applib_mfilepath,
  405.                                 const TFiles& makeapp , 
  406.                                 CProjectItemsTree* tree)
  407. {
  408.     CProjectItemsTree::TFiles::const_iterator m = makeapp.find(applib_mfilepath);
  409.     if (m == makeapp.end()) {
  411.         LOG_POST(Info << "No Makefile.*.app for Makefile.in :"
  412.                   + applib_mfilepath);
  413.         return CProjKey();
  414.     }
  415.     
  416.     const CSimpleMakeFileContents& makefile = m->second;
  418.     CSimpleMakeFileContents::TContents::const_iterator k = 
  419.         makefile.m_Contents.find("SRC");
  420.     if (k == makefile.m_Contents.end()) {
  422.         LOG_POST(Warning << "No SRC key in Makefile.*.app :"
  423.                   + applib_mfilepath);
  424.         return CProjKey();
  425.     }
  427.     //sources - relative  pathes from source_base_dir
  428.     //We'll create relative pathes from them
  429.     CProjSRCResolver src_resolver(applib_mfilepath, 
  430.                                   source_base_dir, k->second);
  431.     list<string> sources;
  432.     src_resolver.ResolveTo(&sources);
  434.     //depends
  435.     list<string> depends;
  436.     k = makefile.m_Contents.find("LIB");
  437.     if (k != makefile.m_Contents.end())
  438.         depends = k->second;
  439.     //Adjust depends by information from msvc Makefile
  440.     CMsvcProjectMakefile project_makefile
  441.                        ((CDirEntry::ConcatPath
  442.                           (source_base_dir, 
  443.                            CreateMsvcProjectMakefileName(proj_name, 
  444.                                                          CProjKey::eApp))));
  445.     list<string> added_depends;
  446.     project_makefile.GetAdditionalLIB(SConfigInfo(), &added_depends);
  448.     list<string> excluded_depends;
  449.     project_makefile.GetExcludedLIB(SConfigInfo(), &excluded_depends);
  451.     list<string> adj_depends(depends);
  452.     copy(added_depends.begin(), 
  453.          added_depends.end(), back_inserter(adj_depends));
  454.     adj_depends.sort();
  455.     adj_depends.unique();
  457.     PLibExclude pred(excluded_depends);
  458.     EraseIf(adj_depends, pred);
  460.     list<CProjKey> depends_ids;
  461.     SMakeProjectT::ConvertLibDepends(adj_depends, &depends_ids);
  462.     ///////////////////////////////////
  464.     //requires
  465.     list<string> requires;
  466.     k = makefile.m_Contents.find("REQUIRES");
  467.     if (k != makefile.m_Contents.end())
  468.         requires = k->second;
  470.     //project name
  471.     k = makefile.m_Contents.find("APP");
  472.     if (k == makefile.m_Contents.end()  ||  
  473.                                            k->second.empty()) {
  475.         LOG_POST(Error << "No APP key or empty in Makefile.*.app :"
  476.                   + applib_mfilepath);
  477.         return CProjKey();
  478.     }
  479.     string proj_id = k->second.front();
  481.     //LIBS
  482.     list<string> libs_3_party;
  483.     k = makefile.m_Contents.find("LIBS");
  484.     if (k != makefile.m_Contents.end()) {
  485.         const list<string> libs_flags = k->second;
  486.         SMakeProjectT::Create3PartyLibs(libs_flags, &libs_3_party);
  487.     }
  488.     
  489.     //CPPFLAGS
  490.     list<string> include_dirs;
  491.     list<string> defines;
  492.     k = makefile.m_Contents.find("CPPFLAGS");
  493.     if (k != makefile.m_Contents.end()) {
  494.         const list<string> cpp_flags = k->second;
  495.         SMakeProjectT::CreateIncludeDirs(cpp_flags, 
  496.                                          source_base_dir, &include_dirs);
  497.         SMakeProjectT::CreateDefines(cpp_flags, &defines);
  498.     }
  500.     //NCBI_C_LIBS - Special case for NCBI C Toolkit
  501.     k = makefile.m_Contents.find("NCBI_C_LIBS");
  502.     list<string> ncbi_clibs;
  503.     if (k != makefile.m_Contents.end()) {
  504.         libs_3_party.push_back("NCBI_C_LIBS");
  505.         CreateNcbiCToolkitLibs(makefile, &ncbi_clibs);
  506.     }
  507.     
  508.     CProjItem project(CProjKey::eApp, 
  509.                       proj_name, 
  510.                       proj_id,
  511.                       source_base_dir,
  512.                       sources, 
  513.                       depends_ids,
  514.                       requires,
  515.                       libs_3_party,
  516.                       include_dirs,
  517.                       defines);
  518.     //
  519.     project.m_NcbiCLibs = ncbi_clibs;
  521.     //DATATOOL_SRC
  522.     k = makefile.m_Contents.find("DATATOOL_SRC");
  523.     if ( k != makefile.m_Contents.end() ) {
  524.         //Add depends from datatoool for ASN projects
  525.         project.m_Depends.push_back(CProjKey(CProjKey::eApp, GetApp().GetDatatoolId()));
  526.         const list<string> datatool_src_list = k->second;
  527.         ITERATE(list<string>, i, datatool_src_list) {
  529.             const string& src = *i;
  530.             //Will process .asn or .dtd files
  531.             string source_file_path = 
  532.                 CDirEntry::ConcatPath(source_base_dir, src);
  533.             source_file_path = CDirEntry::NormalizePath(source_file_path);
  534.             if ( CDirEntry(source_file_path + ".asn").Exists() )
  535.                 source_file_path += ".asn";
  536.             else if ( CDirEntry(source_file_path + ".dtd").Exists() )
  537.                 source_file_path += ".dtd";
  539.             CDataToolGeneratedSrc data_tool_src;
  540.             CDataToolGeneratedSrc::LoadFrom(source_file_path, &data_tool_src);
  541.             if ( !data_tool_src.IsEmpty() )
  542.                 project.m_DatatoolSources.push_back(data_tool_src);
  543.         }
  544.     }
  545.     CProjKey proj_key(CProjKey::eApp, proj_id);
  546.     tree->m_Projects[proj_key] = project;
  548.     return proj_key;
  549. }
  552. //-----------------------------------------------------------------------------
  553. CProjKey SLibProjectT::DoCreate(const string& source_base_dir,
  554.                                 const string& proj_name,
  555.                                 const string& applib_mfilepath,
  556.                                 const TFiles& makelib , 
  557.                                 CProjectItemsTree* tree)
  558. {
  559.     TFiles::const_iterator m = makelib.find(applib_mfilepath);
  560.     if (m == makelib.end()) {
  562.         LOG_POST(Info << "No Makefile.*.lib for Makefile.in :"
  563.                   + applib_mfilepath);
  564.         return CProjKey();
  565.     }
  567.     CSimpleMakeFileContents::TContents::const_iterator k = 
  568.         m->second.m_Contents.find("SRC");
  569.     if (k == m->second.m_Contents.end()) {
  571.         LOG_POST(Warning << "No SRC key in Makefile.*.lib :"
  572.                   + applib_mfilepath);
  573.         return CProjKey();
  574.     }
  576.     // sources - relative pathes from source_base_dir
  577.     // We'll create relative pathes from them)
  578.     CProjSRCResolver src_resolver(applib_mfilepath, 
  579.                                   source_base_dir, k->second);
  580.     list<string> sources;
  581.     src_resolver.ResolveTo(&sources);
  583.     // depends - TODO
  584.     list<CProjKey> depends_ids;
  585.     k = m->second.m_Contents.find("ASN_DEP");
  586.     if (k != m->second.m_Contents.end()) {
  587.         const list<string> depends = k->second;
  588.         SMakeProjectT::ConvertLibDepends(depends, &depends_ids);
  589.     }
  591.     //requires
  592.     list<string> requires;
  593.     k = m->second.m_Contents.find("REQUIRES");
  594.     if (k != m->second.m_Contents.end())
  595.         requires = k->second;
  597.     //project name
  598.     k = m->second.m_Contents.find("LIB");
  599.     if (k == m->second.m_Contents.end()  ||  
  600.                                            k->second.empty()) {
  602.         LOG_POST(Error << "No LIB key or empty in Makefile.*.lib :"
  603.                   + applib_mfilepath);
  604.         return CProjKey();
  605.     }
  606.     string proj_id = k->second.front();
  608.     //LIBS
  609.     list<string> libs_3_party;
  610.     k = m->second.m_Contents.find("LIBS");
  611.     if (k != m->second.m_Contents.end()) {
  612.         const list<string> libs_flags = k->second;
  613.         SMakeProjectT::Create3PartyLibs(libs_flags, &libs_3_party);
  614.     }
  615.     //CPPFLAGS
  616.     list<string> include_dirs;
  617.     list<string> defines;
  618.     k = m->second.m_Contents.find("CPPFLAGS");
  619.     if (k != m->second.m_Contents.end()) {
  620.         const list<string> cpp_flags = k->second;
  621.         SMakeProjectT::CreateIncludeDirs(cpp_flags, 
  622.                                          source_base_dir, &include_dirs);
  623.         SMakeProjectT::CreateDefines(cpp_flags, &defines);
  625.     }
  626.     CProjKey proj_key(CProjKey::eLib, proj_id);
  627.     tree->m_Projects[proj_key] = CProjItem(CProjKey::eLib,
  628.                                            proj_name, 
  629.                                            proj_id,
  630.                                            source_base_dir,
  631.                                            sources, 
  632.                                            depends_ids,
  633.                                            requires,
  634.                                            libs_3_party,
  635.                                            include_dirs,
  636.                                            defines);
  637.     return proj_key;
  638. }
  641. //-----------------------------------------------------------------------------
  642. CProjKey SAsnProjectT::DoCreate(const string& source_base_dir,
  643.                                 const string& proj_name,
  644.                                 const string& applib_mfilepath,
  645.                                 const TFiles& makeapp, 
  646.                                 const TFiles& makelib, 
  647.                                 CProjectItemsTree* tree)
  648. {
  649.     TAsnType asn_type = GetAsnProjectType(applib_mfilepath, makeapp, makelib);
  650.     if (asn_type == eMultiple) {
  651.         return SAsnProjectMultipleT::DoCreate(source_base_dir,
  652.                                               proj_name,
  653.                                               applib_mfilepath,
  654.                                               makeapp, 
  655.                                               makelib, 
  656.                                               tree);
  657.     }
  658.     if(asn_type == eSingle) {
  659.         return SAsnProjectSingleT::DoCreate(source_base_dir,
  660.                                               proj_name,
  661.                                               applib_mfilepath,
  662.                                               makeapp, 
  663.                                               makelib, 
  664.                                               tree);
  665.     }
  667.     LOG_POST(Error << "Unsupported ASN project" + NStr::IntToString(asn_type));
  668.     return CProjKey();
  669. }
  672. SAsnProjectT::TAsnType SAsnProjectT::GetAsnProjectType(const string& applib_mfilepath,
  673.                                                        const TFiles& makeapp,
  674.                                                        const TFiles& makelib)
  675. {
  676.     TFiles::const_iterator p = makeapp.find(applib_mfilepath);
  677.     if ( p != makeapp.end() ) {
  678.         const CSimpleMakeFileContents& fc = p->second;
  679.         if (fc.m_Contents.find("ASN") != fc.m_Contents.end() )
  680.             return eMultiple;
  681.         else
  682.             return eSingle;
  683.     }
  685.     p = makelib.find(applib_mfilepath);
  686.     if ( p != makelib.end() ) {
  687.         const CSimpleMakeFileContents& fc = p->second;
  688.         if (fc.m_Contents.find("ASN") != fc.m_Contents.end() )
  689.             return eMultiple;
  690.         else
  691.             return eSingle;
  692.     }
  694.     LOG_POST(Error << "Can not define ASN project: " + applib_mfilepath);
  695.     return eNoAsn;
  696. }
  699. //-----------------------------------------------------------------------------
  700. CProjKey SAsnProjectSingleT::DoCreate(const string& source_base_dir,
  701.                                       const string& proj_name,
  702.                                       const string& applib_mfilepath,
  703.                                       const TFiles& makeapp, 
  704.                                       const TFiles& makelib, 
  705.                                       CProjectItemsTree* tree)
  706. {
  707.     CProjItem::TProjType proj_type = 
  708.         SMakeProjectT::GetProjType(source_base_dir, proj_name);
  709.     
  710.     CProjKey proj_id = 
  711.         proj_type == CProjKey::eLib? 
  712.             SLibProjectT::DoCreate(source_base_dir, 
  713.                                proj_name, applib_mfilepath, makelib, tree) : 
  714.             SAppProjectT::DoCreate(source_base_dir, 
  715.                                proj_name, applib_mfilepath, makeapp, tree);
  716.     if ( proj_id.Id().empty() )
  717.         return CProjKey();
  718.     
  719.     TProjects::iterator p = tree->m_Projects.find(proj_id);
  720.     if (p == tree->m_Projects.end()) {
  721.         LOG_POST(Error << "Can not find ASN project with id : " + proj_id.Id());
  722.         return CProjKey();
  723.     }
  724.     CProjItem& project = p->second;
  726.     //Add depends from datatoool for ASN projects
  727.     project.m_Depends.push_back(CProjKey(CProjKey::eApp,
  728.                                          GetApp().GetDatatoolId()));
  730.     //Will process .asn or .dtd files
  731.     string source_file_path = CDirEntry::ConcatPath(source_base_dir, proj_name);
  732.     if ( CDirEntry(source_file_path + ".asn").Exists() )
  733.         source_file_path += ".asn";
  734.     else if ( CDirEntry(source_file_path + ".dtd").Exists() )
  735.         source_file_path += ".dtd";
  737.     CDataToolGeneratedSrc data_tool_src;
  738.     CDataToolGeneratedSrc::LoadFrom(source_file_path, &data_tool_src);
  739.     if ( !data_tool_src.IsEmpty() )
  740.         project.m_DatatoolSources.push_back(data_tool_src);
  742.     return proj_id;
  743. }
  746. //-----------------------------------------------------------------------------
  747. CProjKey SAsnProjectMultipleT::DoCreate(const string& source_base_dir,
  748.                                         const string& proj_name,
  749.                                         const string& applib_mfilepath,
  750.                                         const TFiles& makeapp, 
  751.                                         const TFiles& makelib, 
  752.                                         CProjectItemsTree* tree)
  753. {
  754.     CProjItem::TProjType proj_type = 
  755.         SMakeProjectT::GetProjType(source_base_dir, proj_name);
  756.     
  758.     const TFiles& makefile = proj_type == CProjKey::eLib? makelib : makeapp;
  759.     TFiles::const_iterator m = makefile.find(applib_mfilepath);
  760.     if (m == makefile.end()) {
  762.         LOG_POST(Info << "No Makefile.*.lib/app  for Makefile.in :"
  763.                   + applib_mfilepath);
  764.         return CProjKey();
  765.     }
  766.     const CSimpleMakeFileContents& fc = m->second;
  768.     // ASN
  769.     CSimpleMakeFileContents::TContents::const_iterator k = 
  770.         fc.m_Contents.find("ASN");
  771.     if (k == fc.m_Contents.end()) {
  773.         LOG_POST(Error << "No ASN key in multiple ASN  project:"
  774.                   + applib_mfilepath);
  775.         return CProjKey();
  776.     }
  777.     const list<string> asn_names = k->second;
  779.     string parent_dir_abs = ParentDir(source_base_dir);
  780.     list<CDataToolGeneratedSrc> datatool_sources;
  781.     ITERATE(list<string>, p, asn_names) {
  782.         const string& asn = *p;
  783.         // one level up
  784.         string asn_dir_abs = CDirEntry::ConcatPath(parent_dir_abs, asn);
  785.         asn_dir_abs = CDirEntry::NormalizePath(asn_dir_abs);
  786.         asn_dir_abs = CDirEntry::AddTrailingPathSeparator(asn_dir_abs);
  787.     
  788.         string asn_path_abs = CDirEntry::ConcatPath(asn_dir_abs, asn);
  789.         if ( CDirEntry(asn_path_abs + ".asn").Exists() )
  790.             asn_path_abs += ".asn";
  791.         else if ( CDirEntry(asn_dir_abs + ".dtd").Exists() )
  792.             asn_path_abs += ".dtd";
  794.         CDataToolGeneratedSrc data_tool_src;
  795.         CDataToolGeneratedSrc::LoadFrom(asn_path_abs, &data_tool_src);
  796.         if ( !data_tool_src.IsEmpty() )
  797.             datatool_sources.push_back(data_tool_src);
  799.     }
  801.     // SRC
  802.     k = fc.m_Contents.find("SRC");
  803.     if (k == fc.m_Contents.end()) {
  805.         LOG_POST(Error << "No SRC key in multiple ASN  project:"
  806.                   + applib_mfilepath);
  807.         return CProjKey();
  808.     }
  809.     const list<string> src_list = k->second;
  810.     list<string> sources;
  811.     ITERATE(list<string>, p, src_list) {
  812.         const string& src = *p;
  813.         if ( !CSymResolver::IsDefine(src) )
  814.             sources.push_back(src);
  815.     }
  817.     CProjKey proj_id = 
  818.         proj_type == CProjKey::eLib? 
  819.         SLibProjectT::DoCreate(source_base_dir, 
  820.                                proj_name, applib_mfilepath, makelib, tree) :
  821.         SAppProjectT::DoCreate(source_base_dir, 
  822.                                proj_name, applib_mfilepath, makeapp, tree);
  823.     if ( proj_id.Id().empty() )
  824.         return CProjKey();
  825.     
  826.     TProjects::iterator p = tree->m_Projects.find(proj_id);
  827.     if (p == tree->m_Projects.end()) {
  828.         LOG_POST(Error << "Can not find ASN project with id : " +proj_id.Id());
  829.         return CProjKey();
  830.     }
  831.     CProjItem& project = p->second;
  833.     // Adjust created proj item
  834.     //SRC - 
  835.     project.m_Sources.clear();
  836.     ITERATE(list<string>, p, src_list) {
  837.         const string& src = *p;
  838.         if ( !CSymResolver::IsDefine(src) )
  839.             project.m_Sources.push_front(src);    
  840.     }
  841.     project.m_Sources.push_back(proj_name + "__");
  842.     project.m_Sources.push_back(proj_name + "___");
  843.     ITERATE(list<string>, p, asn_names) {
  844.         const string& asn = *p;
  845.         if (asn == proj_name)
  846.             continue;
  847.         string src(1, CDirEntry::GetPathSeparator());
  848.         src += "..";
  849.         src += CDirEntry::GetPathSeparator();
  850.         src += asn;
  851.         src += CDirEntry::GetPathSeparator();
  852.         src += asn;
  854.         project.m_Sources.push_back(src + "__");
  855.         project.m_Sources.push_back(src + "___");
  856.     }
  858.     project.m_DatatoolSources = datatool_sources;
  860.     //Add depends from datatoool for ASN projects
  861.     project.m_Depends.push_back(CProjKey(CProjKey::eApp, 
  862.                                          GetApp().GetDatatoolId()));
  864.     return proj_id;
  865. }
  867. //-----------------------------------------------------------------------------
  868. CProjKey SMsvcProjectT::DoCreate(const string&      source_base_dir,
  869.                                  const string&      proj_name,
  870.                                  const string&      applib_mfilepath,
  871.                                  const TFiles&      makemsvc, 
  872.                                  CProjectItemsTree* tree)
  873. {
  874.     TFiles::const_iterator m = makemsvc.find(applib_mfilepath);
  875.     if (m == makemsvc.end()) {
  877.         LOG_POST(Info << "No User makefile.*.* for Makefile.in :"
  878.                   + applib_mfilepath);
  879.         return CProjKey();
  880.     }
  882.     // VCPROJ - will map to src
  883.     CSimpleMakeFileContents::TContents::const_iterator k = 
  884.         m->second.m_Contents.find("VCPROJ");
  885.     if (k == m->second.m_Contents.end()) {
  887.         LOG_POST(Warning << "No VCPROJ key in User Makefile.*.* :"
  888.                   + applib_mfilepath);
  889.         return CProjKey();
  890.     }
  891.     list<string> sources = k->second;
  893.     // depends - 
  894.     list<CProjKey> depends_ids;
  895.     k = m->second.m_Contents.find("LIB_DEP");
  896.     if (k != m->second.m_Contents.end()) {
  897.         const list<string> deps = k->second;
  898.         ITERATE(list<string>, p, deps) {
  899.             depends_ids.push_back(CProjKey(CProjKey::eLib, *p));
  900.         }
  901.     }
  902.     k = m->second.m_Contents.find("APP_DEP");
  903.     if (k != m->second.m_Contents.end()) {
  904.         const list<string> deps = k->second;
  905.         ITERATE(list<string>, p, deps) {
  906.             depends_ids.push_back(CProjKey(CProjKey::eApp, *p));
  907.         }
  908.     }
  909.     k = m->second.m_Contents.find("DLL_DEP");
  910.     if (k != m->second.m_Contents.end()) {
  911.         const list<string> deps = k->second;
  912.         ITERATE(list<string>, p, deps) {
  913.             depends_ids.push_back(CProjKey(CProjKey::eDll, *p));
  914.         }
  915.     }
  916.     k = m->second.m_Contents.find("MSVC_DEP");
  917.     if (k != m->second.m_Contents.end()) {
  918.         const list<string> deps = k->second;
  919.         ITERATE(list<string>, p, deps) {
  920.             depends_ids.push_back(CProjKey(CProjKey::eMsvc, *p));
  921.         }
  922.     }
  924.     //requires
  925.     list<string> requires;
  926.     k = m->second.m_Contents.find("REQUIRES");
  927.     if (k != m->second.m_Contents.end())
  928.         requires = k->second;
  930.     //project id
  931.     k = m->second.m_Contents.find("MSVC_PROJ");
  932.     if (k == m->second.m_Contents.end()  ||  
  933.                                            k->second.empty()) {
  935.         LOG_POST(Error << "No LIB key or empty in Makefile.*.lib :"
  936.                   + applib_mfilepath);
  937.         return CProjKey();
  938.     }
  939.     string proj_id = k->second.front();
  941.     list<string> libs_3_party;
  942.     list<string> include_dirs;
  943.     list<string> defines;
  945.     CProjKey proj_key(CProjKey::eMsvc, proj_id);
  946.     tree->m_Projects[proj_key] = CProjItem(CProjKey::eMsvc,
  947.                                            proj_name, 
  948.                                            proj_id,
  949.                                            source_base_dir,
  950.                                            sources, 
  951.                                            depends_ids,
  952.                                            requires,
  953.                                            libs_3_party,
  954.                                            include_dirs,
  955.                                            defines);
  956.     return proj_key;
  957. }
  958. //-----------------------------------------------------------------------------
  959. void 
  960. CProjectTreeBuilder::BuildOneProjectTree(const IProjectFilter* filter,
  961.                                          const string&         root_src_path,
  962.                                          CProjectItemsTree*    tree)
  963. {
  964.     SMakeFiles subtree_makefiles;
  966.     ProcessDir(root_src_path, 
  967.                true,
  968.                filter,
  969.                &subtree_makefiles);
  971.     // Resolve macrodefines
  972.     list<string> metadata_files;
  973.     GetApp().GetMetaDataFiles(&metadata_files);
  974.     CSymResolver resolver;
  975.     ITERATE(list<string>, p, metadata_files) {
  976.     resolver += CSymResolver(CDirEntry::ConcatPath(root_src_path, *p));
  977. }
  978.     ResolveDefs(resolver, subtree_makefiles);
  980.     // Build projects tree
  981.     CProjectItemsTree::CreateFrom(root_src_path,
  982.                                   subtree_makefiles.m_In, 
  983.                                   subtree_makefiles.m_Lib, 
  984.                                   subtree_makefiles.m_App,
  985.                                   subtree_makefiles.m_User, tree);
  986. }
  989. void 
  990. CProjectTreeBuilder::BuildProjectTree(const IProjectFilter* filter,
  991.                                       const string&         root_src_path,
  992.                                       CProjectItemsTree*    tree)
  993. {
  994.     // Bulid subtree
  995.     CProjectItemsTree target_tree;
  996.     BuildOneProjectTree(filter, root_src_path, &target_tree);
  998.     // Analyze subtree depends
  999.     list<CProjKey> external_depends;
  1000.     target_tree.GetExternalDepends(&external_depends);
  1002.     // We have to add more projects to the target tree
  1003.     if ( !external_depends.empty()  &&  !filter->PassAll() ) {
  1005.         list<CProjKey> depends_to_resolve = external_depends;
  1007.         while ( !depends_to_resolve.empty() ) {
  1008.             bool modified = false;
  1009.             ITERATE(list<CProjKey>, p, depends_to_resolve) {
  1010.                 // id of project we have to resolve
  1011.                 const CProjKey& prj_id = *p;
  1012.                 CProjectItemsTree::TProjects::const_iterator n = 
  1013.                                GetApp().GetWholeTree().m_Projects.find(prj_id);
  1014.             
  1015.                 if (n != GetApp().GetWholeTree().m_Projects.end()) {
  1016.                     //insert this project to target_tree
  1017.                     target_tree.m_Projects[prj_id] = n->second;
  1018.                     modified = true;
  1019.                 } else {
  1020.                     LOG_POST (Error << "No project with id :" + prj_id.Id());
  1021.                 }
  1022.             }
  1024.             if (!modified) {
  1025.                 //we done - no more projects was added to target_tree
  1026.                 AddDatatoolSourcesDepends(&target_tree);
  1027.                 *tree = target_tree;
  1028.                 return;
  1029.             } else {
  1030.                 //continue resolving dependences
  1031.                 target_tree.GetExternalDepends(&depends_to_resolve);
  1032.             }
  1033.         }
  1034.     }
  1036.     AddDatatoolSourcesDepends(&target_tree);
  1037.     *tree = target_tree;
  1038. }
  1041. void CProjectTreeBuilder::ProcessDir(const string&         dir_name, 
  1042.                                      bool                  is_root,
  1043.                                      const IProjectFilter* filter,
  1044.                                      SMakeFiles*           makefiles)
  1045. {
  1046. #if 1
  1047.     // Do not collect makefile from root directory
  1048.     CDir dir(dir_name);
  1049.     CDir::TEntries contents = dir.GetEntries("*");
  1050.     ITERATE(CDir::TEntries, i, contents) {
  1051.         string name  = (*i)->GetName();
  1052.         if ( name == "."  ||  name == ".."  ||  
  1053.              name == string(1,CDir::GetPathSeparator()) ) {
  1054.             continue;
  1055.         }
  1056.         string path = (*i)->GetPath();
  1058.         if ( (*i)->IsFile()  &&  
  1059.              !is_root        &&  
  1060.              filter->CheckProject(CDirEntry(path).GetDir()) ) {
  1062.             if ( SMakeProjectT::IsMakeInFile(name) )
  1063.             ProcessMakeInFile(path, makefiles);
  1064.             else if ( SMakeProjectT::IsMakeLibFile(name) )
  1065.             ProcessMakeLibFile(path, makefiles);
  1066.             else if ( SMakeProjectT::IsMakeAppFile(name) )
  1067.             ProcessMakeAppFile(path, makefiles);
  1068.             else if ( SMakeProjectT::IsUserProjFile(name) )
  1069.             ProcessUserProjFile(path, makefiles);
  1070.         } 
  1071.         else if ( (*i)->IsDir() ) {
  1073.             ProcessDir(path, false, filter, makefiles);
  1074.         }
  1075.     }
  1076. #endif
  1078. #if 0
  1080.     // Node - Makefile.in should present
  1081.     string node_path = 
  1082.         CDirEntry::ConcatPath(dir_name, 
  1083.                               GetApp().GetProjectTreeInfo().m_TreeNode);
  1084.     if ( !CDirEntry(node_path).Exists() )
  1085.         return;
  1086.     
  1087.     bool process_projects = !is_root && filter->CheckProject(dir_name);
  1088.     
  1089.     // Process Makefile.*.lib
  1090.     if ( process_projects ) {
  1091.         CDir dir(dir_name);
  1092.         CDir::TEntries contents = dir.GetEntries("Makefile.*.lib");
  1093.         ITERATE(CDir::TEntries, p, contents) {
  1094.             const AutoPtr<CDirEntry>& dir_entry = *p;
  1095.             if ( SMakeProjectT::IsMakeLibFile(dir_entry->GetName()) )
  1096.             ProcessMakeLibFile(dir_entry->GetPath(), makefiles);
  1098.         }
  1099.     }
  1100.     // Process Makefile.*.app
  1101.     if ( process_projects ) {
  1102.         CDir dir(dir_name);
  1103.         CDir::TEntries contents = dir.GetEntries("Makefile.*.app");
  1104.         ITERATE(CDir::TEntries, p, contents) {
  1105.             const AutoPtr<CDirEntry>& dir_entry = *p;
  1106.             if ( SMakeProjectT::IsMakeAppFile(dir_entry->GetName()) )
  1107.             ProcessMakeAppFile(dir_entry->GetPath(), makefiles);
  1109.         }
  1110.     }
  1111.     // Process Makefile.*.msvcproj
  1112.     if ( process_projects ) {
  1113.         CDir dir(dir_name);
  1114.         CDir::TEntries contents = dir.GetEntries("Makefile.*.msvcproj");
  1115.         ITERATE(CDir::TEntries, p, contents) {
  1116.             const AutoPtr<CDirEntry>& dir_entry = *p;
  1117.             if ( SMakeProjectT::IsUserProjFile(dir_entry->GetName()) )
  1118.             ProcessUserProjFile(dir_entry->GetPath(), makefiles);
  1120.         }
  1121.     }
  1123.     // Process Makefile.in
  1124.     list<string> subprojects;
  1125.     if ( process_projects ) {
  1126.         ProcessMakeInFile(node_path, makefiles);
  1127.         TFiles::const_iterator p = makefiles->m_In.find(node_path);
  1128.         const CSimpleMakeFileContents& makefile = p->second;
  1129.         // 
  1130.         CSimpleMakeFileContents::TContents::const_iterator k = 
  1131.             makefile.m_Contents.find("SUB_PROJ");
  1132.         if (k != makefile.m_Contents.end()) {
  1133.             const list<string>& values = k->second;
  1134.             copy(values.begin(), 
  1135.                  values.end(), 
  1136.                  back_inserter(subprojects));
  1137.         }
  1138.         k = makefile.m_Contents.find("EXPENDABLE_SUB_PROJ");
  1139.         if (k != makefile.m_Contents.end()) {
  1140.             const list<string>& values = k->second;
  1141.             copy(values.begin(), 
  1142.                  values.end(), 
  1143.                  back_inserter(subprojects));
  1144.         }
  1145.     }
  1146.     subprojects.sort();
  1147.     subprojects.unique();
  1149.     // Convert subprojects to subdirs
  1150.     list<string> subprojects_dirs;
  1151.     if ( is_root ) {
  1152.         // for root node we'll take all subdirs
  1153.         CDir dir(dir_name);
  1154.         CDir::TEntries contents = dir.GetEntries("*");
  1155.         ITERATE(CDir::TEntries, p, contents) {
  1156.             const AutoPtr<CDirEntry>& dir_entry = *p;
  1157.             string name  = dir_entry->GetName();
  1158.             if ( name == "."  ||  name == ".."  ||  
  1159.                  name == string(1,CDir::GetPathSeparator()) ) {
  1160.                 continue;
  1161.             }
  1162.             if ( dir_entry->IsDir() ) {
  1163.                 subprojects_dirs.push_back(dir_entry->GetPath());
  1164.             }
  1165.         }
  1166.     } else {
  1167.         // for non-root only subprojects
  1168.         ITERATE(list<string>, p, subprojects) {
  1169.             const string& subproject = *p;
  1170.             string subproject_dir = 
  1171.                 CDirEntry::ConcatPath(dir_name, subproject);
  1172.             subprojects_dirs.push_back(subproject_dir);
  1173.         }
  1174.     }
  1176.     // Process subproj ( e.t. subdirs )
  1177.     ITERATE(list<string>, p, subprojects_dirs) {
  1178.         const string& subproject_dir = *p;
  1179.         ProcessDir(subproject_dir, false, filter, makefiles);
  1180.     }
  1182. #endif
  1183. }
  1186. void CProjectTreeBuilder::ProcessMakeInFile(const string& file_name, 
  1187.                                             SMakeFiles*   makefiles)
  1188. {
  1189.     LOG_POST(Info << "Processing MakeIn: " + file_name);
  1191.     CSimpleMakeFileContents fc(file_name);
  1192.     if ( !fc.m_Contents.empty() )
  1193.     makefiles->m_In[file_name] = fc;
  1194. }
  1197. void CProjectTreeBuilder::ProcessMakeLibFile(const string& file_name, 
  1198.                                              SMakeFiles*   makefiles)
  1199. {
  1200.     LOG_POST(Info << "Processing MakeLib: " + file_name);
  1202.     CSimpleMakeFileContents fc(file_name);
  1203.     if ( !fc.m_Contents.empty() )
  1204.     makefiles->m_Lib[file_name] = fc;
  1205. }
  1208. void CProjectTreeBuilder::ProcessMakeAppFile(const string& file_name, 
  1209.                                              SMakeFiles*   makefiles)
  1210. {
  1211.     LOG_POST(Info << "Processing MakeApp: " + file_name);
  1213.     CSimpleMakeFileContents fc(file_name);
  1214.     if ( !fc.m_Contents.empty() )
  1215.     makefiles->m_App[file_name] = fc;
  1216. }
  1219. void CProjectTreeBuilder::ProcessUserProjFile(const string& file_name, 
  1220.                                              SMakeFiles*   makefiles)
  1221. {
  1222.     LOG_POST(Info << "Processing MakeApp: " + file_name);
  1224.     CSimpleMakeFileContents fc(file_name);
  1225.     if ( !fc.m_Contents.empty() )
  1226.     makefiles->m_User[file_name] = fc;
  1227. }
  1230. //recursive resolving
  1231. void CProjectTreeBuilder::ResolveDefs(CSymResolver& resolver, 
  1232.                                       SMakeFiles&   makefiles)
  1233. {
  1234.     {{
  1235.         //App
  1236.         set<string> keys;
  1237.         keys.insert("LIB");
  1238.         keys.insert("LIBS");
  1239.         keys.insert("NCBI_C_LIBS");
  1240.         SMakeProjectT::DoResolveDefs(resolver, makefiles.m_App, keys);
  1241.     }}
  1243.     {{
  1244.         //Lib
  1245.         set<string> keys;
  1246.         keys.insert("LIBS");
  1247.         SMakeProjectT::DoResolveDefs(resolver, makefiles.m_Lib, keys);
  1248.     }}
  1249. }
  1252. //analyze modules
  1253. void s_CollectDatatoolIds(const CProjectItemsTree& tree,
  1254.                           map<string, CProjKey>*   datatool_ids)
  1255. {
  1256.     ITERATE(CProjectItemsTree::TProjects, p, tree.m_Projects) {
  1257.         const CProjKey&  project_id = p->first;
  1258.         const CProjItem& project    = p->second;
  1259.         ITERATE(list<CDataToolGeneratedSrc>, n, project.m_DatatoolSources) {
  1260.             const CDataToolGeneratedSrc& src = *n;
  1261.             string src_abs_path = 
  1262.                 CDirEntry::ConcatPath(src.m_SourceBaseDir, src.m_SourceFile);
  1263.             string src_rel_path = 
  1264.                 CDirEntry::CreateRelativePath
  1265.                                  (GetApp().GetProjectTreeInfo().m_Src, 
  1266.                                   src_abs_path);
  1267.             (*datatool_ids)[src_rel_path] = project_id;
  1268.         }
  1269.     }
  1270. }
  1273. void CProjectTreeBuilder::AddDatatoolSourcesDepends(CProjectItemsTree* tree)
  1274. {
  1275.     //datatool src rel path / project ID
  1277.     // 1. Collect all projects with datatool-generated-sources
  1278.     map<string, CProjKey> whole_datatool_ids;
  1279.     s_CollectDatatoolIds(GetApp().GetWholeTree(), &whole_datatool_ids);
  1283.     // 2. Extent tree to accomodate more ASN projects if necessary
  1284.     bool tree_extented = false;
  1285.     map<string, CProjKey> datatool_ids;
  1287.     do {
  1288.         
  1289.         tree_extented = false;
  1290.         s_CollectDatatoolIds(*tree, &datatool_ids);
  1292.         NON_CONST_ITERATE(CProjectItemsTree::TProjects, p, tree->m_Projects) {
  1293.             const CProjKey&  project_id = p->first;
  1294.             CProjItem& project          = p->second;
  1295.             ITERATE(list<CDataToolGeneratedSrc>, n, project.m_DatatoolSources) {
  1296.                 const CDataToolGeneratedSrc& src = *n;
  1297.                 ITERATE(list<string>, i, src.m_ImportModules) {
  1298.                     const string& module = *i;
  1299.                     map<string, CProjKey>::const_iterator j = 
  1300.                         datatool_ids.find(module);
  1301.                     if (j == datatool_ids.end()) {
  1302.                         j = whole_datatool_ids.find(module);
  1303.                         if (j != whole_datatool_ids.end()) {
  1304.                             const CProjKey& depends_id = j->second;
  1305.                             tree->m_Projects[depends_id] = 
  1306.                                 GetApp().GetWholeTree().m_Projects.find(depends_id)->second;
  1307.                             tree_extented = true;
  1308.                         }
  1309.                     }
  1310.                 }
  1311.             }
  1312.         }
  1313.     } while( tree_extented );
  1316.     // 3. Finally - generate depends
  1317.     NON_CONST_ITERATE(CProjectItemsTree::TProjects, p, tree->m_Projects) {
  1318.         const CProjKey&  project_id = p->first;
  1319.         CProjItem& project          = p->second;
  1320.         ITERATE(list<CDataToolGeneratedSrc>, n, project.m_DatatoolSources) {
  1321.             const CDataToolGeneratedSrc& src = *n;
  1322.             ITERATE(list<string>, i, src.m_ImportModules) {
  1323.                 const string& module = *i;
  1324.                 map<string, CProjKey>::const_iterator j = 
  1325.                     datatool_ids.find(module);
  1326.                 if (j != datatool_ids.end()) {
  1327.                     const CProjKey& depends_id = j->second;
  1328.                     if (depends_id != project_id) {
  1329.                         project.m_Depends.push_back(depends_id);
  1330.                         project.m_Depends.sort();
  1331.                         project.m_Depends.unique();
  1332.                     }
  1333.                 }
  1334.             }
  1335.         }
  1336.     }
  1338. }
  1341. END_NCBI_SCOPE
  1343. /*
  1344.  * ===========================================================================
  1345.  * $Log: proj_tree_builder.cpp,v $
  1346.  * Revision 1000.3  2004/06/16 17:02:39  gouriano
  1347.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
  1348.  *
  1349.  * Revision 1.13  2004/06/16 16:29:11  gorelenk
  1350.  * Changed directories traversing proc.
  1351.  *
  1352.  * Revision 1.12  2004/06/16 14:26:05  gorelenk
  1353.  * Re-designed CProjectTreeBuilder::ProcessDir .
  1354.  *
  1355.  * Revision 1.11  2004/06/15 14:14:31  gorelenk
  1356.  * Changed CProjectTreeBuilder::ProcessDir - changed procedure of
  1357.  * subdirs iteration .
  1358.  *
  1359.  * Revision 1.10  2004/06/14 18:57:59  gorelenk
  1360.  * Changed CProjectTreeBuilder::ProcessDir
  1361.  * - added support of EXPENDABLE_SUB_PROJ .
  1362.  *
  1363.  * Revision 1.9  2004/06/14 14:18:21  gorelenk
  1364.  * Changed CProjectTreeBuilder::ProcessDir - added SUB_PROJ processing.
  1365.  *
  1366.  * Revision 1.8  2004/05/21 21:41:41  gorelenk
  1367.  * Added PCH ncbi_pch.hpp
  1368.  *
  1369.  * Revision 1.7  2004/05/13 14:55:35  gorelenk
  1370.  * Changed SMakeProjectT::CreateIncludeDirs .
  1371.  *
  1372.  * Revision 1.6  2004/05/10 19:50:42  gorelenk
  1373.  * Implemented SMsvcProjectT .
  1374.  *
  1375.  * Revision 1.5  2004/04/06 17:15:47  gorelenk
  1376.  * Implemented member-functions IsConfigurableDefine and
  1377.  * StripConfigurableDefine of struct SMakeProjectT.
  1378.  * Changed implementations of SMakeProjectT::DoResolveDefs
  1379.  * SMakeProjectT::Create3PartyLibs and SAppProjectT::CreateNcbiCToolkitLibs.
  1380.  *
  1381.  * Revision 1.4  2004/03/23 14:41:50  gorelenk
  1382.  * Changed implementations of CProjectTreeBuilder::AddDatatoolSourcesDepends
  1383.  * and CProjectTreeBuilder::BuildProjectTree.
  1384.  *
  1385.  * Revision 1.3  2004/03/16 23:53:14  gorelenk
  1386.  * Changed implementations of:
  1387.  * SAppProjectT::DoCreate and
  1388.  * SAppProjectT::CreateNcbiCToolkitLibs .
  1389.  *
  1390.  * Revision 1.2  2004/03/04 23:31:10  gorelenk
  1391.  * Added call to AddDatatoolSourcesDepends in implementation of
  1392.  * CProjectTreeBuilder::BuildProjectTree.
  1393.  *
  1394.  * Revision 1.1  2004/03/02 16:23:57  gorelenk
  1395.  * Initial revision.
  1396.  *
  1397.  * ===========================================================================
  1398.  */