---

Use Class Reference

#include <cmt_use.h>

Collaboration diagram for Use:

[legend]List of all members.

Public Types
typedef cmt_vector<Use>	UseVector
typedef cmt_vector<Use*>	UsePtrVector
Public Methods
	Use ()
	Use (const cmt_string& new_package, const cmt_string& new_version, const cmt_string& new_path)
	~Use ()
void	set (const cmt_string& new_package, const cmt_string& new_version, const cmt_string& new_path, const cmt_string& new_version_alias = "", const cmt_string& new_path_alias = "")
void	author_action (const CmtSystem::cmt_string_vector& words)
void	manager_action (const CmtSystem::cmt_string_vector& words)
bool	move_to ()
void	discard ()
	Get the previous set of effective use statements that might have been obtained in a previous build. More...
void	undiscard ()
void	apply_global_patterns ()
void	set_include_path (const cmt_string& new_path)
void	get_full_path (cmt_string& s) const
	Compute the full real path of a found package. More...
cmt_string	get_full_path () const
	Compute the full real path of a found package. More...
void	reduce_path (cmt_string& s) const
	Considering a given path, try and reduce the part of it that corresponds to the full path of this package into its normal form ${<PACKAGE>ROOT} The argument is modified if the pattern is exactly found. More...
void	fill_includes_macro (cmt_string& buffer) const
void	fill_macro (cmt_string& buffer, const cmt_string& suffix) const
bool	get_paths (Use* to, UsePtrVector& list)
bool	located () const
void	change_path (const cmt_string& path)
void	set_auto_imports (State new_state)
void	set_native_version (bool state)
bool	has_native_version () const
Public Attributes
cmt_string	package
cmt_string	specified_version
cmt_string	specified_path
cmt_string	version_alias
cmt_string	path_alias
cmt_string	author
cmt_string	manager
cmt_string	path
cmt_string	version
cmt_string	real_path
CmtDirStyle	style
cmt_string	prefix
ScopeType	scope
bool	done
bool	discarded
bool	selected
State	auto_imports
Include::IncludeVector	includes
cmt_string	include_path
Script::ScriptVector	scripts
ApplyPattern::ApplyPatternVector	apply_patterns
IgnorePattern::IgnorePatternVector	ignore_patterns
Static Public Methods
Use*	action (const CmtSystem::cmt_string_vector& words, Use* use)
Use*	find (const cmt_string& package, const cmt_string& version = "", const cmt_string& path = "")
int	find_index (const cmt_string& package, const cmt_string& version, const cmt_string& path)
void	set_auto_imports_state (int use_index, cmt_vector<bool>& auto_imports_states)
	1) Given a Use object identified by its index in the uses() array, 2) Given a vector of states containing the auto_imports states of all Uses,. More...
Use*	add (const cmt_string& path, const cmt_string& package, const cmt_string& version, const cmt_string& version_alias, const cmt_string& path_alias, Use* context_use, State specified_auto_imports = Unspecified)
void	move (Use* use1)
	Here, use points to a Use object which had been declared as no_auto_imports. More...
void	reorder (Use* use1, Use* use2)
	Reorder use1 versus use2 in the UsePtrVector list, so that the order reflects the fact that use2 makes use of use1. More...
void	select_clients (const cmt_string& package, const cmt_string& version)
	Mark all clients of the current package. More...
void	show_all (bool skip_discarded = false)
void	show_all (const cmt_string& prefix, bool skip_discarded = false)
Use&	current ()
const Use&	const_current ()
UseVector&	all_uses ()
UsePtrVector&	uses ()
void	clear_all ()
void	unselect_all ()
void	undiscard_all ()
void	fill_macro_all (cmt_string& buffer, const cmt_string& suffix)
Private Methods
void	clear ()
int	reach_package (const cmt_string& current_path)
void	select ()
void	unselect ()
bool	is_selected ()
bool	is_client (const cmt_string& package, const cmt_string& version)
	Check if the package makes use of the specified package/version. More...
void	show_sub_uses (bool skip_discarded = false)
bool	select_alternate ()
Use*	get_selected_version ()
	This function tries to get the replacement of a Use when it has been discarded by a better match to version constraints. More...
Private Attributes
bool	m_located
bool	m_has_native_version
UsePtrVector	sub_uses
cmt_vector<ScopeType>	sub_use_scopes
cmt_vector<State>	sub_use_auto_imports
CmtSystem::cmt_string_vector	alternate_versions
CmtSystem::cmt_string_vector	alternate_paths
Static Private Methods
Use*	create (const cmt_string& path, const cmt_string& package, const cmt_string& version, const cmt_string& version_alias, const cmt_string& path_alias)
bool	need_new (const cmt_string& path, const cmt_string& package, const cmt_string& version, Use** old_use)

---

Member Typedef Documentation

typedef cmt_vector<Use*> Use::UsePtrVector

Definition at line 12 of file cmt_use.h.

typedef cmt_vector<Use> Use::UseVector

Definition at line 11 of file cmt_use.h.

---

Constructor & Destructor Documentation

Use::Use ( )

Definition at line 934 of file cmt_use.cxx. { done = false; discarded = false; auto_imports = Unspecified; clear (); }

Use::Use ( const cmt_string & new_package, const cmt_string & new_version, const cmt_string & new_path )

Definition at line 944 of file cmt_use.cxx. { auto_imports = Unspecified; m_located = false; set (new_package, new_version, new_path); }

Use::~Use ( )

Definition at line 954 of file cmt_use.cxx. { clear (); }

---

Member Function Documentation

Use * Use::action ( const CmtSystem::cmt_string_vector & words, Use * parent ) [static]

