? ? ? ? ? ?

---

CvsImplementation Class Reference

Internal implementation of CVS to CMT operations. More...

Collaboration diagram for CvsImplementation:

[legend] List of all members.

Public Methods
?	CvsImplementation ()
void?	filter_list (cmt_string &text, const cmt_regexp &exp)
void?	show_cvs_infos (const cmt_string &module)
void?	show_cvs_infos (const cmt_string &offset, const cmt_string &module)
?	Now retrieve all info fields :.
void?	filter_dir (cmt_string &d)
bool?	match_version_request (const cmt_string &text, const cmt_regexp &version_exp, cmt_string &version)
?	From a space-separated list of version tags, try to find one tag matching a given regular expression.
bool?	get_version (const cmt_string &prefix, const cmt_string &package, const cmt_string &version_request, cmt_string &module, cmt_string &version, bool &at_head)
cmt_string?	build_version_directory (const cmt_string &prefix, const cmt_string &package, const cmt_string &version)
?	Here we have at least one version matching the requested expression.
bool?	really_checkout_package (const cmt_string &prefix, const cmt_string &package, const cmt_string &version, const cmt_string &module, const cmt_string &basedir, bool at_head)
cmt_string?	find_matching_version (const cmt_string &expression)
?	The CVS repository had not been created (this is generally due to the lack of top files).
void?	checkout_package (const cmt_string &prefix, const cmt_string &package, const cmt_string &specified_version)
void?	checkout_from_requirements (const cmt_string &requirements_path)
?	We provide a path to a requirements file.
void?	tags (const CmtSystem::cmt_string_vector &arguments)
void?	branches (const cmt_string &module)
void?	subpackages (const cmt_string &module)
void?	help ()
void?	do_checkout (const cmt_string &module, const cmt_string &version_tag)
void?	checkout (const CmtSystem::cmt_string_vector &arguments)
Private Attributes
bool?	m_recursive
bool?	m_head
bool?	m_cmtcvstest
bool?	m_verbose
bool?	m_simulation
cmt_string?	m_home_dir
cmt_string?	m_checkout_dir
cmt_string?	m_offset
cmt_string?	m_branch_suffix
cmt_string?	m_last_module
cmt_string?	m_last_cvs_infos
cmt_string?	error_info
cmt_string?	tags_top_info
cmt_string?	tags_info
cmt_string?	cvsversions_top_info
cmt_string?	cvsversions_info
cmt_string?	branches_info
cmt_string?	subpackages_info

---

Detailed Description

Internal implementation of CVS to CMT operations.

The Cvs class only provides abstract interface.

Definition at line 125 of file cmt_cvs.cxx.

---

Constructor & Destructor Documentation

CvsImplementation::CvsImplementation (? ? )? [inline]

?

Definition at line 129 of file cmt_cvs.cxx. References branches_info, cvsversions_info, cvsversions_top_info, error_info, m_branch_suffix, m_checkout_dir, m_cmtcvstest, m_head, m_home_dir, m_last_cvs_infos, m_last_module, m_offset, m_recursive, m_simulation, m_verbose, subpackages_info, tags_info, and tags_top_info. { m_recursive = false; m_head = false; m_cmtcvstest = false; m_verbose = false; m_simulation = false; m_home_dir = ""; m_checkout_dir = ""; m_offset = ""; m_branch_suffix = ""; m_last_module = ""; m_last_cvs_infos = ""; error_info = ""; tags_top_info = ""; tags_info = ""; cvsversions_top_info = ""; cvsversions_info = ""; branches_info = ""; subpackages_info = ""; }

---

Member Function Documentation

void CvsImplementation::branches (? const cmt_string &? ? module )? [inline]

?

Definition at line 1520 of file cmt_cvs.cxx. References CmtSystem::getenv(), and show_cvs_infos(). Referenced by Cvs::branches(). { cmt_string out; show_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), module); if (error_info != "") { cout << error_info << endl; } else { cout << branches_info << endl; } }

cmt_string CvsImplementation::build_version_directory (? const cmt_string &? ? prefix, const cmt_string &? ? package, const cmt_string &? ? version )? [inline]

?

Here we have at least one version matching the requested expression. Definition at line 693 of file cmt_cvs.cxx. References CmtSystem::file_separator(), Cmt::get_current_structuring_style(), m_checkout_dir, m_home_dir, CmtSystem::reduce_file_separators(), and with_version_directory. Referenced by checkout_package(). { cmt_string dir = m_home_dir; if (m_checkout_dir != "") { dir += CmtSystem::file_separator (); dir += m_checkout_dir; } dir += CmtSystem::file_separator (); dir += prefix; dir += CmtSystem::file_separator (); dir += package; if (Cmt::get_current_structuring_style () == with_version_directory) { dir += CmtSystem::file_separator (); dir += version; } CmtSystem::reduce_file_separators (dir); return (dir); }

void CvsImplementation::checkout (? const CmtSystem::cmt_string_vector &? ? arguments )? [inline]

?

