---

CmtSystem Class Reference

#include <cmt_system.h>

List of all members.

Public Types
typedef cmt_vector<cmt_string>	cmt_string_vector
Static Public Methods
cmt_string	pwd ()
bool	cd (const cmt_string& dir)
void	basename (const cmt_string& file_name, cmt_string& result)
void	basename (const cmt_string& file_name, const cmt_string& suffix, cmt_string& result)
void	dirname (const cmt_string& file_name, cmt_string& result)
void	name (const cmt_string& file, cmt_string& result)
void	get_suffix (const cmt_string& file, cmt_string& result)
void	get_dot_suffix (const cmt_string& file, cmt_string& result)
bool	has_prefix (const cmt_string& name)
bool	absolute_path (const cmt_string& name)
bool	has_device (const cmt_string& name)
cmt_string	current_branch ()
bool	test_directory (const cmt_string& name)
	Implementation of the "test -d" equivalent. More...
bool	test_file (const cmt_string& name)
	Implementation of the "test -f" equivalent. More...
bool	compare_files (const cmt_string& name1, const cmt_string& name2)
	Check if the file "name1" is identical to "name2". More...
bool	compare_and_update_files (const cmt_string& name1, const cmt_string& name2)
	Check if the file "name1" is identical to "name2" if they are identical, "name1" will be simply deleted otherwise "name1" will be copied to "name2" and deleted afterwards. More...
int	file_size (const cmt_string& name)
char	file_separator ()
void	reduce_file_separators (cmt_string& text)
	Transform all / or \ characters in the text into the current file_separator Reduce all multiple file_separator into single ones. More...
char	path_separator ()
char	command_separator ()
const cmt_string&	ev_open ()
const cmt_string&	ev_close ()
bool	create_symlink (const cmt_string& oldname, const cmt_string& newname)
bool	remove_file (const cmt_string& name)
bool	remove_directory (const cmt_string& name)
bool	mkdir (const cmt_string& name)
void	scan_dir (const cmt_string& dir_name, cmt_string_vector& list)
void	scan_dir (const cmt_string& dir_name, const cmt_regexp& expression, cmt_string_vector& list)
cmt_string_vector&	scan_dir (const cmt_string& dir_name)
const cmt_string&	get_cmt_root ()
void	get_cmt_version (cmt_string& version)
cmt_string	get_cmt_config ()
cmt_string	get_cmt_site ()
void	get_uname (cmt_string& uname)
void	get_hosttype (cmt_string& hosttype)
cmt_string	get_temporary_name ()
cmt_string	get_home_package ()
bool	is_home_package (const cmt_string& name, const cmt_string& version)
cmt_string	get_user_context_package ()
bool	is_user_context_package (const cmt_string& name, const cmt_string& version)
bool	testenv (const cmt_string& name)
cmt_string	getenv (const cmt_string& name)
void	add_cmt_path (const cmt_string& path, const cmt_string& path_source, cmt_string_vector& paths, cmt_string_vector& path_pwds, cmt_string_vector& path_sources)
void	get_cmt_paths (cmt_string_vector& paths, cmt_string_vector& path_pwds, cmt_string_vector& path_sources, const cmt_string& init_text = "")
int	execute (const cmt_string& command)
int	execute (const cmt_string& command, cmt_string& output)
bool	is_package_directory (const cmt_string& name)
bool	is_version_directory (const cmt_string& name)
bool	is_version_directory (const cmt_string& name, int& v, int& r, int& p)
void	split (const cmt_string& text, const cmt_string& separators, cmt_string_vector& strings)
void	compress_path (const cmt_string& dir, cmt_string& new_dir)
void	compress_path (cmt_string& dir)
cmt_string	now ()
cmt_string	user ()
void	get_cvsroot (cmt_string& cvsroot)

---

Member Typedef Documentation

typedef cmt_vector<cmt_string> CmtSystem::cmt_string_vector

Definition at line 12 of file cmt_system.h.

---

Member Function Documentation

bool CmtSystem::absolute_path ( const cmt_string & name ) [static]

Definition at line 216 of file cmt_system.cxx. Referenced by Symbol::action(), Generator::build_dependencies(), Use::change_path(), Cmt::do_build_library_links(), Cmt::do_create(), Cmt::do_remove(), Cmt::do_remove_library_links(), mkdir(), Use::move_to(), Use::reach_package(), constituents_action_iterator::set(), and MakefileGenerator::set_full_name(). { if (name.size () == 0) return (false); if ((name[0] == '/') || (name[0] == '\\')) return (true); if (name.size () >= 2) { if (name[1] == ':') { return (true); } } return (false); }

void CmtSystem::add_cmt_path ( const cmt_string & path, const cmt_string & path_source, cmt_string_vector & paths, cmt_string_vector & path_pwds, cmt_string_vector & path_sources ) [static]

Definition at line 1160 of file cmt_system.cxx. Referenced by add_cmt_paths_from_text(), get_cmt_paths(), Cmt::parse_arguments(), and Cmt::reach_current_package(). { cmt_string npath = path; if (path == "") return; npath.replace_all ("\\", file_separator ()); npath.replace_all ("/", file_separator ()); if (!test_directory (npath)) { CmtError::set (CmtError::path_not_found, npath); return; } for (int i = 0; i < paths.size (); i++) { const cmt_string& p = paths[i]; if (p == npath) return; } cmt_string& new_path = paths.add (); new_path = npath; cmt_string here = pwd (); cd (npath); cmt_string& new_pwd = path_pwds.add (); new_pwd = pwd (); cd (here); cmt_string& new_source = path_sources.add (); new_source = path_source; }

void CmtSystem::basename ( const cmt_string & file_name, const cmt_string & suffix, cmt_string & result ) [static]

Definition at line 105 of file cmt_system.cxx. { basename (file_name, result); int pos; pos = result.find_last_of ('.'); if (pos != cmt_string::npos) { result.erase (pos); } }

void CmtSystem::basename ( const cmt_string & file_name, cmt_string & result ) [static]