Definition at line 525 of file cmt_use.cxx. Referenced by Cmt::select(). { Use* new_use; // // complete syntax : "use <package> <version> <path>" // minimal syntax : "use <package>" // // o if <version> is omitted then take any version available // o <version> can be specified using "v*" or "v<n>r*" or "v<n>r<m>p*" // // o the notation "v*" is preferred to omission (particularly since // omission does not permit <path>) // if (words.size () < 2) return (0); use_action_iterator it; for (int i = 1; i < words.size (); i++) { const cmt_string& w = words[i]; cmt_string ew = w; Symbol::expand (ew); if (ew != w) { CmtSystem::cmt_string_vector ws; CmtSystem::split (ew, " ", ws); for (int j = 0; j < ws.size (); ++j) { const cmt_string& ww = ws[j]; it.set (ww); } } else { it.set (ew); } } if (!it.ok ()) return (0); static int level = 0; level++; new_use = it.get_use (parent); level--; return (new_use); }

Use * Use::add ( const cmt_string & path, const cmt_string & package, const cmt_string & version, const cmt_string & version_alias, const cmt_string & path_alias, Use * context_use, State specified_auto_imports = Unspecified ) [static]

Definition at line 1548 of file cmt_use.cxx. Referenced by use_action_iterator::get_use(), Cmt::use_cmt(), Cmt::use_home_requirements(), and Cmt::use_user_context_requirements(). { static UsePtrVector& Uses = uses (); bool do_need_new = false; Use* old_use = 0; Use* use = 0; do_need_new = need_new (path, package, version, &old_use); /* if (old_use != 0) { cout << "add> old_use " << old_use->package << " " << old_use->version << " " << old_use->path << endl; } */ if (do_need_new) { use = create (path, package, version, version_alias, path_alias); } else { // Since we don't need a new Use, it means that old_use exists ! use = old_use; old_use = 0; } if (package == CmtSystem::get_home_package ()) { return (use); } if (package == CmtSystem::get_user_context_package ()) { return (use); } cmt_string here = CmtSystem::pwd (); // // Store the specified sub_uses. Some of them may become discarded // later on. // if (context_use != 0) { context_use->sub_uses.push_back (use); context_use->sub_use_scopes.push_back (Cmt::get_scope ()); context_use->sub_use_auto_imports.push_back (specified_auto_imports); if (Cmt::get_debug ()) { cout << "Use::add context(" << context_use->package << ") " << "[u:" << package << " s:" << Cmt::get_scope () << " ai:" << specified_auto_imports << "]" << endl; } } /* * Now we have a Use object. If it is a new one, we have to * 1) understand if it exists physically * 2) it is better than the old ones. * * Here, we may have : * 1) old_use = 0 * there was no Use object before for this package * the existing one is fine * * 2) old_use != 0 * we have created a new Use (which has to be validated) */ bool found = use->move_to (); if (Cmt::get_debug ()) { cout << "add> use " << use->package << " " << use->version << " " << use->path << " found=" << found << endl; } if (!found) { if (!Cmt::get_quiet ()) { cerr << "#(Warning) package " << use->package << " " << use->version << " " << use->path << " not found" << endl; } CmtError::set (CmtError::package_not_found, use->package); use = 0; } if ((old_use != 0) && (use != old_use)) { /* * There was another version of this Use. But a new one was created due to * some criteria. * New we are going to apply the version strategy to make the final selection. */ /* if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "") { cout << "select? [" << use << "] vs old_use[" << old_use << "] " << old_use->package << " " << old_use->version << " " << old_use->path << endl; } */ if (!found) { /* * This new Use does not correspond to any physical package. * let's simply discard it */ if (use != 0) use->discard (); use = old_use; found = use->move_to (); } else { // // This new version is different from the old one // thus we have to choose // VersionSelector& selector = VersionSelector::instance (); Use* selected_use = selector.operate (old_use, use); // // Some situations managed by selector.operate happen // to fail discarding the rejected Use. // if (use != selected_use) { use->discard (); } use = selected_use; /* * current directory is moved to the selected one */ found = use->move_to (); } } // // The following statement is no longer considered as useful. // It is commented. But we should clarify why it was really needed! // //use->undiscard (); if (found) { bool registered = false; const Use& cu = Use::current (); // // A pointer to this new object is also added or replaced. // if ((use != &cu) && (package == cu.package)) { // This is a recursive call to the current package!! registered = true; use->done = true; } else { for (int i = 0; i < Uses.size(); i++) { Use* u = Uses[i]; if (u->package == package) { registered = true; Uses[i] = use; break; } } } if (!registered) Uses.push_back (use); if (!use->done && Cmt::get_recursive ()) { use->done = true; /* if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "") { for (int use_index = 0; use_index < Uses.size (); use_index++) { Use* u = (Use*) Uses[use_index]; cout << " use[" << use_index << "] p=" << u->package << " v=" << u->version << " discarded=" << u->discarded << " selected=" << u->selected << endl; } cout << "parsing at " << CmtSystem::pwd () << endl; } */ //Cmt::parse_requirements ("uses.log", use); if (Cmt::get_debug ()) { cout << "Parsing requirements file at " << CmtSystem::pwd () << endl; } Cmt::parse_requirements ("requirements", use); } } CmtSystem::cd (here); return (use); }

Use::UseVector & Use::all_uses ( ) [static]

Definition at line 2300 of file cmt_use.cxx. Referenced by clear_all(), create(), current(), find(), find_index(), and need_new(). { static Database& db = Database::instance (); static UseVector& AllUses = db.all_uses (); return (AllUses); }

void Use::apply_global_patterns ( )

Definition at line 1860 of file cmt_use.cxx. { int i; Pattern::PatternVector& vector = Pattern::patterns (); for (i = 0; i < vector.size (); i++) { Pattern& p = vector[i]; if (p.global) { p.apply (this); } } }

void Use::author_action ( const CmtSystem::cmt_string_vector & words )

Definition at line 579 of file cmt_use.cxx. Referenced by Cmt::select(). { if (author != "") author += "\n"; for (int i = 1; i < words.size (); i++) { const cmt_string& w = words[i]; if (i > 1) author += " "; author += w; } }

void Use::change_path ( const cmt_string & new_path )

Definition at line 1027 of file cmt_use.cxx. Referenced by Cmt::configure(), Cmt::do_config(), move_to(), Cmt::select(), and select_alternate(). { // // This methods changes real_path after an actual location // where this package/version has been found. // real_path = ""; if (new_path != "") { if ((path.size () > 0) && (!CmtSystem::absolute_path (path))) { real_path = new_path; real_path += CmtSystem::file_separator (); real_path += path; } else { real_path = new_path; } // real_path.replace_all ("\\", "/"); } m_located = true; }

void Use::clear ( ) [private]

Definition at line 960 of file cmt_use.cxx. Referenced by Use(), clear_all(), set(), and ~Use(). { specified_path = ""; path = ""; package = ""; version = ""; author = ""; manager = ""; real_path = ""; prefix = ""; style = mgr_style; scope = Cmt::get_scope (); done = false; discarded = false; selected = false; auto_imports = Unspecified; includes.clear (); include_path = ""; scripts.clear (); apply_patterns.clear (); ignore_patterns.clear (); sub_uses.clear (); sub_use_scopes.clear (); sub_use_auto_imports.clear (); alternate_versions.clear (); alternate_paths.clear (); version_alias = ""; path_alias = ""; m_located = false; m_has_native_version = false; }

void Use::clear_all ( ) [static]

Definition at line 851 of file cmt_use.cxx. Referenced by Database::clear(). { static UsePtrVector& Uses = uses (); static UseVector& AllUses = all_uses (); int use_index; for (use_index = 0; use_index < AllUses.size (); use_index++) { Use& use = AllUses[use_index]; use.clear (); } Uses.clear (); AllUses.clear (); }

const Use & Use::const_current ( ) [static]

Definition at line 2292 of file cmt_use.cxx. { const Use& use = Use::current (); return (use); }

Use * Use::create ( const cmt_string & path, const cmt_string & package, const cmt_string & version, const cmt_string & version_alias, const cmt_string & path_alias ) [static, private]

Definition at line 1513 of file cmt_use.cxx. Referenced by add(). { static UseVector& AllUses = all_uses (); // We first look in the database. for (int use_index = 0; use_index < AllUses.size (); use_index++) { Use& use = AllUses[use_index]; if (use.package == package) { if ((use.specified_version == version) && (use.specified_path == path)) return (&use); } } // We now really create a new Use entry. Use& use_object = AllUses.add (); use_object.set (package, version, path, version_alias, path_alias); return (&use_object); }

Use & Use::current ( ) [static]

Definition at line 2277 of file cmt_use.cxx. Referenced by StandardMacroBuilder::StandardMacroBuilder(), Script::action(), IgnorePattern::action(), ApplyPattern::action(), Include::action(), add(), Script::add(), Include::add(), Script::all_print(), ApplyPattern::apply(), Pattern::apply(), Generator::build_dependencies(), Cmt::configure(), const_current(), Cmt::do_broadcast(), Cmt::do_build_library_links(), Cmt::do_config(), Cmt::do_remove_library_links(), Cmt::do_show_author(), Cmt::do_show_include_dirs(), Cmt::do_show_manager(), Pattern::expand(), StandardMacroBuilder::fill_for_includes(), StandardMacroBuilder::fill_for_use_stamps(), fill_macro_all(), Script::find(), IgnorePattern::find(), Pattern::find(), Include::find(), use_action_iterator::get_use(), Cmt::load(), Cmt::parse_arguments(), Cmt::parse_requirements(), Cmt::parse_requirements_text(), MakefileGenerator::prepare_use_context(), Fragment::print(), Include::print_all(), Include::print_filters(), Cmt::reach_current_package(), TriggerGenerator::run(), UseAnalyzer::run(), Cmt::select(), Cmt::set_standard_macros(), ApplyPattern::show(), Pattern::show(), show_all(), Pattern::show_all(), and Pattern::show_all_applied_patterns(). { static UseVector& AllUses = all_uses (); static Use* current_use = 0; if ((current_use == 0) || (AllUses.size () == 0)) { Use& use_object = AllUses.add (); current_use = &use_object; } return (*current_use); }

void Use::discard ( )

Get the previous set of effective use statements that might have been obtained in a previous build. This is stored in uses.log. Ignored if file does not exist. Definition at line 1794 of file cmt_use.cxx. Referenced by add(), LastChoiceSelector::operate(), FirstChoiceSelector::operate(), BestFitNoCheckSelector::operate(), BestFitSelector::operate(), and select_clients(). { discarded = true; }

void Use::fill_includes_macro ( cmt_string & buffer ) const

Definition at line 1935 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_all_constituents(), and StandardMacroBuilder::fill_for_use_includes(). { if (include_path == "") { buffer += "$(ppcmd)\"$("; buffer += package; buffer += "_root)"; buffer += CmtSystem::file_separator (); buffer += "src\" "; } else if (include_path != "none") { buffer += "$(ppcmd)\""; buffer += include_path; buffer += "\" "; } for (int i = 0; i < includes.size (); i++) { Include& incl = includes[i]; buffer += "$(ppcmd)\""; buffer += incl.name; buffer += "\" "; } }

void Use::fill_macro ( cmt_string & buffer, const cmt_string & suffix ) const

Definition at line 1963 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_all_constituents(), StandardMacroBuilder::fill_for_use_libraries(), StandardMacroBuilder::fill_for_use_stamps(), and fill_macro_all(). { buffer += " $("; buffer += package; buffer += "_"; buffer += suffix; buffer += ") "; }

void Use::fill_macro_all ( cmt_string & buffer, const cmt_string & suffix ) [static]

Definition at line 909 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_use_cflags(), StandardMacroBuilder::fill_for_use_cppflags(), StandardMacroBuilder::fill_for_use_fflags(), StandardMacroBuilder::fill_for_use_linkopts(), StandardMacroBuilder::fill_for_use_pp_cflags(), StandardMacroBuilder::fill_for_use_pp_cppflags(), and StandardMacroBuilder::fill_for_use_pp_fflags(). { UsePtrVector& Uses = uses (); buffer = "macro_append use_"; buffer += suffix; buffer += " \" "; (Use::current()).fill_macro (buffer, suffix); for (int number = 0; number < Uses.size (); number++) { Use* use = Uses[number]; if (use->package == "CMT") continue; if (use->package == "methods") continue; if (use->discarded) continue; if (use->auto_imports == Off) continue; use->fill_macro (buffer, suffix); } buffer += "\""; }

Use * Use::find ( const cmt_string & package, const cmt_string & version = "", const cmt_string & path = "" ) [static]

Definition at line 605 of file cmt_use.cxx. Referenced by Fragment::locate(), need_new(), and show_all(). { static UsePtrVector& Uses = uses (); static UseVector& AllUses = all_uses (); int use_index; if (AllUses.size () == 0) return (0); for (use_index = 0; use_index < Uses.size (); use_index++) { Use& use = (*Uses[use_index]); if (use.package == package) { // If the version argument is omitted then // take the first registered version if (version == "") return (&use); // Otherwise compare against specified_version and path //if ((use.specified_version == version) && // (use.specified_path == path)) return (&use); // what about comparing wild cards? if (use.specified_version == version) return (&use); } } return (0); }

int Use::find_index ( const cmt_string & package, const cmt_string & version, const cmt_string & path ) [static]

Definition at line 640 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_all_constituents(). { static UsePtrVector& Uses = uses (); static UseVector& AllUses = all_uses (); int use_index; if (AllUses.size () == 0) return (-1); for (use_index = 0; use_index < Uses.size (); use_index++) { Use& use = (*Uses[use_index]); if (use.package == package) { // If the version argument is omitted then // take the first registered version if (version == "") return (use_index); // Otherwise compare against specified_version and path //if ((use.specified_version == version) && // (use.specified_path == path)) return (&use); // what about comparing wild cards? if (use.specified_version == version) return (use_index); } } return (-1); }

cmt_string Use::get_full_path ( ) const

Compute the full real path of a found package. Takes the structuring style into account Definition at line 1906 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_use_ROOT(), and reduce_path(). { cmt_string result; get_full_path (result); return (result); }

void Use::get_full_path ( cmt_string & s ) const

Compute the full real path of a found package. Takes the structuring style into account Result is used to fill in the referenced string Result does NOT include the trailing file_separator Definition at line 1890 of file cmt_use.cxx. Referenced by Fragment::locate(). { if (real_path == "") s = CmtSystem::pwd (); else s = real_path; s += CmtSystem::file_separator (); s += package; s += CmtSystem::file_separator (); s += version; }

bool Use::get_paths ( Use * to, UsePtrVector & list )

Definition at line 2067 of file cmt_use.cxx. Referenced by Pattern::apply(). { bool found = false; bool cycle = false; static int level = 0; static UsePtrVector stack; if (level == 0) { stack.clear (); } // Protect against cycles. for (int k = 0; k < stack.size (); k++) { Use* u = stack[k]; if (u == this) { if (Cmt::get_debug ()) { cout << "Use::get_paths." << level << ">" << package << " cycle " << endl; } return (false); } } // Save this to the protection stack. if (stack.size () <= level) { stack.push_back (this); } else { stack[level] = this; } // First figure out whether 'to' is used by 'this'. if (Cmt::get_debug ()) { cout << "Use::get_paths." << level << ">" << package << " to=" << to->package << " list[" << list.size () << "]" << endl; } if (this == to) { found = true; } else { for (int n = 0; n < sub_uses.size (); n++) { Use* use = sub_uses[n]; if (use == 0) continue; if (Cmt::get_debug ()) { cout << " Use::get_paths." << level << "> try1 sub=" << use->package << endl; } if (use->discarded) { Use* u; u = use->get_selected_version (); if (u == 0) continue; use = u; } cycle = false; // This use must not be already in the list (protection against cycles) for (int m = 0; m < list.size (); m++) { Use* u = list[m]; if (u == use) { cycle = true; break; } } if (cycle) { found = true; continue; } if (Cmt::get_debug ()) { cout << " Use::get_paths." << level << "> try2 sub=" << use->package << endl; } level++; bool r = use->get_paths (to, list); level--; if (r) { found = true; } } } if (found) { cycle = false; for (int m = 0; m < list.size (); m++) { Use* u = list[m]; if (u == this) { cycle = true; break; } } if (!cycle) { if (Cmt::get_debug ()) { cout << "Use::get_paths." << level << "> push " << package << endl; } list.push_back (this); } } return (found); }

Use * Use::get_selected_version ( ) [private]

This function tries to get the replacement of a Use when it has been discarded by a better match to version constraints. Definition at line 1976 of file cmt_use.cxx. Referenced by get_paths(). { static Use::UsePtrVector& Uses = uses (); //cout << "get_selected_version for package " << package << endl; if (!discarded) return (this); for (int i = 0; i < Uses.size (); i++) { Use* u = Uses[i]; if (u == 0) continue; if (u->discarded) continue; if (u->package == package) { //cout << " got a version" << endl; return (u); } } return (0); }

bool Use::has_native_version ( ) const

Definition at line 2061 of file cmt_use.cxx. { return (m_has_native_version); }

bool Use::is_client ( const cmt_string & used_package, const cmt_string & used_version ) [private]

Check if the package makes use of the specified package/version. The seach only considers the first level of uses (thus it is NOT recursive) Definition at line 1829 of file cmt_use.cxx. Referenced by select_clients(). { // A package is client of itself if ((package == used_package) && (version == used_version)) return (true); if (discarded) return (false); int i; for (i = 0; i < sub_uses.size (); i++) { Use* use = sub_uses[i]; if (use == 0) continue; if ((use->package == used_package) && (use->version == used_version)) return (true); /* if (use->is_client (used_package, used_version)) { return (true); } */ } return (false); }

bool Use::is_selected ( ) [private]

Definition at line 1818 of file cmt_use.cxx. Referenced by select_clients(). { return (selected); }

bool Use::located ( ) const

Definition at line 2203 of file cmt_use.cxx. Referenced by Cmt::do_broadcast(), Cmt::do_build_library_links(), Cmt::do_remove_library_links(), StandardMacroBuilder::fill_for_use_ROOT(), StandardMacroBuilder::fill_for_use_requirements(), StandardMacroBuilder::fill_for_use_root(), and show_all(). { return (m_located); }

void Use::manager_action ( const CmtSystem::cmt_string_vector & words )

Definition at line 592 of file cmt_use.cxx. Referenced by Cmt::select(). { if (manager != "") manager += "\n"; for (int i = 1; i < words.size (); i++) { const cmt_string& w = words[i]; if (i > 1) manager += " "; manager += w; } }

void Use::move ( Use * use1 ) [static]

Here, use points to a Use object which had been declared as no_auto_imports. But we need to switch it On. Therefore, 1) the state in auto_imports_states has to be set On 2) the operation has to be recursively propagated to all sub_uses which also had no_auto_imports. (only to those) Definition at line 732 of file cmt_use.cxx. Referenced by show_all(). { static UsePtrVector& Uses = uses (); int use_index; Use* use; int found = 0; if (Uses.size () == 0) return; if (use1 == 0) return; // // On se positionne sur le pointeur. // for (use_index = 0; use_index < Uses.size (); use_index++) { use = Uses[use_index]; if (use == use1) { found = 1; break; } } if (!found) return; // // On deplace tous les pointeurs d'une case en arriere // for (use_index++; use_index < Uses.size (); use_index++) { Uses[use_index - 1] = Uses[use_index]; } // // use1 est donc replace en derniere position // { Uses[Uses.size () - 1] = use1; } }

bool Use::move_to ( )

Definition at line 1226 of file cmt_use.cxx. Referenced by add(), and Cmt::reach_current_package(). { if (m_located) { // // The real path where this version/package can be found // has already been resolved. We thus first go there. // if (Cmt::get_debug ()) { cout << "move_to1> " << real_path << endl; } reach_package (real_path); return (true); } cmt_string expanded_path = path; // // Try here. // if (expanded_path == "") { if (reach_package ("")) { if (Cmt::get_debug ()) { cout << "move_to2> " << expanded_path << endl; } change_path (expanded_path); return (true); } else if (alternate_versions.size () > 0) { if (select_alternate ()) { if (Cmt::get_debug ()) { cout << "move_to5> " << real_path << endl; } return (true); } } } // // If the path specified in this use is a true absolute path, // then we search the package from there first. // if (CmtSystem::absolute_path (expanded_path)) { if (reach_package (expanded_path)) { if (Cmt::get_debug ()) { cout << "move_to3> " << expanded_path << endl; } change_path (expanded_path); return (true); } else if (alternate_versions.size () > 0) { if (select_alternate ()) { if (Cmt::get_debug ()) { cout << "move_to5> " << real_path << endl; } return (true); } } } // // Second try is among the CMTPATHs // static const CmtSystem::cmt_string_vector& search_path = Cmt::get_cmt_path (); int path_index = 0; for (path_index = 0; path_index < search_path.size (); path_index++) { const cmt_string& next_path = search_path[path_index]; alternate_versions.clear (); alternate_paths.clear (); if (reach_package (next_path)) { if (Cmt::get_debug ()) { cout << "move_to4> " << next_path << endl; } change_path (next_path); return (true); } else if (alternate_versions.size () > 0) { if (select_alternate ()) { if (Cmt::get_debug ()) { cout << "move_to5> " << real_path << endl; } return (true); } } } return (false); }

bool Use::need_new ( const cmt_string & path, const cmt_string & package, const cmt_string & version, Use ** old_use ) [static, private]

Definition at line 1447 of file cmt_use.cxx. Referenced by add(). { bool has_wild_card = (version.find ("*") != cmt_string::npos); static UsePtrVector& Uses = uses (); static UseVector& AllUses = all_uses (); bool result = true; Use* found = 0; int use_index; if (old_use != 0) *old_use = 0; if (AllUses.size () == 0) return (true); for (use_index = 0; use_index < Uses.size (); use_index++) { Use& use = (*Uses[use_index]); if (use.package != package) continue; found = &use; /* cerr << "Use::need_new> (" << package << ") requested version=" << version << " vs existing=" << use->version << " (specified as " << use->specified_version << ")" << endl; */ bool use_has_wild_card = (use.specified_version.find ("*") != cmt_string::npos); if (has_wild_card && !use_has_wild_card) { //cerr << " ... requested wildcarded loses against existing explicit" << endl; result = false; break; } if ((version == use.specified_version) && (path == use.specified_path)) { // exactly same version and path! result = false; break; } // requested explicit wins against existing wildcarded // In any case when paths are different, consider the new one. // Now paths are identical (thus versions are different). } if (old_use != 0) *old_use = found; return (result); }

int Use::reach_package ( const cmt_string & from_path ) [private]

Definition at line 1056 of file cmt_use.cxx. Referenced by move_to(), and select_alternate(). { //cerr << "Use::reach_package> (" << package << " " << version << ")from " << from_path << endl; // // We try to reach a package/version starting from from_path // // check if from_path is at least real if ((from_path != "") && !CmtSystem::cd (from_path)) return (0); // check in case from_path is a new search path if (from_path != real_path) { // Move to that prefix only if it is a relative path. if ((path.size () > 0) && (!CmtSystem::absolute_path (path))) { if (!CmtSystem::cd (path)) { return (0); } } } // Special treatment for CMTHOME package... if (package == CmtSystem::get_home_package ()) { discarded = 1; if (!CmtSystem::test_file ("requirements")) { return (0); } else { return (1); } } // Special treatment for CMTUSERCONTEXT package... if (package == CmtSystem::get_user_context_package ()) { discarded = 1; if (!CmtSystem::test_file ("requirements")) { return (0); } else { return (1); } } // Now from_path exists, try if the package exists there if (!CmtSystem::cd (package)) { return (0); } if (!CmtSystem::cd (version)) { // // The specified version cannot be found per-se // There are alternate possibilities when it contains wild cards // if ((version == "") || (version.find ("*") != cmt_string::npos)) { static CmtSystem::cmt_string_vector versions; static cmt_string name; name = "."; name += CmtSystem::file_separator (); if (version == "") name += "*"; else name += version; CmtSystem::scan_dir (name, versions); int i; bool found = false; for (i = 0; i < versions.size (); i++) { const cmt_string& vers = versions[i]; if (Cmt::get_debug ()) { cout << " ... version " << vers << " exists" << endl; } CmtSystem::basename (vers, name); int v; int r; int p; if (CmtSystem::is_version_directory (name, v, r, p)) { /* This check is not sufficient !! We need to check in addition that the selected directory is really the start of a true CMT package (ie with either /mgr/requirements or /cmt/requirements below) */ cmt_string req; req = name; req += CmtSystem::file_separator (); req += "mgr"; req += CmtSystem::file_separator (); req += "requirements"; if (!CmtSystem::test_file (req)) { req = name; req += CmtSystem::file_separator (); req += "cmt"; req += CmtSystem::file_separator (); req += "requirements"; if (!CmtSystem::test_file (req)) continue; } cmt_string& new_v = alternate_versions.add (); new_v = name; cmt_string& new_p = alternate_paths.add (); new_p = from_path; found = true; } } } if (Cmt::get_debug ()) { cout << " ... end of version scan" << endl; } // // We have now the list of possible alternate versions. However // we return that the expected package/version was not found (yet). // return (0); } //cerr << " ... version " << version << " exists" << endl; // Now we have met the exact specified version! if (!CmtSystem::test_file ("cmt/requirements")) { if (!CmtSystem::test_file ("mgr/requirements")) { return (0); } else { CmtSystem::cd ("mgr"); style = mgr_style; } } else { CmtSystem::cd ("cmt"); style = cmt_style; } return (1); }

void Use::reduce_path ( cmt_string & s ) const

Considering a given path, try and reduce the part of it that corresponds to the full path of this package into its normal form ${<PACKAGE>ROOT} The argument is modified if the pattern is exactly found. Definition at line 1921 of file cmt_use.cxx. Referenced by Fragment::print(). { cmt_string pattern; get_full_path (pattern); pattern += CmtSystem::file_separator (); cmt_string replacement = "${"; replacement += prefix; replacement += "ROOT}"; s.replace (pattern, replacement); }

void Use::reorder ( Use * use1, Use * use2 ) [static]

Reorder use1 versus use2 in the UsePtrVector list, so that the order reflects the fact that use2 makes use of use1. The result should be that use1 appears before use2 in the list. Definition at line 782 of file cmt_use.cxx. Referenced by use_action_iterator::get_use(). { static UsePtrVector& Uses = uses (); int use_index; int index1 = -1; int index2 = -1; Use* use; if (Uses.size () == 0) return; if (use1 == use2) return; // // First locate the two use objects into the Uses vector. // -> index1 and index 2 // for (use_index = 0; use_index < Uses.size (); use_index++) { use = (Use*) Uses[use_index]; if (use == use1) index1 = use_index; if (use == use2) index2 = use_index; } if (Cmt::get_debug ()) { cout << "Use::reorder> 1=" << index1 << " 2=" << index2 << endl; } // // Both objects must be installed in Uses before acting. // if (index1 == -1) return; if (index2 == -1) return; if (index2 < index1) { // // 2 is already before 1 so job is finished // return; } else { // // before : <a a a 1 b b b 2 c c c> // ^ ^ // i1 i2 // // 1) move "1 b b b" by one place to the right // thus : <a a a 1 1 b b b c c c> // // 2) move "2" to [i1] // // after : <a a a 2 1 b b b c c c> // use = use2; for (use_index = index2 - 1; use_index >= index1; use_index--) { Uses[use_index + 1] = Uses[use_index]; } Uses[index1] = use; } }

void Use::select ( ) [private]

Definition at line 1806 of file cmt_use.cxx. Referenced by select_clients(). { selected = true; }

bool Use::select_alternate ( ) [private]

Definition at line 1352 of file cmt_use.cxx. Referenced by move_to(). { int i; int v0 = 0; int r0 = 0; int p0 = 0; int v = 0; int r = 0; int p = 0; int selected_index = -1; for (i = 0; i < alternate_versions.size (); i++) { cmt_string& name = alternate_versions[i]; /* if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "") { cout << "select_alternate[" << this << "]> package " << package << " sv=" << specified_version << " v=" << version << " av[" << i << "]=" << name << endl; } */ if (i == 0) { CmtSystem::is_version_directory (name, v0, r0, p0); selected_index = 0; } else { CmtSystem::is_version_directory (name, v, r, p); if (v > v0) { selected_index = i; v0 = v; r0 = r; p0 = p; } else if (v == v0) { if (r > r0) { selected_index = i; r0 = r; p0 = p; } else if (r == r0) { if (p > p0) { selected_index = i; p0 = p; } } } } } if (selected_index >= 0) { if (CmtSystem::cd (alternate_paths[selected_index])) { version = alternate_versions[selected_index]; if (reach_package (alternate_paths[selected_index])) { /* if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "") { cout << "select_alternate2> package " << package << " sv=" << specified_version << " v=" << version << endl; } */ if (Cmt::get_debug ()) { cout << "select_alternate> " << alternate_paths[selected_index] << endl; } change_path (alternate_paths[selected_index]); return (true); } } } return (false); }

void Use::select_clients ( const cmt_string & package, const cmt_string & version ) [static]

Mark all clients of the current package. Definition at line 148 of file cmt_use.cxx. { static UsePtrVector& Uses = uses (); int number; Use* use = 0; unselect_all (); undiscard_all (); for (number = Uses.size () - 1; number >= 0; number--) { use = Uses[number]; if (use == 0) continue; if (use->is_selected ()) continue; use->select (); if (!use->is_client (package, version)) use->discard (); } }

void Use::set ( const cmt_string & new_package, const cmt_string & new_version, const cmt_string & new_path, const cmt_string & new_version_alias = "", const cmt_string & new_path_alias = "" )

Definition at line 999 of file cmt_use.cxx. Referenced by Use(), Cmt::configure(), create(), Cmt::do_config(), Cmt::parse_arguments(), and Cmt::select(). { clear (); package = new_package; specified_path = new_path; // specified_path.replace_all ("\\", "/"); specified_version = new_version; version = new_version; path = specified_path; Symbol::expand (path); real_path = ""; style = mgr_style; scope = Cmt::get_scope (); done = false; discarded = false; Cmt::build_prefix (new_package, prefix); version_alias = new_version_alias; path_alias = new_path_alias; }

void Use::set_auto_imports ( State new_state )

Definition at line 1999 of file cmt_use.cxx. Referenced by use_action_iterator::get_use(). { if (Cmt::get_debug ()) { cout << "Use::set_auto_imports>(" << package << ") " << auto_imports << " -> " << new_state << endl; } if (auto_imports == new_state) return; State old_state = auto_imports; auto_imports = new_state; // We propagate only when we switch from Off to On if ((old_state == Off) && (new_state == On)) { cmt_string s; static const cmt_string state_text[] = {"Unspecified", "Off", "On"}; if (Cmt::get_debug ()) { s = "Use::set_auto_imports>("; s += package; s += ") "; cout << s << endl; } for (int i = 0; i < sub_uses.size (); i++) { Use* u = sub_uses[i]; State state = sub_use_auto_imports[i]; if (Cmt::get_debug ()) { s += " "; s += u->package; s += "("; s += state_text[state]; s += ")"; } if (state == Unspecified) { u->set_auto_imports (On); } } if (Cmt::get_debug ()) { cout << s << endl; } } }

void Use::set_auto_imports_state ( int use_index, cmt_vector< bool >& auto_imports_states ) [static]

1) Given a Use object identified by its index in the uses() array, 2) Given a vector of states containing the auto_imports states of all Uses,. we want to switch to 'On' the auto_imports states of all sub_uses of the argument that were Off. Definition at line 682 of file cmt_use.cxx. Referenced by StandardMacroBuilder::fill_for_all_constituents(). { // check if this is already done (recursivity ending) if (auto_imports_states[use_index]) return; Use::UsePtrVector& Uses = Use::uses (); Use* use = Uses[use_index]; // Is this a mistake? we only have to deal with Use objects that were // actually turned Off if (use->auto_imports != Off) return; auto_imports_states[use_index] = true; for (int i = 0; i < use->sub_uses.size (); i++) { Use* u = use->sub_uses[i]; if (u->sub_use_auto_imports[i] == Off) { int j; // first find the index of this use. for (j = 0; j < Uses.size(); j++) { if (u == Uses[j]) break; } set_auto_imports_state (j, auto_imports_states); } } }

void Use::set_include_path ( const cmt_string & new_path )

Definition at line 1878 of file cmt_use.cxx. Referenced by Cmt::select(). { include_path = new_path; }

void Use::set_native_version ( bool state )

Definition at line 2056 of file cmt_use.cxx. Referenced by Symbol::action(). { m_has_native_version = state; }

void Use::show_all ( const cmt_string & prefix, bool skip_discarded = false ) [static]

Definition at line 176 of file cmt_use.cxx. { static UsePtrVector& Uses = uses (); Use* use; int number; unselect_all (); use = &(current ()); use->unselect (); if (!Cmt::get_quiet ()) use->show_sub_uses (skip_discarded); if (Uses.size () > 0) { if (!Cmt::get_quiet ()) { cout << "#\n"; cout << "# Selection :\n"; } // // First move the CMT package to the end of the use set. // (ie. used by everybody) // use = Use::find ("CMT"); Use::move (use); for (number = Uses.size () - 1; number >= 0; number--) { use = Uses[number]; if (use->discarded) continue; if (!use->located ()) { if (!Cmt::get_quiet ()) { cout << "# package " << use->package << " " << use->version << " " << use->path << " not found" << endl; } CmtError::set (CmtError::package_not_found, use->package); } else { static const cmt_string empty; cmt_string p = use->real_path; if (use->path != "") { p.replace (use->path, empty); } cout << prefix << use->package << " " << use->version << " " << use->path; if (!Cmt::get_quiet ()) { if (p != "") cout << " (" << p << ")"; if (use->auto_imports == Off) cout << " (no_auto_imports)"; } cout << endl; } } if (Cmt::get_cmt_home () != "") { cout << prefix << CmtSystem::get_home_package () << " " << Cmt::get_cmt_home () << endl; } if (Cmt::get_cmt_user_context () != "") { cout << prefix << CmtSystem::get_user_context_package () << " " << Cmt::get_cmt_user_context () << endl; } } }

void Use::show_all ( bool skip_discarded = false ) [static]

Definition at line 170 of file cmt_use.cxx. Referenced by Cmt::do_show_uses(). { show_all ("use ", skip_discarded); }

void Use::show_sub_uses ( bool skip_discarded = false ) [private]

Definition at line 2209 of file cmt_use.cxx. Referenced by show_all(). { int n; Use* use; static int level = 0; if (skip_discarded && discarded) return; if (level > 0) { cout << "# "; for (n = 0; n < (level-1); n++) cout << " "; cout << "use " << package << " " << specified_version; if (specified_path != "") cout << " " << specified_path; if (version_alias != "") { cout << " | " << version_alias << " " << path_alias; } if (scope == ScopeUnspecified) cout << " unspecified"; else if (scope != ScopePublic) cout << " (private)"; //else cout << " private"; if (auto_imports == Off) cout << " (no_auto_imports)"; if (m_has_native_version) { cmt_string n = package; n += "_native_version"; Symbol* s = Symbol::find (n); if (s != 0) { cmt_string value = s->resolve_macro_value (); cout << " (native_version=" << value << ")"; } } cout << endl; } if (selected) return; selected = true; level++; for (n = 0; n < sub_uses.size (); n++) { use = sub_uses[n]; if (use == 0) continue; ScopeType saved_scope = use->scope; State saved_state = use->auto_imports; use->scope = sub_use_scopes[n]; use->auto_imports = sub_use_auto_imports[n]; use->show_sub_uses (skip_discarded); use->scope = saved_scope; use->auto_imports = saved_state; } level--; }

void Use::undiscard ( )

Definition at line 1800 of file cmt_use.cxx. Referenced by KeepAllSelector::operate(), LastChoiceSelector::operate(), FirstChoiceSelector::operate(), BestFitNoCheckSelector::operate(), BestFitSelector::operate(), and undiscard_all(). { discarded = false; }

void Use::undiscard_all ( ) [static]

Definition at line 889 of file cmt_use.cxx. Referenced by select_clients(). { static UsePtrVector& Uses = uses (); int use_index; if (Uses.size () == 0) return; for (use_index = 0; use_index < Uses.size (); use_index++) { Use* use = Uses[use_index]; if (use != 0) { use->undiscard (); } } }

void Use::unselect ( ) [private]

Definition at line 1812 of file cmt_use.cxx. Referenced by show_all(), and unselect_all(). { selected = false; }

void Use::unselect_all ( ) [static]

Definition at line 869 of file cmt_use.cxx. Referenced by select_clients(), and show_all(). { static UsePtrVector& Uses = uses (); int use_index; if (Uses.size () == 0) return; for (use_index = 0; use_index < Uses.size (); use_index++) { Use* use = Uses[use_index]; if (use != 0) { use->unselect (); } } }

Use::UsePtrVector & Use::uses ( ) [static]

Definition at line 2309 of file cmt_use.cxx. Referenced by add(), Script::all_print(), Script::all_print_clean(), Pattern::apply(), Generator::build_make_setup(), Generator::build_readme(), clear_all(), Cmt::do_broadcast(), Cmt::do_build_library_links(), Cmt::do_remove_library_links(), StandardMacroBuilder::fill_for_all_constituents(), StandardMacroBuilder::fill_for_fincludes(), StandardMacroBuilder::fill_for_includes(), StandardMacroBuilder::fill_for_use_cflags(), StandardMacroBuilder::fill_for_use_cppflags(), StandardMacroBuilder::fill_for_use_fflags(), StandardMacroBuilder::fill_for_use_fincludes(), StandardMacroBuilder::fill_for_use_includes(), StandardMacroBuilder::fill_for_use_libraries(), StandardMacroBuilder::fill_for_use_linkopts(), StandardMacroBuilder::fill_for_use_pp_cflags(), StandardMacroBuilder::fill_for_use_pp_cppflags(), StandardMacroBuilder::fill_for_use_pp_fflags(), StandardMacroBuilder::fill_for_use_requirements(), StandardMacroBuilder::fill_for_use_stamps(), StandardMacroBuilder::fill_for_uses(), fill_macro_all(), find(), Pattern::find(), find_index(), get_selected_version(), use_action_iterator::get_use(), move(), need_new(), MakefileGenerator::prepare_use_context(), Cmt::print(), Include::print_all(), Cmt::print_clean(), Include::print_filters(), reorder(), UseAnalyzer::run(), select_clients(), set_auto_imports_state(), Cmt::set_standard_macros(), Pattern::show(), show_all(), undiscard_all(), and unselect_all(). { static Database& db = Database::instance (); static UsePtrVector& Uses = db.uses (); return (Uses); }

---

Member Data Documentation

CmtSystem::cmt_string_vector Use::alternate_paths [private]

Definition at line 139 of file cmt_use.h.

CmtSystem::cmt_string_vector Use::alternate_versions [private]

Definition at line 138 of file cmt_use.h.

ApplyPattern::ApplyPatternVector Use::apply_patterns

Definition at line 111 of file cmt_use.h.

cmt_string Use::author

Definition at line 91 of file cmt_use.h.

State Use::auto_imports

Definition at line 106 of file cmt_use.h.

bool Use::discarded

Definition at line 103 of file cmt_use.h.

bool Use::done

Definition at line 101 of file cmt_use.h.

IgnorePattern::IgnorePatternVector Use::ignore_patterns

Definition at line 112 of file cmt_use.h.

cmt_string Use::include_path

Definition at line 109 of file cmt_use.h.

Include::IncludeVector Use::includes

Definition at line 108 of file cmt_use.h.

bool Use::m_has_native_version [private]

Definition at line 132 of file cmt_use.h.

bool Use::m_located [private]

Definition at line 131 of file cmt_use.h.

cmt_string Use::manager

Definition at line 92 of file cmt_use.h.

cmt_string Use::package

Definition at line 86 of file cmt_use.h.

cmt_string Use::path

Definition at line 94 of file cmt_use.h.

cmt_string Use::path_alias

Definition at line 90 of file cmt_use.h.

cmt_string Use::prefix

Definition at line 99 of file cmt_use.h.

cmt_string Use::real_path

Definition at line 96 of file cmt_use.h.

ScopeType Use::scope

Definition at line 100 of file cmt_use.h.

Script::ScriptVector Use::scripts

Definition at line 110 of file cmt_use.h.

bool Use::selected

Definition at line 104 of file cmt_use.h.

cmt_string Use::specified_path

Definition at line 88 of file cmt_use.h.

cmt_string Use::specified_version

Definition at line 87 of file cmt_use.h.

CmtDirStyle Use::style

Definition at line 97 of file cmt_use.h.

cmt_vector< State > Use::sub_use_auto_imports [private]

Definition at line 136 of file cmt_use.h.

cmt_vector< ScopeType > Use::sub_use_scopes [private]

Definition at line 135 of file cmt_use.h.

UsePtrVector Use::sub_uses [private]

Definition at line 134 of file cmt_use.h.

cmt_string Use::version

Definition at line 95 of file cmt_use.h.

cmt_string Use::version_alias

Definition at line 89 of file cmt_use.h.

---

The documentation for this class was generated from the following files:

• cmt_use.h
• cmt_use.cxx

---