Definition at line 1741 of file cmt_cvs.cxx. References checkout_from_requirements(), do_checkout(), CmtSystem::getenv(), help(), CmtSystem::pwd(), cmt_string::replace_all(), and cmt_vector< cmt_string >::size(). Referenced by Cvs::checkout(). { if (arguments.size () < 1) { help (); return; } if (CmtSystem::getenv ("CVSROOT") == "") { cout << "# Please set CVSROOT first !" << endl; return; } if (CmtSystem::getenv ("CMTCVSTEST") != "") { m_cmtcvstest = true; } else { m_cmtcvstest = false; } m_home_dir = CmtSystem::pwd (); m_checkout_dir = ""; m_offset = ""; m_branch_suffix = ""; cmt_string module; m_recursive = false; bool need_version_tag = false; cmt_string version_tag; bool need_checkout_dir = false; bool need_offset = false; bool need_requirements_file = false; m_simulation = false; //m_verbose = true; m_verbose = false; bool need_branch_suffix = false; m_head = true; m_offset = CmtSystem::getenv ("CMTCVSOFFSET"); if (m_offset != "") { m_offset += "/"; m_offset.replace_all ("//", "/"); } for (int arg = 0; arg < arguments.size (); arg++) { const cmt_string& option = arguments[arg]; if (need_version_tag) { need_version_tag = false; if (option == "HEAD") { m_head = true; } else { version_tag = option; } } else if (need_checkout_dir) { need_checkout_dir = false; m_checkout_dir = option; } else if (need_offset) { need_offset = false; m_offset = option; m_offset += '/'; m_offset.replace_all ("//", "/"); } else if (need_branch_suffix) { need_branch_suffix = false; m_branch_suffix = "-"; m_branch_suffix += option; } else if (need_requirements_file) { need_requirements_file = false; m_head = false; checkout_from_requirements (option); } else { if (option == "-R") { m_recursive = true; } else if (option == "-l") { m_recursive = false; } else if (option == "-r") { need_version_tag = true; m_head = false; } else if (option == "-d") { need_checkout_dir = true; } else if (option == "-o") { need_offset = true; } else if (option == "-n") { m_simulation = true; } else if (option == "-v") { m_verbose = true; } else if (option == "-branch") { need_branch_suffix = true; } else if (option == "-requirements") { need_requirements_file = true; } else if (option == "--help") { help (); return; } else if (option[0] == '-') { help (); return; } else { do_checkout (option, version_tag); } } } }

void CvsImplementation::checkout_from_requirements (? const cmt_string &? ? requirements_path )? [inline]

?

We provide a path to a requirements file. From it we read the use statements, and we try to checkout the corresponding packages. Definition at line 1427 of file cmt_cvs.cxx. References cmt_string::read(), RecursivePass1::result(), and Awk::run(). Referenced by checkout(), and checkout_package(). { static cmt_regexp expression ("^[ \t]*use[ \t]"); cmt_string text; text.read (requirements_path); RecursivePass1 p1; p1.run (text, expression); RecursivePass2 p2 (*this); p2.run (p1.result ()); }

void CvsImplementation::checkout_package (? const cmt_string &? ? prefix, const cmt_string &? ? package, const cmt_string &? ? specified_version )? [inline]

?

Definition at line 1193 of file cmt_cvs.cxx. References build_version_directory(), CmtSystem::cd(), checkout_from_requirements(), CmtSystem::file_separator(), cmt_string::find(), find_matching_version(), Cmt::get_current_structuring_style(), get_version(), cmt_string::npos, really_checkout_package(), CmtSystem::test_directory(), CmtSystem::test_file(), without_version_directory, and cmt_string::write(). Referenced by do_checkout(), and RecursivePass2::filter(). { if (m_verbose) { cout << "#CMT> checkout_package> prefix=" << prefix << " package=" << package << " specified_version=" << specified_version << endl; } cmt_string version = specified_version; cmt_string empty; cmt_string full_prefix; full_prefix = m_offset; full_prefix += prefix; cmt_string echo_ppath; if (prefix != "") { echo_ppath = " path "; echo_ppath += prefix; } if (version == "") { cout << "# ================= No version specified for package " << package << endl; return; } // // First make an attempt to locate the specified version of // this package "as-it-is" in the work area. // Since 'version' may contain wild-card, it's likely that // we should not simply use CmtSystem::test_directory but // use the wild-card search. // cmt_string dir; dir = build_version_directory (prefix, package, version); if (m_cmtcvstest) cout << "## (testing dir= " << dir << ")" << endl; bool recursive = m_recursive; /* if (m_cmtcvstest) { cmt_string v = find_matching_version (dir); cout << "---> v=" << v << endl; } */ cmt_string effective_version = find_matching_version (dir); if (effective_version != "") { version = effective_version; dir = build_version_directory (prefix, package, version); cout << "# ================= Package " << package << " version " << version << echo_ppath << " already installed in " << dir << endl; recursive = false; } else { bool at_head = false; cmt_string module; // // get_version attempts to find the most appropriate version // tag matching the specification FROM the repository. However, // we should take into account situations where some versions have // already been checked out, in which case they might be sufficient // (or preferred?) // if (version.find ("*") != cmt_string::npos) { cout << "# ================= Package " << package << " version " << version << echo_ppath << " has wild cards and will not be considered." << endl; return; } if (!get_version (full_prefix, package, version, module, version, at_head)) { return; } //cout << " full_prefix=[" << full_prefix << "] module=[" << module << "]" << endl; if (m_cmtcvstest) cout << "## after get_version at_head=" << at_head << " m_head=" << m_head << endl; if (m_head) { m_head = false; at_head = true; } else { at_head = false; } // // Make a second try after having selected a version from all the // available versions compatible with the specified version // dir = build_version_directory (prefix, package, version); if (CmtSystem::test_directory (dir)) { cout << "# ================= Package " << package << " version " << version << echo_ppath << " already installed." << endl; recursive = false; } else { // // Now we can say that we have to perform the real checkout. // if (!really_checkout_package (prefix, package, version, module, dir, at_head)) { cout << "# bad return from really_checkout_package" << endl; return; } } } // // Now reach the newly checked out package. // if (m_simulation) { cout << "#CMT> Package directory not really created " << dir << endl; } else { if (!CmtSystem::cd (dir)) { cout << "#CMT> Package directory not created " << dir << endl; } /* if (m_verbose) { cout << "#CMT> pwd.4=" << CmtSystem::pwd () << endl; } */ // Check if it is a true CMT package. cmt_string file_name; file_name = "cmt"; file_name += CmtSystem::file_separator (); file_name += "requirements"; if (CmtSystem::test_file (file_name)) { dir += CmtSystem::file_separator (); dir += "cmt"; CmtSystem::cd ("cmt"); /* if (m_verbose) { cout << "#CMT> pwd.5=" << CmtSystem::pwd () << endl; } */ if (Cmt::get_current_structuring_style () == without_version_directory) { cmt_string text = version; text += "\n"; text.write ("version.cmt"); } } else { file_name = "mgr"; file_name += CmtSystem::file_separator (); file_name += "requirements"; if (CmtSystem::test_file (file_name)) { dir += CmtSystem::file_separator (); dir += "mgr"; CmtSystem::cd ("mgr"); /* if (m_verbose) { cout << "#CMT> pwd.6=" << CmtSystem::pwd () << endl; } */ } else { cout << "# " << package << " not a CMT package" << endl; return; } } //cout << "# (recursive is " << recursive << ")" << endl; if (recursive) { checkout_from_requirements ("requirements"); } } }

void CvsImplementation::do_checkout (? const cmt_string &? ? module, const cmt_string &? ? version_tag )? [inline]

?

Definition at line 1570 of file cmt_cvs.cxx. References CmtSystem::basename(), CmtSystem::cd(), checkout_package(), History::clear(), CmtSystem::dirname(), CmtSystem::execute(), CmtSystem::file_separator(), History::instance(), CmtSystem::reduce_file_separators(), Cut::result(), Awk::run(), show_cvs_infos(), and CmtSystem::test_file(). Referenced by checkout(). { //CMTPATH=${CMTPATH}:${m_home_dir}; export CMTPATH History& h = History::instance (); h.clear (); if (module == "") { if (m_verbose) { cout << "#CMT> Missing module name" << endl; } return; } cmt_string prefix; cmt_string package; cmt_string version; if (version_tag == "") { Cut cut (0); cmt_string m; m = m_offset; m += module; show_cvs_infos (m); if (error_info != "") { cout << error_info << endl; return; } if (tags_top_info != "") version = tags_top_info; else version = tags_info; //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "version=" << version << endl; cut.run (version); version = cut.result (); //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "version=" << version << endl; } else { version = version_tag; } CmtSystem::dirname (module, prefix); CmtSystem::basename (module, package); cmt_string top_dir; top_dir = m_home_dir; top_dir += CmtSystem::file_separator (); top_dir += m_checkout_dir; top_dir += CmtSystem::file_separator (); top_dir += prefix; top_dir += CmtSystem::file_separator (); top_dir += package; top_dir += CmtSystem::file_separator (); top_dir += version; CmtSystem::reduce_file_separators (top_dir); if (m_verbose) { cout << "#CMT> about to checkout package " << package << " version " << version << " into " << top_dir << endl; } checkout_package (prefix, package, version); /* if (m_verbose) { cout << "#CMT> after checkout_package pwd.7=" << CmtSystem::pwd () << " top_dir=" << top_dir << endl; } */ if (m_simulation) return; if (!CmtSystem::cd (top_dir)) return; /* if (m_verbose) { cout << "#CMT> pwd.8=" << CmtSystem::pwd () << endl; } */ cmt_string file_name; file_name = "cmt"; file_name += CmtSystem::file_separator (); file_name += "requirements"; if (CmtSystem::test_file (file_name)) { top_dir += CmtSystem::file_separator (); top_dir += "cmt"; CmtSystem::cd ("cmt"); /* if (m_verbose) { cout << "#CMT> pwd.9=" << CmtSystem::pwd () << endl; } */ } else { file_name = "mgr"; file_name += CmtSystem::file_separator (); file_name += "requirements"; if (CmtSystem::test_file (file_name)) { top_dir += CmtSystem::file_separator (); top_dir += "mgr"; CmtSystem::cd ("mgr"); /* if (m_verbose) { cout << "#CMT> pwd.10=" << CmtSystem::pwd () << endl; } */ } else { cout << "# " << package << " was not properly checked out and is missing its cmt/requirements file" << endl; return; } } if (m_verbose) { cout << "#CMT> package " << package << " has been checked out" << endl; } if (m_recursive) { if (m_verbose || m_simulation) { cout << "#CMT> Executing [" << "cmt -quiet broadcast cmt -quiet config" << "]" << endl; } if (!m_simulation) { CmtSystem::execute ("cmt -quiet broadcast cmt -quiet config"); } } else { if (m_verbose || m_simulation) { cout << "#CMT> Executing [" << "cmt -quiet config" << "]" << endl; } if (!m_simulation) { CmtSystem::execute ("cmt -quiet config"); } } }

void CvsImplementation::filter_dir (? cmt_string &? ? d )? [inline]

?

Definition at line 484 of file cmt_cvs.cxx. References cmt_string::erase(), cmt_string::find(), and cmt_string::npos. { while (true) { int pos = d.find ("/../"); if (pos == cmt_string::npos) break; int slash = d.find ("/"); if (slash < pos) { // // xxxxx/yyy/../zzzz -> xxxxx/zzzz // 01234567890123456 // 1234567 // pos = 9 // slash = 5 // length = 9+3-5 // d.erase (slash + 1, pos + 3 - slash); } else { // // yyy/../zzzz -> zzzz // 01234567890 // 1234567 // pos = 3 // length = 3+1+3 // d.erase (0, pos + 1 + 3); } } }

void CvsImplementation::filter_list (? cmt_string &? ? text, const cmt_regexp &? ? exp )? [inline]

?

Definition at line 153 of file cmt_cvs.cxx. References cmt_regexp::match(), cmt_vector< cmt_string >::size(), and CmtSystem::split(). Referenced by show_cvs_infos(). { CmtSystem::cmt_string_vector list; CmtSystem::split (text, " ", list); int i; text = ""; for (i = 0; i < list.size (); i++) { const cmt_string& s = list[i]; if (exp.match (s)) { if (i > 0) text += " "; text += s; } } }

cmt_string CvsImplementation::find_matching_version (? const cmt_string &? ? expression )? [inline]

?

The CVS repository had not been created (this is generally due to the lack of top files). Definition at line 1132 of file cmt_cvs.cxx. References CmtSystem::basename(), CmtSystem::dirname(), CmtSystem::file_separator(), cmt_string::find(), cmt_string::npos, cmt_string::replace(), CmtSystem::scan_dir(), cmt_vector< cmt_string >::size(), and CmtSystem::test_directory(). Referenced by checkout_package(). { cmt_string result; // // Here expression takes the form // / // cmt_string dir; CmtSystem::dirname (expression, dir); dir += CmtSystem::file_separator (); cmt_string version; CmtSystem::basename (expression, version); if (version.find ("*") == cmt_string::npos) { // there is no wildcarding here. A simple test is enough. if (CmtSystem::test_directory (expression)) { if (m_cmtcvstest) cout << "## Found direct match with " << version << endl; result = version; } else { if (m_cmtcvstest) cout << "## Explicit version " << version << " has no direct match" << endl; } } else { version.replace ("*", ".*"); cmt_regexp exp (version); CmtSystem::cmt_string_vector list; if (m_cmtcvstest) cout << "## Trying scan_dir dir=" << dir << " exp=" << version << endl; CmtSystem::scan_dir (dir, exp, list); if (list.size () > 0) { result = list[0]; if (m_cmtcvstest) cout << "## At least one version is matching " << version << "(" << list.size () << " matches) " << result << endl; CmtSystem::basename (result, result); } else { if (m_cmtcvstest) cout << "## There is no version matching " << version << endl; } } return (result); }

bool CvsImplementation::get_version (? const cmt_string &? ? prefix, const cmt_string &? ? package, const cmt_string &? ? version_request, cmt_string &? ? module, cmt_string &? ? version, bool &? ? at_head )? [inline]

?

Definition at line 550 of file cmt_cvs.cxx. References error_info, cmt_string::find(), match_version_request(), cmt_string::npos, cmt_string::replace(), cmt_string::replace_all(), show_cvs_infos(), tags_info, and tags_top_info. Referenced by checkout_package(). { Grep grep; cmt_string topversions; cmt_string versions; cmt_string requested_version = version_request; at_head = false; module = ""; if (prefix != "") { module = prefix; module += "/"; // This is for CVS only thus we don't use the real separator. while (module.find ("//") != cmt_string::npos) { module.replace_all ("//", "/"); } } module += package; if (m_verbose) { cout << "#CMT> requesting cvs infos onto module " << module << endl; } show_cvs_infos (module); if (error_info != "") { versions = ""; cout << "# Package " << package << " not found in ${CVSROOT}" << endl; return (false); } versions = tags_top_info; cmt_string v = version_request; if (version_request.find ("*") != cmt_string::npos) { v.replace_all ("*", ".*"); } else { v += "$"; } if (m_cmtcvstest) cout << "## (version expression is " << v << ")" << endl; cmt_regexp version_exp (v); if (!match_version_request (versions, version_exp, version)) { if (m_cmtcvstest) cout << "## (no match in " << versions << ")" << endl; // We try on non-top versions versions = tags_info; if (!match_version_request (versions, version_exp, version)) { if (m_cmtcvstest) cout << "## (no match in " << versions << ")" << endl; version = requested_version; int pos = 0; if ((pos = version.find ("*")) != cmt_string::npos) { // // There was a wild card but the expression does not match // any of the existing tags in CVS. // Things will be retreived from HEAD but we have to build // a reasonable version tag from the wild card expression. // If the letter before the * was a digit, then simply remove // the * (v5* -> v5) otherwise add a zero (v5r* -> v5r0) // if (pos > 0) { char letter = version[pos-1]; static const cmt_string digits = "0123456789"; if (digits.find (letter) == cmt_string::npos) { // "v5r*" -> "v5r0" version.replace ("*", "0"); } else { // "v5*" -> "v5" version.replace ("*", ""); } } else { // The expression was simply "*" !!! version = "v0"; } } at_head = true; } else { if (m_cmtcvstest) cout << "## (match in non head " << versions << ")" << endl; at_head = false; } } else { if (m_cmtcvstest) cout << "## (match in head " << versions << ")" << endl; at_head = true; } return (true); }

void CvsImplementation::help (? ? )? [inline]

?

Definition at line 1552 of file cmt_cvs.cxx. Referenced by checkout(), and tags(). { cout << "> cd " << endl; cout << "> cmt checkout [modifier ...] " << endl; cout << "" << endl; cout << " modifier :" << endl; cout << " -l Do not process used packages (default)." << endl; cout << " -R Process used packages recursively." << endl; cout << " -r rev Check out version tag. (is sticky)" << endl; cout << " -d dir Check out into dir instead of module name." << endl; cout << " -o offset Offset in the CVS repository" << endl; cout << " -requirements Check out packages referenced in this requirements file" << endl; cout << " -n simulation mode on" << endl; cout << " -v verbose mode on" << endl; cout << " --help print this help" << endl; cout << "" << endl; }

bool CvsImplementation::match_version_request (? const cmt_string &? ? text, const cmt_regexp &? ? version_exp, cmt_string &? ? version )? [inline]

?

From a space-separated list of version tags, try to find one tag matching a given regular expression. o The first matching tag is returned into 'version' o Success is returned as function value. Definition at line 526 of file cmt_cvs.cxx. References cmt_regexp::match(), cmt_vector< cmt_string >::size(), and CmtSystem::split(). Referenced by get_version(). { CmtSystem::cmt_string_vector vs; CmtSystem::split (text, " \t", vs); version = ""; for (int i = 0; i < vs.size (); i++) { const cmt_string& vv = vs[i]; if (version_exp.match (vv)) { version = vv; return (true); } } return (false); }

bool CvsImplementation::really_checkout_package (? const cmt_string &? ? prefix, const cmt_string &? ? package, const cmt_string &? ? version, const cmt_string &? ? module, const cmt_string &? ? basedir, bool? ? at_head )? [inline]

?

Definition at line 721 of file cmt_cvs.cxx. References CmtSystem::cd(), CmtSystem::command_separator(), CmtSystem::dirname(), cmt_string::erase(), CmtSystem::execute(), CmtSystem::file_separator(), cmt_string::find(), Cmt::get_current_structuring_style(), CmtSystem::get_cvsroot(), CmtSystem::getenv(), CmtSystem::mkdir(), cmt_string::read(), cmt_vector< cmt_string >::size(), CmtSystem::split(), CmtSystem::test_directory(), with_version_directory, and cmt_string::write(). Referenced by checkout_package(). { cmt_string dir = basedir; cmt_string out; cout << "# ================= working on package " << package << " version " << version; if (at_head) cout << " (At head) "; { cmt_string full_prefix; full_prefix = m_offset; full_prefix += prefix; cmt_string echo_ppath; if (prefix != "") { echo_ppath = " path "; echo_ppath += prefix; } cout << echo_ppath << endl; } CmtSystem::dirname (dir, dir); //if (Cmt::get_current_structuring_style () == with_version_directory) { if (m_simulation) { cout << "#CMT> Would mkdir " << dir << endl; } else { if (m_verbose) { cout << "#CMT> About to mkdir " << dir << endl; } if (!CmtSystem::mkdir (dir)) { cout << "# Error creating the base directory :" << dir << endl; cout << "#---------------------------------------------------------" << endl; return (false); } CmtSystem::cd (dir); /* if (m_verbose) { cout << "#CMT> pwd.1=" << CmtSystem::pwd () << endl; } */ } } cout << " # get top files " << endl; cmt_string command = "cvs -Q co -P -l "; if (!at_head) { command += "-r "; command += version; } if (Cmt::get_current_structuring_style () == with_version_directory) { command += " -d "; command += version; } else { command += " -d "; command += package; } command += " "; command += module; if (m_cmtcvstest) { cmt_string cvsroot; CmtSystem::get_cvsroot (cvsroot); cout << "## cvsroot=" << cvsroot << " command[" << command << "]" << endl; } int status = 0; int retry = 0; for (;;) { if (m_verbose || m_simulation) { cout << "#CMT> Executing [" << command << "]" << endl; } if (!m_simulation) { //status = CmtSystem::execute (command, out); status = CmtSystem::execute (command); } if (status != 0) { retry++; cout << "# Error getting package CMT contents: status=" << status << endl; cout << "#---------------------------------------------------------" << endl; if (retry > 5) exit(0); } else { break; } } { if (Cmt::get_current_structuring_style () == with_version_directory) { if (m_simulation) { cout << "#CMT> Would mkdir " << version << endl; } else { if (m_verbose) { cout << "#CMT> About to mkdir " << version << endl; } if (!CmtSystem::cd (version)) { CmtSystem::mkdir (version); if (!CmtSystem::cd (version)) { cout << "# Error creating the version directory :" << version << endl; cout << "#---------------------------------------------------------" << endl; return (false); } } /* if (m_verbose) { cout << "#CMT> pwd.2=" << CmtSystem::pwd () << endl; } */ } dir += CmtSystem::file_separator (); dir += version; } else { if (m_simulation) { cout << "#CMT> will mkdir " << package << endl; } else { if (!CmtSystem::cd (package)) { if (m_verbose) { cout << "#CMT> About to mkdir " << package << endl; } CmtSystem::mkdir (package); if (!CmtSystem::cd (package)) { cout << "# Error creating the package directory :" << package << endl; cout << "#---------------------------------------------------------" << endl; return (false); } } /* if (m_verbose) { cout << "#CMT> pwd.3=" << CmtSystem::pwd () << endl; } */ } dir += CmtSystem::file_separator (); dir += package; } } cmt_string entries_file_name; cmt_string text; cmt_string branches = CmtSystem::getenv ("CMTCVSBRANCHES"); if (branches == "") { branches = branches_info; } CmtSystem::cmt_string_vector branch_vector; CmtSystem::split (branches, " \t", branch_vector); int i; cout << " # get branches " << branches << endl; //command = "("; command = ""; entries_file_name = "CVS"; entries_file_name += CmtSystem::file_separator (); entries_file_name += "Entries"; if (!text.read (entries_file_name)) { // This happens when there were no top files } for (i = 0; i < branch_vector.size (); i++) { cmt_string& branch = branch_vector[i]; if (i > 0) { command += CmtSystem::command_separator (); } //command += "cvs -Q co -P "; command += "cvs -Q co "; // if (branch != "cmt") // { if (!at_head) { command += "-r "; command += version; } // } command += " -d "; command += branch; command += " "; command += module; command += "/"; // CVS uses the '/' notation on all platforms!! command += branch; //command += "\n"; text += "D/"; text += branch; text += " } //command += "; echo cmtcvsstatus=$?) 2>&1 "; if (m_cmtcvstest) { cmt_string cvsroot; CmtSystem::get_cvsroot (cvsroot); cout << " cvsroot=" << cvsroot << " command[" << command << "]" << endl; } status = 0; retry = 0; for (;;) { if (m_verbose || m_simulation) { cout << "#CMT> Executing [" << command << "]" << endl; } if (!m_simulation) { //status = CmtSystem::execute (command, out); status = CmtSystem::execute (command); } if (status != 0) { retry++; cout << "# Error getting package contents: status=" << status << endl; cout << "#---------------------------------------------------------" << endl; if (retry > 5) exit(0); } else { break; } } { if (!CmtSystem::test_directory ("CVS")) { if (m_simulation) { cout << "#CMT> Would create the CVS directory" << endl; } else { if (m_verbose) { cout << "#CMT> About to mkdir " << "CVS" << endl; } CmtSystem::mkdir ("CVS"); } cmt_string s; // Let's create first the CVS/Root file. CmtSystem::get_cvsroot (s); s += "\n"; cmt_string f; f = "CVS"; f += CmtSystem::file_separator (); f += "Root"; if (m_simulation) { cout << "#CMT> Would fill in the CVS/Root file with " << endl; cout << s << endl; } else { if (m_verbose) { cout << "#CMT> Fill in the CVS/Root file with " << endl; cout << s << endl; } s.write (f); } // Now we create the CVS/Repository file f = "CVS"; f += CmtSystem::file_separator (); f += "Repository"; CmtSystem::get_cvsroot (s); if (s[0] == ':') { int pos = s.find (1, ":"); s.erase (0, pos+1); pos = s.find (0, ":"); s.erase (0, pos+1); } s += "/"; s += module; s += "\n"; if (m_simulation) { cout << "#CMT> Would fill in the CVS/Repository file with " << endl; cout << s << endl; } else { if (m_verbose) { cout << "#CMT> Fill in the CVS/Repository file with " << endl; cout << s << endl; } s.write (f); } } if (m_simulation) { cout << "#CMT> Would write the top CVS/Entries file with " << endl; cout << text << endl; } else { // Now the CVS/Entries is ready to be created. if (m_verbose) { cout << "#CMT> Fill in the top CVS/Entries file with " << endl; cout << text << endl; } text.write (entries_file_name); } } return (true); }

void CvsImplementation::show_cvs_infos (? const cmt_string &? ? offset, const cmt_string &? ? module )? [inline]

?

Now retrieve all info fields :. error= tags_top= tags= branches= subpackages= Definition at line 461 of file cmt_cvs.cxx. References cmt_string::find(), cmt_string::npos, cmt_string::replace_all(), and show_cvs_infos(). { cmt_string full_name; if (offset != "") { full_name = offset; full_name += "/"; while (full_name.find ("//") != cmt_string::npos) { full_name.replace_all ("//", "/"); } } full_name += module; show_cvs_infos (full_name); }

void CvsImplementation::show_cvs_infos (? const cmt_string &? ? module )? [inline]

?

Definition at line 195 of file cmt_cvs.cxx. References CmtSystem::basename(), branches_info, CmtSystem::cd(), cvsversions_info, cvsversions_top_info, error_info, CmtSystem::execute(), CmtSystem::file_separator(), filter_list(), CmtSystem::get_cvsroot(), CmtSystem::get_temporary_name(), CmtSystem::getenv(), m_last_cvs_infos, m_last_module, m_simulation, m_verbose, CmtSystem::mkdir(), CmtSystem::pwd(), CmtSystem::remove_directory(), cmt_string::replace(), cmt_string::replace_all(), Grep::result(), Awk::run(), subpackages_info, tags_info, tags_top_info, and CmtSystem::test_directory(). Referenced by branches(), do_checkout(), get_version(), show_cvs_infos(), subpackages(), and tags(). { if (module == "") { cout << "# cmt cvs needs a module name" << endl; return; } if (module == m_last_module) { if (m_verbose) { cout << "#CMT> cvs infos for module " << module << " already there" << endl; } } else { m_last_module = module; cmt_string home_dir = CmtSystem::pwd (); // // Activities related with .cmtcvsinfos will occur in a temporary directory // cmt_string tmp_dir = CmtSystem::getenv ("TMPDIR"); if (tmp_dir == "") { tmp_dir = CmtSystem::file_separator (); tmp_dir += "tmp"; } if (!CmtSystem::cd (tmp_dir)) { tmp_dir = home_dir; } tmp_dir += CmtSystem::file_separator (); tmp_dir += "cmtcvs"; { cmt_string temp = CmtSystem::get_temporary_name (); CmtSystem::basename (temp, temp); tmp_dir += temp; } if (!CmtSystem::test_directory (tmp_dir)) { if (!CmtSystem::mkdir (tmp_dir)) { cout << "# Cannot create the temporary directory [" << tmp_dir << "]" << endl; return; } } //trap "rm -rf ${tmp_dir}" 0 1 2 15 if (!CmtSystem::cd (tmp_dir)) { cout << "# Cannot move to the temporary directory " << tmp_dir << endl; if (m_verbose) { cout << "#CMT> now removing tmp_dir " << tmp_dir << " home=" << home_dir << endl; } CmtSystem::remove_directory (tmp_dir); return; } if (m_verbose) { cout << "#CMT> cvs infos are now obtained from the temporary directory " << CmtSystem::pwd () << endl; } /* # # The script associated to such entries is supposed to : # 1) extract the set of from the ${module}/cmt/requirements file # 2) build an output of the form : # =info1 info2 info3 ... # # Currently this script can be found in # # ${CMTROOT}/cmt/cmt_buildcvsinfos2.sh # %CMTROOT%/cmt/cmt_buildcvsinfos.py # */ if (!CmtSystem::test_directory (".cmtcvsinfos")) { CmtSystem::mkdir (".cmtcvsinfos"); } CmtSystem::cd (".cmtcvsinfos"); cmt_string cvsroot; CmtSystem::get_cvsroot (cvsroot); cmt_string command; command = "cvs"; if (cvsroot != "") { command += " -d "; command += cvsroot; } command += " -Q import -m cmt "; if (m_cmtcvstest) { command += ".cmtcvsinfos/cmtcvstest"; } else { command += ".cmtcvsinfos"; } command += "/"; command += module; command += " CMT v1"; if (m_verbose || m_simulation) { cout << "#CMT> Executing [" << command << "]" << endl; } m_last_cvs_infos = ""; CmtSystem::execute (command, m_last_cvs_infos); if (m_verbose) { cout << "#CMT> now removing tmp_dir " << tmp_dir << " home=" << home_dir << endl; } CmtSystem::remove_directory (tmp_dir); CmtSystem::cd (home_dir); } Grep grep; grep.run (m_last_cvs_infos, "error="); if (grep.result () != "") { error_info = grep.result (); error_info.replace ("error=", ""); } else { error_info = ""; } grep.run (m_last_cvs_infos, "tags_top="); if (grep.result () != "") { tags_top_info = grep.result (); tags_top_info.replace ("tags_top=", ""); } else { tags_top_info = ""; } grep.run (m_last_cvs_infos, "tags="); if (grep.result () != "") { tags_info = grep.result (); tags_info.replace ("tags=", ""); } else { tags_info = ""; } grep.run (m_last_cvs_infos, "cvsversions_top="); if (grep.result () != "") { cvsversions_top_info = grep.result (); cvsversions_top_info.replace ("cvsversions_top=", ""); } else { cvsversions_top_info = ""; } grep.run (m_last_cvs_infos, "cvsversions="); if (grep.result () != "") { cvsversions_info = grep.result (); cvsversions_info.replace ("cvsversions=", ""); } else { cvsversions_info = ""; } cmt_string tag_filter = CmtSystem::getenv ("CMTCVSTAGFILTER"); if (tag_filter != "") { cmt_string package; CmtSystem::basename (module, package); cmt_string pattern = ""; tag_filter.replace_all (pattern, package); cmt_regexp exp (tag_filter); cmt_string text; filter_list (tags_top_info, exp); filter_list (tags_info, exp); filter_list (cvsversions_top_info, exp); filter_list (cvsversions_info, exp); } if (m_cmtcvstest) { cout << "## tags_top_info=" << tags_top_info << endl; cout << "## tags_info=" << tags_info << endl; cout << "## cvsversions_top_info=" << cvsversions_top_info << endl; cout << "## cvsversions_info=" << cvsversions_info << endl; } grep.run (m_last_cvs_infos, "branches="); if (grep.result () != "") { branches_info = grep.result (); branches_info.replace ("branches=", ""); } else { branches_info = ""; } grep.run (m_last_cvs_infos, "subpackages="); if (grep.result () != "") { subpackages_info = grep.result (); subpackages_info.replace ("subpackages=", ""); } else { subpackages_info = ""; } }

void CvsImplementation::subpackages (? const cmt_string &? ? module )? [inline]

?

Definition at line 1536 of file cmt_cvs.cxx. References CmtSystem::getenv(), and show_cvs_infos(). Referenced by Cvs::subpackages(). { cmt_string out; show_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), module); if (error_info != "") { cout << error_info << endl; } else { cout << subpackages_info << endl; } }

void CvsImplementation::tags (? const CmtSystem::cmt_string_vector &? ? arguments )? [inline]

?

Definition at line 1442 of file cmt_cvs.cxx. References CmtSystem::getenv(), help(), show_cvs_infos(), cmt_vector< cmt_string >::size(), and CmtSystem::split(). Referenced by Cvs::tags(). { if (arguments.size () < 1) { help (); return; } if (CmtSystem::getenv ("CVSROOT") == "") { cout << "# Please set CVSROOT first !" << endl; return; } if (CmtSystem::getenv ("CMTCVSTEST") != "") { m_cmtcvstest = true; } else { m_cmtcvstest = false; } m_offset = CmtSystem::getenv ("CMTCVSOFFSET"); if (m_offset != "") { m_offset += "/"; m_offset.replace_all ("//", "/"); } bool all = false; for (int arg = 0; arg < arguments.size (); arg++) { const cmt_string& option = arguments[arg]; if (option == "-all") { all = true; } else { show_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), option); if (error_info != "") { cout << error_info << endl; } else { cmt_string tags; if (all) { tags = cvsversions_top_info; tags += " "; tags += cvsversions_info; } else { tags = tags_top_info; tags += " "; tags += tags_info; } CmtSystem::cmt_string_vector v; CmtSystem::split (tags, " \t", v); for (int i = 0; i < v.size (); i++) { const cmt_string& s = v[i]; cout << s << endl; } } } } }

---

Member Data Documentation

cmt_string CvsImplementation::branches_info [private]

?	Definition at line 1914 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::cvsversions_info [private]

?	Definition at line 1913 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::cvsversions_top_info [private]

?	Definition at line 1912 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::error_info [private]

?	Definition at line 1909 of file cmt_cvs.cxx. Referenced by CvsImplementation(), get_version(), and show_cvs_infos().

cmt_string CvsImplementation::m_branch_suffix [private]

?	Definition at line 1905 of file cmt_cvs.cxx. Referenced by CvsImplementation().

cmt_string CvsImplementation::m_checkout_dir [private]

?	Definition at line 1903 of file cmt_cvs.cxx. Referenced by build_version_directory(), and CvsImplementation().

bool CvsImplementation::m_cmtcvstest [private]

?	Definition at line 1898 of file cmt_cvs.cxx. Referenced by CvsImplementation().

bool CvsImplementation::m_head [private]

?	Definition at line 1897 of file cmt_cvs.cxx. Referenced by CvsImplementation().

cmt_string CvsImplementation::m_home_dir [private]

?	Definition at line 1902 of file cmt_cvs.cxx. Referenced by build_version_directory(), and CvsImplementation().

cmt_string CvsImplementation::m_last_cvs_infos [private]

?	Definition at line 1908 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::m_last_module [private]

?	Definition at line 1907 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::m_offset [private]

?	Definition at line 1904 of file cmt_cvs.cxx. Referenced by CvsImplementation().

bool CvsImplementation::m_recursive [private]

?	Definition at line 1896 of file cmt_cvs.cxx. Referenced by CvsImplementation().

bool CvsImplementation::m_simulation [private]

?	Definition at line 1900 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

bool CvsImplementation::m_verbose [private]

?	Definition at line 1899 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::subpackages_info [private]

?	Definition at line 1915 of file cmt_cvs.cxx. Referenced by CvsImplementation(), and show_cvs_infos().

cmt_string CvsImplementation::tags_info [private]

?	Definition at line 1911 of file cmt_cvs.cxx. Referenced by CvsImplementation(), get_version(), and show_cvs_infos().

cmt_string CvsImplementation::tags_top_info [private]

?	Definition at line 1910 of file cmt_cvs.cxx. Referenced by CvsImplementation(), get_version(), and show_cvs_infos().

---

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

• cmt_cvs.cxx

---