#include <cmt_system.h>
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) |
|
Definition at line 12 of file cmt_system.h. |
|
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(). 00217 { 00218 if (name.size () == 0) return (false); 00219 00220 if ((name[0] == '/') || 00221 (name[0] == '\\')) return (true); 00222 00223 if (name.size () >= 2) 00224 { 00225 if (name[1] == ':') 00226 { 00227 return (true); 00228 } 00229 } 00230 return (false); 00231 } |
|
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(). 01165 { 01166 cmt_string npath = path; 01167 01168 if (path == "") return; 01169 01170 npath.replace_all ("\\", file_separator ()); 01171 npath.replace_all ("/", file_separator ()); 01172 01173 if (!test_directory (npath)) 01174 { 01175 CmtError::set (CmtError::path_not_found, npath); 01176 return; 01177 } 01178 01179 for (int i = 0; i < paths.size (); i++) 01180 { 01181 const cmt_string& p = paths[i]; 01182 01183 if (p == npath) return; 01184 } 01185 01186 cmt_string& new_path = paths.add (); 01187 new_path = npath; 01188 01189 cmt_string here = pwd (); 01190 cd (npath); 01191 cmt_string& new_pwd = path_pwds.add (); 01192 new_pwd = pwd (); 01193 cd (here); 01194 01195 cmt_string& new_source = path_sources.add (); 01196 new_source = path_source; 01197 } |
|
Definition at line 105 of file cmt_system.cxx. 00108 { 00109 basename (file_name, result); 00110 00111 int pos; 00112 00113 pos = result.find_last_of ('.'); 00114 00115 if (pos != cmt_string::npos) 00116 { 00117 result.erase (pos); 00118 } 00119 } |
|
|
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(). 00070 { 00071 if ((dir.size () == 2) && (dir[1] == ':')) 00072 { 00073 cmt_string new_dir = dir; 00074 new_dir += file_separator (); 00075 if (chdir (new_dir.c_str ()) == 0) return (true); 00076 return (false); 00077 } 00078 else 00079 { 00080 if (chdir (dir.c_str ()) == 0) return (true); 00081 return (false); 00082 } 00083 } |
|
Definition at line 497 of file cmt_system.cxx. Referenced by SequenceRunner::filter(), and CvsImplementation::really_checkout_package(). 00498 { 00499 #ifdef WIN32 00500 return ('&'); 00501 #else 00502 return (';'); 00503 #endif 00504 } |
|
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(). 00374 { 00375 struct stat file_stat1; 00376 struct stat file_stat2; 00377 static cmt_string s1; 00378 static cmt_string s2; 00379 int status; 00380 00381 status = stat (name1.c_str (), &file_stat1); 00382 00383 if (status == 0) 00384 { 00385 if ((file_stat1.st_mode & S_IFDIR) != 0) 00386 { 00387 // name1 is a directory. 00388 return (false); 00389 } 00390 } 00391 else 00392 { 00393 // name1 does not exist 00394 return (false); 00395 } 00396 00397 s1.read (name1); 00398 00399 status = stat (name2.c_str (), &file_stat2); 00400 00401 if (status == 0) 00402 { 00403 if ((file_stat2.st_mode & S_IFDIR) != 0) 00404 { 00405 // name2 is a directory 00406 return (false); 00407 } 00408 00409 if (((int) file_stat1.st_size) == ((int) file_stat2.st_size)) 00410 { 00411 s2.read (name2); 00412 if (s1 == s2) 00413 { 00414 unlink (name1); 00415 return (true); 00416 } 00417 } 00418 } 00419 00420 FILE* f = fopen (name2, "wb"); 00421 if (f != NULL) 00422 { 00423 s1.write (f); 00424 fclose (f); 00425 00426 unlink (name1); 00427 00428 return (true); 00429 } 00430 else 00431 { 00432 // 00433 // keep the new file "name1" since it cannot be 00434 // copied to "name2" 00435 // 00436 return (false); 00437 } 00438 } |
|
Check if the file "name1" is identical to "name2".
Definition at line 316 of file cmt_system.cxx. Referenced by Generator::check(). 00318 { 00319 struct stat file_stat1; 00320 struct stat file_stat2; 00321 int status; 00322 00323 status = stat (name1.c_str (), &file_stat1); 00324 00325 if (status == 0) 00326 { 00327 if ((file_stat1.st_mode & S_IFDIR) != 0) 00328 { 00329 return (false); 00330 } 00331 } 00332 else 00333 { 00334 return (false); 00335 } 00336 00337 status = stat (name2.c_str (), &file_stat2); 00338 00339 if (status == 0) 00340 { 00341 if ((file_stat2.st_mode & S_IFDIR) != 0) 00342 { 00343 return (false); 00344 } 00345 } 00346 else 00347 { 00348 return (false); 00349 } 00350 00351 if (((int) file_stat1.st_size) != ((int) file_stat2.st_size)) 00352 { 00353 return (false); 00354 } 00355 00356 static cmt_string s1; 00357 static cmt_string s2; 00358 00359 s1.read (name1); 00360 s2.read (name2); 00361 00362 return ((s1 == s2)); 00363 } |
|
Definition at line 1851 of file cmt_system.cxx. 01852 { 01853 #ifdef WIN32 01854 static const char pattern[] = "\\..\\"; 01855 //static const char here[] = ".\\"; 01856 static const char fs[] = "\\\\"; 01857 #else 01858 static const char pattern[] = "/../"; 01859 //static const char here[] = "./"; 01860 static const char fs[] = "//"; 01861 #endif 01862 01863 if (dir.size () == 0) return; 01864 01865 // 01866 // We first synchronize to using file_separator() in any case. 01867 // 01868 01869 if (file_separator () == '/') 01870 { 01871 dir.replace_all ("\\", file_separator ()); 01872 } 01873 else 01874 { 01875 dir.replace_all ("/", file_separator ()); 01876 } 01877 01878 dir.replace_all (fs, file_separator ()); 01879 01880 for (;;) 01881 { 01882 int pos1; 01883 int pos2; 01884 01885 pos1 = dir.find (pattern); 01886 if (pos1 == cmt_string::npos) break; 01887 01888 // 01889 // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb" 01890 // 01891 cmt_string p = dir.substr (0, pos1); 01892 01893 // 01894 // Is "aaaa/xxxx" only made of "xxxx" ? 01895 // 01896 pos2 = p.find_last_of (file_separator ()); 01897 01898 if (pos2 == cmt_string::npos) break; 01899 01900 // 01234567890123456 01901 // aaaa/xxxx/../bbbb 01902 // 2 1 3 01903 // 01904 // erase the "/xxxx/../" pattern 01905 // result will be "aaaa/bbbb" 01906 // 01907 dir.erase (pos2, pos1 + 4 - pos2 - 1); 01908 } 01909 01910 //if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1); 01911 } |
|
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(). 01838 { 01839 new_dir = dir; 01840 01841 compress_path (new_dir); 01842 } |
|
Definition at line 531 of file cmt_system.cxx. Referenced by Cmt::do_build_library_links(). 00533 { 00534 ::unlink (newname.c_str ()); 00535 00536 #ifdef WIN32 00537 int status = 1; 00538 #else 00539 int status = ::symlink (oldname.c_str (), newname.c_str ()); 00540 #endif 00541 00542 if (status == 0) return (true); 00543 return (false); 00544 } |
|
Definition at line 256 of file cmt_system.cxx. Referenced by Generator::build_dependencies(), and MakefileGenerator::reset(). 00257 { 00258 cmt_string result; 00259 00260 basename (pwd (), result); 00261 00262 return (result); 00263 } |
|
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(). 00123 { 00124 int pos = file_name.find_last_of ('/'); 00125 if (pos == cmt_string::npos) 00126 { 00127 pos = file_name.find_last_of ('\\'); 00128 } 00129 00130 if (pos == cmt_string::npos) 00131 { 00132 result = ""; 00133 } 00134 else 00135 { 00136 result = file_name; 00137 result.erase (pos); 00138 } 00139 } |
|
Definition at line 519 of file cmt_system.cxx. Referenced by resolve_value_for_macros(). 00520 { 00521 #ifdef WIN32 00522 static const cmt_string s = "%"; 00523 #else 00524 static const cmt_string s = "}"; 00525 #endif 00526 00527 return (s); 00528 } |
|
Definition at line 507 of file cmt_system.cxx. Referenced by resolve_value_for_macros(). 00508 { 00509 #ifdef WIN32 00510 static const cmt_string s = "%"; 00511 #else 00512 static const cmt_string s = "${"; 00513 #endif 00514 00515 return (s); 00516 } |
|
Definition at line 1393 of file cmt_system.cxx. 01394 { 01395 output = ""; 01396 01397 //cout << "CmtSystem::execute2> [" << command << "]" << endl; 01398 01399 FILE* f = popen (command.c_str (), "r"); 01400 01401 if (f != 0) 01402 { 01403 char line[256]; 01404 char* ptr; 01405 01406 while ((ptr = fgets (line, sizeof (line), f)) != NULL) 01407 { 01408 output += ptr; 01409 } 01410 pclose (f); 01411 01412 return (1); 01413 } 01414 01415 return (0); 01416 } |
|
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(). 01386 { 01387 //cout << "CmtSystem::execute1> [" << command << "]" << endl; 01388 01389 return (system (command.c_str ())); 01390 } |
|
|
Definition at line 441 of file cmt_system.cxx. 00442 { 00443 struct stat file_stat; 00444 int status; 00445 00446 status = stat (name.c_str (), &file_stat); 00447 00448 if (status == 0) 00449 { 00450 return ((int) file_stat.st_size); 00451 } 00452 else 00453 { 00454 return (0); 00455 } 00456 } |
|
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(). 00953 { 00954 const char* env = ::getenv ("CMTCONFIG"); 00955 if (env != 0) 00956 { 00957 return (cmt_string (env)); 00958 } 00959 00960 env = ::getenv ("CMTBIN"); 00961 if (env != 0) 00962 { 00963 return (cmt_string (env)); 00964 } 00965 00966 #ifdef WIN32 00967 LONG status; 00968 HKEY key = 0; 00969 00970 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 00971 0, KEY_READ, &key); 00972 if (status == ERROR_SUCCESS) 00973 { 00974 char temp[256]; 00975 DWORD length = sizeof (temp) - 1; 00976 DWORD type; 00977 00978 status = RegQueryValueEx (key, "config", 0, &type, 00979 (LPBYTE) temp, &length); 00980 if (status == ERROR_SUCCESS) 00981 { 00982 cmt_string config (temp); 00983 return (config); 00984 } 00985 } 00986 00987 return ("VisualC"); 00988 #endif 00989 00990 return (""); 00991 00992 } |
|
Definition at line 1247 of file cmt_system.cxx. Referenced by Cmt::configure_cmt_path(). 01251 { 01252 paths.clear (); 01253 path_pwds.clear (); 01254 path_sources.clear (); 01255 01256 if (init_text != "") 01257 { 01258 add_cmt_paths_from_text (init_text, "initialization", paths, path_pwds, path_sources); 01259 } 01260 01261 #ifdef WIN32 01262 LONG status; 01263 HKEY key = 0; 01264 01265 status = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\CMT\\path", 01266 0, KEY_READ, &key); 01267 if (status == ERROR_SUCCESS) 01268 { 01269 DWORD index = 0; 01270 char name[256]; 01271 char temp[256]; 01272 01273 for (;;) 01274 { 01275 DWORD name_length = sizeof (name) - 1; 01276 DWORD length = sizeof (temp) - 1; 01277 DWORD type; 01278 status = RegEnumValue (key, index, 01279 name, &name_length, 0, &type, 01280 (LPBYTE) temp, &length); 01281 if ((status == ERROR_SUCCESS) || 01282 (status == 234)) 01283 { 01284 const cmt_string path = temp; 01285 add_cmt_path (path, "HKEY_CURRENT_USER", paths, path_pwds, path_sources); 01286 } 01287 01288 if (status == 259) 01289 { 01290 break; 01291 } 01292 01293 index++; 01294 } 01295 } 01296 01297 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT\\path", 01298 0, KEY_READ, &key); 01299 if (status == ERROR_SUCCESS) 01300 { 01301 DWORD index = 0; 01302 char name[256]; 01303 char temp[256]; 01304 01305 for (;;) 01306 { 01307 DWORD type; 01308 DWORD name_length = sizeof (name) - 1; 01309 DWORD length = sizeof (temp) - 1; 01310 01311 01312 status = RegEnumValue (key, index, 01313 name, &name_length, 0, &type, 01314 (LPBYTE) temp, &length); 01315 if (status != ERROR_NO_MORE_ITEMS) 01316 { 01317 const cmt_string path = temp; 01318 add_cmt_path (path, "HKEY_LOCAL_MACHINE", paths, path_pwds, path_sources); 01319 } 01320 else 01321 { 01322 break; 01323 } 01324 index++; 01325 } 01326 } 01327 01328 #endif 01329 01330 //----------------------------------------- 01331 // look for .cmtrc files : 01332 // first look in ./ 01333 // then in "~/" 01334 // then in ${CMTROOT}/mgr 01335 //----------------------------------------- 01336 cmt_string rc_name; 01337 01338 const cmt_string env = CmtSystem::getenv ("CMTPATH"); 01339 01340 if (env != "") 01341 { 01342 static cmt_string_vector path_vector; 01343 int i; 01344 01345 split (env, path_separator (), path_vector); 01346 01347 for (i = 0; i < path_vector.size (); i++) 01348 { 01349 const cmt_string& path = path_vector[i]; 01350 01351 add_cmt_path (path, "${CMTPATH}", paths, path_pwds, path_sources); 01352 } 01353 } 01354 01355 add_cmt_paths (".cmtrc", paths, path_pwds, path_sources); 01356 01357 const char* home_env = ::getenv ("HOME"); 01358 if (home_env != 0) 01359 { 01360 rc_name = home_env; 01361 rc_name += file_separator (); 01362 rc_name += ".cmtrc"; 01363 add_cmt_paths (rc_name, paths, path_pwds, path_sources); 01364 } 01365 01366 rc_name = get_cmt_root (); 01367 rc_name += file_separator (); 01368 rc_name += "CMT"; 01369 rc_name += file_separator (); 01370 cmt_string version; 01371 get_cmt_version (version); 01372 rc_name += version; 01373 rc_name += file_separator (); 01374 rc_name += "mgr"; 01375 rc_name += file_separator (); 01376 rc_name += ".cmtrc"; 01377 01378 add_cmt_paths (rc_name, paths, path_pwds, path_sources); 01379 01380 add_cmt_path (get_cmt_root (), "default path", paths, path_pwds, path_sources); 01381 01382 } |
|
Definition at line 875 of file cmt_system.cxx. Referenced by Cmt::configure_default_path(), and get_cmt_paths(). 00876 { 00877 static cmt_string root; 00878 00879 root = ""; 00880 00881 const char* env = ::getenv ("CMTROOT"); 00882 if (env != 0) 00883 { 00884 root = env; 00885 00886 dirname (root, root); 00887 dirname (root, root); 00888 return (root); 00889 } 00890 00891 #ifdef WIN32 00892 LONG status; 00893 HKEY key = 0; 00894 00895 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 00896 0, KEY_READ, &key); 00897 if (status == ERROR_SUCCESS) 00898 { 00899 char temp[256]; 00900 DWORD length = sizeof (temp) - 1; 00901 DWORD type; 00902 00903 status = RegQueryValueEx (key, "root", 0, &type, (LPBYTE) temp, &length); 00904 if (status == ERROR_SUCCESS) 00905 { 00906 root = temp; 00907 return (root); 00908 } 00909 } 00910 #endif 00911 00912 return (root); 00913 } |
|
Definition at line 995 of file cmt_system.cxx. Referenced by Cmt::configure_site_tag(). 00996 { 00997 const char* env = ::getenv ("CMTSITE"); 00998 if (env != 0) 00999 { 01000 return (cmt_string (env)); 01001 } 01002 01003 #ifdef WIN32 01004 LONG status; 01005 HKEY key = 0; 01006 01007 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 01008 0, KEY_READ, &key); 01009 if (status == ERROR_SUCCESS) 01010 { 01011 char temp[256]; 01012 DWORD length = sizeof (temp) - 1; 01013 DWORD type; 01014 01015 status = RegQueryValueEx (key, "site", 0, &type, (LPBYTE) temp, &length); 01016 if (status == ERROR_SUCCESS) 01017 { 01018 cmt_string site (temp); 01019 return (site); 01020 } 01021 } 01022 #endif 01023 01024 return (""); 01025 } |
|
Definition at line 916 of file cmt_system.cxx. Referenced by Cmt::configure_default_path(), and get_cmt_paths(). 00917 { 00918 version = ""; 00919 00920 const char* env = ::getenv ("CMTROOT"); 00921 if (env != 0) 00922 { 00923 cmt_string s = env; 00924 basename (s, version); 00925 } 00926 else 00927 { 00928 #ifdef WIN32 00929 LONG status; 00930 HKEY key = 0; 00931 00932 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 00933 0, KEY_READ, &key); 00934 if (status == ERROR_SUCCESS) 00935 { 00936 char temp[256]; 00937 DWORD length = sizeof (temp) - 1; 00938 DWORD type; 00939 00940 status = RegQueryValueEx (key, "version", 0, &type, 00941 (LPBYTE) temp, &length); 00942 if (status == ERROR_SUCCESS) 00943 { 00944 version = temp; 00945 } 00946 } 00947 #endif 00948 } 00949 } |
|
Definition at line 1940 of file cmt_system.cxx. Referenced by CvsImplementation::really_checkout_package(), and CvsImplementation::show_cvs_infos(). 01941 { 01942 cvsroot = ""; 01943 01944 const char* env = ::getenv ("CVSROOT"); 01945 if (env != 0) 01946 { 01947 cvsroot = env; 01948 return; 01949 } 01950 01951 #ifdef WIN32 01952 LONG status; 01953 HKEY key = 0; 01954 01955 status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 01956 0, KEY_READ, &key); 01957 if (status == ERROR_SUCCESS) 01958 { 01959 char temp[256]; 01960 DWORD length = sizeof (temp) - 1; 01961 DWORD type; 01962 01963 status = RegQueryValueEx (key, "CVSROOT", 0, &type, 01964 (LPBYTE) temp, &length); 01965 if (status == ERROR_SUCCESS) 01966 { 01967 cvsroot = temp; 01968 return; 01969 } 01970 } 01971 #endif 01972 } |
|
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(). 00189 { 00190 int pos = file.find_last_of ('.'); 00191 int sep = file.find_last_of (file_separator ()); 00192 00193 if ((pos == cmt_string::npos) || (pos < sep)) 00194 { 00195 result = ""; 00196 } 00197 else 00198 { 00199 file.substr (pos, result); 00200 } 00201 } |
|
Definition at line 1085 of file cmt_system.cxx. Referenced by Use::add(), Use::reach_package(), Use::show_all(), and Cmt::use_home_requirements(). 01086 { 01087 cmt_string name = "CMTHOME context"; 01088 01089 return (name); 01090 } |
|
Definition at line 1061 of file cmt_system.cxx. Referenced by Cmt::configure_hosttype_tag(). 01062 { 01063 hosttype = ""; 01064 01065 char* ptr; 01066 01067 ptr = ::getenv ("HOSTTYPE"); 01068 if (ptr != 0) 01069 { 01070 hosttype = ptr; 01071 } 01072 } |
|
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(). 00173 { 00174 int pos = file.find_last_of ('.'); 00175 int sep = file.find_last_of (file_separator ()); 00176 00177 if ((pos == cmt_string::npos) || (pos < sep)) 00178 { 00179 result = ""; 00180 } 00181 else 00182 { 00183 file.substr (pos + 1, result); 00184 } 00185 } |
|
Definition at line 1075 of file cmt_system.cxx. Referenced by Cmt::do_build_temporary_name(), and CvsImplementation::show_cvs_infos(). 01076 { 01077 cmt_string name; 01078 01079 name = ::tmpnam (NULL); 01080 01081 return (name); 01082 } |
|
Definition at line 1028 of file cmt_system.cxx. Referenced by Cmt::configure_tags(), and Cmt::configure_uname_tag(). 01029 { 01030 #ifdef WIN32 01031 uname = "WIN32"; 01032 #else 01033 01034 uname = ""; 01035 01036 FILE* file; 01037 01038 file = popen ("uname", "r"); 01039 01040 if (file != 0) 01041 { 01042 char line[1024]; 01043 char* ptr; 01044 char* nl; 01045 01046 line[0] = 0; 01047 ptr = fgets (line, sizeof (line), file); 01048 if (ptr != 0) 01049 { 01050 nl = strrchr (ptr, '\n'); 01051 if (nl != 0) *nl = 0; 01052 01053 uname = ptr; 01054 } 01055 pclose (file); 01056 } 01057 #endif 01058 } |
|
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(). 01104 { 01105 cmt_string name = "CMTUSERCONTEXT context"; 01106 01107 return (name); 01108 } |
|
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(). 01130 { 01131 cmt_string result; 01132 01133 const char* env = ::getenv (name); 01134 if (env != 0) 01135 { 01136 result = env; 01137 } 01138 01139 if (name == "CMTCONFIG") 01140 { 01141 return (get_cmt_config ()); 01142 } 01143 01144 /* 01145 if (name == "CMTROOT") 01146 { 01147 return (get_cmt_root ()); 01148 } 01149 01150 if (name == "CMTSITE") 01151 { 01152 return (get_cmt_site ()); 01153 } 01154 */ 01155 01156 return (result); 01157 } |
|
Definition at line 234 of file cmt_system.cxx. Referenced by mkdir(). 00235 { 00236 #ifdef WIN32 00237 if (name.size () == 0) return (false); 00238 00239 if (name.size () >= 2) 00240 { 00241 if (name[1] == ':') 00242 { 00243 return (true); 00244 } 00245 else if ((name[0] == '\\') && (name[1] == '\\')) 00246 { 00247 return (true); 00248 } 00249 } 00250 #endif 00251 00252 return (false); 00253 } |
|
Definition at line 204 of file cmt_system.cxx. 00205 { 00206 if ((name.find ('/') == cmt_string::npos) && 00207 (name.find ('\\') == cmt_string::npos)) 00208 { 00209 return (false); 00210 } 00211 00212 return (true); 00213 } |
|
Definition at line 1093 of file cmt_system.cxx. Referenced by use_action_iterator::ok(). 01095 { 01096 if ((name == "CMTHOME") && 01097 (version == "context")) return (true); 01098 01099 return (false); 01100 } |
|
Definition at line 1419 of file cmt_system.cxx. Referenced by Cmt::reach_current_package(). 01420 { 01421 cmt_string_vector dirs; 01422 01423 cmt_regexp exp ("^[a-zA-Z.][0-9]+([a-zA-Z.][0-9]+([a-zA-Z.][0-9]+)?)?"); 01424 01425 scan_dir (name, exp, dirs); 01426 01427 cmt_string req; 01428 01429 req = name; 01430 req += file_separator (); 01431 req += "cmt"; 01432 req += file_separator (); 01433 req += "requirements"; 01434 01435 if (test_file (req)) return (true); 01436 01437 if (dirs.size () == 0) 01438 { 01439 return (false); 01440 } 01441 01442 for (int i = 0; i < dirs.size (); i++) 01443 { 01444 const cmt_string& d = dirs[i]; 01445 01446 req = d; 01447 req += file_separator (); 01448 req += "mgr"; 01449 req += file_separator (); 01450 req += "requirements"; 01451 01452 if (test_file (req)) return (true); 01453 01454 req = d; 01455 req += file_separator (); 01456 req += "cmt"; 01457 req += file_separator (); 01458 req += "requirements"; 01459 01460 if (test_file (req)) return (true); 01461 } 01462 01463 return (false); 01464 } |
|
Definition at line 1111 of file cmt_system.cxx. Referenced by use_action_iterator::ok(). 01113 { 01114 if ((name == "CMTUSERCONTEXT") && 01115 (version == "context")) return (true); 01116 01117 return (false); 01118 } |
|
Definition at line 1477 of file cmt_system.cxx. 01481 { 01482 static const cmt_string numbers = "0123456789"; 01483 01484 static const int id_version = 0; 01485 static const int id_release = 1; 01486 static const int id_patch = 2; 01487 01488 cmt_string buffer; 01489 01490 enum 01491 { 01492 starting, 01493 at_key, 01494 at_number 01495 } state; 01496 01497 int id; 01498 int pos; 01499 int value; 01500 01501 v = 0; 01502 r = 0; 01503 p = 0; 01504 01505 // 01506 // version : v-field 01507 // | v-field r-field 01508 // | v-field r-field p-field 01509 // 01510 // v-field : field 01511 // r-field : field 01512 // p-field : field 01513 // 01514 // field : key '*' 01515 // | key number 01516 // 01517 // key : letters 01518 // 01519 01520 state = starting; 01521 id = id_version; 01522 01523 for (pos = 0; pos < name.size (); pos++) 01524 { 01525 char c = name[pos]; 01526 01527 if (c == '*') 01528 { 01529 // A wild card 01530 switch (state) 01531 { 01532 case starting: 01533 // cannot start with a wild card ?? 01534 return (false); 01535 case at_key: 01536 // the numeric field is valued with a wild card 01537 switch (id) 01538 { 01539 case id_version: 01540 v = -1; 01541 case id_release: 01542 r = -1; 01543 case id_patch: 01544 p = -1; 01545 break; 01546 } 01547 return (true); 01548 case at_number: 01549 // Syntax error : number followed by a wild-card ?? 01550 return (false); 01551 } 01552 } 01553 else if (numbers.find (c) == cmt_string::npos) 01554 { 01555 // A letter 01556 switch (state) 01557 { 01558 case starting: 01559 state = at_key; 01560 break; 01561 case at_key: 01562 // Multiple letter key (is it permitted??) 01563 break; 01564 case at_number: 01565 sscanf (buffer.c_str (), "%d", &value); 01566 switch (id) 01567 { 01568 case id_version: 01569 v = value; 01570 break; 01571 case id_release: 01572 r = value; 01573 break; 01574 case id_patch: 01575 p = value; 01576 break; 01577 } 01578 buffer = ""; 01579 id++; 01580 state = at_key; 01581 break; 01582 } 01583 } 01584 else 01585 { 01586 // a number 01587 switch (state) 01588 { 01589 case starting: 01590 // not starting by a letter (syntax error) 01591 return (false); 01592 case at_key: 01593 // the numeric field for the current id is starting now 01594 buffer += c; 01595 state = at_number; 01596 break; 01597 case at_number: 01598 // continuing the current numeric field 01599 buffer += c; 01600 break; 01601 } 01602 } 01603 } 01604 01605 switch (state) 01606 { 01607 case starting: 01608 // Empty version string 01609 return (false); 01610 case at_key: 01611 // Syntax error (only letters) 01612 return (false); 01613 case at_number: 01614 sscanf (buffer.c_str (), "%d", &value); 01615 switch (id) 01616 { 01617 case id_version: 01618 v = value; 01619 break; 01620 case id_release: 01621 r = value; 01622 break; 01623 case id_patch: 01624 p = value; 01625 break; 01626 } 01627 id++; 01628 state = at_key; 01629 return (true); 01630 } 01631 01632 return (false); 01633 } |
|
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(). 01468 { 01469 int v; 01470 int r; 01471 int p; 01472 01473 return (is_version_directory (name, v, r, p)); 01474 } |
|
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(). 00593 { 00594 static cmt_string_vector path_vector; 00595 int i; 00596 static cmt_string full_path; 00597 char double_fs[] = " "; 00598 00599 double_fs[0] = file_separator (); 00600 double_fs[1] = file_separator (); 00601 00602 full_path = name; 00603 00604 if (file_separator () == '/') 00605 { 00606 full_path.replace_all ("\\", file_separator ()); 00607 } 00608 else 00609 { 00610 full_path.replace_all ("/", file_separator ()); 00611 } 00612 00613 full_path.replace_all (double_fs, file_separator ()); 00614 00615 split (full_path, file_separator (), path_vector); 00616 00617 full_path = ""; 00618 00619 if (absolute_path (name)) 00620 { 00621 if (!has_device (name)) 00622 { 00623 full_path = file_separator (); 00624 } 00625 } 00626 00627 for (i = 0; i < path_vector.size (); i++) 00628 { 00629 const cmt_string& path = path_vector[i]; 00630 00631 if (i > 0) full_path += file_separator (); 00632 full_path += path; 00633 00634 if (has_device (path)) continue; 00635 00636 if (!test_directory (full_path)) 00637 { 00638 #ifdef WIN32 00639 if (::_mkdir (full_path.c_str ()) != 0) 00640 { 00641 cerr << "CMT> cannot create directory " << full_path << endl; 00642 return (false); 00643 } 00644 #else 00645 if (::mkdir (full_path.c_str (), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0) 00646 { 00647 cerr << "CMT> cannot create directory " << full_path << endl; 00648 return (false); 00649 } 00650 #endif 00651 } 00652 } 00653 00654 return (true); 00655 } |
|
Definition at line 142 of file cmt_system.cxx. Referenced by MakefileGenerator::prepare_proto_file(). 00143 { 00144 int pos; 00145 00146 result = file_name; 00147 00148 // remove the suffix 00149 00150 pos = result.find_last_of ('.'); 00151 00152 if (pos != cmt_string::npos) 00153 { 00154 result.erase (pos); 00155 } 00156 00157 // remove the directory name 00158 00159 pos = result.find_last_of ('/'); 00160 if (pos == cmt_string::npos) 00161 { 00162 pos = result.find_last_of ('\\'); 00163 } 00164 00165 if (pos != cmt_string::npos) 00166 { 00167 result.erase (0, pos + 1); 00168 } 00169 } |
|
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(). 01915 { 01916 cmt_string result; 01917 01918 time_t ltime; 01919 time (<ime); 01920 result = ctime (<ime); 01921 01922 result.replace_all ("\n", ""); 01923 01924 return (result); 01925 } |
|
Definition at line 487 of file cmt_system.cxx. Referenced by PathBuilder::build(), PathBuilder::clean(), Cmt::do_show_path(), and find_path_entry(). 00488 { 00489 #ifdef WIN32 00490 return (';'); 00491 #else 00492 return (':'); 00493 #endif 00494 } |
|
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(). 00058 { 00059 char buffer[256] = ""; 00060 char* ptr; 00061 00062 ptr = getcwd (buffer, sizeof (buffer)); 00063 00064 const char* t = &buffer[0]; 00065 return ((cmt_string) t); 00066 } |
|
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. 00473 { 00474 if (file_separator () == '/') 00475 { 00476 text.replace_all ("\\", "/"); 00477 text.replace_all ("//", "/"); 00478 } 00479 else 00480 { 00481 text.replace_all ("/", "\\"); 00482 text.replace_all ("\\\\", "\\"); 00483 } 00484 } |
|
Definition at line 559 of file cmt_system.cxx. Referenced by Cmt::do_remove(), and CvsImplementation::show_cvs_infos(). 00560 { 00561 //cout << "Try to remove directory " << name << endl; 00562 00563 cmt_string_vector files; 00564 00565 scan_dir (name, files); 00566 00567 for (int i = 0; i < files.size (); i++) 00568 { 00569 cmt_string& file = files[i]; 00570 00571 if (test_directory (file)) 00572 { 00573 if (!remove_directory (file)) return (false); 00574 } 00575 else 00576 { 00577 if (!remove_file (file)) return (false); 00578 } 00579 } 00580 00581 int status = ::rmdir (name); 00582 if (status != 0) 00583 { 00584 cout << "Cannot remove directory " << name << " errno=" << errno << endl; 00585 return (false); 00586 } 00587 00588 return (true); 00589 } |
|
Definition at line 547 of file cmt_system.cxx. Referenced by Cmt::do_config(), remove_directory(), and CmtLock::unlock(). 00548 { 00549 if (::unlink (name) != 0) 00550 { 00551 cout << "Cannot remove file " << name << endl; 00552 return (false); 00553 } 00554 00555 return (true); 00556 } |
|
Definition at line 865 of file cmt_system.cxx. 00866 { 00867 static cmt_string_vector result; 00868 00869 scan_dir (dir_name, result); 00870 00871 return (result); 00872 } |
|
Definition at line 773 of file cmt_system.cxx. 00776 { 00777 static cmt_string dir_prefix; 00778 00779 dir_prefix = dir_name; 00780 if (dir_name == "") dir_prefix = "."; 00781 00782 if (!test_directory (dir_prefix)) 00783 { 00784 dirname (dir_prefix, dir_prefix); 00785 } 00786 00787 list.clear (); 00788 00789 #ifdef WIN32 00790 00791 long dir; 00792 struct _finddata_t entry; 00793 00794 static cmt_string search; 00795 00796 search = dir_prefix; 00797 search += file_separator (); 00798 search += "*"; 00799 00800 dir = _findfirst (search.c_str (), &entry); 00801 if (dir > 0) 00802 { 00803 for (;;) 00804 { 00805 if ((entry.name[0] != '.') && 00806 (strcmp ((char*) entry.name, ".") != 0) && 00807 (strcmp ((char*) entry.name, "..") != 0) && 00808 (strncmp ((char*) entry.name, ".nfs", 4) != 0)) 00809 { 00810 const char* name = entry.name; 00811 00812 if (expression.match (name)) 00813 { 00814 cmt_string& name_entry = list.add (); 00815 00816 name_entry = dir_prefix; 00817 name_entry += file_separator (); 00818 name_entry += name; 00819 } 00820 } 00821 00822 int status = _findnext (dir, &entry); 00823 if (status != 0) 00824 { 00825 break; 00826 } 00827 } 00828 _findclose (dir); 00829 } 00830 #else 00831 00832 //cout << "scan_dir> dir=" << dir_name << endl; 00833 00834 DIR* dir = opendir (dir_prefix.c_str ()); 00835 00836 struct dirent* entry; 00837 00838 if (dir != 0) 00839 { 00840 while ((entry = readdir (dir)) != 0) 00841 { 00842 //if (entry->d_name[0] == '.') continue; 00843 if (!strcmp ((char*) entry->d_name, ".")) continue; 00844 if (!strcmp ((char*) entry->d_name, "..")) continue; 00845 if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue; 00846 00847 const char* name = entry->d_name; 00848 00849 if (!expression.match (name)) continue; 00850 00851 cmt_string& name_entry = list.add (); 00852 00853 name_entry = dir_prefix; 00854 name_entry += file_separator (); 00855 name_entry += name; 00856 } 00857 00858 closedir (dir); 00859 } 00860 #endif 00861 00862 } |
|
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(). 00660 { 00661 static cmt_string dir_prefix; 00662 static cmt_string name_prefix; 00663 00664 dir_prefix = dir_name; 00665 if (dir_name == "") dir_prefix = "."; 00666 00667 if (!test_directory (dir_prefix)) 00668 { 00669 dirname (dir_prefix, dir_prefix); 00670 basename (dir_name, name_prefix); 00671 } 00672 else 00673 { 00674 } 00675 00676 bool need_filter = false; 00677 00678 int wild_card; 00679 00680 wild_card = name_prefix.find ('*'); 00681 if (wild_card != cmt_string::npos) 00682 { 00683 name_prefix.erase (wild_card); 00684 } 00685 00686 if (name_prefix.size () > 0) 00687 { 00688 need_filter = true; 00689 } 00690 00691 list.clear (); 00692 00693 #ifdef WIN32 00694 00695 long dir; 00696 struct _finddata_t entry; 00697 00698 static cmt_string search; 00699 00700 search = dir_prefix; 00701 search += file_separator (); 00702 search += "*"; 00703 00704 dir = _findfirst (search.c_str (), &entry); 00705 if (dir > 0) 00706 { 00707 for (;;) 00708 { 00709 if ((strcmp ((char*) entry.name, ".") != 0) && 00710 (strcmp ((char*) entry.name, "..") != 0) && 00711 (strncmp ((char*) entry.name, ".nfs", 4) != 0)) 00712 { 00713 const char* name = entry.name; 00714 00715 if (!need_filter || 00716 (strncmp (name, name_prefix.c_str (), name_prefix.size ()) == 0)) 00717 { 00718 cmt_string& name_entry = list.add (); 00719 00720 name_entry = dir_prefix; 00721 name_entry += file_separator (); 00722 name_entry += name; 00723 } 00724 } 00725 00726 int status = _findnext (dir, &entry); 00727 if (status != 0) 00728 { 00729 break; 00730 } 00731 } 00732 00733 _findclose (dir); 00734 } 00735 #else 00736 00737 //cout << "scan_dir> dir=" << dir_name << endl; 00738 00739 DIR* dir = opendir (dir_prefix.c_str ()); 00740 00741 struct dirent* entry; 00742 00743 if (dir != 0) 00744 { 00745 while ((entry = readdir (dir)) != 0) 00746 { 00747 //if (entry->d_name[0] == '.') continue; 00748 if (!strcmp ((char*) entry->d_name, ".")) continue; 00749 if (!strcmp ((char*) entry->d_name, "..")) continue; 00750 if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue; 00751 00752 const char* name = entry->d_name; 00753 00754 if (need_filter && 00755 (strncmp (name, name_prefix.c_str (), name_prefix.size ()) != 0)) continue; 00756 00757 //cout << "scan_dir> name=" << name << endl; 00758 00759 cmt_string& name_entry = list.add (); 00760 00761 name_entry = dir_prefix; 00762 name_entry += file_separator (); 00763 name_entry += name; 00764 } 00765 00766 closedir (dir); 00767 } 00768 #endif 00769 00770 } |
|
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(). 01642 { 01643 static char* buffer = 0; 01644 static int allocated = 0; 01645 01646 bool finished = false; 01647 01648 strings.clear (); 01649 01650 if (text.size () == 0) return; 01651 01652 /* 01653 We are going to work in a copy of the text, since 01654 \0 will be inserted right after each found word. 01655 01656 Then the vector of strings is iteratively filled by each found word. 01657 */ 01658 01659 if (buffer == 0) 01660 { 01661 allocated = text.size (); 01662 buffer = (char*) malloc (allocated + 1); 01663 } 01664 else 01665 { 01666 if (text.size () > allocated) 01667 { 01668 allocated = text.size (); 01669 buffer = (char*) realloc (buffer, allocated + 1); 01670 } 01671 } 01672 01673 strcpy (buffer, text.c_str ()); 01674 01675 /* 01676 Algorithm : 01677 01678 We look for words separated by <separators> which may be 01679 o spaces (' ' or '\t') 01680 o other characters such as ':' 01681 01682 A word is a character string not containing any separator. A substring in 01683 this word my be enclosed between quotes (" or ') which permits separator 01684 inclusion within words. 01685 */ 01686 01687 char* current_word = buffer; 01688 01689 while (*current_word != 0) 01690 { 01691 size_t prefix_length; 01692 size_t word_length; 01693 01694 /* 01695 while ((*current_word == ' ') || 01696 (*current_word == '\t')) 01697 { 01698 current_word++; 01699 } 01700 */ 01701 01702 // first skip all starting separators. 01703 01704 prefix_length = strspn (current_word, separators.c_str ()); 01705 if (prefix_length > 0) 01706 { 01707 // Move to the first non-separator character 01708 01709 current_word += prefix_length; 01710 } 01711 01712 /* 01713 Parse the next word. 01714 01715 It may contain enclosures in quote characters or not. 01716 Quotes must be identical on both sides of each enclosure. 01717 */ 01718 01719 char* running_char = current_word; 01720 01721 word_length = 0; 01722 01723 for (;;) 01724 { 01725 size_t unquoted_length; 01726 size_t separator_offset; 01727 01728 unquoted_length = strcspn (running_char, "\"\'"); 01729 separator_offset = strcspn (running_char, separators.c_str ()); 01730 01731 if (separator_offset <= unquoted_length) 01732 { 01733 // no quote in this word -> we are finished for this one. 01734 running_char += separator_offset; 01735 break; 01736 } 01737 01738 // We have found a quoted enclosure. Move to it. 01739 01740 running_char += unquoted_length; 01741 01742 char quote = running_char[0]; 01743 01744 // Remove it. 01745 { 01746 char* p = running_char; 01747 while (p[1] != 0) 01748 { 01749 *p = p[1]; 01750 p++; 01751 } 01752 *p = 0; 01753 } 01754 01755 // Look for the next occurence of this quote. 01756 { 01757 char* p = strchr (running_char, quote); 01758 if (p == 0) 01759 { 01760 // Unmatched quote : the rest of the line will be taken as a word... 01761 running_char += strlen (running_char); 01762 finished = true; 01763 break; 01764 } 01765 else 01766 { 01767 running_char = p; 01768 } 01769 } 01770 01771 // Now we remove the ending quote from the word 01772 // (by shifting all remaining characters by one place to the left) 01773 01774 { 01775 char* p = running_char; 01776 while (p[1] != 0) 01777 { 01778 *p = p[1]; 01779 p++; 01780 } 01781 *p = 0; 01782 } 01783 } 01784 01785 word_length = running_char - current_word; 01786 01787 if (current_word[word_length] == 0) 01788 { 01789 finished = true; 01790 } 01791 else 01792 { 01793 current_word[word_length] = 0; 01794 } 01795 01796 /* 01797 if ((t[0] == '"') || 01798 (t[0] == '\'') || 01799 (t[0] == ':')) 01800 { 01801 char* quote; 01802 01803 t++; 01804 quote = strchr (t, sep); 01805 if (quote != 0) *quote = 0; 01806 else finished = true; 01807 } 01808 else 01809 { 01810 int offset; 01811 01812 offset = strcspn (t, " \t:"); 01813 if ((offset < 0) || (t[offset] == 0)) finished = true; 01814 if (!finished) 01815 { 01816 space = t + offset; 01817 *space = 0; 01818 } 01819 } 01820 */ 01821 01822 // Store the current word into the vector of strings 01823 01824 { 01825 cmt_string& s = strings.add (); 01826 s = current_word; 01827 } 01828 01829 if (finished) break; 01830 01831 // Move to the next possible word. 01832 current_word += word_length + 1; 01833 } 01834 } |
|
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(). 00267 { 00268 struct stat file_stat; 00269 int status; 00270 00271 status = stat (name.c_str (), &file_stat); 00272 00273 if (status == 0) 00274 { 00275 if ((file_stat.st_mode & S_IFDIR) == 0) 00276 { 00277 return (false); 00278 } 00279 else 00280 { 00281 return (true); 00282 } 00283 } 00284 else 00285 { 00286 return (false); 00287 } 00288 } |
|
|
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(). 01122 { 01123 const char* env = ::getenv (name); 01124 if (env == 0) return (false); 01125 return (true); 01126 } |
|
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(). 01929 { 01930 #ifdef _WIN32 01931 cmt_string result = getenv ("USERNAME"); 01932 #else 01933 cmt_string result = getenv ("USER"); 01934 #endif 01935 01936 return (result); 01937 } |