Collaboration diagram for StandardMacroBuilder:
Public Member Functions | |
void | fill_for_CMTVERSION () |
CMTVERSION. | |
StandardMacroBuilder (const cmt_string &tag, const cmt_string &package, const cmt_string &version, const cmt_string &prefix, CmtDirStyle style) | |
void | apply () |
void | fill_for_tag () |
tag | |
void | fill_for_package (const cmt_string ¤t_dir) |
PACKAGE_ROOT. | |
void | fill_for_branches () |
srcdir src =/ inc mgrdir mgr =..// bin javabin doc version package | |
void | fill_for_project () |
project | |
void | fill_for_use_requirements () |
use_requirements | |
void | fill_for_use_includes () |
use_includes | |
void | fill_for_use_fincludes () |
use_fincludes | |
void | fill_for_use_stamps () |
use_stamps | |
void | fill_for_use_cflags () |
use_cflags | |
void | fill_for_use_pp_cflags () |
use_pp_cflags | |
void | fill_for_use_cppflags () |
use_cppflags | |
void | fill_for_use_pp_cppflags () |
use_pp_cppflags | |
void | fill_for_use_fflags () |
use_fflags | |
void | fill_for_use_pp_fflags () |
use_pp_fflags | |
void | fill_for_use_linkopts () |
use_linkopts | |
void | fill_for_use_libraries () |
use_libraries | |
void | fill_for_includes () |
includes | |
void | fill_for_fincludes () |
fincludes | |
void | fill_for_all_constituents () |
Macros specific to constituents. | |
void | fill_for_constituent_macros () |
Macros implied or required to manage constituents. | |
void | fill_for_install_area () |
Definitions for installation area mechanisms. | |
void | fill_for_current_package (const cmt_string ¤t_dir) |
Macros to be defined once current_package is known and even before reading its requirements file. | |
Private Attributes | |
cmt_string | fs |
cmt_string | buffer |
CmtSystem::cmt_string_vector | vb |
cmt_string | pwd |
Use * | current_use |
cmt_string | current_tag |
cmt_string | current_package |
cmt_string | current_version |
cmt_string | current_prefix |
CmtDirStyle | current_style |
Definition at line 6165 of file cmt_parser.cxx.
|
Definition at line 6180 of file cmt_parser.cxx. References buffer, Use::current(), current_package, current_prefix, current_style, current_tag, current_use, current_version, CmtSystem::file_separator(), fs, CmtSystem::pwd(), pwd, CmtSystem::split(), and vb.
06185 { 06186 fs = CmtSystem::file_separator (); 06187 buffer = ""; 06188 pwd = CmtSystem::pwd (); 06189 CmtSystem::split (pwd, fs, vb); 06190 current_use = &(Use::current ()); 06191 current_tag = tag; 06192 current_package = package; 06193 current_version = version; 06194 current_prefix = prefix; 06195 current_style = style; 06196 } |
|
Definition at line 6198 of file cmt_parser.cxx. References buffer, current_use, and SyntaxParser::parse_requirements_line(). Referenced by fill_for_all_constituents(), fill_for_branches(), fill_for_CMTVERSION(), fill_for_fincludes(), fill_for_includes(), fill_for_package(), fill_for_project(), fill_for_tag(), fill_for_use_cflags(), fill_for_use_cppflags(), fill_for_use_fflags(), fill_for_use_fincludes(), fill_for_use_includes(), fill_for_use_libraries(), fill_for_use_linkopts(), fill_for_use_pp_cflags(), fill_for_use_pp_cppflags(), fill_for_use_pp_fflags(), fill_for_use_requirements(), and fill_for_use_stamps().
06199 { 06200 SyntaxParser::parse_requirements_line (buffer, current_use); 06201 buffer = ""; 06202 } |
|
Macros specific to constituents. This includes the compiler flags and fills in these macros from uses packages. This takes care of -no_auto_imports and -import= directives _use_linkopts _<constituent>_cflags _<constituent>_pp_cflags _<constituent>_cppflags _<constituent>_pp_cppflags _<constituent>_fflags _<constituent>_pp_fflags linkopts _GUID First, finish the parsing of constituent parameters. Prepare the auto_imports states in a vector Now scan all constituents Problem for imports in constituents. 1) use_xxx has holes due to the corresponding -no_auto_imports options attached to some use statements (including the transitive ones) 2) the -import=yyy options provided to a given constituent should restore the appropriate holes as well as all transitive ones. 3) for use_linkopts, missing pieces must be filled at the right position. (for others, order is not relevant while transitive access is required for all) Create a private copy of the state vector. This private copy will be updated according to -import=xxx modifiers for the current constituent. Find all newly exposed packages and precompute this list inside a vector. Setting ${CONSTITUENT}linkopts is a temporary solution until the backward compatibility solution for a proper replacement of use_linkopts by ${CONSTITUENT}_use_linkopts is acheived. Only for linkopts we take care of the order. This means that ${CONSTITUENT}_use_linkopts should be used in place of use_linkopts. (see the application fragments) that ${CONSTITUENT}_use_linkopts will be used in place of use_linkopts. Definition at line 6783 of file cmt_parser.cxx. References Application, apply(), Use::auto_imports, buffer, Constituent::constituents(), Constituent::ConstituentVector, current_use, Use::discarded, Document, Use::fill_includes_macro(), Use::fill_macro(), Use::find_index(), Cmt::get_debug(), Package::get_name(), Use::get_ordered_uses(), Use::get_package(), Constituent::imports, Package::is_cmt(), Library, Constituent::name, Off, Constituent::parse_all(), cmt_vector< T >::push_back(), cmt_vector< T >::resize(), Use::set_auto_imports_state(), cmt_vector< T >::size(), Constituent::type, and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06784 { 06786 Constituent::parse_all (); 06787 06788 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06789 06790 const Constituent::ConstituentVector& constituents = 06791 Constituent::constituents (); 06792 06793 06795 06796 cmt_vector<bool> base_auto_imports_states; 06797 06798 base_auto_imports_states.resize (Uses.size ()); 06799 06800 int number; 06801 06802 for (number = 0; number < Uses.size (); number++) 06803 { 06804 Use* use = Uses[number]; 06805 base_auto_imports_states[number] = (use->auto_imports != Off); 06806 } 06807 06809 06810 for (number = 0; number < constituents.size (); number++) 06811 { 06812 const Constituent& constituent = constituents[number]; 06813 06814 if (Cmt::get_debug ()) 06815 { 06816 cout << "Checking " << constituent.name << " against imports requests" << endl; 06817 } 06818 06819 Use::UsePtrVector imports; 06820 int i; 06821 06839 if (constituent.type == Document) continue; 06840 if (constituent.imports.size () == 0) 06841 { 06842 buffer = "macro_append "; 06843 buffer += constituent.name; 06844 buffer += "_use_linkopts "; 06845 buffer += " \" "; 06846 06847 current_use->fill_macro (buffer, "linkopts"); 06848 06849 for (i = 0; i < Uses.size (); i++) 06850 { 06851 if (base_auto_imports_states[i]) 06852 { 06853 Use* u = Uses[i]; 06854 06855 if (u->discarded) continue; 06856 06857 Package* p = u->get_package (); 06858 if (p->is_cmt ()) continue; 06859 06860 u->fill_macro (buffer, "linkopts"); 06861 } 06862 } 06863 buffer += "\""; 06864 apply (); 06865 06866 /* 06867 buffer = "macro_append "; 06868 buffer += constituent.name; 06869 buffer += "_use_linkopts "; 06870 06871 buffer += " \" $(use_linkopts)\""; 06872 apply (); 06873 */ 06874 06875 continue; 06876 } 06877 06883 cmt_vector<bool> auto_imports_states (base_auto_imports_states); 06884 06885 for (i = 0; i < constituent.imports.size (); i++) 06886 { 06887 const cmt_string& import = constituent.imports[i]; 06888 06889 // 06890 // Resolve the imported uses 06891 // 06892 06893 int use_index = Use::find_index (import, "", ""); 06894 06895 if (use_index >= 0) 06896 { 06897 Use* u = Uses[use_index]; 06898 06899 if (u->discarded) continue; 06900 06901 if (Cmt::get_debug ()) 06902 { 06903 cout << constituent.name << " needs imports " << import << " " 06904 << use_index << " " 06905 << u->get_package()->get_name() << endl; 06906 } 06907 06908 Package* p = u->get_package (); 06909 if (p->is_cmt ()) continue; 06910 06911 if (u->auto_imports != Off) continue; 06912 06913 Use::set_auto_imports_state (use_index, auto_imports_states); 06914 } 06915 } 06916 06917 if (Cmt::get_debug ()) 06918 { 06919 cout << constituent.name << " has imports " << endl; 06920 } 06921 06922 06927 for (i = 0; i < base_auto_imports_states.size (); i++) 06928 { 06929 if (auto_imports_states[i] != base_auto_imports_states[i]) 06930 { 06931 Use* u = Uses[i]; 06932 06933 if (u->discarded) continue; 06934 06935 Package* p = u->get_package (); 06936 if (p->is_cmt ()) continue; 06937 06938 if (Cmt::get_debug ()) 06939 { 06940 cout << constituent.name << " has import " << p->get_name () << endl; 06941 } 06942 06943 if (u->auto_imports != Off) continue; 06944 06945 imports.push_back (u); 06946 } 06947 } 06948 06949 if (imports.size () == 0) continue; 06950 06951 cmt_string prefix; 06952 06953 // 06954 // Documents are not considered 06955 // 06956 switch (constituent.type) 06957 { 06958 case Application: 06959 prefix = "app_"; 06960 break; 06961 case Library: 06962 prefix = "lib_"; 06963 break; 06964 } 06965 06966 buffer = "macro_append "; 06967 buffer += prefix; 06968 buffer += constituent.name; 06969 buffer += "_cflags "; 06970 buffer += " \' "; 06971 for (i = 0; i < imports.size (); i++) 06972 { 06973 Use* u = imports[i]; 06974 06975 u->fill_includes_macro (buffer); 06976 u->fill_macro (buffer, "cflags"); 06977 } 06978 buffer += "\'"; 06979 apply (); 06980 06981 buffer = "macro_append "; 06982 buffer += prefix; 06983 buffer += constituent.name; 06984 buffer += "_pp_cflags "; 06985 buffer += " \" "; 06986 for (i = 0; i < imports.size (); i++) 06987 { 06988 Use* u = imports[i]; 06989 06990 u->fill_macro (buffer, "pp_cflags"); 06991 } 06992 buffer += "\""; 06993 apply (); 06994 06995 buffer = "macro_append "; 06996 buffer += prefix; 06997 buffer += constituent.name; 06998 buffer += "_cppflags "; 06999 buffer += " \' "; 07000 for (i = 0; i < imports.size (); i++) 07001 { 07002 Use* u = imports[i]; 07003 07004 u->fill_includes_macro (buffer); 07005 u->fill_macro (buffer, "cppflags"); 07006 } 07007 buffer += "\'"; 07008 apply (); 07009 07010 buffer = "macro_append "; 07011 buffer += prefix; 07012 buffer += constituent.name; 07013 buffer += "_pp_cppflags "; 07014 buffer += " \" "; 07015 for (i = 0; i < imports.size (); i++) 07016 { 07017 Use* u = imports[i]; 07018 07019 u->fill_macro (buffer, "pp_cppflags"); 07020 } 07021 buffer += "\""; 07022 apply (); 07023 07024 buffer = "macro_append "; 07025 buffer += prefix; 07026 buffer += constituent.name; 07027 buffer += "_fflags "; 07028 buffer += " \' "; 07029 for (i = 0; i < imports.size (); i++) 07030 { 07031 Use* u = imports[i]; 07032 07033 u->fill_includes_macro (buffer); 07034 u->fill_macro (buffer, "fflags"); 07035 } 07036 buffer += "\'"; 07037 apply (); 07038 07039 buffer = "macro_append "; 07040 buffer += prefix; 07041 buffer += constituent.name; 07042 buffer += "_pp_fflags "; 07043 buffer += " \" "; 07044 for (i = 0; i < imports.size (); i++) 07045 { 07046 Use* u = imports[i]; 07047 07048 u->fill_macro (buffer, "pp_fflags"); 07049 } 07050 buffer += "\""; 07051 apply (); 07052 07060 buffer = "macro_append "; 07061 buffer += constituent.name; 07062 buffer += "linkopts "; 07063 buffer += " \" "; 07064 for (i = 0; i < imports.size (); i++) 07065 { 07066 Use* u = imports[i]; 07067 07068 u->fill_macro (buffer, "linkopts"); 07069 } 07070 buffer += "\""; 07071 apply (); 07072 07080 buffer = "macro_append "; 07081 buffer += constituent.name; 07082 buffer += "_use_linkopts "; 07083 buffer += " \" "; 07084 07085 current_use->fill_macro (buffer, "linkopts"); 07086 07087 for (i = 0; i < Uses.size (); i++) 07088 { 07089 if (auto_imports_states[i]) 07090 { 07091 Use* u = Uses[i]; 07092 07093 if (u->discarded) continue; 07094 07095 Package* p = u->get_package (); 07096 if (p->is_cmt ()) continue; 07097 07098 u->fill_macro (buffer, "linkopts"); 07099 } 07100 } 07101 buffer += "\""; 07102 apply (); 07103 07104 //==== GLAST addition for vs.net ========== 07105 buffer = "macro "; 07106 buffer += constituent.name; 07107 buffer += "_GUID \"{88BF15AB-5A2D-4bea-B64F-02752C2A1F4F}\" "; 07108 apply (); 07109 } 07110 } |
|
srcdir src =/ inc mgrdir mgr =..// bin javabin doc version package _project _cmtpath _offset package_cmtpath package_offset project Basic macros (src, mgr, ...) Definition at line 6278 of file cmt_parser.cxx. References apply(), buffer, Cmt::configure_current_cmtpath(), current_package, current_style, fs, Symbol::is_selected(), mgr_style, and none_style. Referenced by Cmt::set_standard_macros().
06279 { 06284 if (current_style == none_style) 06285 { 06286 buffer = "macro srcdir \"."; 06287 buffer += "\""; 06288 apply (); 06289 06290 buffer = "macro src \"."; 06291 buffer += fs; 06292 buffer += "\""; 06293 apply (); 06294 06295 buffer = "macro inc \"."; 06296 buffer += fs; 06297 buffer += "\""; 06298 apply (); 06299 06300 buffer = "macro mgr \"."; 06301 buffer += fs; 06302 buffer += "\""; 06303 apply (); 06304 06305 buffer = "macro bin \"."; 06306 buffer += fs; 06307 buffer += "\""; 06308 apply (); 06309 06310 buffer = "macro javabin \"."; 06311 buffer += fs; 06312 buffer += "\""; 06313 apply (); 06314 06315 buffer = "macro doc \"."; 06316 buffer += fs; 06317 buffer += "\""; 06318 apply (); 06319 } 06320 else 06321 { 06322 if (!Symbol::is_selected ("srcdir")) 06323 { 06324 buffer = "macro srcdir \".."; 06325 buffer += fs; 06326 buffer += "src"; 06327 buffer += "\""; 06328 apply (); 06329 } 06330 06331 if (!Symbol::is_selected ("src")) 06332 { 06333 buffer = "macro src \".."; 06334 buffer += fs; 06335 buffer += "src"; 06336 buffer += fs; 06337 buffer += "\""; 06338 apply (); 06339 } 06340 06341 if (!Symbol::is_selected ("inc")) 06342 { 06343 buffer = "macro inc \".."; 06344 buffer += fs; 06345 buffer += "src"; 06346 buffer += fs; 06347 buffer += "\""; 06348 apply (); 06349 } 06350 06351 if (!Symbol::is_selected ("doc")) 06352 { 06353 buffer = "macro doc \".."; 06354 buffer += fs; 06355 buffer += "doc"; 06356 buffer += fs; 06357 buffer += "\""; 06358 apply (); 06359 } 06360 06361 if (!Symbol::is_selected ("bin")) 06362 { 06363 cmt_string package_tag = current_package; 06364 package_tag += "_tag"; 06365 06366 buffer = "macro bin \".."; 06367 buffer += fs; 06368 buffer += "$("; 06369 buffer += package_tag; 06370 buffer += ")"; 06371 buffer += fs; 06372 buffer += "\""; 06373 apply (); 06374 } 06375 06376 if (!Symbol::is_selected ("javabin")) 06377 { 06378 buffer = "macro javabin \".."; 06379 buffer += fs; 06380 buffer += "classes"; 06381 buffer += fs; 06382 buffer += "\""; 06383 apply (); 06384 } 06385 06386 if (current_style == mgr_style) 06387 { 06388 buffer = "macro mgrdir \"mgr\""; 06389 apply (); 06390 06391 buffer = "macro mgr \".."; 06392 buffer += fs; 06393 buffer += "mgr"; 06394 buffer += fs; 06395 buffer += "\""; 06396 apply (); 06397 } 06398 else 06399 { 06400 buffer = "macro mgrdir \"cmt\""; 06401 apply (); 06402 06403 buffer = "macro mgr \".."; 06404 buffer += fs; 06405 buffer += "cmt"; 06406 buffer += fs; 06407 buffer += "\""; 06408 apply (); 06409 } 06410 06411 Cmt::configure_current_cmtpath (); 06412 } 06413 } |
|
CMTVERSION.
Definition at line 6172 of file cmt_parser.cxx. References apply(), buffer, and CMTVERSION.
06173 { 06174 buffer = "macro CMTVERSION \""; 06175 buffer += CMTVERSION; 06176 buffer += "\""; 06177 apply (); 06178 } |
|
Macros implied or required to manage constituents.
Definition at line 7115 of file cmt_parser.cxx. References Constituent::constituents(), Constituent::ConstituentVector, current_use, Constituent::group, Group::groups(), Group::GroupVector, Symbol::is_selected(), Group::name(), Constituent::name, SyntaxParser::parse_requirements_line(), and cmt_vector< T >::size(). Referenced by Cmt::set_standard_macros().
07116 { 07117 int number; 07118 cmt_string temp; 07119 07120 const Constituent::ConstituentVector& constituents = Constituent::constituents (); 07121 07122 if (!Symbol::is_selected ("constituents")) 07123 { 07124 temp = "macro_append constituents \" "; 07125 07126 for (number = 0; number < constituents.size (); number++) 07127 { 07128 const Constituent& constituent = constituents[number]; 07129 07130 if (constituent.group == 0) 07131 { 07132 temp += constituent.name; 07133 temp += " "; 07134 } 07135 } 07136 07137 temp += "\""; 07138 07139 SyntaxParser::parse_requirements_line (temp, current_use); 07140 } 07141 07142 SyntaxParser::parse_requirements_line ("macro_append all_constituents \" $(constituents)\"", 07143 current_use); 07144 07145 if (!Symbol::is_selected ("constituentsclean")) 07146 { 07147 temp = "macro_append constituentsclean \" "; 07148 07149 for (number = constituents.size () - 1; number >= 0 ; number--) 07150 { 07151 const Constituent& constituent = constituents[number]; 07152 07153 if (constituent.group == 0) 07154 { 07155 temp += constituent.name; 07156 temp += "clean "; 07157 } 07158 } 07159 07160 temp += "\""; 07161 07162 SyntaxParser::parse_requirements_line (temp, current_use); 07163 } 07164 07165 SyntaxParser::parse_requirements_line ("macro_append all_constituentsclean \" $(constituentsclean)\"", 07166 current_use); 07167 07168 const Group::GroupVector& groups = Group::groups (); 07169 07170 for (number = 0; number < groups.size (); number++) 07171 { 07172 const Group& group = groups[number]; 07173 07174 temp = "macro_append "; 07175 temp += group.name (); 07176 temp += "_constituents \" "; 07177 07178 int i; 07179 07180 for (i = 0; i < constituents.size (); i++) 07181 { 07182 const Constituent& constituent = constituents[i]; 07183 07184 if ((constituent.group != 0) && 07185 (group.name () == constituent.group->name ())) 07186 { 07187 temp += constituent.name; 07188 temp += " "; 07189 } 07190 } 07191 07192 temp += "\""; 07193 07194 SyntaxParser::parse_requirements_line (temp, current_use); 07195 07196 temp = "macro_append "; 07197 temp += group.name (); 07198 temp += "_constituentsclean \" "; 07199 07200 for (i = constituents.size () - 1; i >= 0 ; i--) 07201 { 07202 const Constituent& constituent = constituents[i]; 07203 07204 if ((constituent.group != 0) && 07205 (group.name () == constituent.group->name ())) 07206 { 07207 temp += constituent.name; 07208 temp += "clean "; 07209 } 07210 } 07211 07212 temp += "\""; 07213 07214 SyntaxParser::parse_requirements_line (temp, current_use); 07215 } 07216 } |
|
Macros to be defined once current_package is known and even before reading its requirements file.
Definition at line 7239 of file cmt_parser.cxx. References fill_for_package(), and fill_for_tag(). Referenced by Cmt::set_standard_macros().
07240 { 07241 fill_for_tag (); 07242 fill_for_package (current_dir); 07243 } |
|
fincludes
Definition at line 6753 of file cmt_parser.cxx. References apply(), buffer, Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06754 { 06755 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06756 06757 if (Uses.size () == 0) return; 06758 06759 if (!Symbol::is_selected ("fincludes")) 06760 { 06761 buffer = "macro_append fincludes \" $(includes)\""; 06762 apply (); 06763 } 06764 } |
|
includes
Definition at line 6710 of file cmt_parser.cxx. References apply(), buffer, Use::current(), Use::get_ordered_uses(), Use::include_path, Use::includes, Symbol::is_selected(), Include::name, cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06711 { 06712 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06713 06714 if (Uses.size () == 0) return; 06715 06716 if (!Symbol::is_selected ("includes")) 06717 { 06718 buffer = "macro_append includes \' "; 06719 06720 Use& use = Use::current(); 06721 06722 if (use.include_path == "") 06723 { 06724 buffer += "$(ppcmd)\"$(srcdir)\" "; 06725 } 06726 else if (use.include_path != "none") 06727 { 06728 buffer += "$(ppcmd)\""; 06729 buffer += use.include_path; 06730 buffer += "\" "; 06731 } 06732 06733 for (int include_number = 0; 06734 include_number < use.includes.size (); 06735 include_number++) 06736 { 06737 Include& incl = use.includes[include_number]; 06738 06739 buffer += "$(ppcmd)\""; 06740 buffer += incl.name; 06741 buffer += "\" "; 06742 } 06743 06744 buffer += "$(use_includes)\'"; 06745 06746 apply (); 06747 } 06748 } |
|
Definitions for installation area mechanisms. Apply all cmtpath patterns Definition at line 7221 of file cmt_parser.cxx. References CmtPathPattern::apply_all(), get_strategy(), CmtInstallAreaMgr::instance(), and CmtInstallAreaMgr::setup(). Referenced by Cmt::set_standard_macros().
07222 { 07223 CmtPathPattern::apply_all (); 07224 07225 if (get_strategy ("InstallArea")) 07226 { 07227 CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance (); 07228 07229 //cout << "#IA7>" << endl; 07230 07231 ia_mgr.setup (); 07232 } 07233 } |
|
PACKAGE_ROOT.
Definition at line 6235 of file cmt_parser.cxx. References apply(), buffer, current_package, current_prefix, current_version, and Symbol::is_selected(). Referenced by fill_for_current_package().
06236 { 06237 buffer = "macro package \""; 06238 buffer += current_package; 06239 buffer += "\""; 06240 apply (); 06241 06242 buffer = "macro version \""; 06243 buffer += current_version; 06244 buffer += "\""; 06245 apply (); 06246 06247 if (!Symbol::is_selected ("PACKAGE_ROOT")) 06248 { 06249 buffer = "macro PACKAGE_ROOT \"$("; 06250 buffer += current_prefix; 06251 buffer += "ROOT"; 06252 buffer += ")\""; 06253 06254 apply (); 06255 } 06256 } |
|
project
Definition at line 6418 of file cmt_parser.cxx. References apply(), buffer, current_style, Project::get_current(), Project::get_name(), and none_style. Referenced by Cmt::set_standard_macros().
06419 { 06420 if (current_style == none_style) return; 06421 06422 cmt_string project_name; 06423 Project* project = Project::get_current (); 06424 if (project != 0) 06425 { 06426 project_name = project->get_name (); 06427 } 06428 06429 buffer = "macro project \""; 06430 buffer += project_name; 06431 buffer += "\""; 06432 apply (); 06433 } |
|
tag
Definition at line 6207 of file cmt_parser.cxx. References apply(), buffer, current_tag, Symbol::is_selected(), and CmtSystem::testenv(). Referenced by fill_for_current_package().
06208 { 06209 static bool tag_debug = CmtSystem::testenv ("TAGDEBUG"); 06210 06211 if (!Symbol::is_selected ("tag")) 06212 { 06213 if (tag_debug) cerr << "set_standard_macro2.1> current_tag=" << current_tag << endl; 06214 06215 if (current_tag == "") 06216 { 06217 buffer = "macro tag \"$(CMTCONFIG)\""; 06218 } 06219 else 06220 { 06221 buffer = "macro tag \""; 06222 buffer += current_tag; 06223 buffer += "\""; 06224 } 06225 06226 if (tag_debug) cerr << " define tag: " << buffer << endl; 06227 06228 apply (); 06229 } 06230 } |
|
use_cflags
Definition at line 6567 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06568 { 06569 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06570 06571 if (Uses.size () == 0) return; 06572 06573 if (!Symbol::is_selected ("use_cflags")) 06574 { 06575 Use::fill_macro_all (buffer, "cflags"); 06576 apply (); 06577 } 06578 } |
|
use_cppflags
Definition at line 6599 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06600 { 06601 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06602 06603 if (Uses.size () == 0) return; 06604 06605 if (!Symbol::is_selected ("use_cppflags")) 06606 { 06607 Use::fill_macro_all (buffer, "cppflags"); 06608 apply (); 06609 } 06610 } |
|
use_fflags
Definition at line 6631 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06632 { 06633 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06634 06635 if (Uses.size () == 0) return; 06636 06637 if (!Symbol::is_selected ("use_fflags")) 06638 { 06639 Use::fill_macro_all (buffer, "fflags"); 06640 apply (); 06641 } 06642 } |
|
use_fincludes
Definition at line 6519 of file cmt_parser.cxx. References apply(), buffer, Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06520 { 06521 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06522 06523 if (Uses.size () == 0) return; 06524 06525 if (!Symbol::is_selected ("use_fincludes")) 06526 { 06527 buffer = "macro_append use_fincludes \" $(use_includes)\""; 06528 apply (); 06529 } 06530 } |
|
use_includes
Definition at line 6479 of file cmt_parser.cxx. References apply(), Use::auto_imports, buffer, Use::discarded, Use::fill_includes_macro(), Cmt::get_debug(), Use::get_ordered_uses(), Use::get_package(), Use::get_package_name(), Package::is_cmt(), Symbol::is_selected(), Off, cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06480 { 06481 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06482 06483 if (Uses.size () == 0) return; 06484 06485 if (!Symbol::is_selected ("use_includes")) 06486 { 06487 buffer = "macro_append use_includes \' "; 06488 06489 for (int number = 0; number < Uses.size (); number++) 06490 { 06491 Use* use = Uses[number]; 06492 06493 if (use->discarded) continue; 06494 06495 Package* p = use->get_package (); 06496 if (p->is_cmt ()) continue; 06497 06498 if (Cmt::get_debug ()) 06499 { 06500 cout << "fill use_includes for " << use->get_package_name () 06501 << " discarded=" << use->discarded 06502 << " auto_imports=" << use->auto_imports << endl; 06503 } 06504 06505 if (use->auto_imports == Off) continue; 06506 06507 use->fill_includes_macro (buffer); 06508 } 06509 06510 buffer += "\'"; 06511 06512 apply (); 06513 } 06514 } |
|
use_libraries
Definition at line 6679 of file cmt_parser.cxx. References apply(), buffer, Use::discarded, Use::fill_macro(), Use::get_ordered_uses(), Use::get_package(), Package::is_cmt(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06680 { 06681 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06682 06683 if (Uses.size () == 0) return; 06684 06685 if (!Symbol::is_selected ("use_libraries")) 06686 { 06687 buffer = "macro use_libraries \""; 06688 06689 for (int number = 0; number < Uses.size (); number++) 06690 { 06691 Use* use = Uses[number]; 06692 06693 if (use->discarded) continue; 06694 06695 Package* p = use->get_package (); 06696 if (p->is_cmt ()) continue; 06697 06698 use->fill_macro (buffer, "libraries"); 06699 } 06700 06701 buffer += "\""; 06702 06703 apply (); 06704 } 06705 } |
|
use_linkopts
Definition at line 6663 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06664 { 06665 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06666 06667 if (Uses.size () == 0) return; 06668 06669 if (!Symbol::is_selected ("use_linkopts")) 06670 { 06671 Use::fill_macro_all (buffer, "linkopts"); 06672 apply (); 06673 } 06674 } |
|
use_pp_cflags
Definition at line 6583 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06584 { 06585 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06586 06587 if (Uses.size () == 0) return; 06588 06589 if (!Symbol::is_selected ("use_pp_cflags")) 06590 { 06591 Use::fill_macro_all (buffer, "pp_cflags"); 06592 apply (); 06593 } 06594 } |
|
use_pp_cppflags
Definition at line 6615 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06616 { 06617 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06618 06619 if (Uses.size () == 0) return; 06620 06621 if (!Symbol::is_selected ("use_pp_cppflags")) 06622 { 06623 Use::fill_macro_all (buffer, "pp_cppflags"); 06624 apply (); 06625 } 06626 } |
|
use_pp_fflags
Definition at line 6647 of file cmt_parser.cxx. References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06648 { 06649 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06650 06651 if (Uses.size () == 0) return; 06652 06653 if (!Symbol::is_selected ("use_pp_fflags")) 06654 { 06655 Use::fill_macro_all (buffer, "pp_fflags"); 06656 apply (); 06657 } 06658 } |
|
use_requirements
Definition at line 6438 of file cmt_parser.cxx. References apply(), buffer, Use::discarded, fs, Use::get_ordered_uses(), Symbol::is_selected(), Use::located(), mgr_style, Use::prefix, cmt_vector< T >::size(), Use::style, and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06439 { 06440 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06441 06442 if (Uses.size () == 0) return; 06443 06444 if (!Symbol::is_selected ("use_requirements")) 06445 { 06446 buffer = "macro use_requirements \""; 06447 buffer += "requirements "; 06448 06449 for (int number = 0; number < Uses.size (); number++) 06450 { 06451 Use* use = Uses[number]; 06452 06453 if (use->discarded) continue; 06454 06455 if (use->located ()) 06456 { 06457 buffer += "$("; 06458 buffer += use->prefix; 06459 buffer += "ROOT)"; 06460 buffer += fs; 06461 06462 if (use->style == mgr_style) buffer += "mgr"; 06463 else buffer += "cmt"; 06464 06465 buffer += fs; 06466 buffer += "requirements "; 06467 } 06468 } 06469 06470 buffer += "\""; 06471 06472 apply (); 06473 } 06474 } |
|
use_stamps
Definition at line 6535 of file cmt_parser.cxx. References apply(), buffer, Use::current(), Use::discarded, Use::fill_macro(), Use::get_ordered_uses(), Use::get_package(), Package::is_cmt(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector. Referenced by Cmt::set_standard_macros().
06536 { 06537 Use::UsePtrVector& Uses = Use::get_ordered_uses (); 06538 06539 if (Uses.size () == 0) return; 06540 06541 if (!Symbol::is_selected ("use_stamps")) 06542 { 06543 buffer = "macro use_stamps \""; 06544 (Use::current()).fill_macro (buffer, "stamps"); 06545 06546 for (int number = 0; number < Uses.size (); number++) 06547 { 06548 Use* use = Uses[number]; 06549 06550 if (use->discarded) continue; 06551 06552 Package* p = use->get_package (); 06553 if (p->is_cmt ()) continue; 06554 06555 use->fill_macro (buffer, "stamps"); 06556 } 06557 06558 buffer += "\""; 06559 06560 apply (); 06561 } 06562 } |
|
|
Definition at line 7252 of file cmt_parser.cxx. Referenced by fill_for_branches(), fill_for_package(), and StandardMacroBuilder(). |
|
Definition at line 7254 of file cmt_parser.cxx. Referenced by fill_for_package(), and StandardMacroBuilder(). |
|
Definition at line 7255 of file cmt_parser.cxx. Referenced by fill_for_branches(), fill_for_project(), and StandardMacroBuilder(). |
|
Definition at line 7251 of file cmt_parser.cxx. Referenced by fill_for_tag(), and StandardMacroBuilder(). |
|
Definition at line 7250 of file cmt_parser.cxx. Referenced by apply(), fill_for_all_constituents(), fill_for_constituent_macros(), and StandardMacroBuilder(). |
|
Definition at line 7253 of file cmt_parser.cxx. Referenced by fill_for_package(), and StandardMacroBuilder(). |
|
Definition at line 7246 of file cmt_parser.cxx. Referenced by fill_for_branches(), fill_for_use_requirements(), and StandardMacroBuilder(). |
|
Definition at line 7249 of file cmt_parser.cxx. Referenced by StandardMacroBuilder(). |
|
Definition at line 7248 of file cmt_parser.cxx. Referenced by StandardMacroBuilder(). |