Definition at line 86 of file cmt_system.cxx. Referenced by DependencyFilter::add_source(), MakefileGenerator::analyze_document_file(), MakefileGenerator::analyze_file(), basename(), Prototyper::begin(), Generator::build_dependencies(), MakefileGenerator::build_document_makefile(), Generator::build_windefs(), Cmt::configure_current_package(), current_branch(), Cmt::do_build_library_links(), CvsImplementation::do_checkout(), Cmt::do_config(), Cmt::do_remove_library_links(), get_cmt_version(), DependencyFilter::has_source(), MakefileGenerator::java_file_action(), Cmt::load(), MakefileGenerator::module_file_action(), MakefileGenerator::proto_file_action(), Cmt::reach_current_package(), Use::reach_package(), UseAnalyzer::run(), DepsBuilder::run(), FAwk::run(), scan_dir(), FileScanner::scan_package(), FileScanner::scan_path(), constituents_action_iterator::set(), and CvsImplementation::show_cvs_infos(). { int pos = file_name.find_last_of ('/'); if (pos == cmt_string::npos) { pos = file_name.find_last_of ('\\'); } if (pos == cmt_string::npos) { result = file_name; } else { file_name.substr (pos + 1, result); } }

bool CmtSystem::cd ( const cmt_string & dir ) [static]

Definition at line 69 of file cmt_system.cxx. Referenced by Use::add(), add_cmt_path(), Generator::build_windefs(), Cmt::do_broadcast(), CvsImplementation::do_checkout(), Cmt::do_config(), Cmt::do_create(), Cmt::do_remove(), Cmt::load(), Cmt::reach_current_package(), Use::reach_package(), CvsImplementation::really_checkout_package(), MakefileGenerator::reset(), Use::select_alternate(), and CvsImplementation::show_cvs_infos(). { if ((dir.size () == 2) && (dir[1] == ':')) { cmt_string new_dir = dir; new_dir += file_separator (); if (chdir (new_dir.c_str ()) == 0) return (true); return (false); } else { if (chdir (dir.c_str ()) == 0) return (true); return (false); } }

char CmtSystem::command_separator ( ) [static]

Definition at line 497 of file cmt_system.cxx. Referenced by SequenceRunner::filter(), and CvsImplementation::really_checkout_package(). { #ifdef WIN32 return ('&'); #else return (';'); #endif }

bool CmtSystem::compare_and_update_files ( const cmt_string & name1, const cmt_string & name2 ) [static]

Check if the file "name1" is identical to "name2" if they are identical, "name1" will be simply deleted otherwise "name1" will be copied to "name2" and deleted afterwards. Definition at line 372 of file cmt_system.cxx. Referenced by Cmt::do_check_files(), Cmt::install_cleanup_scripts(), Cmt::install_setup_scripts(), Cmt::install_test_cleanup_scripts(), and Cmt::install_test_setup_scripts(). { struct stat file_stat1; struct stat file_stat2; static cmt_string s1; static cmt_string s2; int status; status = stat (name1.c_str (), &file_stat1); if (status == 0) { if ((file_stat1.st_mode & S_IFDIR) != 0) { // name1 is a directory. return (false); } } else { // name1 does not exist return (false); } s1.read (name1); status = stat (name2.c_str (), &file_stat2); if (status == 0) { if ((file_stat2.st_mode & S_IFDIR) != 0) { // name2 is a directory return (false); } if (((int) file_stat1.st_size) == ((int) file_stat2.st_size)) { s2.read (name2); if (s1 == s2) { unlink (name1); return (true); } } } FILE* f = fopen (name2, "wb"); if (f != NULL) { s1.write (f); fclose (f); unlink (name1); return (true); } else { // // keep the new file "name1" since it cannot be // copied to "name2" // return (false); } }

bool CmtSystem::compare_files ( const cmt_string & name1, const cmt_string & name2 ) [static]

Check if the file "name1" is identical to "name2". Definition at line 316 of file cmt_system.cxx. Referenced by Generator::check(). { struct stat file_stat1; struct stat file_stat2; int status; status = stat (name1.c_str (), &file_stat1); if (status == 0) { if ((file_stat1.st_mode & S_IFDIR) != 0) { return (false); } } else { return (false); } status = stat (name2.c_str (), &file_stat2); if (status == 0) { if ((file_stat2.st_mode & S_IFDIR) != 0) { return (false); } } else { return (false); } if (((int) file_stat1.st_size) != ((int) file_stat2.st_size)) { return (false); } static cmt_string s1; static cmt_string s2; s1.read (name1); s2.read (name2); return ((s1 == s2)); }

void CmtSystem::compress_path ( cmt_string & dir ) [static]

Definition at line 1851 of file cmt_system.cxx. { #ifdef WIN32 static const char pattern[] = "\\..\\"; //static const char here[] = ".\\"; static const char fs[] = "\\\\"; #else static const char pattern[] = "/../"; //static const char here[] = "./"; static const char fs[] = "//"; #endif if (dir.size () == 0) return; // // We first synchronize to using file_separator() in any case. // if (file_separator () == '/') { dir.replace_all ("\\", file_separator ()); } else { dir.replace_all ("/", file_separator ()); } dir.replace_all (fs, file_separator ()); for (;;) { int pos1; int pos2; pos1 = dir.find (pattern); if (pos1 == cmt_string::npos) break; // // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb" // cmt_string p = dir.substr (0, pos1); // // Is "aaaa/xxxx" only made of "xxxx" ? // pos2 = p.find_last_of (file_separator ()); if (pos2 == cmt_string::npos) break; // 01234567890123456 // aaaa/xxxx/../bbbb // 2 1 3 // // erase the "/xxxx/../" pattern // result will be "aaaa/bbbb" // dir.erase (pos2, pos1 + 4 - pos2 - 1); } //if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1); }

void CmtSystem::compress_path ( const cmt_string & dir, cmt_string & new_dir ) [static]

Definition at line 1837 of file cmt_system.cxx. Referenced by Generator::build_dependencies(), MakefileGenerator::build_library_makefile(), Cmt::do_create(), Cmt::do_remove(), Cmt::filter_dir(), and filter_paths(). { new_dir = dir; compress_path (new_dir); }

bool CmtSystem::create_symlink ( const cmt_string & oldname, const cmt_string & newname ) [static]

Definition at line 531 of file cmt_system.cxx. Referenced by Cmt::do_build_library_links(). { ::unlink (newname.c_str ()); #ifdef WIN32 int status = 1; #else int status = ::symlink (oldname.c_str (), newname.c_str ()); #endif if (status == 0) return (true); return (false); }

cmt_string CmtSystem::current_branch ( ) [static]

Definition at line 256 of file cmt_system.cxx. Referenced by Generator::build_dependencies(), and MakefileGenerator::reset(). { cmt_string result; basename (pwd (), result); return (result); }

void CmtSystem::dirname ( const cmt_string & file_name, cmt_string & result ) [static]

Definition at line 122 of file cmt_system.cxx. Referenced by MakefileGenerator::analyze_document_file(), build_deps(), MakefileGenerator::build_document_makefile(), Generator::build_windefs(), Cmt::configure_current_package(), CvsImplementation::do_checkout(), Cmt::do_config(), SequenceRunner::filter(), get_cmt_root(), Cmt::load(), MakefileGenerator::module_file_action(), MakefileGenerator::proto_file_action(), Cmt::reach_current_package(), CvsImplementation::really_checkout_package(), DepsBuilder::run(), FAwk::run(), scan_dir(), and constituents_action_iterator::set(). { int pos = file_name.find_last_of ('/'); if (pos == cmt_string::npos) { pos = file_name.find_last_of ('\\'); } if (pos == cmt_string::npos) { result = ""; } else { result = file_name; result.erase (pos); } }

const cmt_string & CmtSystem::ev_close ( ) [static]

Definition at line 519 of file cmt_system.cxx. Referenced by resolve_value_for_macros(). { #ifdef WIN32 static const cmt_string s = "%"; #else static const cmt_string s = "}"; #endif return (s); }

const cmt_string & CmtSystem::ev_open ( ) [static]

Definition at line 507 of file cmt_system.cxx. Referenced by resolve_value_for_macros(). { #ifdef WIN32 static const cmt_string s = "%"; #else static const cmt_string s = "${"; #endif return (s); }

int CmtSystem::execute ( const cmt_string & command, cmt_string & output ) [static]

Definition at line 1393 of file cmt_system.cxx. { output = ""; //cout << "CmtSystem::execute2> [" << command << "]" << endl; FILE* f = popen (command.c_str (), "r"); if (f != 0) { char line[256]; char* ptr; while ((ptr = fgets (line, sizeof (line), f)) != NULL) { output += ptr; } pclose (f); return (1); } return (0); }

int CmtSystem::execute ( const cmt_string & command ) [static]

Definition at line 1385 of file cmt_system.cxx. Referenced by DependencyAnalyzer::DependencyAnalyzer(), Cmt::do_broadcast(), CvsImplementation::do_checkout(), Cmt::do_remove_library_links(), Cmt::do_run(), SequenceRunner::filter(), CmtLock::lock(), CvsImplementation::really_checkout_package(), DepsBuilder::run(), CvsImplementation::show_cvs_infos(), and CmtLock::unlock(). { //cout << "CmtSystem::execute1> [" << command << "]" << endl; return (system (command.c_str ())); }

char CmtSystem::file_separator ( ) [static]

Definition at line 459 of file cmt_system.cxx. Referenced by StandardMacroBuilder::StandardMacroBuilder(), Symbol::action(), DepsBuilder::add(), DepsBuilder::add_includes(), MakefileGenerator::analyze_document_file(), MakefileGenerator::analyze_file(), SequenceRunner::begin(), Prototyper::begin(), Generator::build_dependencies(), build_deps(), MakefileGenerator::build_document_makefile(), Generator::build_make_setup(), Generator::build_readme(), CvsImplementation::build_version_directory(), cd(), Use::change_path(), compress_path(), Cmt::configure_current_dir(), Cmt::configure_default_path(), Cmt::do_broadcast(), CvsImplementation::do_checkout(), Cmt::do_create(), Cmt::do_remove(), Use::fill_includes_macro(), DependencyAnalyzer::filter(), SequenceRunner::filter(), get_best_form(), get_cmt_paths(), Use::get_full_path(), header_file_action(), is_package_directory(), Cmt::load(), Fragment::locate(), mkdir(), MakefileGenerator::module_file_action(), Cmt::parse_requirements(), MakefileGenerator::prepare_use_context(), Cmt::print_context(), MakefileGenerator::proto_file_action(), Cmt::reach_current_package(), Use::reach_package(), CvsImplementation::really_checkout_package(), reduce_file_separators(), Use::reduce_path(), MakefileGenerator::reset(), UseAnalyzer::run(), PackageCollector::run(), scan_dir(), FileScanner::scan_package(), FileScanner::scan_path(), SourceFile::set(), constituents_action_iterator::set(), MakefileGenerator::set_full_name(), Cmt::set_standard_macros(), CvsImplementation::show_cvs_infos(), Cmt::use_home_requirements(), and Cmt::use_user_context_requirements(). { #ifdef WIN32 return ('\\'); #else return ('/'); #endif }

int CmtSystem::file_size ( const cmt_string & name ) [static]

Definition at line 441 of file cmt_system.cxx. { struct stat file_stat; int status; status = stat (name.c_str (), &file_stat); if (status == 0) { return ((int) file_stat.st_size); } else { return (0); } }

cmt_string CmtSystem::get_cmt_config ( ) [static]

Definition at line 952 of file cmt_system.cxx. Referenced by Cmt::configure_config_tag(), Cmt::do_show_system(), getenv(), Cmt::parse_arguments(), and Cmt::print_context(). { const char* env = ::getenv ("CMTCONFIG"); if (env != 0) { return (cmt_string (env)); } env = ::getenv ("CMTBIN"); if (env != 0) { return (cmt_string (env)); } #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { char temp[256]; DWORD length = sizeof (temp) - 1; DWORD type; status = RegQueryValueEx (key, "config", 0, &type, (LPBYTE) temp, &length); if (status == ERROR_SUCCESS) { cmt_string config (temp); return (config); } } return ("VisualC"); #endif return (""); }

void CmtSystem::get_cmt_paths ( cmt_string_vector & paths, cmt_string_vector & path_pwds, cmt_string_vector & path_sources, const cmt_string & init_text = "" ) [static]

Definition at line 1247 of file cmt_system.cxx. Referenced by Cmt::configure_cmt_path(). { paths.clear (); path_pwds.clear (); path_sources.clear (); if (init_text != "") { add_cmt_paths_from_text (init_text, "initialization", paths, path_pwds, path_sources); } #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\CMT\\path", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { DWORD index = 0; char name[256]; char temp[256]; for (;;) { DWORD name_length = sizeof (name) - 1; DWORD length = sizeof (temp) - 1; DWORD type; status = RegEnumValue (key, index, name, &name_length, 0, &type, (LPBYTE) temp, &length); if ((status == ERROR_SUCCESS) || (status == 234)) { const cmt_string path = temp; add_cmt_path (path, "HKEY_CURRENT_USER", paths, path_pwds, path_sources); } if (status == 259) { break; } index++; } } status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT\\path", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { DWORD index = 0; char name[256]; char temp[256]; for (;;) { DWORD type; DWORD name_length = sizeof (name) - 1; DWORD length = sizeof (temp) - 1; status = RegEnumValue (key, index, name, &name_length, 0, &type, (LPBYTE) temp, &length); if (status != ERROR_NO_MORE_ITEMS) { const cmt_string path = temp; add_cmt_path (path, "HKEY_LOCAL_MACHINE", paths, path_pwds, path_sources); } else { break; } index++; } } #endif //----------------------------------------- // look for .cmtrc files : // first look in ./ // then in "~/" // then in ${CMTROOT}/mgr //----------------------------------------- cmt_string rc_name; const cmt_string env = CmtSystem::getenv ("CMTPATH"); if (env != "") { static cmt_string_vector path_vector; int i; split (env, path_separator (), path_vector); for (i = 0; i < path_vector.size (); i++) { const cmt_string& path = path_vector[i]; add_cmt_path (path, "${CMTPATH}", paths, path_pwds, path_sources); } } add_cmt_paths (".cmtrc", paths, path_pwds, path_sources); const char* home_env = ::getenv ("HOME"); if (home_env != 0) { rc_name = home_env; rc_name += file_separator (); rc_name += ".cmtrc"; add_cmt_paths (rc_name, paths, path_pwds, path_sources); } rc_name = get_cmt_root (); rc_name += file_separator (); rc_name += "CMT"; rc_name += file_separator (); cmt_string version; get_cmt_version (version); rc_name += version; rc_name += file_separator (); rc_name += "mgr"; rc_name += file_separator (); rc_name += ".cmtrc"; add_cmt_paths (rc_name, paths, path_pwds, path_sources); add_cmt_path (get_cmt_root (), "default path", paths, path_pwds, path_sources); }

const cmt_string & CmtSystem::get_cmt_root ( ) [static]

Definition at line 875 of file cmt_system.cxx. Referenced by Cmt::configure_default_path(), and get_cmt_paths(). { static cmt_string root; root = ""; const char* env = ::getenv ("CMTROOT"); if (env != 0) { root = env; dirname (root, root); dirname (root, root); return (root); } #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { char temp[256]; DWORD length = sizeof (temp) - 1; DWORD type; status = RegQueryValueEx (key, "root", 0, &type, (LPBYTE) temp, &length); if (status == ERROR_SUCCESS) { root = temp; return (root); } } #endif return (root); }

cmt_string CmtSystem::get_cmt_site ( ) [static]

Definition at line 995 of file cmt_system.cxx. Referenced by Cmt::configure_site_tag(). { const char* env = ::getenv ("CMTSITE"); if (env != 0) { return (cmt_string (env)); } #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { char temp[256]; DWORD length = sizeof (temp) - 1; DWORD type; status = RegQueryValueEx (key, "site", 0, &type, (LPBYTE) temp, &length); if (status == ERROR_SUCCESS) { cmt_string site (temp); return (site); } } #endif return (""); }

void CmtSystem::get_cmt_version ( cmt_string & version ) [static]

Definition at line 916 of file cmt_system.cxx. Referenced by Cmt::configure_default_path(), and get_cmt_paths(). { version = ""; const char* env = ::getenv ("CMTROOT"); if (env != 0) { cmt_string s = env; basename (s, version); } else { #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { char temp[256]; DWORD length = sizeof (temp) - 1; DWORD type; status = RegQueryValueEx (key, "version", 0, &type, (LPBYTE) temp, &length); if (status == ERROR_SUCCESS) { version = temp; } } #endif } }

void CmtSystem::get_cvsroot ( cmt_string & cvsroot ) [static]

Definition at line 1940 of file cmt_system.cxx. Referenced by CvsImplementation::really_checkout_package(), and CvsImplementation::show_cvs_infos(). { cvsroot = ""; const char* env = ::getenv ("CVSROOT"); if (env != 0) { cvsroot = env; return; } #ifdef WIN32 LONG status; HKEY key = 0; status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key); if (status == ERROR_SUCCESS) { char temp[256]; DWORD length = sizeof (temp) - 1; DWORD type; status = RegQueryValueEx (key, "CVSROOT", 0, &type, (LPBYTE) temp, &length); if (status == ERROR_SUCCESS) { cvsroot = temp; return; } } #endif }

void CmtSystem::get_dot_suffix ( const cmt_string & file, cmt_string & result ) [static]

Definition at line 188 of file cmt_system.cxx. Referenced by DependencyFilter::add_source(), Prototyper::begin(), Generator::build_dependencies(), MakefileGenerator::build_document_makefile(), Generator::build_windefs(), get_all_files(), DependencyFilter::has_source(), MakefileGenerator::java_file_action(), MakefileGenerator::module_file_action(), and MakefileGenerator::proto_file_action(). { int pos = file.find_last_of ('.'); int sep = file.find_last_of (file_separator ()); if ((pos == cmt_string::npos) || (pos < sep)) { result = ""; } else { file.substr (pos, result); } }

cmt_string CmtSystem::get_home_package ( ) [static]

Definition at line 1085 of file cmt_system.cxx. Referenced by Use::add(), Use::reach_package(), Use::show_all(), and Cmt::use_home_requirements(). { cmt_string name = "CMTHOME context"; return (name); }

void CmtSystem::get_hosttype ( cmt_string & hosttype ) [static]

Definition at line 1061 of file cmt_system.cxx. Referenced by Cmt::configure_hosttype_tag(). { hosttype = ""; char* ptr; ptr = ::getenv ("HOSTTYPE"); if (ptr != 0) { hosttype = ptr; } }

void CmtSystem::get_suffix ( const cmt_string & file, cmt_string & result ) [static]

Definition at line 172 of file cmt_system.cxx. Referenced by DependencyFilter::add_source(), MakefileGenerator::analyze_document_file(), MakefileGenerator::analyze_file(), Generator::build_dependencies(), MakefileGenerator::build_document_makefile(), DependencyFilter::has_source(), and MakefileGenerator::module_file_action(). { int pos = file.find_last_of ('.'); int sep = file.find_last_of (file_separator ()); if ((pos == cmt_string::npos) || (pos < sep)) { result = ""; } else { file.substr (pos + 1, result); } }

cmt_string CmtSystem::get_temporary_name ( ) [static]

Definition at line 1075 of file cmt_system.cxx. Referenced by Cmt::do_build_temporary_name(), and CvsImplementation::show_cvs_infos(). { cmt_string name; name = ::tmpnam (NULL); return (name); }

void CmtSystem::get_uname ( cmt_string & uname ) [static]

Definition at line 1028 of file cmt_system.cxx. Referenced by Cmt::configure_tags(), and Cmt::configure_uname_tag(). { #ifdef WIN32 uname = "WIN32"; #else uname = ""; FILE* file; file = popen ("uname", "r"); if (file != 0) { char line[1024]; char* ptr; char* nl; line[0] = 0; ptr = fgets (line, sizeof (line), file); if (ptr != 0) { nl = strrchr (ptr, '\n'); if (nl != 0) *nl = 0; uname = ptr; } pclose (file); } #endif }

cmt_string CmtSystem::get_user_context_package ( ) [static]

Definition at line 1103 of file cmt_system.cxx. Referenced by Use::add(), Use::reach_package(), Use::show_all(), and Cmt::use_user_context_requirements(). { cmt_string name = "CMTUSERCONTEXT context"; return (name); }

cmt_string CmtSystem::getenv ( const cmt_string & name ) [static]

Definition at line 1129 of file cmt_system.cxx. Referenced by DepsBuilder::add_includes(), SequenceRunner::begin(), PathBuilder::build(), SetBuilder::build(), Generator::build_dependencies(), CvsImplementation::checkout(), PathBuilder::clean(), Cmt::configure_home(), Cmt::configure_tags(), Cmt::configure_user_context(), get_cmt_paths(), Cmt::reach_current_package(), CvsImplementation::really_checkout_package(), Symbol::resolve_macro_value(), resolve_value(), Cmt::restore_all_tags(), Cmt::set_standard_macros(), CvsImplementation::show_cvs_infos(), user(), and Fragment::wincopy(). { cmt_string result; const char* env = ::getenv (name); if (env != 0) { result = env; } if (name == "CMTCONFIG") { return (get_cmt_config ()); } /* if (name == "CMTROOT") { return (get_cmt_root ()); } if (name == "CMTSITE") { return (get_cmt_site ()); } */ return (result); }

bool CmtSystem::has_device ( const cmt_string & name ) [static]

Definition at line 234 of file cmt_system.cxx. Referenced by mkdir(). { #ifdef WIN32 if (name.size () == 0) return (false); if (name.size () >= 2) { if (name[1] == ':') { return (true); } else if ((name[0] == '\\') && (name[1] == '\\')) { return (true); } } #endif return (false); }

bool CmtSystem::has_prefix ( const cmt_string & name ) [static]

Definition at line 204 of file cmt_system.cxx. { if ((name.find ('/') == cmt_string::npos) && (name.find ('\\') == cmt_string::npos)) { return (false); } return (true); }

bool CmtSystem::is_home_package ( const cmt_string & name, const cmt_string & version ) [static]

Definition at line 1093 of file cmt_system.cxx. Referenced by use_action_iterator::ok(). { if ((name == "CMTHOME") && (version == "context")) return (true); return (false); }

bool CmtSystem::is_package_directory ( const cmt_string & name ) [static]

Definition at line 1419 of file cmt_system.cxx. Referenced by Cmt::reach_current_package(). { cmt_string_vector dirs; cmt_regexp exp ("^[a-zA-Z.][0-9]+([a-zA-Z.][0-9]+([a-zA-Z.][0-9]+)?)?"); scan_dir (name, exp, dirs); cmt_string req; req = name; req += file_separator (); req += "cmt"; req += file_separator (); req += "requirements"; if (test_file (req)) return (true); if (dirs.size () == 0) { return (false); } for (int i = 0; i < dirs.size (); i++) { const cmt_string& d = dirs[i]; req = d; req += file_separator (); req += "mgr"; req += file_separator (); req += "requirements"; if (test_file (req)) return (true); req = d; req += file_separator (); req += "cmt"; req += file_separator (); req += "requirements"; if (test_file (req)) return (true); } return (false); }

bool CmtSystem::is_user_context_package ( const cmt_string & name, const cmt_string & version ) [static]

Definition at line 1111 of file cmt_system.cxx. Referenced by use_action_iterator::ok(). { if ((name == "CMTUSERCONTEXT") && (version == "context")) return (true); return (false); }

bool CmtSystem::is_version_directory ( const cmt_string & name, int & v, int & r, int & p ) [static]

Definition at line 1477 of file cmt_system.cxx. { static const cmt_string numbers = "0123456789"; static const int id_version = 0; static const int id_release = 1; static const int id_patch = 2; cmt_string buffer; enum { starting, at_key, at_number } state; int id; int pos; int value; v = 0; r = 0; p = 0; // // version : v-field // | v-field r-field // | v-field r-field p-field // // v-field : field // r-field : field // p-field : field // // field : key '*' // | key number // // key : letters // state = starting; id = id_version; for (pos = 0; pos < name.size (); pos++) { char c = name[pos]; if (c == '*') { // A wild card switch (state) { case starting: // cannot start with a wild card ?? return (false); case at_key: // the numeric field is valued with a wild card switch (id) { case id_version: v = -1; case id_release: r = -1; case id_patch: p = -1; break; } return (true); case at_number: // Syntax error : number followed by a wild-card ?? return (false); } } else if (numbers.find (c) == cmt_string::npos) { // A letter switch (state) { case starting: state = at_key; break; case at_key: // Multiple letter key (is it permitted??) break; case at_number: sscanf (buffer.c_str (), "%d", &value); switch (id) { case id_version: v = value; break; case id_release: r = value; break; case id_patch: p = value; break; } buffer = ""; id++; state = at_key; break; } } else { // a number switch (state) { case starting: // not starting by a letter (syntax error) return (false); case at_key: // the numeric field for the current id is starting now buffer += c; state = at_number; break; case at_number: // continuing the current numeric field buffer += c; break; } } } switch (state) { case starting: // Empty version string return (false); case at_key: // Syntax error (only letters) return (false); case at_number: sscanf (buffer.c_str (), "%d", &value); switch (id) { case id_version: v = value; break; case id_release: r = value; break; case id_patch: p = value; break; } id++; state = at_key; return (true); } return (false); }

bool CmtSystem::is_version_directory ( const cmt_string & name ) [static]

Definition at line 1467 of file cmt_system.cxx. Referenced by Cmt::do_check_version(), BestFitNoCheckSelector::operate(), BestFitSelector::operate(), Use::reach_package(), FileScanner::scan_package(), FileScanner::scan_path(), and Use::select_alternate(). { int v; int r; int p; return (is_version_directory (name, v, r, p)); }

bool CmtSystem::mkdir ( const cmt_string & name ) [static]

Definition at line 592 of file cmt_system.cxx. Referenced by Cmt::do_config(), Cmt::do_create(), SequenceRunner::filter(), CvsImplementation::really_checkout_package(), MakefileGenerator::reset(), and CvsImplementation::show_cvs_infos(). { static cmt_string_vector path_vector; int i; static cmt_string full_path; char double_fs[] = " "; double_fs[0] = file_separator (); double_fs[1] = file_separator (); full_path = name; if (file_separator () == '/') { full_path.replace_all ("\\", file_separator ()); } else { full_path.replace_all ("/", file_separator ()); } full_path.replace_all (double_fs, file_separator ()); split (full_path, file_separator (), path_vector); full_path = ""; if (absolute_path (name)) { if (!has_device (name)) { full_path = file_separator (); } } for (i = 0; i < path_vector.size (); i++) { const cmt_string& path = path_vector[i]; if (i > 0) full_path += file_separator (); full_path += path; if (has_device (path)) continue; if (!test_directory (full_path)) { #ifdef WIN32 if (::_mkdir (full_path.c_str ()) != 0) { cerr << "CMT> cannot create directory " << full_path << endl; return (false); } #else if (::mkdir (full_path.c_str (), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0) { cerr << "CMT> cannot create directory " << full_path << endl; return (false); } #endif } } return (true); }

void CmtSystem::name ( const cmt_string & file_name, cmt_string & result ) [static]

Definition at line 142 of file cmt_system.cxx. Referenced by MakefileGenerator::prepare_proto_file(). { int pos; result = file_name; // remove the suffix pos = result.find_last_of ('.'); if (pos != cmt_string::npos) { result.erase (pos); } // remove the directory name pos = result.find_last_of ('/'); if (pos == cmt_string::npos) { pos = result.find_last_of ('\\'); } if (pos != cmt_string::npos) { result.erase (0, pos + 1); } }

cmt_string CmtSystem::now ( ) [static]

Definition at line 1914 of file cmt_system.cxx. Referenced by MakefileGenerator::build_document_makefile(), MakefileGenerator::build_library_makefile(), Generator::build_readme(), and CmtLock::lock(). { cmt_string result; time_t ltime; time (&ltime); result = ctime (&ltime); result.replace_all ("\n", ""); return (result); }

char CmtSystem::path_separator ( ) [static]

Definition at line 487 of file cmt_system.cxx. Referenced by PathBuilder::build(), PathBuilder::clean(), Cmt::do_show_path(), and find_path_entry(). { #ifdef WIN32 return (';'); #else return (':'); #endif }

cmt_string CmtSystem::pwd ( ) [static]

Definition at line 57 of file cmt_system.cxx. Referenced by StandardMacroBuilder::StandardMacroBuilder(), Use::add(), add_cmt_path(), CvsImplementation::checkout(), Cmt::configure_current_dir(), Cmt::do_broadcast(), Cmt::do_create(), Cmt::do_lock(), Cmt::do_remove(), Cmt::do_unlock(), get_all_files(), Use::get_full_path(), Cmt::load(), Cmt::reach_current_package(), MakefileGenerator::reset(), Cmt::set_standard_macros(), and CvsImplementation::show_cvs_infos(). { char buffer[256] = ""; char* ptr; ptr = getcwd (buffer, sizeof (buffer)); const char* t = &buffer[0]; return ((cmt_string) t); }

void CmtSystem::reduce_file_separators ( cmt_string & text ) [static]

Transform all / or \ characters in the text into the current file_separator Reduce all multiple file_separator into single ones. Definition at line 472 of file cmt_system.cxx. { if (file_separator () == '/') { text.replace_all ("\\", "/"); text.replace_all ("//", "/"); } else { text.replace_all ("/", "\\"); text.replace_all ("\\\\", "\\"); } }

bool CmtSystem::remove_directory ( const cmt_string & name ) [static]

Definition at line 559 of file cmt_system.cxx. Referenced by Cmt::do_remove(), and CvsImplementation::show_cvs_infos(). { //cout << "Try to remove directory " << name << endl; cmt_string_vector files; scan_dir (name, files); for (int i = 0; i < files.size (); i++) { cmt_string& file = files[i]; if (test_directory (file)) { if (!remove_directory (file)) return (false); } else { if (!remove_file (file)) return (false); } } int status = ::rmdir (name); if (status != 0) { cout << "Cannot remove directory " << name << " errno=" << errno << endl; return (false); } return (true); }

bool CmtSystem::remove_file ( const cmt_string & name ) [static]

Definition at line 547 of file cmt_system.cxx. Referenced by Cmt::do_config(), remove_directory(), and CmtLock::unlock(). { if (::unlink (name) != 0) { cout << "Cannot remove file " << name << endl; return (false); } return (true); }

CmtSystem::cmt_string_vector & CmtSystem::scan_dir ( const cmt_string & dir_name ) [static]

Definition at line 865 of file cmt_system.cxx. { static cmt_string_vector result; scan_dir (dir_name, result); return (result); }

void CmtSystem::scan_dir ( const cmt_string & dir_name, const cmt_regexp & expression, cmt_string_vector & list ) [static]

Definition at line 773 of file cmt_system.cxx. { static cmt_string dir_prefix; dir_prefix = dir_name; if (dir_name == "") dir_prefix = "."; if (!test_directory (dir_prefix)) { dirname (dir_prefix, dir_prefix); } list.clear (); #ifdef WIN32 long dir; struct _finddata_t entry; static cmt_string search; search = dir_prefix; search += file_separator (); search += "*"; dir = _findfirst (search.c_str (), &entry); if (dir > 0) { for (;;) { if ((entry.name[0] != '.') && (strcmp ((char*) entry.name, ".") != 0) && (strcmp ((char*) entry.name, "..") != 0) && (strncmp ((char*) entry.name, ".nfs", 4) != 0)) { const char* name = entry.name; if (expression.match (name)) { cmt_string& name_entry = list.add (); name_entry = dir_prefix; name_entry += file_separator (); name_entry += name; } } int status = _findnext (dir, &entry); if (status != 0) { break; } } _findclose (dir); } #else //cout << "scan_dir> dir=" << dir_name << endl; DIR* dir = opendir (dir_prefix.c_str ()); struct dirent* entry; if (dir != 0) { while ((entry = readdir (dir)) != 0) { //if (entry->d_name[0] == '.') continue; if (!strcmp ((char*) entry->d_name, ".")) continue; if (!strcmp ((char*) entry->d_name, "..")) continue; if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue; const char* name = entry->d_name; if (!expression.match (name)) continue; cmt_string& name_entry = list.add (); name_entry = dir_prefix; name_entry += file_separator (); name_entry += name; } closedir (dir); } #endif }

void CmtSystem::scan_dir ( const cmt_string & dir_name, cmt_string_vector & list ) [static]

Definition at line 658 of file cmt_system.cxx. Referenced by Cmt::do_config(), Cmt::do_remove(), get_all_files(), is_package_directory(), Use::reach_package(), remove_directory(), UseAnalyzer::run(), scan_dir(), FileScanner::scan_package(), and FileScanner::scan_path(). { static cmt_string dir_prefix; static cmt_string name_prefix; dir_prefix = dir_name; if (dir_name == "") dir_prefix = "."; if (!test_directory (dir_prefix)) { dirname (dir_prefix, dir_prefix); basename (dir_name, name_prefix); } else { } bool need_filter = false; int wild_card; wild_card = name_prefix.find ('*'); if (wild_card != cmt_string::npos) { name_prefix.erase (wild_card); } if (name_prefix.size () > 0) { need_filter = true; } list.clear (); #ifdef WIN32 long dir; struct _finddata_t entry; static cmt_string search; search = dir_prefix; search += file_separator (); search += "*"; dir = _findfirst (search.c_str (), &entry); if (dir > 0) { for (;;) { if ((strcmp ((char*) entry.name, ".") != 0) && (strcmp ((char*) entry.name, "..") != 0) && (strncmp ((char*) entry.name, ".nfs", 4) != 0)) { const char* name = entry.name; if (!need_filter || (strncmp (name, name_prefix.c_str (), name_prefix.size ()) == 0)) { cmt_string& name_entry = list.add (); name_entry = dir_prefix; name_entry += file_separator (); name_entry += name; } } int status = _findnext (dir, &entry); if (status != 0) { break; } } _findclose (dir); } #else //cout << "scan_dir> dir=" << dir_name << endl; DIR* dir = opendir (dir_prefix.c_str ()); struct dirent* entry; if (dir != 0) { while ((entry = readdir (dir)) != 0) { //if (entry->d_name[0] == '.') continue; if (!strcmp ((char*) entry->d_name, ".")) continue; if (!strcmp ((char*) entry->d_name, "..")) continue; if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue; const char* name = entry->d_name; if (need_filter && (strncmp (name, name_prefix.c_str (), name_prefix.size ()) != 0)) continue; //cout << "scan_dir> name=" << name << endl; cmt_string& name_entry = list.add (); name_entry = dir_prefix; name_entry += file_separator (); name_entry += name; } closedir (dir); } #endif }

void CmtSystem::split ( const cmt_string & text, const cmt_string & separators, cmt_string_vector & strings ) [static]

Definition at line 1639 of file cmt_system.cxx. Referenced by DependencyAnalyzer::DependencyAnalyzer(), StandardMacroBuilder::StandardMacroBuilder(), Use::action(), add_cmt_paths_from_text(), PathBuilder::build(), CmtLock::check(), PathBuilder::clean(), Cmt::configure_current_dir(), Cmt::do_broadcast(), Cmt::do_build_library_links(), Cmt::do_remove_library_links(), CmtModel::expand(), DependencyAnalyzer::filter(), TriggerAnalyzer::filter(), SequenceRunner::filter(), Packager::filter(), WinDefAwk::filter(), Prototyper::filter(), RecursivePass2::filter(), RecursivePass1::filter(), Cut::filter(), CvsImplementation::filter_list(), filter_paths(), get_best_form(), get_cmt_paths(), CvsImplementation::match_version_request(), mkdir(), Constituent::parse(), Cmt::parse_arguments(), Cmt::parse_requirements_line(), Cmt::parser(), Cmt::print(), CvsImplementation::really_checkout_package(), Cmt::restore_all_tags(), PackageCollector::run(), DepsBuilder::run(), and Cmt::set_standard_macros(). { static char* buffer = 0; static int allocated = 0; bool finished = false; strings.clear (); if (text.size () == 0) return; /* We are going to work in a copy of the text, since \0 will be inserted right after each found word. Then the vector of strings is iteratively filled by each found word. */ if (buffer == 0) { allocated = text.size (); buffer = (char*) malloc (allocated + 1); } else { if (text.size () > allocated) { allocated = text.size (); buffer = (char*) realloc (buffer, allocated + 1); } } strcpy (buffer, text.c_str ()); /* Algorithm : We look for words separated by <separators> which may be o spaces (' ' or '\t') o other characters such as ':' A word is a character string not containing any separator. A substring in this word my be enclosed between quotes (" or ') which permits separator inclusion within words. */ char* current_word = buffer; while (*current_word != 0) { size_t prefix_length; size_t word_length; /* while ((*current_word == ' ') || (*current_word == '\t')) { current_word++; } */ // first skip all starting separators. prefix_length = strspn (current_word, separators.c_str ()); if (prefix_length > 0) { // Move to the first non-separator character current_word += prefix_length; } /* Parse the next word. It may contain enclosures in quote characters or not. Quotes must be identical on both sides of each enclosure. */ char* running_char = current_word; word_length = 0; for (;;) { size_t unquoted_length; size_t separator_offset; unquoted_length = strcspn (running_char, "\"\'"); separator_offset = strcspn (running_char, separators.c_str ()); if (separator_offset <= unquoted_length) { // no quote in this word -> we are finished for this one. running_char += separator_offset; break; } // We have found a quoted enclosure. Move to it. running_char += unquoted_length; char quote = running_char[0]; // Remove it. { char* p = running_char; while (p[1] != 0) { *p = p[1]; p++; } *p = 0; } // Look for the next occurence of this quote. { char* p = strchr (running_char, quote); if (p == 0) { // Unmatched quote : the rest of the line will be taken as a word... running_char += strlen (running_char); finished = true; break; } else { running_char = p; } } // Now we remove the ending quote from the word // (by shifting all remaining characters by one place to the left) { char* p = running_char; while (p[1] != 0) { *p = p[1]; p++; } *p = 0; } } word_length = running_char - current_word; if (current_word[word_length] == 0) { finished = true; } else { current_word[word_length] = 0; } /* if ((t[0] == '"') || (t[0] == '\'') || (t[0] == ':')) { char* quote; t++; quote = strchr (t, sep); if (quote != 0) *quote = 0; else finished = true; } else { int offset; offset = strcspn (t, " \t:"); if ((offset < 0) || (t[offset] == 0)) finished = true; if (!finished) { space = t + offset; *space = 0; } } */ // Store the current word into the vector of strings { cmt_string& s = strings.add (); s = current_word; } if (finished) break; // Move to the next possible word. current_word += word_length + 1; } }

bool CmtSystem::test_directory ( const cmt_string & name ) [static]

Implementation of the "test -d" equivalent. Definition at line 266 of file cmt_system.cxx. Referenced by add_cmt_path(), Cmt::configure_home(), Cmt::configure_user_context(), Cmt::do_config(), Cmt::do_create(), Cmt::do_remove(), mkdir(), Cmt::parse_arguments(), remove_directory(), MakefileGenerator::reset(), scan_dir(), FileScanner::scan_package(), FileScanner::scan_path(), and CvsImplementation::show_cvs_infos(). { struct stat file_stat; int status; status = stat (name.c_str (), &file_stat); if (status == 0) { if ((file_stat.st_mode & S_IFDIR) == 0) { return (false); } else { return (true); } } else { return (false); } }

bool CmtSystem::test_file ( const cmt_string & name ) [static]

Implementation of the "test -f" equivalent. Definition at line 291 of file cmt_system.cxx. Referenced by add_cmt_paths(), Generator::build_constituents_makefile(), Generator::build_default_makefile(), build_deps(), MakefileGenerator::build_document_makefile(), Generator::commit(), Cmt::configure_current_package(), CvsImplementation::do_checkout(), Cmt::do_config(), Cmt::do_create(), Cmt::do_filter(), is_package_directory(), MakefileGenerator::java_file_action(), Fragment::locate(), MakefileGenerator::module_file_action(), Cmt::parse_requirements(), MakefileGenerator::prepare_proto_file(), Cmt::reach_current_package(), Use::reach_package(), PackageCollector::run(), PackageSelector::run(), FAwk::run(), FileScanner::scan_package(), FileScanner::scan_path(), and Cmt::set_standard_macros(). { struct stat file_stat; int status; status = stat (name.c_str (), &file_stat); if (status == 0) { if ((file_stat.st_mode & S_IFDIR) == 0) { return (true); } else { return (false); } } else { return (false); } }

bool CmtSystem::testenv ( const cmt_string & name ) [static]

Definition at line 1121 of file cmt_system.cxx. Referenced by Pattern::action(), ApplyPattern::apply(), Cmt::configure_home(), Cmt::configure_tags(), Cmt::configure_user_context(), CmtModel::expand(), StandardMacroBuilder::fill_for_tag(), Cmt::parse_arguments(), Cmt::restore_all_tags(), Awk::run(), and Cmt::set_standard_macros(). { const char* env = ::getenv (name); if (env == 0) return (false); return (true); }

cmt_string CmtSystem::user ( ) [static]

Definition at line 1928 of file cmt_system.cxx. Referenced by MakefileGenerator::build_document_makefile(), MakefileGenerator::build_library_makefile(), Generator::build_readme(), CmtLock::check(), and CmtLock::lock(). { #ifdef _WIN32 cmt_string result = getenv ("USERNAME"); #else cmt_string result = getenv ("USER"); #endif return (result); }

---

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

• cmt_system.h
• cmt_system.cxx

---