#include <cmt.h>
Collaboration diagram for Cmt:
|
Definition at line 604 of file cmt_parser.cxx. Referenced by do_build_os9_makefile(). 00605 { 00606 build_makefile (target); 00607 } |
|
Append "CONFIG" to the prefix.
Definition at line 534 of file cmt_parser.cxx. Referenced by configure_current_package(), and load(). 00536 { 00537 /* 00538 Building the config from <prefix> 00539 */ 00540 00541 config = prefix; 00542 config += "CONFIG"; 00543 } |
|
Definition at line 546 of file cmt_parser.cxx. Referenced by build_OS9_makefile(). 00547 { 00548 Constituent* constituent = 0; 00549 00550 if (target.size () > 0) 00551 { 00552 /* 00553 Do genmake for one specific target. 00554 */ 00555 constituent = Constituent::find (target); 00556 if (constituent != 0) 00557 { 00558 constituent->build_makefile (m_simulation); 00559 } 00560 } 00561 else 00562 { 00563 /* 00564 Do genmake for all possible targets. 00565 */ 00566 Constituent::build_all_makefiles (m_simulation); 00567 } 00568 } |
|
Definition at line 571 of file cmt_parser.cxx. Referenced by do_build_msdev(). 00572 { 00573 Constituent* constituent = 0; 00574 00575 set_standard_macros (); 00576 00577 if (target != "") 00578 { 00579 /* 00580 Do genmsdev for one specific target. 00581 */ 00582 constituent = Constituent::find (target); 00583 if (constituent != 0) 00584 { 00585 constituent->build_msdev_file (m_simulation); 00586 } 00587 } 00588 else 00589 { 00590 /* 00591 Do genmsdev for all possible targets. 00592 */ 00593 Constituent::build_all_msdev_files (m_simulation); 00594 } 00595 } |
|
Definition at line 598 of file cmt_parser.cxx. Referenced by MakefileGenerator::analyze_file(), Generator::build_constituent_makefile(), Generator::build_constituents_makefile(), Generator::build_dependencies(), Generator::build_make_setup(), and Fragment::locate(). 00599 { 00600 return (m_build_nmake); 00601 } |
|
Convert a package name to its upper case copy.
Definition at line 612 of file cmt_parser.cxx. Referenced by configure_current_package(), load(), select(), and Use::set(). 00613 { 00614 int pos; 00615 char c; 00616 00617 /* 00618 Building the prefix from <package> 00619 */ 00620 00621 prefix = package; 00622 00623 for (pos = 0; pos < package.size (); pos++) 00624 { 00625 c = package[pos]; 00626 prefix[pos] = toupper (c); 00627 } 00628 } |
|
Definition at line 631 of file cmt_parser.cxx. Referenced by do_show_clients(), load(), and parser(). 00632 { 00633 m_action = action_none; 00634 m_build_nmake = false; 00635 m_cmt_config = ""; 00636 m_cmt_path.clear (); 00637 m_cmt_path_pwds.clear (); 00638 m_cmt_path_sources.clear (); 00639 m_cmt_root = ""; 00640 m_cmt_version = ""; 00641 m_current_build_strategy = DefaultBuildStrategy; 00642 m_current_dir = ""; 00643 m_current_package = ""; 00644 m_current_config = ""; 00645 m_current_path = ""; 00646 m_current_prefix = ""; 00647 m_current_access = DeveloperMode; 00648 m_current_strategy = BestFit; 00649 00650 m_current_tag = ""; 00651 m_current_target = ""; 00652 m_current_version = ""; 00653 m_default_path = ""; 00654 m_quiet = false; 00655 m_recursive = false; 00656 00657 m_scope = ScopePublic; 00658 m_simulation = false; 00659 00660 m_filtered_text = ""; 00661 m_standard_macros_done = false; 00662 00663 Database::clear (); 00664 Include::clear_all (); 00665 Script::clear_all (); 00666 CmtError::clear (); 00667 } |
|
Definition at line 670 of file cmt_parser.cxx. Referenced by do_show_clients(), load(), and parser(). 00671 { 00672 static bool configured = false; 00673 00674 if (configured) return; 00675 00676 m_cmt_version = ""; 00677 m_current_dir = ""; 00678 m_current_package = ""; 00679 m_current_prefix = ""; 00680 m_current_config = ""; 00681 m_current_path = ""; 00682 00683 m_current_tag = ""; 00684 m_current_version = ""; 00685 00686 m_configure_error = ""; 00687 00688 m_debug = false; 00689 if (getenv ("CMTDEBUG") != 0) m_debug = true; 00690 00691 m_default_path = ""; 00692 00693 configure_default_path (); 00694 configure_uname_tag (); 00695 configure_hosttype_tag (); 00696 configure_config_tag (); 00697 configure_site_tag (0); 00698 configure_cmt_path (0); 00699 configure_current_dir (); 00700 configure_current_package (); 00701 configure_home (0); 00702 configure_user_context (0); 00703 00704 Use& use = Use::current(); 00705 00706 use.set (m_current_package, 00707 m_current_version, 00708 m_current_path, 00709 "", 00710 ""); 00711 00712 use.style = m_current_style; 00713 00714 use.change_path (m_current_path); 00715 00716 if (CmtError::has_pending_error ()) 00717 { 00718 m_configure_error = CmtError::get_last_error (); 00719 } 00720 } |
|
Definition at line 723 of file cmt_parser.cxx. Referenced by Symbol::action(), and configure(). 00724 { 00725 cmt_string s; 00726 00727 Symbol* symbol = Symbol::find ("CMTPATH"); 00728 if (symbol != 0) 00729 { 00730 bool show_set_hidden = false; 00731 00732 if (Cmt::m_action == action_show_set) 00733 { 00734 show_set_hidden = true; 00735 Cmt::m_action = action_none; 00736 } 00737 00738 s = symbol->build_macro_value (); 00739 Symbol::expand (s); 00740 00741 if (show_set_hidden) 00742 { 00743 show_set_hidden = false; 00744 Cmt::m_action = action_show_set; 00745 } 00746 } 00747 00748 CmtSystem::get_cmt_paths (m_cmt_path, 00749 m_cmt_path_pwds, 00750 m_cmt_path_sources, s); 00751 } |
|
Definition at line 754 of file cmt_parser.cxx. Referenced by configure(), and parse_arguments(). 00755 { 00756 m_cmt_config = CmtSystem::get_cmt_config (); 00757 if (m_cmt_config != "") 00758 { 00759 Tag* tag; 00760 00761 tag = Tag::add (m_cmt_config, PriorityConfig, "CMTCONFIG", 0); 00762 tag->mark (); 00763 } 00764 } |
|
Definition at line 767 of file cmt_parser.cxx. Referenced by configure(), load(), and reach_current_package(). 00768 { 00769 cmt_string file_name; 00770 00771 /* 00772 Building current_dir : 00773 00774 o we first get the physical value (using getwd) 00775 o then this value is possibly filtered using the 00776 cmt_mount_filter file. 00777 */ 00778 00779 m_current_dir.erase (0); 00780 00781 file_name = m_default_path; 00782 if (file_name != "") 00783 { 00784 file_name += CmtSystem::file_separator (); 00785 file_name += "CMT"; 00786 file_name += CmtSystem::file_separator (); 00787 file_name += m_cmt_version; 00788 file_name += CmtSystem::file_separator (); 00789 file_name += "mgr"; 00790 file_name += CmtSystem::file_separator (); 00791 } 00792 00793 file_name += "cmt_mount_filter"; 00794 00795 m_current_dir = CmtSystem::pwd (); 00796 00797 { 00798 cmt_string text; 00799 cmt_string line; 00800 CmtSystem::cmt_string_vector words; 00801 00802 text.read (file_name); 00803 00804 int pos = 0; 00805 int max_pos = text.size (); 00806 00807 for (pos = 0; pos < max_pos; ) 00808 { 00809 int cr = text.find (pos, "\r\n"); 00810 int nl = text.find (pos, '\n'); 00811 int first = nl; 00812 int length = 1; 00813 00814 if (cr != cmt_string::npos) 00815 { 00816 if (nl == cmt_string::npos) 00817 { 00818 first = cr; 00819 length = 2; 00820 } 00821 else 00822 { 00823 first = (nl < cr) ? nl : cr; 00824 length = (nl < cr) ? 1 : 2; 00825 } 00826 } 00827 00828 if (first == cmt_string::npos) 00829 { 00830 text.substr (pos, line); 00831 pos = max_pos; 00832 } 00833 else if (first > pos) 00834 { 00835 text.substr (pos, first - pos, line); 00836 pos = first + length; 00837 } 00838 else 00839 { 00840 line.erase (0); 00841 pos += length; 00842 } 00843 00844 CmtSystem::split (line, " \t", words); 00845 00846 if (words.size () >= 2) 00847 { 00848 cmt_string& path_name = words[0]; 00849 cmt_string& replacement = words[1]; 00850 00851 if (m_current_dir.find (path_name) != cmt_string::npos) 00852 { 00853 m_current_dir.replace (path_name, replacement); 00854 break; 00855 } 00856 } 00857 } 00858 } 00859 } |
|
Definition at line 862 of file cmt_parser.cxx. Referenced by configure(). 00863 { 00864 /* 00865 Build current_package and current_prefix. 00866 00867 This is only possible if we are within the cmt/mgr branch of a 00868 standard directory tree (i.e. <package>/<version>/cmt or mgr) 00869 */ 00870 00871 if (CmtSystem::test_file ("../cmt/requirements")) 00872 { 00873 m_current_style = cmt_style; 00874 } 00875 else if (CmtSystem::test_file ("../mgr/requirements")) 00876 { 00877 m_current_style = mgr_style; 00878 } 00879 else 00880 { 00881 m_current_style = none_style; 00882 } 00883 00884 if (m_current_style != none_style) 00885 { 00886 CmtSystem::dirname (m_current_dir, m_current_path); 00887 CmtSystem::basename (m_current_path, m_current_version); 00888 CmtSystem::dirname (m_current_path, m_current_path); 00889 CmtSystem::basename (m_current_path, m_current_package); 00890 CmtSystem::dirname (m_current_path, m_current_path); 00891 build_prefix (m_current_package, m_current_prefix); 00892 build_config (m_current_prefix, m_current_config); 00893 } 00894 else 00895 { 00896 m_current_package = "cmt_standalone"; 00897 m_current_version = ""; 00898 m_current_path = m_current_dir; 00899 build_prefix (m_current_package, m_current_prefix); 00900 build_config (m_current_prefix, m_current_config); 00901 } 00902 00903 //cout << "configure_current_package> current style=" << m_current_style << endl; 00904 } |
|
Definition at line 907 of file cmt_parser.cxx. Referenced by configure(). 00908 { 00909 m_default_path = CmtSystem::get_cmt_root (); 00910 CmtSystem::get_cmt_version (m_cmt_version); 00911 m_cmt_root = m_default_path; 00912 m_cmt_root += CmtSystem::file_separator (); 00913 m_cmt_root += "CMT"; 00914 m_cmt_root += CmtSystem::file_separator (); 00915 m_cmt_root += m_cmt_version; 00916 } |
|
Definition at line 919 of file cmt_parser.cxx. Referenced by Symbol::action(), and configure(). 00920 { 00921 m_cmt_home = ""; 00922 00923 Symbol* symbol = Symbol::find ("CMTHOME"); 00924 if (symbol != 0) 00925 { 00926 m_cmt_home = symbol->build_macro_value (); 00927 } 00928 else if (CmtSystem::testenv ("CMTHOME")) 00929 { 00930 m_cmt_home = CmtSystem::getenv ("CMTHOME"); 00931 } 00932 00933 if ((m_cmt_home != "") && !CmtSystem::test_directory (m_cmt_home)) 00934 { 00935 m_cmt_home = ""; 00936 } 00937 } |
|
Definition at line 961 of file cmt_parser.cxx. Referenced by configure(), load(), and parse_arguments(). 00962 { 00963 cmt_string hosttype; 00964 00965 CmtSystem::get_hosttype (hosttype); 00966 00967 if (hosttype != "") 00968 { 00969 Tag* tag; 00970 00971 tag = Tag::add (hosttype, PriorityUname, "HOSTTYPE", 0); 00972 tag->mark (); 00973 } 00974 } |
|
Definition at line 977 of file cmt_parser.cxx. Referenced by Symbol::action(), configure(), load(), and parse_arguments(). 00978 { 00979 Symbol* symbol = Symbol::find ("CMTSITE"); 00980 if (symbol != 0) 00981 { 00982 m_cmt_site = symbol->build_macro_value (); 00983 } 00984 else 00985 { 00986 m_cmt_site = CmtSystem::get_cmt_site (); 00987 } 00988 00989 if (m_cmt_site != "") 00990 { 00991 cmt_string s = "CMTSITE"; 00992 00993 if (use != 0) 00994 { 00995 s += " in "; 00996 } 00997 00998 Tag* tag; 00999 01000 tag = Tag::add (m_cmt_site, PrioritySite, s, use); 01001 tag->mark (); 01002 } 01003 } |
|
Definition at line 1049 of file cmt_parser.cxx. Referenced by Symbol::action(), and restore_all_tags(). 01050 { 01051 cmt_string config_tag; 01052 01053 if (m_debug) cerr << "configure_tags0> current_tag=" << m_current_tag << endl; 01054 01055 Symbol* symbol = Symbol::find ("CMTCONFIG"); 01056 if (symbol != 0) 01057 { 01058 bool show_set_hidden = false; 01059 01060 if (Cmt::m_action == action_show_set) 01061 { 01062 show_set_hidden = true; 01063 Cmt::m_action = action_none; 01064 } 01065 01066 config_tag = symbol->build_macro_value (); 01067 01068 if (show_set_hidden) 01069 { 01070 show_set_hidden = false; 01071 Cmt::m_action = action_show_set; 01072 } 01073 } 01074 else if (CmtSystem::testenv ("CMTCONFIG")) 01075 { 01076 config_tag = CmtSystem::getenv ("CMTCONFIG"); 01077 } 01078 else if (CmtSystem::testenv ("CMTBIN")) 01079 { 01080 config_tag = CmtSystem::getenv ("CMTBIN"); 01081 } 01082 01083 if (config_tag == "") 01084 { 01085 CmtSystem::get_uname (config_tag); 01086 } 01087 01088 if (m_debug) cerr << "configure_tags> current_tag=" << m_current_tag << endl; 01089 01090 cmt_string s = "CMTCONFIG"; 01091 01092 if (use != 0) 01093 { 01094 s += " in "; 01095 } 01096 01097 Tag* tag; 01098 01099 tag = Tag::add (config_tag, PriorityConfig, s, use); 01100 tag->mark (); 01101 01102 //m_current_tag = config_tag; 01103 } |
|
Definition at line 1106 of file cmt_parser.cxx. Referenced by configure(), load(), and parse_arguments(). 01107 { 01108 cmt_string uname; 01109 01110 CmtSystem::get_uname (uname); 01111 01112 if (uname != "") 01113 { 01114 Tag* tag; 01115 01116 tag = Tag::add (uname, PriorityUname, "uname", 0); 01117 tag->mark (); 01118 } 01119 } |
|
Definition at line 940 of file cmt_parser.cxx. Referenced by Symbol::action(), and configure(). 00941 { 00942 m_cmt_user_context = ""; 00943 00944 Symbol* symbol = Symbol::find ("CMTUSERCONTEXT"); 00945 if (symbol != 0) 00946 { 00947 m_cmt_user_context = symbol->build_macro_value (); 00948 } 00949 else if (CmtSystem::testenv ("CMTUSERCONTEXT")) 00950 { 00951 m_cmt_user_context = CmtSystem::getenv ("CMTUSERCONTEXT"); 00952 } 00953 00954 if ((m_cmt_user_context != "") && !CmtSystem::test_directory (m_cmt_user_context)) 00955 { 00956 m_cmt_user_context = ""; 00957 } 00958 } |
|
Definition at line 1138 of file cmt_parser.cxx. Referenced by parser(). 01139 { 01140 if (arguments.size () < 1) 01141 { 01142 cout << "> cmt broadcast <file> <pattern>" << endl; 01143 return; 01144 } 01145 01146 const cmt_string& file = arguments[0]; 01147 const cmt_string& pattern = arguments[1]; 01148 cmt_string text; 01149 01150 text.read (file); 01151 01152 static AwkActor a; 01153 01154 cmt_regexp exp (pattern); 01155 01156 a.run (text, exp); 01157 } |
|
Definition at line 1160 of file cmt_parser.cxx. Referenced by parser(). 01163 { 01164 Use::UsePtrVector& Uses = Use::uses (); 01165 01166 CmtSystem::cmt_string_vector uses; 01167 CmtSystem::cmt_string_vector path_selections; 01168 CmtSystem::cmt_string_vector selections; 01169 CmtSystem::cmt_string_vector exclusions; 01170 cmt_string begin; 01171 cmt_string command; 01172 bool is_cmt = false; 01173 int first = 0; 01174 int i; 01175 bool ignore_errors = false; 01176 bool all_packages = false; 01177 01178 bool local = true; 01179 01180 for (i = 0; i < arguments.size (); i++) 01181 { 01182 const cmt_string& w = arguments[i]; 01183 01184 if (command == "") 01185 { 01186 if (w.substr (0, 13) == "-all_packages") 01187 { 01188 local = false; 01189 all_packages = true; 01190 } 01191 else if (w.substr (0, 7) == "-depth=") 01192 { 01193 local = false; 01194 01195 cmt_string depth_str; 01196 int depth_value = 0; 01197 01198 w.substr (7, depth_str); 01199 if ((sscanf (depth_str.c_str (), "%d", &depth_value) < 1) || 01200 (depth_value < 1)) 01201 { 01202 // Syntax error 01203 // We shall restrict to packages found within 01204 // the <depth_value> first elements of CMTPATH. 01205 // If CMTPATH is empty, nothing is selected. 01206 // depth=1 is equivalent to local 01207 } 01208 01209 int i = 0; 01210 while (i < m_cmt_path.size ()) 01211 { 01212 cmt_string& p = m_cmt_path[i]; 01213 cmt_string& pwd = m_cmt_path_pwds[i]; 01214 cmt_string& src = m_cmt_path_sources[i]; 01215 01216 if (src == "current package") 01217 { 01218 cmt_string& s1 = path_selections.add (); 01219 s1 = p; 01220 cmt_string& s2 = path_selections.add (); 01221 s2 = pwd; 01222 } 01223 else if (src != "default path") 01224 { 01225 if (depth_value > 0) 01226 { 01227 cmt_string& s1 = path_selections.add (); 01228 s1 = p; 01229 cmt_string& s2 = path_selections.add (); 01230 s2 = pwd; 01231 depth_value--; 01232 } 01233 } 01234 i++; 01235 } 01236 } 01237 else if (w.substr (0, 9) == "-exclude=") 01238 { 01239 cmt_string exclusion; 01240 01241 w.substr (9, exclusion); 01242 01243 int size = exclusion.size (); 01244 01245 if (size >= 2) 01246 { 01247 if (((exclusion[0] == '"') && (exclusion[size - 1] == '"')) || 01248 ((exclusion[0] == '\'') && (exclusion[size - 1] == '\''))) 01249 { 01250 exclusion.erase (size - 1); 01251 exclusion.erase (0, 1); 01252 } 01253 01254 CmtSystem::split (exclusion, " \t", exclusions); 01255 } 01256 } 01257 else if (w.substr (0, 7) == "-global") 01258 { 01259 path_selections.clear (); 01260 local = false; 01261 } 01262 else if (w.substr (0, 6) == "-local") 01263 { 01264 local = true; 01265 } 01266 else if (w.substr (0, 8) == "-select=") 01267 { 01268 cmt_string selection; 01269 01270 w.substr (8, selection); 01271 01272 int size = selection.size (); 01273 01274 if (size >= 2) 01275 { 01276 if (((selection[0] == '"') && (selection[size - 1] == '"')) || 01277 ((selection[0] == '\'') && (selection[size - 1] == '\''))) 01278 { 01279 selection.erase (size - 1); 01280 selection.erase (0, 1); 01281 } 01282 01283 CmtSystem::split (selection, " \t", selections); 01284 } 01285 } 01286 else if (w.substr (0, 7) == "-begin=") 01287 { 01288 w.substr (7, begin); 01289 } 01290 else 01291 { 01292 command = w; 01293 } 01294 } 01295 else 01296 { 01297 command += " "; 01298 command += w; 01299 } 01300 01301 } 01302 01303 if (local) 01304 { 01305 int depth_value = 1; 01306 01307 int i = 0; 01308 while (i < m_cmt_path.size ()) 01309 { 01310 cmt_string& p = m_cmt_path[i]; 01311 cmt_string& pwd = m_cmt_path_pwds[i]; 01312 cmt_string& src = m_cmt_path_sources[i]; 01313 01314 if (src == "current package") 01315 { 01316 cmt_string& s1 = path_selections.add (); 01317 s1 = p; 01318 cmt_string& s2 = path_selections.add (); 01319 s2 = pwd; 01320 } 01321 else if (src != "default path") 01322 { 01323 if (depth_value > 0) 01324 { 01325 cmt_string& s1 = path_selections.add (); 01326 s1 = p; 01327 cmt_string& s2 = path_selections.add (); 01328 s2 = pwd; 01329 depth_value--; 01330 } 01331 } 01332 i++; 01333 } 01334 } 01335 01336 if (command[0] == '-') 01337 { 01338 ignore_errors = true; 01339 command.erase (0, 1); 01340 } 01341 01342 //if (command.substr (0, 3) == "cmt") is_cmt = true; 01343 01344 if (all_packages) 01345 { 01346 PackageSelector selector (uses); 01347 FileScanner scanner; 01348 01349 for (i = 0; i < m_cmt_path.size (); i++) 01350 { 01351 cmt_string& p = m_cmt_path[i]; 01352 scanner.scan_path (p, selector); 01353 } 01354 } 01355 else 01356 { 01357 for (i = Uses.size () - 1; i >= 0; i--) 01358 { 01359 Use* use = Uses[i]; 01360 01361 if (use->discarded) continue; 01362 01363 if (!use->located ()) 01364 { 01365 if (!Cmt::m_quiet) 01366 { 01367 cout << "# package " << use->package << 01368 " " << use->version << " " << use->path << 01369 " not found" << 01370 endl; 01371 } 01372 } 01373 else 01374 { 01375 if (use->package != "CMT") 01376 { 01377 cmt_string& s = uses.add (); 01378 01379 if (use->real_path == "") s = CmtSystem::pwd (); 01380 else s = use->real_path; 01381 s += CmtSystem::file_separator (); 01382 s += use->package; 01383 s += CmtSystem::file_separator (); 01384 s += use->version; 01385 s += CmtSystem::file_separator (); 01386 01387 if (use->style == mgr_style) s += "mgr"; 01388 else s += "cmt"; 01389 01390 //cout << ">>> adding " << s << " to selection" << endl; 01391 } 01392 } 01393 } 01394 01395 { 01396 cmt_string& s = uses.add (); 01397 01398 Use* use = &(Use::current ()); 01399 01400 if (use->package.find ("cmt_standalone") != cmt_string::npos) 01401 { 01402 s = CmtSystem::pwd (); 01403 } 01404 else 01405 { 01406 if (use->real_path == "") s = CmtSystem::pwd (); 01407 else s = use->real_path; 01408 s += CmtSystem::file_separator (); 01409 s += use->package; 01410 s += CmtSystem::file_separator (); 01411 s += use->version; 01412 s += CmtSystem::file_separator (); 01413 01414 if (use->style == mgr_style) s += "mgr"; 01415 else s += "cmt"; 01416 } 01417 01418 //cout << ">>> adding current " << s << " to selection" << endl; 01419 } 01420 } 01421 01422 bool started = false; 01423 01424 if (begin == "") started = true; 01425 01426 for (i = 0; i < uses.size (); i++) 01427 { 01428 const cmt_string& s = uses[i]; 01429 bool ok = true; 01430 bool selected = true; 01431 bool excluded = false; 01432 01433 if (path_selections.size () > 0) 01434 { 01435 selected = false; 01436 01437 for (int j = 0; j < path_selections.size (); j++) 01438 { 01439 const cmt_string& sel = path_selections[j]; 01440 01441 if (s.find (sel) != cmt_string::npos) 01442 { 01443 selected = true; 01444 break; 01445 } 01446 } 01447 01448 ok = selected; 01449 } 01450 01451 if (ok) 01452 { 01453 if (selections.size () > 0) 01454 { 01455 selected = false; 01456 01457 for (int j = 0; j < selections.size (); j++) 01458 { 01459 const cmt_string& sel = selections[j]; 01460 01461 if (s.find (sel) != cmt_string::npos) 01462 { 01463 selected = true; 01464 break; 01465 } 01466 } 01467 01468 ok = selected; 01469 } 01470 } 01471 01472 if (ok && !started) 01473 { 01474 if (s.find (begin) != cmt_string::npos) 01475 { 01476 started = true; 01477 ok = true; 01478 } 01479 else 01480 { 01481 ok = false; 01482 } 01483 } 01484 01485 01486 if (ok) 01487 { 01488 excluded = false; 01489 01490 for (int j = 0; j < exclusions.size (); j++) 01491 { 01492 const cmt_string& exc = exclusions[j]; 01493 01494 if (s.find (exc) != cmt_string::npos) 01495 { 01496 excluded = true; 01497 break; 01498 } 01499 } 01500 01501 if (excluded) ok = false; 01502 } 01503 01504 if (!ok) 01505 { 01506 continue; 01507 } 01508 01509 01510 01511 if (!CmtSystem::cd (s)) 01512 { 01513 if (s.find ("cmt_standalone") != cmt_string::npos) 01514 { 01515 cout << "# Currently not in a CMT package" << endl; 01516 } 01517 else 01518 { 01519 cout << "# Cannot move to the package in " << s << " (" << i+1 << "/" 01520 << uses.size () << ")"<< endl; 01521 } 01522 01523 if (!ignore_errors) break; 01524 01525 continue; 01526 } 01527 01528 if (CmtLock::check () == CmtLock::locked_by_another_user) 01529 { 01530 cout << "# Ignore locked package in " << s << " (" << i+1 << "/" 01531 << uses.size () << ")" << endl; 01532 continue; 01533 } 01534 01535 cout << "#--------------------------------------------------------------" << endl; 01536 cout << "# Now trying [" << command << "] in " << s << " (" << i+1 << "/" << uses.size () 01537 << ")" << endl; 01538 cout << "#--------------------------------------------------------------" << endl; 01539 01540 if (is_cmt) 01541 { 01542 // 01543 // There is a bug in the recursive use of the parser. Macros are not set correctly. 01544 // Thus the recursive optimization is now discarded. 01545 // 01546 if (parser (command) != 0) 01547 { 01548 CmtError::set (CmtError::execution_error, command); 01549 break; 01550 } 01551 } 01552 else 01553 { 01554 int status = CmtSystem::execute (command); 01555 01556 //cerr << "do_broadcast> status=" << status << " ignore_errors=" << ignore_errors << endl; 01557 01558 if (((status != 0) && !ignore_errors) || (status == 2)) 01559 //if ((status != 0) && !ignore_errors) 01560 { 01561 if (status != 2) CmtError::set (CmtError::execution_error, command); 01562 break; 01563 } 01564 } 01565 } 01566 } |
|
Definition at line 1569 of file cmt_parser.cxx. Referenced by parser(). 01572 { 01573 if (CmtLock::check () == CmtLock::locked_by_another_user) 01574 { 01575 CmtError::set (CmtError::conflicting_lock, "build_constituent_makefile>"); 01576 return; 01577 } 01578 if (arguments.size () > 0) 01579 { 01580 set_standard_macros (); 01581 Generator::build_constituent_makefile (arguments[0]); 01582 } 01583 } |
|
Definition at line 1586 of file cmt_parser.cxx. Referenced by parser(). 01589 { 01590 if (CmtLock::check () == CmtLock::locked_by_another_user) 01591 { 01592 CmtError::set (CmtError::conflicting_lock, "build_constituents_makefile>"); 01593 return; 01594 } 01595 set_standard_macros (); 01596 Generator::build_constituents_makefile (m_current_package); 01597 } |
|
Definition at line 1600 of file cmt_parser.cxx. Referenced by parser(). 01603 { 01604 if (CmtLock::check () == CmtLock::locked_by_another_user) 01605 { 01606 CmtError::set (CmtError::conflicting_lock, "build_dependencies>"); 01607 return; 01608 } 01609 if (arguments.size () > 0) 01610 { 01611 set_standard_macros (); 01612 01613 while (argc > 0) 01614 { 01615 if (strcmp (argv[0], "dependencies") != 0) 01616 { 01617 argc--; 01618 argv++; 01619 } 01620 else 01621 { 01622 argc--; 01623 argv++; 01624 argc--; 01625 argv++; 01626 01627 Generator::build_dependencies (arguments[0], argc, argv); 01628 01629 break; 01630 } 01631 } 01632 } 01633 } |
|
Definition at line 1636 of file cmt_parser.cxx. Referenced by parser(). 01637 { 01638 if (CmtLock::check () == CmtLock::locked_by_another_user) 01639 { 01640 CmtError::set (CmtError::conflicting_lock, "build_library_links>"); 01641 return; 01642 } 01643 01644 set_standard_macros (); 01645 01646 Use::UsePtrVector& Uses = Use::uses (); 01647 Use& current_use = Use::current (); 01648 int i; 01649 cmt_string shlibsuffix; 01650 cmt_string bin; 01651 01652 { 01653 Symbol* macro = Symbol::find ("shlibsuffix"); 01654 if (macro == 0) return; 01655 shlibsuffix = macro->build_macro_value (); 01656 } 01657 01658 for (i = 0; i < Uses.size (); i++) 01659 { 01660 Use* use = Uses[i]; 01661 01662 if (use->discarded) continue; 01663 01664 if (!use->located ()) 01665 { 01666 if (!m_quiet) 01667 { 01668 cout << "# package " << use->package << 01669 " " << use->version << " " << use->path << 01670 " not found" << 01671 endl; 01672 } 01673 } 01674 else 01675 { 01676 if (use->package == "CMT") continue; 01677 if (use->package == current_use.package) continue; 01678 01679 cmt_string s; 01680 01681 s = use->package; 01682 s += "_libraries"; 01683 01684 Symbol* libraries_macro = Symbol::find (s); 01685 01686 if (libraries_macro == 0) continue; 01687 01688 cmt_string libraries = libraries_macro->build_macro_value (); 01689 static CmtSystem::cmt_string_vector values; 01690 01691 CmtSystem::split (libraries, " \t", values); 01692 01693 for (int j = 0; j < values.size (); j++) 01694 { 01695 const cmt_string& library = values[j]; 01696 01697 static cmt_string libname; 01698 static cmt_string name; 01699 01700 // Is it a simple name or a complete path? 01701 01702 libname = library; 01703 Symbol::expand (libname); 01704 01705 if (CmtSystem::absolute_path (libname)) 01706 { 01712 cmt_string suffix; 01713 CmtSystem::basename (library, name); 01714 } 01715 else 01716 { 01723 libname = "${"; 01724 libname += use->prefix; 01725 libname += "ROOT}/${"; 01726 libname += use->package; 01727 libname += "_tag}/lib"; 01728 libname += library; 01729 libname += "."; 01730 libname += shlibsuffix; 01731 01732 name = "lib"; 01733 name += library; 01734 name += "."; 01735 name += shlibsuffix; 01736 } 01737 01738 Symbol::expand (libname); 01739 01740 s = "../$("; 01741 s += current_use.package; 01742 s += "_tag)/"; 01743 s += name; 01744 01745 Symbol::expand (s); 01746 01747 if (!m_quiet) cout << " Symlinking " << libname << " to " << s << endl; 01748 01749 if (!CmtSystem::create_symlink (libname, s)) 01750 { 01751 cout << "Cannot create a symbolic link to " << libname << endl; 01752 01753 break; 01754 } 01755 } 01756 } 01757 } 01758 } |
|
Here we expect that only the base name of the library is given : ie it should not contain the "lib" prefix, nor the suffix .so, nor any path prefix. This of course should generally correspond to a constituent name. Definition at line 1761 of file cmt_parser.cxx. Referenced by parser(). 01762 { 01763 if (CmtLock::check () == CmtLock::locked_by_another_user) 01764 { 01765 CmtError::set (CmtError::conflicting_lock, "build_make_setup>"); 01766 return; 01767 } 01768 set_standard_macros (); 01769 Generator::build_make_setup (m_current_package); 01770 } |
|
Definition at line 1773 of file cmt_parser.cxx. Referenced by parser(). 01774 { 01775 if (CmtLock::check () == CmtLock::locked_by_another_user) 01776 { 01777 CmtError::set (CmtError::conflicting_lock, "build_msdev>"); 01778 return; 01779 } 01780 01781 if (true) 01782 { 01783 set_standard_macros (); 01784 if (arguments.size () > 0) build_msdev_file (arguments[0]); 01785 else build_msdev_file (""); 01786 } 01787 } |
|
Definition at line 1790 of file cmt_parser.cxx. Referenced by parser(). 01791 { 01792 if (CmtLock::check () == CmtLock::locked_by_another_user) 01793 { 01794 CmtError::set (CmtError::conflicting_lock, "build_os9_makefile>"); 01795 return; 01796 } 01797 01798 if (arguments.size () > 0) 01799 { 01800 set_standard_macros (); 01801 build_OS9_makefile (arguments[0]); 01802 } 01803 } |
|
Definition at line 1806 of file cmt_parser.cxx. Referenced by parser(). 01807 { 01808 if (CmtLock::check () == CmtLock::locked_by_another_user) 01809 { 01810 CmtError::set (CmtError::conflicting_lock, "build_prototype>"); 01811 return; 01812 } 01813 01814 if (arguments.size () > 0) 01815 { 01816 set_standard_macros (); 01817 Generator::build_prototype (arguments[0]); 01818 } 01819 } |
|
Definition at line 1822 of file cmt_parser.cxx. Referenced by parser(). 01823 { 01824 if (CmtLock::check () == CmtLock::locked_by_another_user) 01825 { 01826 CmtError::set (CmtError::conflicting_lock, "build_readme>"); 01827 return; 01828 } 01829 01830 set_standard_macros (); 01831 Generator::build_readme (arguments); 01832 } |
|
Definition at line 1835 of file cmt_parser.cxx. Referenced by parser(). 01836 { 01837 if (CmtLock::check () == CmtLock::locked_by_another_user) 01838 { 01839 CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>"); 01840 return; 01841 } 01842 01843 print_macros (Make); 01844 } |
|
Definition at line 1847 of file cmt_parser.cxx. Referenced by parser(). 01848 { 01849 cmt_string name = CmtSystem::get_temporary_name (); 01850 cout << name << endl; 01851 } |
|
Definition at line 1854 of file cmt_parser.cxx. Referenced by parser(). 01855 { 01856 if (CmtLock::check () == CmtLock::locked_by_another_user) 01857 { 01858 CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>"); 01859 return; 01860 } 01861 01862 if (arguments.size () > 0) 01863 { 01864 set_standard_macros (); 01865 TriggerGenerator::run (arguments[0]); 01866 } 01867 } |
|
Definition at line 1870 of file cmt_parser.cxx. Referenced by parser(). 01871 { 01872 if (CmtLock::check () == CmtLock::locked_by_another_user) 01873 { 01874 CmtError::set (CmtError::conflicting_lock, "build_windefs>"); 01875 return; 01876 } 01877 01878 if (arguments.size () > 0) 01879 { 01880 set_standard_macros (); 01881 Generator::build_windefs (arguments[0]); 01882 } 01883 } |
|
Definition at line 1886 of file cmt_parser.cxx. Referenced by parser(). 01887 { 01888 } |
|
Definition at line 1891 of file cmt_parser.cxx. Referenced by parser(). 01892 { 01893 if (arguments.size () >= 2) 01894 { 01895 cmt_string first_file = arguments[0]; 01896 cmt_string second_file = arguments[1]; 01897 01898 if (first_file == "") return; 01899 if (second_file == "") return; 01900 01901 CmtSystem::compare_and_update_files (first_file, second_file); 01902 } 01903 } |
|
Definition at line 1906 of file cmt_parser.cxx. Referenced by parser(). 01907 { 01908 if (arguments.size () > 0) 01909 { 01910 cmt_string name = arguments[0]; 01911 01912 if (name == "") return; 01913 int v = 0; 01914 int r = 0; 01915 int p = 0; 01916 01917 bool ok = CmtSystem::is_version_directory (name, v, r, p); 01918 01919 if (ok) 01920 { 01921 cout << "# " << name << " is version " << v << " release " << r << " patch " << p << endl; 01922 } 01923 else 01924 { 01925 cout << "# " << name << " is not a version tag" << endl; 01926 } 01927 } 01928 } |
|
Definition at line 1931 of file cmt_parser.cxx. Referenced by parser(). 01932 { 01933 Cvs::checkout (arguments); 01934 } |
|
Definition at line 1937 of file cmt_parser.cxx. Referenced by parser(). 01938 { 01939 print_clean (mode); 01940 } |
|
Definition at line 1943 of file cmt_parser.cxx. Referenced by do_create(), and parser(). 01944 { 01945 if (CmtLock::check () == CmtLock::locked_by_another_user) 01946 { 01947 CmtError::set (CmtError::conflicting_lock, "config>"); 01948 return; 01949 } 01950 01951 //Use::UsePtrVector& Uses = Use::uses (); 01952 01953 /* 01954 cout << "pwd " << CmtSystem::pwd () << endl; 01955 cout << "current_dir " << m_current_dir << endl; 01956 cout << "default_path " << m_default_path << endl; 01957 cout << "cmt config " << 01958 m_current_package << " " << 01959 m_current_version << " " << 01960 m_current_path << endl; 01961 */ 01962 01963 if (m_current_package == "CMT") return; 01964 if (m_current_package == "methods") return; 01965 01966 cmt_string branch; 01967 01968 CmtSystem::basename (m_current_dir, branch); 01969 01970 if ((branch != "mgr") && (branch != "cmt")) 01971 { 01972 if (CmtSystem::test_file ("requirements")) 01973 { 01974 cout << "------------------------------------------" << endl; 01975 cout << "Configuring environment for standalone package." << endl; 01976 cout << "CMT version " << m_cmt_version << "." << endl; 01977 cout << "System is " << m_cmt_config << endl; 01978 cout << "------------------------------------------" << endl; 01979 01980 install_test_setup_scripts (); 01981 install_test_cleanup_scripts (); 01982 01983 Generator::build_default_makefile (); 01984 } 01985 else 01986 { 01987 cout << "==============================================" << endl; 01988 cout << "cmt config must be operated either upon " 01989 "an existing package" << endl; 01990 cout << " (ie. when a requirements file already exists)" << endl; 01991 cout << " > cd ..." << endl; 01992 cout << " > cmt config" << endl; 01993 cout << "or to create a new package" << endl; 01994 cout << " > cmt config <package> <version> [<path>]" << endl; 01995 cout << "==============================================" << endl; 01996 } 01997 01998 return; 01999 } 02000 02001 if (branch == "cmt") m_current_style = cmt_style; 02002 else if (branch == "mgr") m_current_style = mgr_style; 02003 else m_current_style = none_style; 02004 02005 Generator::build_default_makefile (); 02006 02007 CmtSystem::cmt_string_vector makes; 02008 cmt_regexp expression ("[.]n?make(sav)?$"); 02009 02010 CmtSystem::scan_dir (".", expression, makes); 02011 02012 if (makes.size () > 0) 02013 { 02014 cout << "Removing all previous make fragments from " << branch << endl; 02015 02016 for (int i = 0; i < makes.size (); i++) 02017 { 02018 const cmt_string& s = makes[i]; 02019 CmtSystem::remove_file (s); 02020 } 02021 } 02022 02023 CmtSystem::cd (".."); 02024 02025 CmtSystem::scan_dir (m_cmt_config, expression, makes); 02026 02027 if (makes.size () > 0) 02028 { 02029 cout << "Removing all previous make fragments from " 02030 << m_cmt_config << endl; 02031 02032 for (int i = 0; i < makes.size (); i++) 02033 { 02034 const cmt_string& s = makes[i]; 02035 CmtSystem::remove_file (s); 02036 } 02037 } 02038 02039 CmtSystem::cd (branch); 02040 02041 02042 /* 02043 if (!load (m_current_path, m_current_package, m_current_version)) 02044 { 02045 cout << "Cannot read the requirements file" << endl; 02046 return; 02047 } 02048 */ 02049 02050 CmtSystem::dirname (m_current_dir, m_current_path); 02051 CmtSystem::basename (m_current_path, m_current_version); 02052 CmtSystem::dirname (m_current_path, m_current_path); 02053 CmtSystem::basename (m_current_path, m_current_package); 02054 CmtSystem::dirname (m_current_path, m_current_path); 02055 02056 Use& use = Use::current (); 02057 02058 use.set (m_current_package, 02059 m_current_version, 02060 m_current_path, 02061 "", 02062 ""); 02063 02064 use.change_path (m_current_path); 02065 use.style = m_current_style; 02066 02067 //cout << "do_config> current style=" << m_current_style << endl; 02068 02069 if (!reach_current_package ()) 02070 { 02071 cout << "Cannot read the requirements file" << endl; 02072 return; 02073 } 02074 02075 install_setup_scripts (); 02076 install_cleanup_scripts (); 02077 02078 CmtSystem::cd (".."); 02079 02080 Branch::BranchVector& branches = Branch::branches (); 02081 02082 int i; 02083 02084 for (i = 0; i < branches.size (); i++) 02085 { 02086 const Branch& branch = branches[i]; 02087 const cmt_string& branch_name = branch.name (); 02088 02089 if (!CmtSystem::test_directory (branch_name)) 02090 { 02091 if (!CmtSystem::mkdir (branch_name)) 02092 { 02093 cout << "Cannot create the " << branch_name <<" branch" << endl; 02094 } 02095 else 02096 { 02097 cout << "Installing the " << branch_name << " directory" << endl; 02098 } 02099 } 02100 else 02101 { 02102 cout << branch_name << " directory already installed" << endl; 02103 } 02104 } 02105 } |
|
Definition at line 2108 of file cmt_parser.cxx. Referenced by parser(). 02109 { 02110 if (arguments.size () < 2) return; 02111 02112 const cmt_string& package = arguments[0]; 02113 const cmt_string& version = arguments[1]; 02114 cmt_string offset; 02115 if (arguments.size () >= 3) offset = arguments[2]; 02116 02117 if (m_debug) 02118 { 02119 cout << "do_create>m_current_package=" << m_current_package << endl; 02120 cout << "do_create>package=" << package << endl; 02121 } 02122 02123 //if (m_current_package == "CMT") return; 02124 //if (m_current_package == "methods") return; 02125 02126 cmt_string the_path; 02127 02128 the_path = CmtSystem::pwd (); 02129 02130 if (offset != "") 02131 { 02132 if (!CmtSystem::absolute_path (offset)) 02133 { 02134 // offset is really a relative offset 02135 the_path += CmtSystem::file_separator (); 02136 the_path += offset; 02137 } 02138 else // absolute path 02139 { 02140 the_path = offset; 02141 } 02142 } 02143 02144 CmtSystem::compress_path (the_path); 02145 02146 // Now 'the_path' contains the complete path where the package will be created 02147 02148 cout << "------------------------------------------" << endl; 02149 cout << "Configuring environment for package " << package << 02150 " version " << version << "." << endl; 02151 cout << "CMT version " << m_cmt_version << "." << endl; 02152 cout << "Root set to " << the_path << "." << endl; 02153 cout << "System is " << m_cmt_config << endl; 02154 cout << "------------------------------------------" << endl; 02155 02156 if (!CmtSystem::test_directory (the_path)) 02157 { 02158 if (!CmtSystem::mkdir (the_path)) 02159 { 02160 cout << "Cannot create the path directory" << endl; 02161 return; 02162 } 02163 else 02164 { 02165 cout << "Installing the path directory" << endl; 02166 } 02167 } 02168 02169 CmtSystem::cd (the_path); 02170 02171 if (!CmtSystem::test_directory (package)) 02172 { 02173 if (!CmtSystem::mkdir (package)) 02174 { 02175 cout << "Cannot create the package directory" << endl; 02176 return; 02177 } 02178 else 02179 { 02180 cout << "Installing the package directory" << endl; 02181 } 02182 } 02183 else 02184 { 02185 cout << "Package directory already installed" << endl; 02186 } 02187 02188 CmtSystem::cd (package); 02189 02190 if (!CmtSystem::test_directory (version)) 02191 { 02192 if (!CmtSystem::mkdir (version)) 02193 { 02194 cout << "Cannot create the version directory" << endl; 02195 return; 02196 } 02197 else 02198 { 02199 cout << "Installing the version directory" << endl; 02200 } 02201 } 02202 else 02203 { 02204 cout << "Version directory already installed" << endl; 02205 } 02206 02207 CmtSystem::cd (version); 02208 02209 if (!CmtSystem::test_directory ("cmt")) 02210 { 02211 if (!CmtSystem::test_directory ("mgr")) 02212 { 02213 if (!CmtSystem::mkdir ("cmt")) 02214 { 02215 cout << "Cannot create the cmt directory" << endl; 02216 return; 02217 } 02218 else 02219 { 02220 m_current_style = cmt_style; 02221 cout << "Installing the cmt directory" << endl; 02222 } 02223 } 02224 else 02225 { 02226 m_current_style = mgr_style; 02227 cout << "Mgr directory already installed" << endl; 02228 } 02229 } 02230 else 02231 { 02232 m_current_style = cmt_style; 02233 cout << "Cmt directory already installed" << endl; 02234 } 02235 02236 if (!CmtSystem::test_directory ("src")) 02237 { 02238 if (!CmtSystem::mkdir ("src")) 02239 { 02240 cout << "Cannot create the src directory" << endl; 02241 return; 02242 } 02243 else 02244 { 02245 cout << "Installing the src directory" << endl; 02246 } 02247 } 02248 else 02249 { 02250 cout << "src directory already installed" << endl; 02251 } 02252 02253 switch (m_current_style) 02254 { 02255 case cmt_style: 02256 CmtSystem::cd ("cmt"); 02257 break; 02258 case mgr_style: 02259 CmtSystem::cd ("mgr"); 02260 break; 02261 } 02262 02263 Generator::build_default_makefile (); 02264 02265 if (!CmtSystem::test_file ("requirements")) 02266 { 02267 // create an empty requirement file. 02268 ofstream f ("requirements"); 02269 if (f) 02270 { 02271 f << "package " << package << endl; 02272 f << endl; 02273 f.close (); 02274 } 02275 } 02276 02277 m_current_package = package; 02278 m_current_version = version; 02279 m_current_path = the_path; 02280 m_current_dir = CmtSystem::pwd (); 02281 02282 do_config (); 02283 } |
|
Definition at line 2286 of file cmt_parser.cxx. Referenced by parser(). 02287 { 02288 Cvs::branches (arguments[0]); 02289 } |
|
Definition at line 2292 of file cmt_parser.cxx. Referenced by parser(). 02293 { 02294 Cvs::subpackages (arguments[0]); 02295 } |
|
Definition at line 2298 of file cmt_parser.cxx. Referenced by parser(). 02299 { 02300 Cvs::tags (arguments); 02301 } |
|
Definition at line 2304 of file cmt_parser.cxx. Referenced by parser(). 02305 { 02306 set_standard_macros (); 02307 CmtModel::expand (arguments[0]); 02308 } |
|
Handle free filtering of text files containing or ${xxx} patterns. Substitution is performed against CMT macros and environment variables. Arguments: cmt filter input-file-name output-file-name Definition at line 2320 of file cmt_parser.cxx. Referenced by parser(). 02321 { 02322 if (arguments.size () < 2) return; 02323 02324 cmt_string& input = arguments[0]; 02325 cmt_string& output = arguments[1]; 02326 02327 if (!CmtSystem::test_file (input)) 02328 { 02329 cout << "#CMT> File " << input << " not found" << endl; 02330 return; 02331 } 02332 02333 cmt_string text; 02334 02335 text.read (input); 02336 02337 set_standard_macros (); 02338 02339 Symbol::expand (text); 02340 02341 FILE* file = fopen (output, "wb"); 02342 if (file == NULL) 02343 { 02344 cout << "#CMT> Cannot write filtered file " << output << endl; 02345 } 02346 else 02347 { 02348 text.write (file); 02349 fclose (file); 02350 } 02351 } |
|
Definition at line 2354 of file cmt_parser.cxx. Referenced by parser(). 02355 { 02356 cout << "> cmt command [option...]" << endl; 02357 cout << " command :" << endl; 02358 cout << " broadcast [-select=list] [-exclude=list] [-local] [-global] [-begin=pattern] [-depth=n] <command> : apply a command to [some of] the used packages" << endl; 02359 cout << "" << endl; 02360 cout << " build <key> : build various components :" << endl; 02361 cout << " constituent_makefile <constituent> : generate constituent Makefile fragment" << endl; 02362 cout << " constituents_makefile : generate constituents.make" << endl; 02363 cout << " dependencies : generate dependencies" << endl; 02364 cout << " library_links : build symbolic links towards all imported libraries" << endl; 02365 cout << " make_setup : build a compiled version of setup scripts" << endl; 02366 cout << " msdev : generate MSDEV files" << endl; 02367 cout << " os9_makefile : generate Makefile for OS9" << endl; 02368 cout << " prototype : generate prototype file" << endl; 02369 cout << " readme : generate README.html" << endl; 02370 cout << " tag_makefile : generate tag specific Makefile" << endl; 02371 cout << " triggers <constituent> : generate library trigger file" << endl; 02372 cout << " windefs <library_name> : generate def file for Windows shared libraries" << endl; 02373 cout << "" << endl; 02374 cout << " check <key> : perform various checks" << endl; 02375 cout << " configuration : check configuration" << endl; 02376 cout << " files <old> <new> : compare two files and overrides <old> by <new> if different" << endl; 02377 cout << " version <name> : check if a name follows a version tag syntax " << endl; 02378 cout << " check_files <old> <new> : compare two files and overrides <old> by <new> if different" << endl; 02379 cout << " checkout : perform a cvs checkout over a CMT package" << endl; 02380 cout << " co : perform a cvs checkout over a CMT package" << endl; 02381 cout << " cleanup [-csh|-sh|-bat] : generate a cleanup script" << endl; 02382 cout << " config : generate setup and cleanup scripts" << endl; 02383 cout << " create <package> <version> [<path>] : create and configure a new package" << endl; 02384 cout << " filter <in> <out> : filter a file against CMT macros and env. variables" << endl; 02385 cout << " help : display this help" << endl; 02386 cout << " lock [<p> <v> [<path>]] : lock a package" << endl; 02387 cout << " remove <package> <version> [<path>] : remove a package version" << endl; 02388 cout << " remove library_links : remove symbolic links towards all imported libraries" << endl; 02389 cout << " run <command> : apply a command" << endl; 02390 cout << " setup [-csh|-sh|-bat] : generate a setup script" << endl; 02391 cout << " show <key> : display various infos on :" << endl; 02392 cout << " all_tags : all defined tags" << endl; 02393 cout << " applied_patterns : all patterns actually applied" << endl; 02394 cout << " author : package author" << endl; 02395 cout << " branches : added branches" << endl; 02396 cout << " clients : package clients" << endl; 02397 cout << " constituent_names : constituent names" << endl; 02398 cout << " constituents : constituent definitions" << endl; 02399 cout << " uses : the use tree" << endl; 02400 cout << " fragment <name> : one fragment definition" << endl; 02401 cout << " fragments : fragment definitions" << endl; 02402 cout << " groups : group definitions" << endl; 02403 cout << " languages : language definitions" << endl; 02404 cout << " macro <name> : a formatted macro definition" << endl; 02405 cout << " macro_value <name> : a raw macro definition" << endl; 02406 cout << " macros : all macro definitions" << endl; 02407 cout << " manager : package manager" << endl; 02408 cout << " packages : packages reachable from the current context" << endl; 02409 cout << " path : the package search list" << endl; 02410 cout << " pattern <name> : the pattern definition and usages" << endl; 02411 cout << " pattern_names : pattern names" << endl; 02412 cout << " patterns : the pattern definitions" << endl; 02413 cout << " pwd : filtered current directory" << endl; 02414 cout << " set_value <name> : a raw set definition" << endl; 02415 cout << " set <name> : a formatted set definition" << endl; 02416 cout << " sets : set definitions" << endl; 02417 cout << " strategies : all strategies (build & version)" << endl; 02418 cout << " tags : all currently active tags" << endl; 02419 cout << " uses : used packages" << endl; 02420 cout << " version : version of the current package" << endl; 02421 cout << " versions <name> : visible versions of the selected package" << endl; 02422 cout << "" << endl; 02423 cout << " system : display the system tag" << endl; 02424 cout << " unlock [<p> <v> [<path>]] : unlock a package" << endl; 02425 cout << " version : version of CMT" << endl; 02426 cout << "" << endl; 02427 cout << " cvstags <module> : display the CVS tags for a module" << endl; 02428 cout << " cvsbranches <module> : display the subdirectories for a module" << endl; 02429 cout << " cvssubpackagess <module> : display the subpackages for a module" << endl; 02430 02431 cout << " global options :" << endl; 02432 02433 cout << " -quiet : don't print errors" << endl; 02434 cout << " -use=<p>:<v>:<path> : set package version path" << endl; 02435 cout << " -pack=<package> : set package" << endl; 02436 cout << " -version=<version> : set version" << endl; 02437 cout << " -path=<path> : set root path" << endl; 02438 cout << " -f=<requirement-file> : set input file" << endl; 02439 cout << " -e=<statement> : add a one line statement" << endl; 02440 cout << " -tag=<tag-list> : select a new tag-set" << endl; 02441 cout << " -tag_add=<tag-list> : add specific comma-separated tag(s)" << endl; 02442 cout << " -tag_remove=<tag-list> : remove specific comma-separated tag(s)" << endl; 02443 } |
|
Definition at line 2446 of file cmt_parser.cxx. Referenced by parser(). 02449 { 02450 //(unsused) Use& use = Use::current(); 02451 02452 cout << "try to lock package " << package << " in " << CmtSystem::pwd () << endl; 02453 02454 set_standard_macros (); 02455 02456 CmtLock::status status = CmtLock::lock (); 02457 } |
|
Definition at line 2460 of file cmt_parser.cxx. Referenced by parser(). 02463 { 02464 //Use::UsePtrVector& Uses = Use::uses (); 02465 02466 if (m_current_package == "CMT") return; 02467 if (m_current_package == "methods") return; 02468 02469 cmt_string the_path; 02470 02471 //the_path = m_default_path; 02472 the_path = CmtSystem::pwd (); 02473 02474 if (path != "") 02475 { 02476 if (!CmtSystem::absolute_path (path)) 02477 { 02478 // path is just a suffix 02479 the_path += CmtSystem::file_separator (); 02480 the_path += path; 02481 } 02482 else // absolute path 02483 { 02484 the_path = path; 02485 } 02486 } 02487 02488 CmtSystem::compress_path (the_path); 02489 02490 cout << "------------------------------------------" << endl; 02491 cout << "Removing package " << package << 02492 " version " << version << "." << endl; 02493 cout << "CMT version " << m_cmt_version << "." << endl; 02494 cout << "Root set to " << the_path << "." << endl; 02495 cout << "System is " << m_cmt_config << endl; 02496 cout << "------------------------------------------" << endl; 02497 02498 the_path += CmtSystem::file_separator (); 02499 the_path += package; 02500 02501 if (CmtSystem::cd (the_path) && 02502 CmtSystem::test_directory (version)) 02503 { 02504 if (CmtSystem::remove_directory (version)) 02505 { 02506 cout << "Version " << version << " has been removed from " << the_path << endl; 02507 CmtSystem::cmt_string_vector contents; 02508 CmtSystem::scan_dir (".", contents); 02509 if (contents.size () == 0) 02510 { 02511 CmtSystem::cd (".."); 02512 if (CmtSystem::remove_directory (package)) 02513 { 02514 cout << "Package " << package << " has no more versions. Thus it has been removed."<< endl; 02515 } 02516 } 02517 } 02518 else 02519 { 02520 cout << "Impossible to remove version " << version << " from " << the_path << endl; 02521 } 02522 } 02523 else 02524 { 02525 cout << "Version " << version << " not found" << endl; 02526 } 02527 } |
|
Definition at line 2530 of file cmt_parser.cxx. Referenced by parser(). 02531 { 02532 if (CmtLock::check () == CmtLock::locked_by_another_user) 02533 { 02534 CmtError::set (CmtError::conflicting_lock, "remove_library_links>"); 02535 return; 02536 } 02537 02538 set_standard_macros (); 02539 02540 Use::UsePtrVector& Uses = Use::uses (); 02541 Use& current_use = Use::current (); 02542 int i; 02543 cmt_string shlibsuffix; 02544 cmt_string symunlink; 02545 02546 { 02547 Symbol* macro = Symbol::find ("shlibsuffix"); 02548 if (macro == 0) return; 02549 shlibsuffix = macro->build_macro_value (); 02550 } 02551 02552 { 02553 Symbol* macro = Symbol::find ("symunlink"); 02554 if (macro == 0) return; 02555 symunlink = macro->build_macro_value (); 02556 } 02557 02558 for (i = 0; i < Uses.size (); i++) 02559 { 02560 Use* use = Uses[i]; 02561 02562 if (use->discarded) continue; 02563 02564 if (!use->located ()) 02565 { 02566 if (!m_quiet) 02567 { 02568 cout << "# package " << use->package << 02569 " " << use->version << " " << use->path << 02570 " not found" << 02571 endl; 02572 } 02573 } 02574 else 02575 { 02576 if (use->package == "CMT") continue; 02577 if (use->package == current_use.package) continue; 02578 02579 cmt_string s; 02580 02581 s = use->package; 02582 s += "_libraries"; 02583 02584 Symbol* libraries_macro = Symbol::find (s); 02585 02586 if (libraries_macro == 0) continue; 02587 02588 cmt_string libraries = libraries_macro->build_macro_value (); 02589 static CmtSystem::cmt_string_vector values; 02590 02591 CmtSystem::split (libraries, " \t", values); 02592 02593 for (int j = 0; j < values.size (); j++) 02594 { 02595 const cmt_string& library = values[j]; 02596 02597 static cmt_string libname; 02598 static cmt_string name; 02599 02600 // Is it a simple name or a complete path? 02601 02602 libname = library; 02603 Symbol::expand (libname); 02604 02605 if (CmtSystem::absolute_path (libname)) 02606 { 02612 cmt_string suffix; 02613 CmtSystem::basename (library, name); 02614 } 02615 else 02616 { 02624 name = "lib"; 02625 name += libname; 02626 name += "."; 02627 name += shlibsuffix; 02628 } 02629 02630 s = symunlink; 02631 s += " ../$("; 02632 s += current_use.package; 02633 s += "_tag)/"; 02634 s += name; 02635 02636 Symbol::expand (s); 02637 02638 if (!m_quiet) cout << s << endl; 02639 int status = CmtSystem::execute (s); 02640 02641 if (status != 0) 02642 { 02643 if (status != 2) CmtError::set (CmtError::execution_error, s); 02644 02645 cout << "Cannot remove the symbolic link " << s << endl; 02646 02647 break; 02648 } 02649 } 02650 } 02651 } 02652 } |
|
Here we expect that only the base name of the library is given : ie it should not contain the "lib" prefix, nor the suffix .so, nor any path prefix. This of course should generally correspond to a constituent name. Definition at line 2655 of file cmt_parser.cxx. Referenced by parser(). 02656 { 02657 if (arguments.size () > 0) CmtSystem::execute (arguments[0]); 02658 } |
|
Definition at line 2871 of file cmt_parser.cxx. Referenced by parser(). 02872 { 02873 if (arguments.size () == 0) cout << "# cmt run_sequence: no sequence specified" << endl; 02874 02875 SequenceRunner runner; 02876 02877 cout << "# cmt run_sequence: sequence " << arguments[0] << endl; 02878 02879 runner.run (arguments[0]); 02880 } |
|
Definition at line 2883 of file cmt_parser.cxx. Referenced by parser(). 02884 { 02885 print (mode); 02886 } |
|
Definition at line 2889 of file cmt_parser.cxx. Referenced by parser(). 02890 { 02891 Tag::TagPtrVector tags = Tag::tags (); 02892 int index; 02893 02894 set_standard_macros (); 02895 02896 for (index = 0; index < tags.size (); index++) 02897 { 02898 const Tag* tag = tags[index]; 02899 if (tag != 0) 02900 { 02901 tag->show_definition (true); 02902 } 02903 } 02904 } |
|
Definition at line 2907 of file cmt_parser.cxx. Referenced by parser(). 02908 { 02909 Pattern::show_all_applied_patterns (); 02910 } |
|
Definition at line 2913 of file cmt_parser.cxx. Referenced by parser(). 02914 { 02915 Use& use = Use::current(); 02916 02917 cout << use.author << endl; 02918 } |
|
Definition at line 2921 of file cmt_parser.cxx. Referenced by parser(). 02922 { 02923 Branch::print_all (mode); 02924 } |
|
Definition at line 2927 of file cmt_parser.cxx. Referenced by parser(). 02928 { 02929 cmt_string package; 02930 cmt_string version; 02931 cmt_string path_name; 02932 02933 if (arguments.size () >= 1) package = arguments[0]; 02934 if (arguments.size () >= 2) version = arguments[1]; 02935 if (arguments.size () >= 3) path_name = arguments[2]; 02936 02937 FileScanner scanner; 02938 PackageCollector collector (package, version); 02939 02940 clear (); 02941 configure (); 02942 02943 cout << "# ----------- Clients of " << package << 02944 " " << version << 02945 " " << path_name << 02946 endl; 02947 02948 if (path_name == "") 02949 { 02950 int path_index; 02951 02952 for (path_index = 0; path_index < m_cmt_path.size (); path_index++) 02953 { 02954 const cmt_string& path = m_cmt_path[path_index]; 02955 02956 scanner.scan_path (path, collector); 02957 } 02958 } 02959 else 02960 { 02961 scanner.scan_path (path_name, collector); 02962 } 02963 cout << "# ----------- " << collector.count () << " clients found." << endl; 02964 } |
|
Definition at line 2967 of file cmt_parser.cxx. Referenced by parser(). 02968 { 02969 if (arguments.size () > 0) 02970 { 02971 set_standard_macros (); 02972 Constituent::show (arguments[0]); 02973 } 02974 } |
|
Definition at line 2977 of file cmt_parser.cxx. Referenced by parser(). 02978 { 02979 set_standard_macros (); 02980 Constituent::show_names (); 02981 } |
|
Definition at line 2984 of file cmt_parser.cxx. Referenced by parser(). 02985 { 02986 set_standard_macros (); 02987 Constituent::show_all (); 02988 } |
|
Definition at line 2991 of file cmt_parser.cxx. Referenced by parser(). 02992 { 02993 if (arguments.size () > 0) Fragment::show (arguments[0]); 02994 } |
|
Definition at line 2997 of file cmt_parser.cxx. Referenced by parser(). 02998 { 02999 Fragment::show_all (); 03000 } |
|
Definition at line 3003 of file cmt_parser.cxx. Referenced by parser(). 03004 { 03005 Group::show_all (); 03006 } |
|
Definition at line 3009 of file cmt_parser.cxx. Referenced by parser(). 03010 { 03011 cmt_string temp; 03012 03013 Use& use = Use::current(); 03014 03015 set_standard_macros (); 03016 03017 if (use.include_path == "") 03018 { 03019 temp += "$(src) "; 03020 } 03021 else if (use.include_path != "none") 03022 { 03023 temp += use.include_path; 03024 temp += " "; 03025 } 03026 03027 for (int include_number = 0; 03028 include_number < use.includes.size (); 03029 include_number++) 03030 { 03031 Include& incl = use.includes[include_number]; 03032 03033 temp += incl.name; 03034 temp += " "; 03035 } 03036 03037 cout << temp << endl; 03038 } |
|
Definition at line 3041 of file cmt_parser.cxx. Referenced by parser(). 03042 { 03043 if (arguments.size () > 0) 03044 { 03045 set_standard_macros (); 03046 Language::show (arguments[0]); 03047 } 03048 } |
|
Definition at line 3051 of file cmt_parser.cxx. Referenced by parser(). 03052 { 03053 set_standard_macros (); 03054 Language::show_all (); 03055 } |
|
Definition at line 3058 of file cmt_parser.cxx. Referenced by do_show_macro_value(), do_show_set(), do_show_set_value(), and parser(). 03060 { 03061 cmt_string target; 03062 03063 if (arguments.size () > 0) target = arguments[0]; 03064 03065 Symbol* symbol; 03066 03067 set_standard_macros (); 03068 03069 symbol = Symbol::find (target); 03070 03071 if (symbol == 0) 03072 { 03073 cmt_string t = " "; 03074 t += target; 03075 t += " is not a "; 03076 03077 if ((m_action == action_show_macro) || 03078 (m_action == action_show_macro_value)) 03079 { 03080 t += "macro"; 03081 } 03082 else if ((m_action == action_show_set) || 03083 (m_action == action_show_set_value)) 03084 { 03085 t += "set"; 03086 } 03087 03088 CmtError::set (CmtError::symbol_not_found, t); 03089 03090 return; 03091 } 03092 else 03093 { 03094 cmt_string t = " "; 03095 t += target; 03096 t += " is not a "; 03097 03098 if ((m_action == action_show_macro) || 03099 (m_action == action_show_macro_value)) 03100 { 03101 if ((symbol->command != CommandMacro) && 03102 (symbol->command != CommandMacroAppend) && 03103 (symbol->command != CommandMacroPrepend) && 03104 (symbol->command != CommandMacroRemove) && 03105 (symbol->command != CommandMacroRemoveAll)) 03106 { 03107 t += "macro"; 03108 03109 CmtError::set (CmtError::symbol_not_found, t); 03110 03111 return; 03112 } 03113 } 03114 else if ((m_action == action_show_set) || 03115 (m_action == action_show_set_value)) 03116 { 03117 if ((symbol->command != CommandSet) && 03118 (symbol->command != CommandSetAppend) && 03119 (symbol->command != CommandSetPrepend) && 03120 (symbol->command != CommandSetRemove) && 03121 (symbol->command != CommandPath) && 03122 (symbol->command != CommandPathAppend) && 03123 (symbol->command != CommandPathPrepend) && 03124 (symbol->command != CommandPathRemove)) 03125 { 03126 t += "set"; 03127 03128 CmtError::set (CmtError::symbol_not_found, t); 03129 03130 return; 03131 } 03132 } 03133 } 03134 03135 if (symbol->value_lists.size () < 1) return; 03136 03137 symbol->show_macro (mode); 03138 } |
|
Definition at line 3141 of file cmt_parser.cxx. Referenced by parser(). 03143 { 03144 if (arguments.size () > 0) 03145 { 03146 const cmt_string& pattern = arguments[0]; 03147 print_symbol_names (mode, pattern); 03148 } 03149 else 03150 { 03151 print_symbol_names (mode); 03152 } 03153 } |
|
Definition at line 3156 of file cmt_parser.cxx. Referenced by parser(). 03158 { 03159 do_show_macro (arguments, mode); 03160 } |
|
Definition at line 3163 of file cmt_parser.cxx. Referenced by parser(). 03165 { 03166 if (arguments.size () > 0) 03167 { 03168 const cmt_string& pattern = arguments[0]; 03169 print_macros (mode, pattern); 03170 } 03171 else 03172 { 03173 print_macros (mode); 03174 } 03175 } |
|
Definition at line 3178 of file cmt_parser.cxx. Referenced by parser(). 03179 { 03180 Use& use = Use::current(); 03181 03182 cout << use.manager << endl; 03183 } |
|
Definition at line 3186 of file cmt_parser.cxx. Referenced by parser(). 03187 { 03188 cmt_string path_name; 03189 03190 if (arguments.size () > 0) path_name = arguments[0]; 03191 03192 FileScanner scanner; 03193 PackageViewer viewer; 03194 03195 if (path_name == "") 03196 { 03197 int path_index; 03198 03199 for (path_index = 0; path_index < m_cmt_path.size (); path_index++) 03200 { 03201 const cmt_string& path = m_cmt_path[path_index]; 03202 03203 scanner.scan_path (path, viewer); 03204 } 03205 } 03206 else 03207 { 03208 scanner.scan_path (path_name, viewer); 03209 } 03210 } |
|
Definition at line 3213 of file cmt_parser.cxx. Referenced by parser(). 03214 { 03215 int path_index; 03216 03217 if (!m_quiet) 03218 { 03219 for (path_index = 0; path_index < m_cmt_path.size (); path_index++) 03220 { 03221 const cmt_string& path = m_cmt_path[path_index]; 03222 const cmt_string& source = m_cmt_path_sources[path_index]; 03223 03224 cout << "# Add path " << path << " from " << source << endl; 03225 } 03226 03227 cout << "#" << endl; 03228 } 03229 03230 for (path_index = 0; path_index < m_cmt_path.size (); path_index++) 03231 { 03232 const cmt_string& path = m_cmt_path[path_index]; 03233 const cmt_string& source = m_cmt_path_sources[path_index]; 03234 03235 if (path_index > 0) cout << CmtSystem::path_separator (); 03236 03237 cout << path; 03238 } 03239 03240 cout << endl; 03241 } |
|
Definition at line 3244 of file cmt_parser.cxx. Referenced by parser(). 03245 { 03246 cmt_string name; 03247 if (arguments.size () > 0) name = arguments[0]; 03248 Pattern::show (name); 03249 } |
|
Definition at line 3252 of file cmt_parser.cxx. Referenced by parser(). 03253 { 03254 Pattern::show_all_names (); 03255 } |
|
Definition at line 3258 of file cmt_parser.cxx. Referenced by parser(). 03259 { 03260 Pattern::show_all (); 03261 } |
|
Definition at line 3264 of file cmt_parser.cxx. Referenced by parser(). 03265 { 03266 cout << m_current_dir << endl; 03267 } |
|
Definition at line 3270 of file cmt_parser.cxx. Referenced by parser(). 03272 { 03273 do_show_macro (arguments, mode); 03274 } |
|
Definition at line 3277 of file cmt_parser.cxx. Referenced by parser(). 03279 { 03280 if (arguments.size () > 0) 03281 { 03282 const cmt_string& pattern = arguments[0]; 03283 print_symbol_names (mode, pattern); 03284 } 03285 else 03286 { 03287 print_symbol_names (mode); 03288 } 03289 } |
|
Definition at line 3292 of file cmt_parser.cxx. Referenced by parser(). 03294 { 03295 do_show_macro (arguments, mode); 03296 } |
|
Definition at line 3299 of file cmt_parser.cxx. Referenced by parser(). 03301 { 03302 if (arguments.size () > 0) 03303 { 03304 const cmt_string& pattern = arguments[0]; 03305 print_macros (mode, pattern); 03306 } 03307 else 03308 { 03309 print_macros (mode); 03310 } 03311 } |
|
Definition at line 3314 of file cmt_parser.cxx. Referenced by parser(). 03315 { 03316 cout << "Version strategy : "; 03317 03318 switch (m_current_strategy) 03319 { 03320 case BestFit : 03321 cout << "BestFit"; 03322 break; 03323 case BestFitNoCheck : 03324 cout << "BestFitNoCheck"; 03325 break; 03326 case FirstChoice : 03327 cout << "FirstChoice"; 03328 break; 03329 case LastChoice : 03330 cout << "LastChoice"; 03331 break; 03332 case KeepAll : 03333 cout << "KeepAll"; 03334 break; 03335 default : 03336 cout << "BestFit"; 03337 break; 03338 } 03339 03340 cout << endl; 03341 03342 cout << "Build strategy : "; 03343 03344 if ((m_current_build_strategy & PrototypesMask) == Prototypes) 03345 { 03346 cout << "prototypes"; 03347 } 03348 else 03349 { 03350 cout << "no_prototypes"; 03351 } 03352 03353 if ((m_current_build_strategy & KeepMakefilesMask) == KeepMakefiles) 03354 { 03355 cout << " keep_makefiles"; 03356 } 03357 else 03358 { 03359 cout << " rebuild_makefiles"; 03360 } 03361 03362 cout << endl; 03363 } |
|
Definition at line 3444 of file cmt_parser.cxx. Referenced by parser(). 03445 { 03446 cout << CmtSystem::get_cmt_config () << endl; 03447 } |
|
Definition at line 3366 of file cmt_parser.cxx. Referenced by parser(). 03367 { 03368 Tag::TagPtrVector tags = Tag::tags (); 03369 int index; 03370 03371 set_standard_macros (); 03372 03373 for (index = 0; index < tags.size (); index++) 03374 { 03375 const Tag* tag = tags[index]; 03376 if (tag != 0) 03377 { 03378 tag->show (m_quiet); 03379 } 03380 } 03381 } |
|
Definition at line 3384 of file cmt_parser.cxx. Referenced by parser(). 03385 { 03386 Use::show_all (); 03387 03388 /* 03389 { 03390 Use::UsePtrVector& Uses = Use::uses (); 03391 03392 Use& cu = Use::current (); 03393 03394 for (int i = 0; i < Uses.size (); i++) 03395 { 03396 Use* use = Uses[i]; 03397 03398 if (use == 0) continue; 03399 if (use->discarded) continue; 03400 03401 Use::UsePtrVector list; 03402 03403 cu.get_paths (use, list); 03404 03405 cout << " to " << use->package << endl; 03406 03407 for (int j = list.size (); j >= 0; j--) 03408 { 03409 Use* u = list[j]; 03410 if (u == 0) continue; 03411 cout << " " << u->package << endl; 03412 } 03413 } 03414 } 03415 */ 03416 } |
|
Definition at line 3419 of file cmt_parser.cxx. Referenced by parser(). 03420 { 03421 cout << m_current_version << endl; 03422 } |
|
Definition at line 3425 of file cmt_parser.cxx. Referenced by parser(). 03426 { 03427 cmt_string package_name; 03428 03429 if (arguments.size () > 0) package_name = arguments[0]; 03430 03431 FileScanner scanner; 03432 03433 int path_index; 03434 03435 for (path_index = 0; path_index < m_cmt_path.size (); path_index++) 03436 { 03437 const cmt_string& path = m_cmt_path[path_index]; 03438 03439 scanner.scan_package (path, package_name); 03440 } 03441 } |
|
Definition at line 3450 of file cmt_parser.cxx. Referenced by parser(). 03453 { 03454 // (unused??) Use& use = Use::current(); 03455 03456 cout << "try to unlock package " << package << " in " << CmtSystem::pwd () << endl; 03457 03458 set_standard_macros (); 03459 03460 CmtLock::status status = CmtLock::unlock (); 03461 } |
|
Definition at line 3464 of file cmt_parser.cxx. Referenced by parser(). 03465 { 03466 cout << CMTVERSION << endl; 03467 } |
|
Definition at line 3543 of file cmt_parser.cxx. Referenced by Include::print_filters(). 03544 { 03545 static cmt_string newdir; 03546 03547 CmtSystem::compress_path (dir, newdir); 03548 03549 return (newdir); 03550 } |
|
Definition at line 3472 of file cmt_parser.cxx. Referenced by MacroBuilder::build(), PathBuilder::build(), SetBuilder::build(), use_action_iterator::get_use(), and Symbol::show_macro(). 03473 { 03474 return (m_action); 03475 } |
|
Definition at line 3482 of file cmt_parser.cxx. Referenced by Use::show_all(). 03483 { 03484 return (m_cmt_home); 03485 } |
|
Definition at line 3477 of file cmt_parser.cxx. Referenced by Use::move_to(). 03478 { 03479 return (m_cmt_path); 03480 } |
|
Definition at line 3487 of file cmt_parser.cxx. Referenced by Use::show_all(). 03488 { 03489 return (m_cmt_user_context); 03490 } |
|
Definition at line 3502 of file cmt_parser.cxx. Referenced by Symbol::action(). 03503 { 03504 return (m_current_access); 03505 } |
|
Definition at line 3492 of file cmt_parser.cxx. 03493 { 03494 return (m_current_dir); 03495 } |
|
Definition at line 3497 of file cmt_parser.cxx. Referenced by Generator::build_constituent_makefile(), Generator::build_msdev(), Generator::build_msdev_workspace(), and Generator::build_readme(). 03498 { 03499 return (m_current_package); 03500 } |
|
Definition at line 3507 of file cmt_parser.cxx. Referenced by VersionSelector::instance(). 03508 { 03509 return (m_current_strategy); 03510 } |
|
Definition at line 3517 of file cmt_parser.cxx. Referenced by MacroBuilder::build(), PathBuilder::build(), and SetBuilder::build(). 03518 { 03519 return (m_current_target); 03520 } |
|
Definition at line 3512 of file cmt_parser.cxx. Referenced by Generator::build_readme(). 03513 { 03514 return (m_current_version); 03515 } |
|
Definition at line 3522 of file cmt_parser.cxx. Referenced by Use::add(), MakefileGenerator::analyze_file(), build_deps(), build_deps_stream(), StandardMacroBuilder::fill_for_use_includes(), MakefileGenerator::fill_outputs(), get_all_files(), Use::get_paths(), use_action_iterator::get_use(), Use::move_to(), Use::reach_package(), Use::reorder(), Use::select_alternate(), and Use::set_auto_imports(). 03523 { 03524 return (m_debug); 03525 } |
|
Definition at line 3527 of file cmt_parser.cxx. Referenced by Use::add(), DependencyAnalyzer::filter(), TriggerAnalyzer::filter(), BestFitNoCheckSelector::operate(), BestFitSelector::operate(), Use::show_all(), and Symbol::show_macro(). 03528 { 03529 return (m_quiet); 03530 } |
|
Definition at line 3532 of file cmt_parser.cxx. Referenced by Use::add(). 03533 { 03534 return (m_recursive); 03535 } |
|
Definition at line 3537 of file cmt_parser.cxx. Referenced by Symbol::action(), Use::add(), Use::clear(), use_action_iterator::get_use(), Use::set(), and Symbol::valid(). 03538 { 03539 return (m_scope); 03540 } |
|
Definition at line 3553 of file cmt_parser.cxx. Referenced by do_config(). 03554 { 03555 #ifdef WIN32 03556 static const int modes = 1; 03557 static const cmt_string suffix[1] = {"bat"}; 03558 static const PrintMode mode[1] = {Bat}; 03559 #else 03560 static const int modes = 2; 03561 static const cmt_string suffix[2] = {"csh", "sh"}; 03562 static const PrintMode mode[2] = {Csh, Sh}; 03563 #endif 03564 03565 cout << "Creating cleanup scripts." << endl; 03566 03567 cmt_string temp; 03568 int i; 03569 03570 for (i = 0; i < modes; i++) 03571 { 03572 cmt_string file_name = "cleanup"; 03573 file_name += "."; 03574 file_name += suffix[i]; 03575 file_name += "."; 03576 file_name += "new"; 03577 03578 FILE* f = fopen (file_name.c_str (), "wb"); 03579 if (f != NULL) 03580 { 03581 if (mode[i] == Csh) 03582 { 03583 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03584 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n"); 03585 fprintf (f, "${CMTROOT}/mgr/cmt -quiet cleanup -%s " 03586 "-pack=%s -version=%s -path=%s $* >${tempfile}; " 03587 "source ${tempfile}\n", 03588 suffix[i].c_str (), 03589 m_current_package.c_str (), 03590 m_current_version.c_str (), 03591 m_current_path.c_str ()); 03592 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03593 } 03594 else if (mode[i] == Sh) 03595 { 03596 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03597 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n"); 03598 fprintf (f, "${CMTROOT}/mgr/cmt -quiet cleanup -%s " 03599 "-pack=%s -version=%s -path=%s $* >${tempfile}; " 03600 ". ${tempfile}\n", 03601 suffix[i].c_str (), 03602 m_current_package.c_str (), 03603 m_current_version.c_str (), 03604 m_current_path.c_str ()); 03605 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03606 } 03607 else if (mode[i] == Bat) 03608 { 03609 fprintf (f, "set tempfile=%%HOMEDRIVE%%%%HOMEPATH%%tmpsetup.bat\n"); 03610 fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe -quiet cleanup -%s " 03611 "-path=%s " 03612 "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%tempfile%%\n", 03613 suffix[i].c_str (), 03614 m_current_path.c_str ()); 03615 fprintf (f, "if exist %%tempfile%% call %%tempfile%%\n"); 03616 fprintf (f, "if exist %%tempfile%% del %%tempfile%%\n"); 03617 } 03618 03619 fprintf (f, "\n"); 03620 03621 fclose (f); 03622 03623 cmt_string old_file_name = "cleanup"; 03624 old_file_name += "."; 03625 old_file_name += suffix[i]; 03626 03627 CmtSystem::compare_and_update_files (file_name, old_file_name); 03628 } 03629 } 03630 } |
|
Definition at line 3633 of file cmt_parser.cxx. Referenced by do_config(). 03634 { 03635 #ifdef WIN32 03636 static const int modes = 1; 03637 static const cmt_string suffix[1] = {"bat"}; 03638 static const PrintMode mode[1] = {Bat}; 03639 #else 03640 static const int modes = 2; 03641 static const cmt_string suffix[2] = {"csh", "sh"}; 03642 static const PrintMode mode[2] = {Csh, Sh}; 03643 #endif 03644 03645 cout << "Creating setup scripts." << endl; 03646 03647 cmt_string temp; 03648 int i; 03649 03650 for (i = 0; i < modes; i++) 03651 { 03652 cmt_string file_name = "setup"; 03653 file_name += "."; 03654 file_name += suffix[i]; 03655 file_name += "."; 03656 file_name += "new"; 03657 03658 FILE* f = fopen (file_name.c_str (), "wb"); 03659 if (f != NULL) 03660 { 03661 if (mode[i] == Csh) 03662 { 03663 fprintf (f, "# echo \"Setting %s %s in %s\"\n", 03664 m_current_package.c_str (), 03665 m_current_version.c_str (), 03666 m_current_path.c_str ()); 03667 fprintf (f, "\n"); 03668 03669 fprintf (f, "setenv CMTROOT %s\n", m_cmt_root.c_str ()); 03670 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n"); 03671 fprintf (f, "\n"); 03672 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03673 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n"); 03674 fprintf (f, "${CMTROOT}/mgr/cmt -quiet setup -%s " 03675 "-pack=%s -version=%s -path=%s $* >${tempfile}; " 03676 "source ${tempfile}\n", 03677 suffix[i].c_str (), 03678 m_current_package.c_str (), 03679 m_current_version.c_str (), 03680 m_current_path.c_str ()); 03681 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03682 } 03683 else if (mode[i] == Sh) 03684 { 03685 fprintf (f, "# echo \"Setting %s %s in %s\"\n", 03686 m_current_package.c_str (), 03687 m_current_version.c_str (), 03688 m_current_path.c_str ()); 03689 fprintf (f, "\n"); 03690 03691 fprintf (f, "CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ()); 03692 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n"); 03693 fprintf (f, "\n"); 03694 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03695 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n"); 03696 fprintf (f, "${CMTROOT}/mgr/cmt -quiet setup -%s " 03697 "-pack=%s -version=%s -path=%s $* >${tempfile}; " 03698 ". ${tempfile}\n", 03699 suffix[i].c_str (), 03700 m_current_package.c_str (), 03701 m_current_version.c_str (), 03702 m_current_path.c_str ()); 03703 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03704 } 03705 else if (mode[i] == Bat) 03706 { 03707 fprintf (f, "rem Setting %s %s in %s\n", 03708 m_current_package.c_str (), 03709 m_current_version.c_str (), 03710 m_current_path.c_str ()); 03711 fprintf (f, "@echo off\n"); 03712 03713 fprintf (f, "set CMTROOT=%s\n", m_cmt_root.c_str ()); 03714 fprintf (f, "call %%CMTROOT%%\\mgr\\setup.bat\n"); 03715 fprintf (f, "\n"); 03716 fprintf (f, "set tempfile=%%HOMEDRIVE%%%%HOMEPATH%%tmpsetup.bat\n"); 03717 fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe -quiet setup -%s " 03718 "-pack=%s -version=%s -path=%s " 03719 "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%tempfile%%\n", 03720 suffix[i].c_str (), 03721 m_current_package.c_str (), 03722 m_current_version.c_str (), 03723 m_current_path.c_str ()); 03724 fprintf (f, "if exist %%tempfile%% call %%tempfile%%\n"); 03725 fprintf (f, "if exist %%tempfile%% del %%tempfile%%\n"); 03726 } 03727 03728 fprintf (f, "\n"); 03729 03730 fclose (f); 03731 03732 cmt_string old_file_name = "setup"; 03733 old_file_name += "."; 03734 old_file_name += suffix[i]; 03735 03736 CmtSystem::compare_and_update_files (file_name, old_file_name); 03737 } 03738 } 03739 } |
|
Definition at line 3742 of file cmt_parser.cxx. Referenced by do_config(). 03743 { 03744 #ifdef WIN32 03745 static const int modes = 1; 03746 static const cmt_string suffix[1] = {"bat"}; 03747 static const PrintMode mode[1] = {Bat}; 03748 #else 03749 static const int modes = 2; 03750 static const cmt_string suffix[2] = {"csh", "sh"}; 03751 static const PrintMode mode[2] = {Csh, Sh}; 03752 #endif 03753 03754 cout << "Creating cleanup scripts." << endl; 03755 03756 cmt_string temp; 03757 int i; 03758 03759 for (i = 0; i < modes; i++) 03760 { 03761 cmt_string file_name = "cleanup"; 03762 file_name += "."; 03763 file_name += suffix[i]; 03764 file_name += "."; 03765 file_name += "new"; 03766 03767 FILE* f = fopen (file_name.c_str (), "wb"); 03768 if (f != NULL) 03769 { 03770 if (mode[i] == Csh) 03771 { 03772 fprintf (f, "setenv CMTROOT %s\n", m_cmt_root.c_str ()); 03773 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n"); 03774 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03775 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n"); 03776 fprintf (f, "${CMTROOT}/mgr/cmt -quiet cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; " 03777 "source ${tempfile}\n", 03778 suffix[i].c_str (), 03779 m_current_path.c_str ()); 03780 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03781 } 03782 else if (mode[i] == Sh) 03783 { 03784 fprintf (f, "CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ()); 03785 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n"); 03786 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03787 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n"); 03788 fprintf (f, "${CMTROOT}/mgr/cmt -quiet cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; " 03789 ". ${tempfile}\n", 03790 suffix[i].c_str (), 03791 m_current_path.c_str ()); 03792 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03793 } 03794 else 03795 { 03796 fprintf (f, "set CMTROOT=%s\n", m_cmt_root.c_str ()); 03797 fprintf (f, "call %%CMTROOT%%\\mgr\\setup.bat\n"); 03798 fprintf (f, "set tempfile=%%HOMEDRIVE%%%%HOMEPATH%%tmpsetup.bat\n"); 03799 fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe -quiet cleanup -%s " 03800 "-pack=cmt_standalone -path=%s " 03801 "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%tempfile%%\n", 03802 suffix[i].c_str (), 03803 m_current_path.c_str ()); 03804 fprintf (f, "if exist %%tempfile%% call %%tempfile%%\n"); 03805 fprintf (f, "if exist %%tempfile%% del %%tempfile%%\n"); 03806 } 03807 03808 fprintf (f, "\n"); 03809 03810 fclose (f); 03811 03812 cmt_string old_file_name = "cleanup"; 03813 old_file_name += "."; 03814 old_file_name += suffix[i]; 03815 03816 CmtSystem::compare_and_update_files (file_name, old_file_name); 03817 } 03818 } 03819 } |
|
Definition at line 3822 of file cmt_parser.cxx. Referenced by do_config(). 03823 { 03824 #ifdef WIN32 03825 static const int modes = 1; 03826 static const cmt_string suffix[1] = {"bat"}; 03827 static const PrintMode mode[1] = {Bat}; 03828 #else 03829 static const int modes = 2; 03830 static const cmt_string suffix[2] = {"csh", "sh"}; 03831 static const PrintMode mode[2] = {Csh, Sh}; 03832 #endif 03833 03834 cout << "Creating setup scripts." << endl; 03835 03836 cmt_string temp; 03837 int i; 03838 03839 for (i = 0; i < modes; i++) 03840 { 03841 cmt_string file_name = "setup"; 03842 file_name += "."; 03843 file_name += suffix[i]; 03844 file_name += "."; 03845 file_name += "new"; 03846 03847 FILE* f = fopen (file_name.c_str (), "wb"); 03848 if (f != NULL) 03849 { 03850 if (mode[i] == Csh) 03851 { 03852 fprintf (f, "# echo \"Setting standalone package\"\n"); 03853 fprintf (f, "\n"); 03854 03855 fprintf (f, "setenv CMTROOT %s\n", m_cmt_root.c_str ()); 03856 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n"); 03857 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03858 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n"); 03859 fprintf (f, "${CMTROOT}/mgr/cmt -quiet setup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; " 03860 "source ${tempfile}\n", 03861 suffix[i].c_str (), 03862 m_current_path.c_str ()); 03863 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03864 } 03865 else if (mode[i] == Sh) 03866 { 03867 fprintf (f, "# echo \"Setting standalone package\"\n"); 03868 fprintf (f, "\n"); 03869 03870 fprintf (f, "CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ()); 03871 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n"); 03872 fprintf (f, "\n"); 03873 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt build temporary_name -quiet`\n"); 03874 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n"); 03875 fprintf (f, "${CMTROOT}/mgr/cmt -quiet setup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; " 03876 ". ${tempfile}\n", 03877 suffix[i].c_str (), 03878 m_current_path.c_str ()); 03879 fprintf (f, "/bin/rm -f ${tempfile}\n"); 03880 } 03881 else 03882 { 03883 fprintf (f, "rem Setting standalone package\n"); 03884 fprintf (f, "@echo off\n"); 03885 03886 fprintf (f, "set CMTROOT=%s\n", m_cmt_root.c_str ()); 03887 fprintf (f, "call %%CMTROOT%%\\mgr\\setup.bat\n"); 03888 fprintf (f, "\n"); 03889 fprintf (f, "set tempfile=%%HOMEDRIVE%%%%HOMEPATH%%tmpsetup.bat\n"); 03890 fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe -quiet setup -%s " 03891 "-pack=cmt_standalone -path=%s " 03892 "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%tempfile%%\n", 03893 suffix[i].c_str (), 03894 m_current_path.c_str ()); 03895 fprintf (f, "if exist %%tempfile%% call %%tempfile%%\n"); 03896 fprintf (f, "if exist %%tempfile%% del %%tempfile%%\n"); 03897 } 03898 03899 fprintf (f, "\n"); 03900 03901 fclose (f); 03902 03903 cmt_string old_file_name = "setup"; 03904 old_file_name += "."; 03905 old_file_name += suffix[i]; 03906 03907 CmtSystem::compare_and_update_files (file_name, old_file_name); 03908 } 03909 } 03910 } |
|
load is only called from the Windows GUI which pretends to access directly the internal data model. This is considered to be rather unsafe, and should be replaced by query functions. Definition at line 3917 of file cmt_parser.cxx. 03921 { 03922 clear (); 03923 configure (); 03924 03925 m_action = action_load; 03926 m_recursive = true; 03927 03928 if (((package != "") && (version != "")) || (m_current_package == "")) 03929 { 03930 // 03931 // Here we want to connect to a new package, or to the current package 03932 // but with another tag. 03933 // 03934 // the 'package' argument may include a directory offset. Thus 'path' 03935 // is only expected to hold the base directory. 03936 // 03937 cmt_string offset; 03938 cmt_string package_name; 03939 03940 CmtSystem::dirname (package, offset); 03941 CmtSystem::basename (package, package_name); 03942 03943 if (offset != "") 03944 { 03945 m_current_path = path; 03946 m_current_path += CmtSystem::file_separator (); 03947 m_current_path += offset; 03948 } 03949 else 03950 { 03951 m_current_path = path; 03952 } 03953 03954 m_current_package = package_name; 03955 m_current_version = version; 03956 } 03957 03958 if (tag_name != "") 03959 { 03960 Tag* tag; 03961 03962 Tag::unmark_all (); 03963 configure_site_tag (0); 03964 configure_uname_tag (); 03965 configure_hosttype_tag (); 03966 03967 m_current_tag = tag_name; 03968 03969 //if (!m_quiet) cerr << "load1> current_tag=" << m_current_tag << endl; 03970 03971 tag = Tag::add (tag_name, PriorityTag, "load", 0); 03972 tag->mark (); 03973 } 03974 03975 /* 03976 Set to developer mode if positioned into the package 03977 (which is detected since we were able to retreive the 03978 Version, Package and Path) 03979 */ 03980 03981 if ((m_current_path == "") || 03982 (m_current_package == "") || 03983 (m_current_version == "")) 03984 { 03985 m_current_access = UserMode; 03986 } 03987 else 03988 { 03989 m_current_access = DeveloperMode; 03990 } 03991 03992 use_cmt (); 03993 03994 cmt_string dir; 03995 03996 /* 03997 Try to access the package. 03998 */ 03999 04000 if (m_current_path != "") 04001 { 04002 dir = m_current_path; 04003 } 04004 else 04005 { 04006 dir = m_default_path; 04007 } 04008 04009 if (!CmtSystem::cd (m_current_path)) 04010 { 04011 if (!m_quiet) 04012 { 04013 cout << "#CMT> Cannot reach the directory " << 04014 m_current_path << endl; 04015 } 04016 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the path directory"); 04017 CmtSystem::cd (m_current_dir); 04018 04019 return (false); 04020 } 04021 04022 dir += CmtSystem::file_separator (); 04023 dir += m_current_package; 04024 04025 if (!CmtSystem::cd (m_current_package)) 04026 { 04027 if (!m_quiet) 04028 { 04029 cout << "#CMT::load> Cannot reach the package " << 04030 m_current_package << endl; 04031 } 04032 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the package directory"); 04033 CmtSystem::cd (m_current_dir); 04034 04035 return (false); 04036 } 04037 04038 dir += CmtSystem::file_separator (); 04039 dir += m_current_version; 04040 04041 if (!CmtSystem::cd (m_current_version)) 04042 { 04043 if (!m_quiet) 04044 { 04045 cout << "#CMT> Cannot reach the version " << 04046 m_current_version << endl; 04047 } 04048 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the version directory"); 04049 CmtSystem::cd (m_current_dir); 04050 04051 return (false); 04052 } 04053 04054 if (CmtSystem::cd ("cmt")) 04055 { 04056 dir += CmtSystem::file_separator (); 04057 dir += "cmt"; 04058 m_current_style = cmt_style; 04059 } 04060 else 04061 { 04062 /* 04063 if (!m_quiet) 04064 { 04065 cout << "Cannot reach the cmt branch" << endl; 04066 } 04067 */ 04068 04069 if (CmtSystem::cd ("mgr")) 04070 { 04071 dir += CmtSystem::file_separator (); 04072 dir += "mgr"; 04073 m_current_style = mgr_style; 04074 } 04075 else 04076 { 04077 if (!m_quiet) 04078 { 04079 cout << "#CMT> Cannot reach the mgr branch" << endl; 04080 } 04081 04082 CmtError::set (CmtError::package_not_found, 04083 "Load> Cannot reach the mgr/cmt directory"); 04084 CmtSystem::cd (m_current_dir); 04085 04086 return (false); 04087 } 04088 } 04089 04090 /* 04091 Check Tag is always set up 04092 */ 04093 04094 if (m_current_tag == "") 04095 { 04096 char* env; 04097 04098 env = getenv (m_current_config.c_str ()); 04099 if (env != 0) 04100 { 04101 Tag* tag; 04102 04103 tag = Tag::add (env, PriorityConfig, "load", 0); 04104 tag->mark (); 04105 m_current_tag = env; 04106 04107 //if (!m_quiet) cerr << "load2> current_tag=" << m_current_tag << endl; 04108 04109 } 04110 else 04111 { 04112 m_current_tag = m_cmt_config; 04113 04114 //if (!m_quiet) cerr << "load3> current_tag=" << m_current_tag << endl; 04115 04116 } 04117 } 04118 04119 if (m_debug) 04120 { 04121 cout << "pwd = " << CmtSystem::pwd () << endl; 04122 } 04123 04124 configure_current_dir (); 04125 build_prefix (m_current_package, m_current_prefix); 04126 build_config (m_current_prefix, m_current_config); 04127 04128 Use* use = &(Use::current()); 04129 use->path = m_current_path; 04130 use->package = m_current_package; 04131 use->version = m_current_version; 04132 use->prefix = m_current_prefix; 04133 use->done = false; 04134 04135 /* 04136 Work on the requirements file. 04137 */ 04138 04139 dir += CmtSystem::file_separator (); 04140 dir += "requirements"; 04141 parse_requirements (dir, use); 04142 04143 if (CmtError::has_pending_error ()) return (false); 04144 04148 Pattern::apply_all_globals (); 04149 04150 /* 04151 Select all possible tags 04152 */ 04153 04154 Tag::restore_tree (); 04155 04156 return (true); 04157 } |
|
See reach_current_package for an explanation of this call.
Definition at line 4160 of file cmt_parser.cxx. Referenced by Constituent::add(). 04161 { 04162 if ((m_current_build_strategy & PrototypesMask) == Prototypes) return (true); 04163 else return (false); 04164 } |
|
Definition at line 4167 of file cmt_parser.cxx. Referenced by parser(). 04172 { 04173 /* 04174 Decoding arguments. 04175 04176 While decoding all arguments, no requirements analysis should 04177 occur. Every new option, or parameter should be saved and 04178 used later at actual analysis time. 04179 */ 04180 04181 cmt_string arg; 04182 04183 m_action = action_none; 04184 04185 arguments.clear (); 04186 extra_line.erase (0); 04187 extra_file.erase (0); 04188 mode = Csh; 04189 04190 /* 04191 Tag management. 04192 --------------- 04193 04194 Tag settings may come from : 04195 04196 - existing environment variables: 04197 04198 1) CMTCONFIG 04199 04200 2) CMTEXTRATAGS for addons 04201 04202 - arguments: 04203 04204 -tag=<tag-list> 04205 -tag_add=<tag-list> 04206 -tag_remove=<tag-list> 04207 04208 o Arguments should take precedence over environment variables. 04209 o when nothing is specified: 04210 04211 - primary tag = CMTCONFIG 04212 - tag set is empty 04213 04214 04215 */ 04216 04217 04218 restore_all_tags (0); 04219 04220 #ifdef WIN32 04221 m_build_nmake = true; 04222 #endif 04223 04224 while (argc > 1) 04225 { 04226 int lf; 04227 04228 arg = argv[1]; 04229 lf = arg.find ('\r'); 04230 if (lf != cmt_string::npos) arg.erase (lf); 04231 04232 if ((arg[0] == '\"') && (arg[arg.size () - 1] == '\"')) 04233 { 04234 arg.erase (0, 1); 04235 arg.erase (arg.size () - 1, 1); 04236 } 04237 04238 //fprintf (stderr, "arg=[%s]\n", arg.c_str ()); 04239 04240 switch (arg[0]) 04241 { 04242 case 'a' : 04243 if (arg == "awk") 04244 { 04245 argc--; 04246 argv++; 04247 while (argc > 1) 04248 { 04249 cmt_string& s = arguments.add (); 04250 s = argv[1]; 04251 argc--; 04252 argv++; 04253 } 04254 04255 m_action = action_awk; 04256 } 04257 break; 04258 case 'b' : 04259 if ((arg == "b") || 04260 (arg == "br") || 04261 (arg == "bro") || 04262 (arg == "broa") || 04263 (arg == "broad") || 04264 (arg == "broadc") || 04265 (arg == "broadca") || 04266 (arg == "broadcas") || 04267 (arg == "broadcast")) 04268 { 04269 argc--; 04270 argv++; 04271 while (argc > 1) 04272 { 04273 cmt_string& s = arguments.add (); 04274 s = argv[1]; 04275 argc--; 04276 argv++; 04277 } 04278 04279 m_action = action_broadcast; 04280 } 04281 else if (arg == "build") 04282 { 04283 argc--; 04284 argv++; 04285 04286 if (argc > 1) 04287 { 04288 arg = argv[1]; 04289 04290 if (arg == "-nmake") 04291 { 04292 m_build_nmake = true; 04293 argc--; 04294 argv++; 04295 } 04296 } 04297 04298 if (argc > 1) 04299 { 04300 arg = argv[1]; 04301 04302 if (arg == "-nmake") 04303 { 04304 argc--; 04305 argv++; 04306 } 04307 04308 if (arg == "constituent_makefile") 04309 { 04310 argc--; 04311 argv++; 04312 if (argc > 1) 04313 { 04314 cmt_string& s = arguments.add (); 04315 s = argv[1]; 04316 04317 m_action = action_build_constituent_makefile; 04318 } 04319 else 04320 { 04321 if (!m_quiet) cout << "#CMT> syntax error : constituent name missing" << endl; 04322 } 04323 } 04324 else if (arg == "constituents_makefile") 04325 { 04326 m_action = action_build_constituents_makefile; 04327 } 04328 else if (arg == "dependencies") 04329 { 04330 argc--; 04331 argv++; 04332 if (argc > 1) 04333 { 04334 cmt_string& s = arguments.add (); 04335 s = argv[1]; 04336 04337 m_action = action_build_dependencies; 04338 } 04339 else 04340 { 04341 if (!m_quiet) cout << "#CMT> syntax error : arguments missing " << endl; 04342 } 04343 04344 argc = 0; 04345 } 04346 else if (arg == "library_links") 04347 { 04348 m_action = action_build_library_links; 04349 } 04350 else if (arg == "make_setup") 04351 { 04352 m_action = action_build_make_setup; 04353 } 04354 else if (arg == "msdev") 04355 { 04356 argc--; 04357 argv++; 04358 04359 if (argc > 1) 04360 { 04361 cmt_string& s = arguments.add (); 04362 s = argv[1]; 04363 if (s[0] == '-') 04364 { 04365 s = ""; 04366 argc++; 04367 argv--; 04368 } 04369 } 04370 04371 m_action = action_build_msdev; 04372 } 04373 else if (arg == "os9_makefile") 04374 { 04375 argc--; 04376 argv++; 04377 if (argc > 1) 04378 { 04379 cmt_string& s = arguments.add (); 04380 s = argv[1]; 04381 04382 m_action = action_build_os9_makefile; 04383 } 04384 else 04385 { 04386 if (!m_quiet) cout << "#CMT> syntax error : arguments missing " << endl; 04387 } 04388 } 04389 else if (arg == "prototype") 04390 { 04391 argc--; 04392 argv++; 04393 if (argc > 1) 04394 { 04395 cmt_string& s = arguments.add (); 04396 s = argv[1]; 04397 04398 m_action = action_build_prototype; 04399 } 04400 else 04401 { 04402 if (!m_quiet) cout << "#CMT> syntax error : arguments missing" << endl; 04403 } 04404 } 04405 else if (arg == "readme") 04406 { 04407 m_action = action_build_readme; 04408 04409 argc--; 04410 argv++; 04411 while (argc > 1) 04412 { 04413 cmt_string& s = arguments.add (); 04414 s = argv[1]; 04415 argc--; 04416 argv++; 04417 } 04418 } 04419 else if (arg == "tag_makefile") 04420 { 04421 m_action = action_build_tag_makefile; 04422 } 04423 else if (arg == "temporary_name") 04424 { 04425 m_action = action_build_temporary_name; 04426 } 04427 else if (arg == "triggers") 04428 { 04429 argc--; 04430 argv++; 04431 if (argc > 1) 04432 { 04433 cmt_string& s = arguments.add (); 04434 s = argv[1]; 04435 04436 m_action = action_build_triggers; 04437 } 04438 else 04439 { 04440 if (!m_quiet) cout << "#CMT> syntax error : arguments missing" << endl; 04441 } 04442 } 04443 else if (arg == "windefs") 04444 { 04445 argc--; 04446 argv++; 04447 if (argc > 1) 04448 { 04449 cmt_string& s = arguments.add (); 04450 s = argv[1]; 04451 04452 m_action = action_build_windefs; 04453 } 04454 else 04455 { 04456 if (!m_quiet) cout << "#CMT> syntax error : arguments missing" << endl; 04457 } 04458 } 04459 } 04460 else 04461 { 04462 if (!m_quiet) cout << "#CMT> syntax error : don't know what to build" << endl; 04463 } 04464 } 04465 else 04466 { 04467 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04468 } 04469 break; 04470 case 'c' : 04471 if (arg == "check") 04472 { 04473 argc--; 04474 argv++; 04475 04476 if (argc > 1) 04477 { 04478 arg = argv[1]; 04479 04480 if (arg == "configuration") 04481 { 04482 m_action = action_check_configuration; 04483 } 04484 else if (arg == "files") 04485 { 04486 argc--; 04487 argv++; 04488 if (argc > 1) 04489 { 04490 cmt_string& s = arguments.add (); 04491 s = argv[1]; 04492 argc--; 04493 argv++; 04494 if (argc > 1) 04495 { 04496 cmt_string& s = arguments.add (); 04497 s = argv[1]; 04498 04499 m_action = action_check_files; 04500 } 04501 else 04502 { 04503 if (!m_quiet) cout << "#CMT> syntax error : reference file name missing" 04504 << endl; 04505 } 04506 } 04507 else 04508 { 04509 if (!m_quiet) cout << "#CMT> syntax error : file name missing" << endl; 04510 } 04511 } 04512 else if (arg == "version") 04513 { 04514 argc--; 04515 argv++; 04516 if (argc > 1) 04517 { 04518 cmt_string& s = arguments.add (); 04519 s = argv[1]; 04520 04521 m_action = action_check_version; 04522 } 04523 else 04524 { 04525 if (!m_quiet) cout << "#CMT> syntax error : package name missing" << endl; 04526 } 04527 } 04528 else 04529 { 04530 if (!m_quiet) cout << "#CMT> syntax error : bad check option" << endl; 04531 } 04532 } 04533 else 04534 { 04535 if (!m_quiet) cout << "#CMT> syntax error : don't know what to check" << endl; 04536 } 04537 } 04538 else if (arg == "check_files") 04539 { 04540 argc--; 04541 argv++; 04542 if (argc > 1) 04543 { 04544 cmt_string& s = arguments.add (); 04545 s = argv[1]; 04546 argc--; 04547 argv++; 04548 if (argc > 1) 04549 { 04550 cmt_string& s = arguments.add (); 04551 s = argv[1]; 04552 04553 m_action = action_check_files; 04554 } 04555 else 04556 { 04557 if (!m_quiet) cout << "#CMT> syntax error : reference file missing" << endl; 04558 } 04559 } 04560 else 04561 { 04562 if (!m_quiet) cout << "#CMT> syntax error : file name missing" << endl; 04563 } 04564 } 04565 else if ((arg == "co") || 04566 (arg == "checkout")) 04567 { 04568 // handle all of the command line arguments in a vector 04569 argc--; 04570 argv++; 04571 if (argc > 1) 04572 { 04573 m_action = action_checkout; 04574 04575 while (argc > 1) 04576 { 04577 cmt_string& s = arguments.add (); 04578 s = argv[1]; 04579 argc--; 04580 argv++; 04581 } 04582 } 04583 else 04584 { 04585 if (!m_quiet) cout << "#CMT> syntax error : checkout arguments missing" << endl; 04586 } 04587 } 04588 else if (arg == "cleanup") 04589 { 04590 m_action = action_cleanup; 04591 } 04592 else if (arg == "config") 04593 { 04594 argc--; 04595 argv++; 04596 if (argc > 1) 04597 { 04598 cout << "#---------------------------------------------------------" << endl; 04599 cout << "# Warning : using 'cmt config ...' to create a package is " 04600 "becoming obsolete" << endl; 04601 cout << "# Please use 'cmt create ...' instead" << endl; 04602 cout << "#---------------------------------------------------------" << endl; 04603 04604 m_current_package = argv[1]; 04605 m_current_version.erase (0); 04606 m_current_path.erase (0); 04607 04608 argc--; 04609 argv++; 04610 if (argc > 1) 04611 { 04612 m_current_version = argv[1]; 04613 04614 { 04615 cmt_string& s = arguments.add (); 04616 s = m_current_package; 04617 } 04618 { 04619 cmt_string& s = arguments.add (); 04620 s = m_current_version; 04621 } 04622 04623 argc--; 04624 argv++; 04625 if (argc > 1) 04626 { 04627 m_current_path = argv[1]; 04628 if (m_current_path[0] == '-') 04629 { 04630 m_current_path.erase (0); 04631 } 04632 } 04633 04634 m_action = action_create; 04635 } 04636 else 04637 { 04638 if (!m_quiet) cout << "#CMT> syntax error : create arguments missing" << endl; 04639 } 04640 } 04641 else 04642 { 04643 m_action = action_config; 04644 } 04645 } 04646 else if (arg == "create") 04647 { 04648 argc--; 04649 argv++; 04650 04651 if (argc > 1) 04652 { 04653 while (argc > 1) 04654 { 04655 cmt_string& s = arguments.add (); 04656 s = argv[1]; 04657 argc--; 04658 argv++; 04659 } 04660 04661 m_action = action_create; 04662 } 04663 else 04664 { 04665 if (!m_quiet) cout << "#CMT> syntax error : create arguments missing" << endl; 04666 } 04667 } 04668 else if (arg == "cvsbranches") 04669 { 04670 argc--; 04671 argv++; 04672 if (argc > 1) 04673 { 04674 cmt_string& s = arguments.add (); 04675 s = argv[1]; 04676 argc--; 04677 argv++; 04678 04679 m_action = action_cvsbranches; 04680 } 04681 else 04682 { 04683 if (!m_quiet) cout << "#CMT> syntax error : cvsbranches arguments missing" << endl; 04684 } 04685 } 04686 else if (arg == "cvssubpackages") 04687 { 04688 argc--; 04689 argv++; 04690 if (argc > 1) 04691 { 04692 cmt_string& s = arguments.add (); 04693 s = argv[1]; 04694 argc--; 04695 argv++; 04696 04697 m_action = action_cvssubpackages; 04698 } 04699 else 04700 { 04701 if (!m_quiet) cout << "#CMT> syntax error : cvssubpackages arguments missing" << endl; 04702 } 04703 } 04704 else if (arg == "cvstags") 04705 { 04706 argc--; 04707 argv++; 04708 if (argc > 1) 04709 { 04710 while (argc > 1) 04711 { 04712 cmt_string& s = arguments.add (); 04713 s = argv[1]; 04714 argc--; 04715 argv++; 04716 } 04717 04718 m_action = action_cvstags; 04719 } 04720 else 04721 { 04722 if (!m_quiet) cout << "#CMT> syntax error : package name missing" << endl; 04723 } 04724 } 04725 else 04726 { 04727 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04728 } 04729 break; 04730 case 'e' : 04731 if (arg == "expand") 04732 { 04733 argc--; 04734 argv++; 04735 04736 if (argc > 1) 04737 { 04738 arg = argv[1]; 04739 04740 if (arg == "model") 04741 { 04742 argc--; 04743 argv++; 04744 04745 if (argc > 1) 04746 { 04747 while (argc > 1) 04748 { 04749 cmt_string& s = arguments.add (); 04750 s = argv[1]; 04751 argc--; 04752 argv++; 04753 } 04754 04755 m_action = action_expand_model; 04756 } 04757 else 04758 { 04759 if (!m_quiet) cout << "#CMT> syntax error : model not specified" << endl; 04760 } 04761 } 04762 else 04763 { 04764 if (!m_quiet) cout << "#CMT> syntax error : bad expand option" << endl; 04765 } 04766 } 04767 else 04768 { 04769 if (!m_quiet) cout << "#CMT> syntax error : don't know what to expand" << endl; 04770 } 04771 } 04772 else 04773 { 04774 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04775 } 04776 break; 04777 case 'f' : 04778 if ((arg == "f") || 04779 (arg == "fi") || 04780 (arg == "fil") || 04781 (arg == "filt") || 04782 (arg == "filte") || 04783 (arg == "filter")) 04784 { 04785 // handle all of the command line arguments in a vector 04786 argc--; 04787 argv++; 04788 while (argc > 1) 04789 { 04790 cmt_string& s = arguments.add (); 04791 s = argv[1]; 04792 argc--; 04793 argv++; 04794 } 04795 04796 m_action = action_filter; 04797 } 04798 else 04799 { 04800 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04801 } 04802 break; 04803 case 'h' : 04804 if ((arg == "h") || 04805 (arg == "he") || 04806 (arg == "hel") || 04807 (arg == "help")) 04808 { 04809 m_action = action_help; 04810 } 04811 else 04812 { 04813 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04814 } 04815 break; 04816 case 'l' : 04817 if (arg == "lock") 04818 { 04819 argc--; 04820 argv++; 04821 if (argc > 1) 04822 { 04823 m_current_package = argv[1]; 04824 { 04825 cmt_string& s = arguments.add (); 04826 s = m_current_package; 04827 } 04828 04829 m_current_version.erase (0); 04830 m_current_path.erase (0); 04831 04832 argc--; 04833 argv++; 04834 if (argc > 1) 04835 { 04836 m_current_version = argv[1]; 04837 04838 { 04839 cmt_string& s = arguments.add (); 04840 s = m_current_version; 04841 } 04842 04843 m_action = action_lock; 04844 04845 argc--; 04846 argv++; 04847 if (argc > 1) 04848 { 04849 m_current_path = argv[1]; 04850 if (m_current_path[0] == '-') 04851 { 04852 m_current_path.erase (0); 04853 } 04854 } 04855 04856 m_current_access = UserMode; 04857 (Use::current()).set (m_current_package, 04858 m_current_version, 04859 m_current_path); 04860 04861 } 04862 else 04863 { 04864 if (!m_quiet) cout << "#CMT> syntax error : version missing" << endl; 04865 } 04866 } 04867 else 04868 { 04869 m_action = action_lock; 04870 } 04871 } 04872 else 04873 { 04874 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04875 } 04876 break; 04877 case 'r' : 04878 if (arg == "remove") 04879 { 04880 argc--; 04881 argv++; 04882 04883 if (argc > 1) 04884 { 04885 arg = argv[1]; 04886 04887 if (arg == "library_links") 04888 { 04889 m_action = action_remove_library_links; 04890 } 04891 else 04892 { 04893 m_current_package = argv[1]; 04894 { 04895 cmt_string& s = arguments.add (); 04896 s = m_current_package; 04897 } 04898 04899 m_current_version.erase (0); 04900 m_current_path.erase (0); 04901 04902 argc--; 04903 argv++; 04904 if (argc > 1) 04905 { 04906 m_current_version = argv[1]; 04907 04908 { 04909 cmt_string& s = arguments.add (); 04910 s = m_current_version; 04911 } 04912 04913 argc--; 04914 argv++; 04915 if (argc > 1) 04916 { 04917 m_current_path = argv[1]; 04918 if (m_current_path[0] == '-') 04919 { 04920 m_current_path.erase (0); 04921 } 04922 } 04923 04924 m_action = action_remove; 04925 } 04926 else 04927 { 04928 if (!m_quiet) cout << "#CMT> syntax error : version missing" << endl; 04929 } 04930 } 04931 } 04932 else 04933 { 04934 if (!m_quiet) cout << "#CMT> syntax error : don't know what to remove" << endl; 04935 } 04936 } 04937 else if (arg == "run") 04938 { 04939 argc--; 04940 argv++; 04941 if (argc > 1) 04942 { 04943 cmt_string& s = arguments.add (); 04944 s = argv[1]; 04945 04946 m_action = action_run; 04947 } 04948 else 04949 { 04950 if (!m_quiet) cout << "#CMT> syntax error : run arguments missing" << endl; 04951 } 04952 } 04953 else if (arg == "run_sequence") 04954 { 04955 argc--; 04956 argv++; 04957 if (argc > 1) 04958 { 04959 cmt_string& s = arguments.add (); 04960 s = argv[1]; 04961 04962 m_action = action_run_sequence; 04963 } 04964 else 04965 { 04966 if (!m_quiet) cout << "#CMT> syntax error : run_sequence arguments missing" << endl; 04967 } 04968 } 04969 else 04970 { 04971 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 04972 } 04973 break; 04974 case 's' : 04975 if (arg == "setup") 04976 { 04977 m_action = action_setup; 04978 } 04979 else if ((arg == "s") || 04980 (arg == "sh") || 04981 (arg == "sho") || 04982 (arg == "show")) 04983 { 04984 argc--; 04985 argv++; 04986 if (argc > 1) 04987 { 04988 arg = argv[1]; 04989 04990 if (arg == "all_tags") 04991 { 04992 m_action = action_show_all_tags; 04993 } 04994 else if (arg == "applied_patterns") 04995 { 04996 m_action = action_show_applied_patterns; 04997 } 04998 else if (arg == "author") 04999 { 05000 m_action = action_show_author; 05001 } 05002 else if (arg == "branches") 05003 { 05004 m_action = action_show_branches; 05005 } 05006 else if (arg == "clients") 05007 { 05008 argc--; 05009 argv++; 05010 if (argc > 1) 05011 { 05012 cmt_string& s = arguments.add (); 05013 s = argv[1]; 05014 m_current_target = argv[1]; 05015 05016 m_action = action_show_clients; 05017 05018 argc--; 05019 argv++; 05020 if (argc > 1) 05021 { 05022 cmt_string& s = arguments.add (); 05023 s = argv[1]; 05024 05025 argc--; 05026 argv++; 05027 if (argc > 1) 05028 { 05029 cmt_string& s = arguments.add (); 05030 s = argv[1]; 05031 } 05032 } 05033 } 05034 else 05035 { 05036 if (!m_quiet) cout << "#CMT> syntax error : package name missing" << endl; 05037 } 05038 } 05039 else if (arg == "constituent") 05040 { 05041 argc--; 05042 argv++; 05043 if (argc > 1) 05044 { 05045 cmt_string& s = arguments.add (); 05046 s = argv[1]; 05047 m_current_target = argv[1]; 05048 05049 m_action = action_show_constituent; 05050 } 05051 else 05052 { 05053 if (!m_quiet) cout << "#CMT> syntax error : constituent name missing" << endl; 05054 } 05055 } 05056 else if (arg == "constituent_names") 05057 { 05058 m_action = action_show_constituent_names; 05059 } 05060 else if (arg == "constituents") 05061 { 05062 m_action = action_show_constituents; 05063 } 05064 else if (arg == "fragment") 05065 { 05066 argc--; 05067 argv++; 05068 if (argc > 1) 05069 { 05070 cmt_string& s = arguments.add (); 05071 s = argv[1]; 05072 m_current_target = argv[1]; 05073 05074 m_action = action_show_fragment; 05075 } 05076 else 05077 { 05078 if (!m_quiet) cout << "#CMT> syntax error : fragment name missing" << endl; 05079 } 05080 } 05081 else if (arg == "fragments") 05082 { 05083 m_action = action_show_fragments; 05084 } 05085 else if (arg == "groups") 05086 { 05087 m_action = action_show_groups; 05088 } 05089 else if (arg == "include_dirs") 05090 { 05091 m_action = action_show_include_dirs; 05092 } 05093 else if (arg == "language") 05094 { 05095 argc--; 05096 argv++; 05097 if (argc > 1) 05098 { 05099 cmt_string& s = arguments.add (); 05100 s = argv[1]; 05101 m_current_target = argv[1]; 05102 05103 m_action = action_show_language; 05104 } 05105 else 05106 { 05107 if (!m_quiet) cout << "#CMT> syntax error : language name missing" << endl; 05108 } 05109 } 05110 else if (arg == "languages") 05111 { 05112 m_action = action_show_languages; 05113 } 05114 else if (arg == "macro") 05115 { 05116 argc--; 05117 argv++; 05118 if (argc > 1) 05119 { 05120 cmt_string& s = arguments.add (); 05121 s = argv[1]; 05122 m_current_target = argv[1]; 05123 05124 m_action = action_show_macro; 05125 } 05126 else 05127 { 05128 if (!m_quiet) cout << "#CMT> syntax error : macro name missing" << endl; 05129 } 05130 } 05131 else if (arg == "macro_names") 05132 { 05133 argc--; 05134 argv++; 05135 if (argc > 1) 05136 { 05137 cmt_string& s = arguments.add (); 05138 s = argv[1]; 05139 } 05140 05141 m_action = action_show_macro_names; 05142 } 05143 else if (arg == "macro_value") 05144 { 05145 m_quiet = true; 05146 argc--; 05147 argv++; 05148 if (argc > 1) 05149 { 05150 cmt_string& s = arguments.add (); 05151 s = argv[1]; 05152 m_current_target = argv[1]; 05153 05154 m_action = action_show_macro_value; 05155 } 05156 else 05157 { 05158 if (!m_quiet) cout << "#CMT> syntax error : macro name missing" << endl; 05159 } 05160 } 05161 else if (arg == "macros") 05162 { 05163 argc--; 05164 argv++; 05165 if (argc > 1) 05166 { 05167 cmt_string& s = arguments.add (); 05168 s = argv[1]; 05169 } 05170 05171 m_action = action_show_macros; 05172 } 05173 else if (arg == "manager") 05174 { 05175 m_action = action_show_manager; 05176 } 05177 else if (arg == "packages") 05178 { 05179 argc--; 05180 argv++; 05181 if (argc > 1) 05182 { 05183 cmt_string& s = arguments.add (); 05184 s = argv[1]; 05185 m_current_target = argv[1]; 05186 } 05187 05188 m_action = action_show_packages; 05189 } 05190 else if (arg == "path") 05191 { 05192 m_action = action_show_path; 05193 } 05194 else if (arg == "pattern") 05195 { 05196 argc--; 05197 argv++; 05198 if (argc > 1) 05199 { 05200 cmt_string& s = arguments.add (); 05201 s = argv[1]; 05202 m_current_target = argv[1]; 05203 05204 m_action = action_show_pattern; 05205 } 05206 else 05207 { 05208 if (!m_quiet) cout << "#CMT> syntax error : pattern name missing" << endl; 05209 } 05210 } 05211 else if (arg == "pattern_names") 05212 { 05213 m_action = action_show_pattern_names; 05214 } 05215 else if (arg == "patterns") 05216 { 05217 m_action = action_show_patterns; 05218 } 05219 else if (arg == "pwd") 05220 { 05221 m_action = action_show_pwd; 05222 } 05223 else if (arg == "set_names") 05224 { 05225 argc--; 05226 argv++; 05227 if (argc > 1) 05228 { 05229 cmt_string& s = arguments.add (); 05230 s = argv[1]; 05231 } 05232 05233 m_action = action_show_set_names; 05234 } 05235 else if (arg == "set_value") 05236 { 05237 m_quiet = true; 05238 argc--; 05239 argv++; 05240 if (argc > 1) 05241 { 05242 cmt_string& s = arguments.add (); 05243 s = argv[1]; 05244 m_current_target = argv[1]; 05245 05246 m_action = action_show_set_value; 05247 } 05248 else 05249 { 05250 if (!m_quiet) cout << "#CMT> syntax error : set name missing" << endl; 05251 } 05252 } 05253 else if (arg == "set") 05254 { 05255 argc--; 05256 argv++; 05257 if (argc > 1) 05258 { 05259 cmt_string& s = arguments.add (); 05260 s = argv[1]; 05261 m_current_target = argv[1]; 05262 05263 m_action = action_show_set; 05264 } 05265 else 05266 { 05267 if (!m_quiet) cout << "#CMT> syntax error : set name missing" << endl; 05268 } 05269 } 05270 else if (arg == "sets") 05271 { 05272 argc--; 05273 argv++; 05274 if (argc > 1) 05275 { 05276 cmt_string& s = arguments.add (); 05277 s = argv[1]; 05278 } 05279 05280 m_action = action_show_sets; 05281 } 05282 else if (arg == "strategies") 05283 { 05284 m_action = action_show_strategies; 05285 } 05286 else if (arg == "tags") 05287 { 05288 m_action = action_show_tags; 05289 } 05290 else if ((arg == "u") || 05291 (arg == "us") || 05292 (arg == "use") || 05293 (arg == "uses")) 05294 { 05295 m_action = action_show_uses; 05296 } 05297 else if (arg == "version") 05298 { 05299 m_action = action_show_version; 05300 } 05301 else if (arg == "versions") 05302 { 05303 argc--; 05304 argv++; 05305 if (argc > 1) 05306 { 05307 cmt_string& s = arguments.add (); 05308 s = argv[1]; 05309 m_current_target = argv[1]; 05310 05311 m_action = action_show_versions; 05312 } 05313 else 05314 { 05315 if (!m_quiet) cout << "#CMT> syntax error : package name missing" << endl; 05316 } 05317 } 05318 else 05319 { 05320 if (!m_quiet) cout << "#CMT> syntax error : bad show argument" << endl; 05321 } 05322 } 05323 else 05324 { 05325 if (!m_quiet) cout << "#CMT> syntax error : don't know what to show" << endl; 05326 } 05327 } 05328 else if (arg == "system") 05329 { 05330 m_action = action_system; 05331 } 05332 else 05333 { 05334 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 05335 } 05336 05337 break; 05338 case 'u' : 05339 if (arg == "unlock") 05340 { 05341 argc--; 05342 argv++; 05343 if (argc > 1) 05344 { 05345 m_current_package = argv[1]; 05346 { 05347 cmt_string& s = arguments.add (); 05348 s = m_current_package; 05349 } 05350 05351 m_current_version.erase (0); 05352 m_current_path.erase (0); 05353 05354 argc--; 05355 argv++; 05356 if (argc > 1) 05357 { 05358 m_current_version = argv[1]; 05359 05360 { 05361 cmt_string& s = arguments.add (); 05362 s = m_current_version; 05363 } 05364 05365 m_action = action_unlock; 05366 05367 argc--; 05368 argv++; 05369 if (argc > 1) 05370 { 05371 m_current_path = argv[1]; 05372 if (m_current_path[0] == '-') 05373 { 05374 m_current_path.erase (0); 05375 } 05376 } 05377 05378 m_current_access = UserMode; 05379 (Use::current()).set (m_current_package, 05380 m_current_version, 05381 m_current_path); 05382 05383 } 05384 else 05385 { 05386 if (!m_quiet) cout << "#CMT> syntax error : version missing" << endl; 05387 } 05388 } 05389 else 05390 { 05391 m_action = action_unlock; 05392 } 05393 } 05394 else 05395 { 05396 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 05397 } 05398 05399 break; 05400 case 'v' : 05401 if ((arg == "v") || 05402 (arg == "ve") || 05403 (arg == "ver") || 05404 (arg == "vers") || 05405 (arg == "versi") || 05406 (arg == "versio") || 05407 (arg == "version")) 05408 { 05409 m_action = action_version; 05410 } 05411 else 05412 { 05413 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 05414 } 05415 break; 05416 case '+' : 05417 if (arg.substr (0, 6) == "+path=") 05418 { 05419 arg.erase (0, 6); 05420 CmtSystem::add_cmt_path (arg, "argument", 05421 m_cmt_path, 05422 m_cmt_path_pwds, 05423 m_cmt_path_sources); 05424 } 05425 else 05426 { 05427 if (!m_quiet) cout << "#CMT> syntax error : bad verb " 05428 << arg << endl; 05429 } 05430 05431 break; 05432 case '-' : 05433 if (arg == "-n") 05434 { 05435 m_simulation = true; 05436 } 05437 else if ((arg == "-q") || 05438 (arg == "-qu") || 05439 (arg == "-qui") || 05440 (arg == "-quie") || 05441 (arg == "-quiet")) 05442 { 05443 m_quiet = true; 05444 } 05445 else if (arg == "-csh") 05446 { 05447 mode = Csh; 05448 } 05449 else if (arg == "-sh") 05450 { 05451 mode = Sh; 05452 } 05453 else if (arg == "-bat") 05454 { 05455 mode = Bat; 05456 } 05457 else if (arg.substr (0, 5) == "-use=") 05458 { 05459 arg.erase (0, 5); 05460 05461 if (m_action != action_create) 05462 { 05463 CmtSystem::cmt_string_vector words; 05464 05465 CmtSystem::split (arg, ":", words); 05466 05467 m_current_access = UserMode; 05468 05469 if (words.size () > 0) m_current_package = words[0]; 05470 if (words.size () > 1) m_current_version = words[1]; 05471 if (words.size () > 2) m_current_path = words[2]; 05472 (Use::current()).set (m_current_package, 05473 m_current_version, 05474 m_current_path); 05475 } 05476 } 05477 else if (arg.substr (0, 6) == "-pack=") 05478 { 05479 arg.erase (0, 6); 05480 if ((m_action != action_create) && (m_current_package != arg)) 05481 { 05482 //CmtSystem::cd (m_default_path); 05483 05484 m_current_access = UserMode; 05485 05486 m_current_package = arg; 05487 m_current_version = ""; 05488 m_current_path = m_default_path; 05489 05490 (Use::current()).set (m_current_package, 05491 m_current_version, 05492 m_current_path); 05493 } 05494 } 05495 else if (arg.substr (0, 9) == "-version=") 05496 { 05497 arg.erase (0, 9); 05498 if ((m_action != action_create) && (m_current_version != arg)) 05499 { 05500 m_current_access = UserMode; 05501 m_current_version = arg; 05502 (Use::current()).set (m_current_package, 05503 m_current_version, 05504 m_current_path); 05505 } 05506 } 05507 else if (arg.substr (0, 6) == "-path=") 05508 { 05509 arg.erase (0, 6); 05510 05511 /* 05512 cerr << "-path=" << arg << 05513 " cp=" << m_current_package << 05514 " cv=" << m_current_version << 05515 " cp=" << m_current_path << endl; 05516 */ 05517 05518 if ((m_action != action_create) && (m_current_path != arg)) 05519 { 05520 m_current_access = UserMode; 05521 m_current_path = arg; 05522 (Use::current()).set (m_current_package, 05523 m_current_version, 05524 m_current_path); 05525 05526 CmtSystem::add_cmt_path (m_current_path, "argument", 05527 m_cmt_path, 05528 m_cmt_path_pwds, 05529 m_cmt_path_sources); 05530 } 05531 } 05532 else if (arg.substr (0, 3) == "-f=") 05533 { 05534 arg.substr (3, extra_file); 05535 } 05536 else if (arg.substr (0, 3) == "-e=") 05537 { 05538 cout << "extra statement = " << arg << endl; 05539 arg.substr (3, extra_line); 05540 } 05541 else if (arg.substr (0, 6) == "-home=") 05542 { 05543 arg.erase (0, 6); 05544 if (CmtSystem::test_directory (arg)) 05545 { 05546 m_cmt_home = arg; 05547 } 05548 } 05549 else if (arg.substr (0, 5) == "-tag=") 05550 { 05551 /* 05552 Here we are going to change the complete tag set 05553 */ 05554 05555 Tag* tag; 05556 CmtSystem::cmt_string_vector words; 05557 05559 Tag::clear_all (); 05560 Cmt::m_extra_tags = ""; 05561 05563 configure_site_tag (0); 05564 configure_uname_tag (); 05565 configure_hosttype_tag (); 05566 configure_config_tag (); 05567 05568 arg.erase (0, 5); 05569 05570 CmtSystem::split (arg, " \t,", words); 05571 05572 for (int i = 0; i < words.size (); i++) 05573 { 05574 const cmt_string& a = words[i]; 05575 05576 cmt_string s = a; 05577 s += ","; 05578 05579 if (i == 0) 05580 { 05581 m_current_tag = a; 05582 05583 if (CmtSystem::testenv ("TAGDEBUG")) cerr 05584 << "parse_argument(tag_add)> current_tag=" << m_current_tag << endl; 05585 } 05586 05587 if (Cmt::m_extra_tags.find (s) == cmt_string::npos) 05588 { 05589 //if (!m_quiet) cerr << " a=[" << a << "]" << endl; 05590 05592 if (a == CmtSystem::get_cmt_config ()) 05593 { 05594 configure_uname_tag (); 05595 } 05596 05597 tag = Tag::add (a, PriorityArgument, "arguments", 0); 05598 05599 tag->mark (); 05600 05601 Cmt::m_extra_tags += a; 05602 Cmt::m_extra_tags += ","; 05603 } 05604 } 05605 } 05606 else if (arg.substr (0, 9) == "-tag_add=") 05607 { 05608 Tag* tag; 05609 CmtSystem::cmt_string_vector words; 05610 05611 arg.erase (0, 9); 05612 05613 //if (!m_quiet) cerr << "-tag_add=" << arg << endl; 05614 05615 CmtSystem::split (arg, " \t,", words); 05616 05617 for (int i = 0; i < words.size (); i++) 05618 { 05619 const cmt_string& a = words[i]; 05620 05621 cmt_string s = a; 05622 s += ","; 05623 05624 if (Cmt::m_extra_tags.find (s) == cmt_string::npos) 05625 { 05626 //if (!m_quiet) cerr << " a=[" << a << "]" << endl; 05627 05629 if (a == CmtSystem::get_cmt_config ()) 05630 { 05631 configure_uname_tag (); 05632 } 05633 05634 tag = Tag::add (a, PriorityUserTag, "arguments", 0); 05635 05636 tag->mark (); 05637 05638 Cmt::m_extra_tags += a; 05639 Cmt::m_extra_tags += ","; 05640 } 05641 } 05642 } 05643 else if (arg.substr (0, 12) == "-tag_remove=") 05644 { 05645 Tag::TagPtrVector tags = Tag::tags (); 05646 int i; 05647 Tag* tag; 05648 05649 /* 05650 for (i = 0; i < tags.size (); i++) 05651 { 05652 tag = tags[i]; 05653 if ((tag != 0) && 05654 (tag->selected)) 05655 { 05656 if (!m_quiet) cerr << " original tag_list=" << tag->name << tag->priority << endl; 05657 } 05658 } 05659 */ 05660 05661 CmtSystem::cmt_string_vector words; 05662 05663 arg.erase (0, 12); 05664 05665 //if (!m_quiet) cerr << "-arg_remove=" << arg << endl; 05666 05667 CmtSystem::split (arg, " \t,", words); 05668 05669 // 05670 // Now erase all entries in the old list that match 05671 // the specified tags 05672 // 05673 05674 for (i = 0; i < words.size (); i++) 05675 { 05676 const cmt_string& a = words[i]; 05677 05678 cmt_string s = a; 05679 s += ","; 05680 05681 int pos; 05682 05683 pos = Cmt::m_extra_tags.find (s); 05684 05685 if (pos != cmt_string::npos) 05686 { 05687 Cmt::m_extra_tags.erase (pos, s.size ()); 05688 } 05689 05690 //if (!m_quiet) cerr << " tag_list=[" << tag_list << "]" << endl; 05691 } 05692 05693 // 05694 // Now reinject the purged list of tags into the database 05695 // exactly as when using -tag=<tag-list> 05696 // 05697 05699 Tag::unmark_all (); 05700 05702 configure_site_tag (0); 05703 configure_uname_tag (); 05704 configure_hosttype_tag (); 05705 05706 CmtSystem::split (Cmt::m_extra_tags, " \t,", words); 05707 05708 for (i = 0; i < words.size (); i++) 05709 { 05710 const cmt_string& a = words[i]; 05711 05712 //fprintf (stderr, " a=[%s]\n", a.c_str ()); 05713 05715 if (a == CmtSystem::get_cmt_config ()) 05716 { 05717 configure_uname_tag (); 05718 } 05719 05720 if (i == 0) 05721 { 05722 m_current_tag = a; 05723 05724 //if (!m_quiet) cerr << "parse_argument(tag_remove)> current_tag=" 05725 //<< m_current_tag << endl; 05726 05727 tag = Tag::add (a, PriorityTag, "restore configuration", 0); 05728 } 05729 else 05730 { 05731 tag = Tag::add (a, PriorityUserTag, "restore configuration", 0); 05732 } 05733 05734 tag->mark (); 05735 } 05736 } 05737 else if (arg.substr (0, 14) == "-user_context=") 05738 { 05739 arg.erase (0, 14); 05740 if (CmtSystem::test_directory (arg)) 05741 { 05742 m_cmt_user_context = arg; 05743 } 05744 } 05745 else 05746 { 05747 if (!m_quiet) cout << "#CMT> syntax error : bad verb " << arg << endl; 05748 } 05749 05750 break; 05751 default: 05752 if (!m_quiet) cout << "#CMT> syntax error : bad command parameter " << arg << endl; 05753 break; 05754 } 05755 05756 argc--; 05757 argv++; 05758 } 05759 } |
|
Parse the input file, rejecting comments and rebuilding complete lines (from sections separated by \ characters. Each reformatted line is parsed by filter_line Definition at line 5768 of file cmt_parser.cxx. Referenced by Use::add(), load(), parser(), reach_current_package(), use_home_requirements(), and use_user_context_requirements(). 05769 { 05770 cmt_string actual_file_name = file_name; 05771 cmt_string text; 05772 05773 CmtError::clear (); 05774 05775 if (use == 0) use = &(Use::current ()); 05776 05777 if (!CmtSystem::test_file (actual_file_name)) 05778 { 05779 actual_file_name = ".."; 05780 actual_file_name += CmtSystem::file_separator (); 05781 actual_file_name += "cmt"; 05782 actual_file_name += CmtSystem::file_separator (); 05783 actual_file_name += file_name; 05784 05785 if (!CmtSystem::test_file (actual_file_name)) 05786 { 05787 actual_file_name = ".."; 05788 actual_file_name += CmtSystem::file_separator (); 05789 actual_file_name += "mgr"; 05790 actual_file_name += CmtSystem::file_separator (); 05791 actual_file_name += file_name; 05792 05793 if (!CmtSystem::test_file (actual_file_name)) 05794 { 05795 /* 05796 cmt_string text; 05797 05798 text = "Package "; 05799 text += use->package; 05800 text += " version "; 05801 text += use->specified_version; 05802 text += " path "; 05803 text += use->specified_path; 05804 text += " file "; 05805 text += actual_file_name; 05806 05807 CmtError::set (CmtError::file_access_error, text); 05808 */ 05809 05810 return; 05811 } 05812 } 05813 } 05814 05815 text.read (actual_file_name); 05816 05836 AccessMode saved_current_access; 05837 ScopeType saved_scope; 05838 05839 saved_current_access = Cmt::m_current_access; 05840 saved_scope = Cmt::m_scope; 05841 05842 if (use != &(Use::current ())) 05843 { 05844 Cmt::m_current_access = UserMode; 05845 } 05846 else 05847 { 05848 Cmt::m_current_access = DeveloperMode; 05849 } 05850 05851 Cmt::m_scope = ScopePublic; 05852 05853 parse_requirements_text (text, actual_file_name, use); 05854 05855 //Pattern::apply_all_globals (use); 05856 05857 Cmt::m_current_access = saved_current_access; 05858 Cmt::m_scope = saved_scope; 05859 } |
|
Apply the basic parser to one single line :. o Append to global text if previous back_slash o Split into words o Apply the generic Select operator Definition at line 5868 of file cmt_parser.cxx. Referenced by StandardMacroBuilder::apply(), parse_requirements_text(), parser(), and set_standard_macros(). 05872 { 05873 int length; 05874 int nl; 05875 int back_slash; 05876 cmt_string temp_line = line; 05877 05878 if (temp_line.size () == 0) return; 05879 if (temp_line[0] == '#') return; 05880 05881 nl = temp_line.find_last_of ('\n'); 05882 if (nl != cmt_string::npos) temp_line.erase (nl); 05883 05884 length = temp_line.size (); 05885 if (length == 0) return; 05886 05887 // 05888 // We scan the line for handling backslashes. 05889 // 05890 // o Really terminating backslashes (ie those only followed by spaces/tabs 05891 // mean continued line 05892 // 05893 // 05894 05895 bool finished = true; 05896 05897 length = temp_line.size (); 05898 05899 back_slash = temp_line.find_last_of ('\\'); 05900 05901 if (back_slash != cmt_string::npos) 05902 { 05903 // 05904 // This is the last backslash 05905 // check if there are only space chars after it 05906 // 05907 05908 bool at_end = true; 05909 05910 for (int i = (back_slash + 1); i < length; i++) 05911 { 05912 char c = temp_line[i]; 05913 if ((c != ' ') && (c != '\t')) 05914 { 05915 at_end = false; 05916 break; 05917 } 05918 } 05919 05920 if (at_end) 05921 { 05922 temp_line.erase (back_slash); 05923 finished = false; 05924 } 05925 else 05926 { 05927 // This was not a trailing backslash. 05928 finished = true; 05929 } 05930 } 05931 05932 m_filtered_text += temp_line; 05933 05934 if (!finished) 05935 { 05936 // We still need to accumulate forthcoming lines 05937 // before parsing the resulting text. 05938 return; 05939 } 05940 05941 /* 05942 Here a full line (possibly accumulating several lines 05943 ended by backslashes) is parsed : 05944 05945 o Special characters are filtered now : 05946 05947 <cmt:tab/> \t 05948 <cmt:cr/> \r 05949 <cmt:lf/> \n 05950 05951 o Split into words (a word is a string not containing 05952 spaces or enclosed in quotes) 05953 05954 o Parse the word array (function Select) 05955 05956 */ 05957 05958 m_filtered_text.replace_all ("<cmt:tab/>", "\t"); 05959 m_filtered_text.replace_all ("<cmt:cr/>", "\r"); 05960 m_filtered_text.replace_all ("<cmt:lf/>", "\n"); 05961 05962 if (m_debug) 05963 { 05964 cout << "parse_requirements_line [" << m_filtered_text << "]" << endl; 05965 } 05966 05967 static CmtSystem::cmt_string_vector words; 05968 05969 CmtSystem::split (m_filtered_text, " \t", words); 05970 05971 if (words.size () != 0) 05972 { 05973 select (words, use, file_name, line_number); 05974 } 05975 05976 m_filtered_text.erase (0); 05977 } |
|
Parse a text, rejecting comments and rebuilding complete lines (from sections separated by \ characters. Each reformatted line is parsed by filter_line Definition at line 5986 of file cmt_parser.cxx. Referenced by Pattern::apply(), ApplicationAnalyzer::end(), LibraryAnalyzer::end(), and parse_requirements(). 05989 { 05990 cmt_string line; 05991 int pos; 05992 int max_pos; 05993 int line_number = 1; 05994 05995 if (use == 0) use = &(Use::current ()); 05996 05997 m_filtered_text.erase (0); 05998 05999 pos = 0; 06000 max_pos = text.size (); 06001 06002 for (pos = 0; pos < max_pos;) 06003 { 06004 int cr = text.find (pos, "\r\n"); 06005 int nl = text.find (pos, '\n'); 06006 int first = nl; 06007 int length = 1; 06008 06009 if (cr != cmt_string::npos) 06010 { 06011 if (nl == cmt_string::npos) 06012 { 06013 first = cr; 06014 length = 2; 06015 } 06016 else 06017 { 06018 first = (nl < cr) ? nl : cr; 06019 length = (nl < cr) ? 1 : 2; 06020 } 06021 } 06022 06023 if (first == cmt_string::npos) 06024 { 06025 text.substr (pos, line); 06026 pos = max_pos; 06027 } 06028 else if (first > pos) 06029 { 06030 text.substr (pos, first - pos, line); 06031 pos = first + length; 06032 } 06033 else 06034 { 06035 line.erase (0); 06036 pos += length; 06037 } 06038 06039 parse_requirements_line (line, use, file_name, line_number); 06040 06041 if ((m_action == action_check_configuration) && CmtError::has_pending_error ()) 06042 { 06043 break; 06044 } 06045 06046 line_number++; 06047 } 06048 } |
|
Definition at line 6076 of file cmt_parser.cxx. 06077 { 06078 PrintMode mode = Csh; 06079 CmtSystem::cmt_string_vector arguments; 06080 cmt_string extra_line; 06081 cmt_string extra_file; 06082 06083 if (argc <= 1) 06084 { 06085 do_help (); 06086 exit (0); 06087 } 06088 06089 clear (); 06090 configure (); 06091 06092 CmtError::clear (); 06093 06094 /* 06095 Set private if positioned inside the package 06096 (which is detected since we were able to retreive the 06097 Version, Package and Path) 06098 */ 06099 06100 if ((m_current_path.size () == 0) || 06101 (m_current_package.size () == 0) || 06102 (m_current_version.size () == 0)) 06103 { 06104 m_current_access = UserMode; 06105 } 06106 else 06107 { 06108 m_current_access = DeveloperMode; 06109 } 06110 06111 parse_arguments (argc, argv, arguments, 06112 extra_line, extra_file, mode); 06113 06114 if (m_configure_error != "") 06115 { 06116 if (!m_quiet) cout << "# CMT>" << m_configure_error << endl; 06117 } 06118 06119 if (CmtError::has_pending_error ()) 06120 { 06121 int code = CmtError::get_last_error_code (); 06122 if (!m_quiet) CmtError::print (); 06123 clear (); 06124 06125 return (code); 06126 } 06127 06128 if (m_debug) 06129 { 06130 cout << "After parse_argument> pack=" << m_current_package 06131 << " m_current_tag=" << m_current_tag 06132 << endl; 06133 } 06134 06135 /* 06136 Now actual requirements analysis can take place. 06137 06138 Extra lines or files are analysed first. 06139 */ 06140 06141 if (strlen (extra_file.c_str ()) > 0) parse_requirements (extra_file, 0); 06142 if (strlen (extra_line.c_str ()) > 0) parse_requirements_line (extra_line, 0); 06143 06144 // 06145 // For some of the actions, the CMT package must be automatically 06146 // included 06147 // 06148 06149 if (m_debug) cerr << "parser1> current_tag=" << m_current_tag << endl; 06150 06151 switch (m_action) 06152 { 06153 // case action_none : 06154 case action_awk : 06155 case action_broadcast : 06156 case action_build_constituent_makefile : 06157 case action_build_constituents_makefile : 06158 case action_build_dependencies : 06159 case action_build_library_links : 06160 case action_build_make_setup : 06161 case action_build_msdev : 06162 case action_build_os9_makefile : 06163 // case action_build_prototype : 06164 case action_build_readme : 06165 case action_build_tag_makefile : 06166 // case action_build_temporary_name : 06167 case action_build_triggers : 06168 case action_build_windefs : 06169 case action_check_configuration : 06170 // case action_check_files : 06171 // case action_check_version : 06172 case action_checkout : 06173 case action_cleanup : 06174 case action_config : 06175 case action_create : 06176 // case action_cvsbranches : 06177 // case action_cvssubpackages : 06178 // case action_cvstags : 06179 case action_expand_model : 06180 case action_filter : 06181 // case action_help : 06182 case action_load : 06183 case action_lock : 06184 case action_remove : 06185 case action_remove_library_links : 06186 case action_run : 06187 case action_run_sequence : 06188 case action_setup : 06189 case action_show_all_tags : 06190 case action_show_applied_patterns : 06191 // case action_show_author : 06192 // case action_show_branches : 06193 // case action_show_clients : 06194 // case action_show_constituent : 06195 // case action_show_constituent_names : 06196 // case action_show_constituents : 06197 case action_show_fragment : 06198 case action_show_fragments : 06199 case action_show_groups : 06200 case action_show_include_dirs : 06201 case action_show_language : 06202 case action_show_languages : 06203 case action_show_macro : 06204 case action_show_macro_names : 06205 case action_show_macro_value : 06206 case action_show_macros : 06207 // case action_show_manager : 06208 // case action_show_packages : 06209 case action_show_path : 06210 case action_show_pattern : 06211 case action_show_pattern_names : 06212 case action_show_patterns : 06213 // case action_show_pwd : 06214 case action_show_set : 06215 case action_show_set_names : 06216 case action_show_set_value : 06217 case action_show_sets : 06218 case action_show_strategies : 06219 case action_show_tags : 06220 case action_show_uses : 06221 case action_show_version : 06222 // case action_show_versions : 06223 // case action_system : 06224 case action_unlock : 06225 case action_version : 06226 use_cmt (); 06227 // 06228 // Now parse the requirements file stored in ${CMTHOME} 06229 // 06230 06231 use_home_requirements (); 06232 06233 break; 06234 default: 06235 break; 06236 } 06237 06238 if (m_debug) cerr << "parser2> current_tag=" << m_current_tag << endl; 06239 06240 // 06241 // Setting up recursive actions 06242 // 06243 06244 switch (m_action) 06245 { 06246 // case action_none : 06247 case action_awk : 06248 case action_broadcast : 06249 case action_build_constituent_makefile : 06250 case action_build_constituents_makefile : 06251 case action_build_dependencies : 06252 case action_build_library_links : 06253 case action_build_make_setup : 06254 case action_build_msdev : 06255 case action_build_os9_makefile : 06256 // case action_build_prototype : 06257 case action_build_readme : 06258 case action_build_tag_makefile : 06259 // case action_build_temporary_name : 06260 case action_build_triggers : 06261 case action_build_windefs : 06262 case action_check_configuration : 06263 // case action_check_files : 06264 // case action_check_version : 06265 // case action_checkout : 06266 case action_cleanup : 06267 case action_config : 06268 // case action_create : 06269 // case action_cvsbranches : 06270 // case action_cvssubpackages : 06271 // case action_cvstags : 06272 case action_expand_model : 06273 case action_filter : 06274 // case action_help : 06275 case action_load : 06276 // case action_lock : 06277 // case action_remove : 06278 case action_remove_library_links : 06279 // case action_run : 06280 case action_run_sequence : 06281 case action_setup : 06282 case action_show_all_tags : 06283 case action_show_applied_patterns : 06284 // case action_show_author : 06285 // case action_show_branches : 06286 // case action_show_clients : 06287 case action_show_constituent : 06288 case action_show_constituent_names : 06289 case action_show_constituents : 06290 case action_show_fragment : 06291 case action_show_fragments : 06292 case action_show_groups : 06293 case action_show_include_dirs : 06294 case action_show_language : 06295 case action_show_languages : 06296 case action_show_macro : 06297 case action_show_macro_names : 06298 case action_show_macro_value : 06299 case action_show_macros : 06300 // case action_show_manager : 06301 // case action_show_packages : 06302 case action_show_path : 06303 case action_show_pattern : 06304 case action_show_pattern_names : 06305 case action_show_patterns : 06306 // case action_show_pwd : 06307 case action_show_set : 06308 case action_show_set_names : 06309 case action_show_set_value : 06310 case action_show_sets : 06311 case action_show_strategies : 06312 case action_show_tags : 06313 case action_show_uses : 06314 // case action_show_version : 06315 // case action_show_versions : 06316 // case action_system : 06317 // case action_unlock : 06318 // case action_version : 06319 m_recursive = true; 06320 break; 06321 default: 06322 m_recursive = false; 06323 break; 06324 } 06325 06326 // 06327 // Actions for which the context of the package is checked, 06328 // and the requirements file is analysed. 06329 // 06330 06331 switch (m_action) 06332 { 06333 case action_none : 06334 case action_awk : 06335 case action_broadcast : 06336 case action_build_constituent_makefile : 06337 case action_build_constituents_makefile : 06338 case action_build_dependencies : 06339 case action_build_library_links : 06340 case action_build_make_setup : 06341 case action_build_msdev : 06342 case action_build_os9_makefile : 06343 // case action_build_prototype : 06344 case action_build_readme : 06345 case action_build_tag_makefile : 06346 // case action_build_temporary_name : 06347 case action_build_triggers : 06348 case action_build_windefs : 06349 case action_check_configuration : 06350 // case action_check_files : 06351 // case action_check_version : 06352 // case action_checkout : 06353 case action_cleanup : 06354 case action_config : 06355 // case action_create : 06356 // case action_cvsbranches : 06357 // case action_cvssubpackages : 06358 // case action_cvstags : 06359 case action_expand_model : 06360 case action_filter : 06361 case action_help : 06362 case action_load : 06363 case action_lock : 06364 // case action_remove : 06365 case action_remove_library_links : 06366 case action_run : 06367 // case action_run_sequence : 06368 case action_setup : 06369 case action_show_all_tags : 06370 case action_show_applied_patterns : 06371 case action_show_author : 06372 case action_show_branches : 06373 // case action_show_clients : 06374 case action_show_constituent : 06375 case action_show_constituent_names : 06376 case action_show_constituents : 06377 case action_show_fragment : 06378 case action_show_fragments : 06379 case action_show_groups : 06380 case action_show_include_dirs : 06381 case action_show_language : 06382 case action_show_languages : 06383 case action_show_macro : 06384 case action_show_macro_names : 06385 case action_show_macro_value : 06386 case action_show_macros : 06387 case action_show_manager : 06388 // case action_show_packages : 06389 case action_show_path : 06390 case action_show_pattern : 06391 case action_show_pattern_names : 06392 case action_show_patterns : 06393 case action_show_pwd : 06394 case action_show_set : 06395 case action_show_set_names : 06396 case action_show_set_value : 06397 case action_show_sets : 06398 case action_show_strategies : 06399 case action_show_tags : 06400 case action_show_uses : 06401 case action_show_version : 06402 // case action_show_versions : 06403 // case action_system : 06404 case action_unlock : 06405 // case action_version : 06406 reach_current_package (); 06407 use_user_context_requirements (); 06408 break; 06409 default: 06410 break; 06411 } 06412 06413 if (m_debug) cerr << "parser3> current_tag=" << m_current_tag << endl; 06414 06415 // 06416 // Perform some actions even if there is an error 06417 // 06418 06419 if (CmtError::has_pending_error ()) 06420 { 06421 int code = CmtError::get_last_error_code (); 06422 if (!m_quiet) CmtError::print (); 06423 06424 switch (m_action) 06425 { 06426 // case action_none : 06427 // case action_awk : 06428 // case action_broadcast : 06429 case action_build_constituent_makefile : 06430 case action_build_constituents_makefile : 06431 case action_build_dependencies : 06432 case action_build_library_links : 06433 case action_build_make_setup : 06434 case action_build_msdev : 06435 case action_build_os9_makefile : 06436 case action_build_prototype : 06437 case action_build_readme : 06438 case action_build_tag_makefile : 06439 // case action_build_temporary_name : 06440 case action_build_triggers : 06441 case action_build_windefs : 06442 case action_check_configuration : 06443 // case action_check_files : 06444 // case action_check_version : 06445 // case action_checkout : 06446 case action_cleanup : 06447 // case action_config : 06448 // case action_create : 06449 // case action_cvsbranches : 06450 // case action_cvssubpackages : 06451 // case action_cvstags : 06452 // case action_expand_model : 06453 // case action_filter : 06454 // case action_help : 06455 case action_load : 06456 case action_lock : 06457 case action_remove : 06458 case action_remove_library_links : 06459 // case action_run : 06460 case action_run_sequence : 06461 case action_setup : 06462 // case action_show_all_tags : 06463 // case action_show_applied_patterns : 06464 // case action_show_author : 06465 // case action_show_branches : 06466 // case action_show_clients : 06467 // case action_show_constituent : 06468 // case action_show_constituent_names : 06469 // case action_show_constituents : 06470 // case action_show_fragment : 06471 // case action_show_fragments : 06472 // case action_show_groups : 06473 // case action_show_include_dirs : 06474 // case action_show_language : 06475 // case action_show_languages : 06476 // case action_show_macro : 06477 // case action_show_macro_names : 06478 // case action_show_macro_value : 06479 // case action_show_macros : 06480 // case action_show_manager : 06481 // case action_show_packages : 06482 // case action_show_path : 06483 // case action_show_pattern : 06484 // case action_show_pattern_names : 06485 // case action_show_patterns : 06486 // case action_show_pwd : 06487 // case action_show_set : 06488 // case action_show_set_names : 06489 // case action_show_set_value : 06490 // case action_show_sets : 06491 // case action_show_strategies : 06492 // case action_show_tags : 06493 // case action_show_uses : 06494 // case action_show_version : 06495 // case action_show_versions : 06496 // case action_system : 06497 case action_unlock : 06498 // case action_version : 06499 clear (); 06500 return (code); 06501 default: 06502 CmtError::clear (); 06503 break; 06504 } 06505 } 06506 06507 // 06508 // Perform actions 06509 // 06510 06511 switch (m_action) 06512 { 06513 case action_none : 06514 CmtError::set (CmtError::syntax_error, "ParseArguments> "); 06515 break; 06516 case action_awk : 06517 do_awk (arguments); 06518 break; 06519 case action_broadcast : 06520 do_broadcast (arguments, argc, argv); 06521 break; 06522 case action_build_constituent_makefile : 06523 do_build_constituent_makefile (arguments, argc, argv); 06524 break; 06525 case action_build_constituents_makefile : 06526 do_build_constituents_makefile (arguments, argc, argv); 06527 break; 06528 case action_build_dependencies : 06529 do_build_dependencies (arguments, argc, argv); 06530 break; 06531 case action_build_library_links : 06532 do_build_library_links (); 06533 break; 06534 case action_build_make_setup : 06535 do_build_make_setup (); 06536 break; 06537 case action_build_msdev : 06538 do_build_msdev (arguments); 06539 break; 06540 case action_build_os9_makefile : 06541 do_build_os9_makefile (arguments); 06542 break; 06543 case action_build_prototype : 06544 do_build_prototype (arguments); 06545 break; 06546 case action_build_readme : 06547 do_build_readme (arguments); 06548 break; 06549 case action_build_tag_makefile : 06550 do_build_tag_makefile (); 06551 break; 06552 case action_build_temporary_name : 06553 do_build_temporary_name (); 06554 break; 06555 case action_build_triggers : 06556 do_build_triggers (arguments); 06557 break; 06558 case action_build_windefs : 06559 do_build_windefs (arguments); 06560 break; 06561 case action_check_configuration : 06562 do_check_configuration (); 06563 break; 06564 case action_check_files : 06565 do_check_files (arguments); 06566 break; 06567 case action_check_version : 06568 do_check_version (arguments); 06569 break; 06570 case action_checkout : 06571 do_checkout (arguments); 06572 break; 06573 case action_cleanup : 06574 do_cleanup (mode); 06575 break; 06576 case action_config : 06577 do_config (); 06578 break; 06579 case action_create : 06580 do_create (arguments); 06581 break; 06582 case action_cvsbranches : 06583 do_cvsbranches (arguments); 06584 break; 06585 case action_cvssubpackages : 06586 do_cvssubpackages (arguments); 06587 break; 06588 case action_cvstags : 06589 do_cvstags (arguments); 06590 break; 06591 case action_expand_model : 06592 do_expand_model (arguments); 06593 break; 06594 case action_filter : 06595 do_filter (arguments); 06596 break; 06597 case action_help : 06598 do_help (); 06599 break; 06600 case action_load : 06601 cout << "#CMT> action not implemented" << endl; 06602 break; 06603 case action_lock : 06604 do_lock (m_current_package, m_current_version, m_current_path); 06605 break; 06606 case action_remove : 06607 do_remove (m_current_package, m_current_version, m_current_path); 06608 break; 06609 case action_remove_library_links : 06610 do_remove_library_links (); 06611 break; 06612 case action_run : 06613 do_run (arguments); 06614 break; 06615 case action_run_sequence : 06616 do_run_sequence (arguments); 06617 break; 06618 case action_setup : 06619 do_setup (mode); 06620 break; 06621 case action_show_all_tags : 06622 do_show_all_tags (); 06623 break; 06624 case action_show_applied_patterns : 06625 do_show_applied_patterns (); 06626 break; 06627 case action_show_author : 06628 do_show_author (); 06629 break; 06630 case action_show_branches : 06631 do_show_branches (mode); 06632 break; 06633 case action_show_clients : 06634 do_show_clients (arguments); 06635 break; 06636 case action_show_constituent : 06637 do_show_constituent (arguments); 06638 break; 06639 case action_show_constituent_names : 06640 do_show_constituent_names (); 06641 break; 06642 case action_show_constituents : 06643 do_show_constituents (); 06644 break; 06645 case action_show_fragment : 06646 do_show_fragment (arguments); 06647 break; 06648 case action_show_fragments : 06649 do_show_fragments (); 06650 break; 06651 case action_show_groups : 06652 do_show_groups (); 06653 break; 06654 case action_show_include_dirs : 06655 do_show_include_dirs (); 06656 break; 06657 case action_show_language : 06658 do_show_language (arguments); 06659 break; 06660 case action_show_languages : 06661 do_show_languages (); 06662 break; 06663 case action_show_macro : 06664 do_show_macro (arguments, mode); 06665 break; 06666 case action_show_macro_names : 06667 do_show_macro_names (arguments, mode); 06668 break; 06669 case action_show_macro_value : 06670 do_show_macro_value (arguments, mode); 06671 break; 06672 case action_show_macros : 06673 do_show_macros (arguments, mode); 06674 break; 06675 case action_show_manager : 06676 do_show_manager (); 06677 break; 06678 case action_show_packages : 06679 do_show_packages (arguments); 06680 break; 06681 case action_show_path : 06682 do_show_path (); 06683 break; 06684 case action_show_pattern : 06685 do_show_pattern (arguments); 06686 break; 06687 case action_show_pattern_names : 06688 do_show_pattern_names (); 06689 break; 06690 case action_show_patterns : 06691 do_show_patterns (); 06692 break; 06693 case action_show_pwd : 06694 do_show_pwd (); 06695 break; 06696 case action_show_set : 06697 do_show_set (arguments, mode); 06698 break; 06699 case action_show_set_names : 06700 do_show_set_names (arguments, mode); 06701 break; 06702 case action_show_set_value : 06703 do_show_set_value (arguments, mode); 06704 break; 06705 case action_show_sets : 06706 do_show_sets (arguments, mode); 06707 break; 06708 case action_show_strategies : 06709 do_show_strategies (); 06710 break; 06711 case action_show_tags : 06712 do_show_tags (); 06713 break; 06714 case action_show_uses : 06715 do_show_uses (); 06716 break; 06717 case action_show_version : 06718 do_show_version (); 06719 break; 06720 case action_show_versions : 06721 do_show_versions (arguments); 06722 break; 06723 case action_system : 06724 do_show_system (); 06725 break; 06726 case action_unlock : 06727 do_unlock (m_current_package, m_current_version, m_current_path); 06728 break; 06729 case action_version : 06730 do_version (); 06731 break; 06732 default: 06733 CmtError::set (CmtError::syntax_error, "ParseArguments>"); 06734 break; 06735 } 06736 06737 if (CmtError::has_pending_error ()) 06738 { 06739 int code = CmtError::get_last_error_code (); 06740 if (!m_quiet) CmtError::print (); 06741 clear (); 06742 return (code); 06743 } 06744 else 06745 { 06746 clear (); 06747 return (0); 06748 } 06749 } |
|
Definition at line 6051 of file cmt_parser.cxx. Referenced by do_broadcast(), and main(). 06052 { 06053 CmtSystem::cmt_string_vector v; 06054 06055 CmtSystem::split (command_line, " \t", v); 06056 06057 int argc = v.size (); 06058 06059 char** argv = (char**) malloc ((argc + 1) * sizeof (char*)); 06060 06061 int i; 06062 for (i = 0; i < argc; i++) 06063 { 06064 argv[i] = (char*) v[i].c_str (); 06065 } 06066 argv[argc] = 0; 06067 06068 int status = parser (argc, argv); 06069 06070 free (argv); 06071 06072 return (status); 06073 } |
|
Format as one single line a set of 'setenv' statements joined with semi-colons to form one shell command.
Definition at line 6756 of file cmt_parser.cxx. Referenced by do_setup(). 06757 { 06758 Use::UsePtrVector& Uses = Use::uses (); 06759 06760 cmt_string tag; 06761 06762 set_standard_macros (); 06763 06764 //cerr << "# current_tag=" << m_current_tag << endl; 06765 //cerr << "# current_config=" << m_current_config << endl; 06766 06767 if (m_current_tag == "") 06768 { 06769 if (mode == Bat) tag = "%CMTCONFIG%"; 06770 else tag = "${CMTCONFIG}"; 06771 } 06772 else 06773 { 06774 tag = m_current_tag; 06775 } 06776 06777 if (m_current_access == DeveloperMode) 06778 { 06779 m_scope = ScopePrivate; 06780 } 06781 else 06782 { 06783 m_scope = ScopePublic; 06784 } 06785 06786 // 06787 // Now check if all extra tags are still valid. Some of them 06788 // may be discarded du to some conflict with highest priority 06789 // tags, or with exclude statements 06790 // 06791 06792 { 06793 CmtSystem::cmt_string_vector words; 06794 06795 cmt_string tags; 06796 06797 tags = Cmt::m_extra_tags; 06798 06799 CmtSystem::split (tags, " \t,", words); 06800 06801 Cmt::m_extra_tags = ""; 06802 06803 for (int i = 0; i < words.size (); i++) 06804 { 06805 Tag* tag; 06806 const cmt_string& a = words[i]; 06807 06808 tag = Tag::find (a); 06809 06810 if ((tag != 0) && (tag->is_selected ())) 06811 { 06812 Cmt::m_extra_tags += a; 06813 Cmt::m_extra_tags += ","; 06814 } 06815 } 06816 } 06817 06818 if (Uses.size () > 0) 06819 { 06820 int number; 06821 06822 for (number = 0; number < Uses.size (); number++) 06823 { 06824 Use& use = *(Uses[number]); 06825 06826 if (use.discarded) continue; 06827 06828 print_context (use, mode, tag); 06829 } 06830 } 06831 06832 print_context (Use::current (), mode, tag); 06833 06834 Symbol::all_print (mode); 06835 // Script::all_print (mode); 06836 06837 cout << endl; 06838 } |
|
Definition at line 6841 of file cmt_parser.cxx. Referenced by do_cleanup(). 06842 { 06843 Use::UsePtrVector& Uses = Use::uses (); 06844 06845 set_standard_macros (); 06846 06847 Script::all_print_clean (mode); 06848 Symbol::all_print_clean (mode); 06849 06850 switch (mode) 06851 { 06852 case Csh : 06853 if (m_current_package != "CMT") 06854 { 06855 cout << "unsetenv " << m_current_prefix << "ROOT" << endl; 06856 cout << "unsetenv " << m_current_prefix << "CONFIG" << endl; 06857 } 06858 break; 06859 case Sh : 06860 if (m_current_package != "CMT") 06861 { 06862 cout << "unset " << m_current_prefix << "ROOT" << endl; 06863 cout << "unset " << m_current_prefix << "CONFIG" << endl; 06864 } 06865 break; 06866 case Bat : 06867 if (m_current_package != "CMT") 06868 { 06869 cout << "set " << m_current_prefix << "ROOT=" << endl; 06870 cout << "set " << m_current_prefix << "CONFIG=" << endl; 06871 } 06872 break; 06873 } 06874 06875 if (Uses.size () > 0) 06876 { 06877 int number; 06878 06879 for (number = 0; number < Uses.size (); number++) 06880 { 06881 Use* use = Uses[number]; 06882 06883 if (use->package == "CMT") continue; 06884 if (use->package == "methods") continue; 06885 if (use->discarded) continue; 06886 06887 switch (mode) 06888 { 06889 case Csh : 06890 cout << "unsetenv " << use->prefix << "ROOT" << endl; 06891 cout << "unsetenv " << use->prefix << "CONFIG" << endl; 06892 break; 06893 case Sh : 06894 cout << "unset " << use->prefix << "ROOT" << endl; 06895 cout << "unset " << use->prefix << "CONFIG" << endl; 06896 break; 06897 case Bat : 06898 cout << "set " << use->prefix << "ROOT=" << endl; 06899 cout << "set " << use->prefix << "CONFIG" << endl; 06900 break; 06901 } 06902 } 06903 } 06904 06905 switch (mode) 06906 { 06907 case Csh : 06908 cout << "unsetenv CMTEXTRATAGS" << endl; 06909 break; 06910 case Sh : 06911 cout << "unset CMTEXTRATAGS" << endl; 06912 break; 06913 case Bat : 06914 cout << "set CMTEXTRATAGS=" << endl; 06915 break; 06916 } 06917 06918 cout << endl; 06919 } |
|
Definition at line 6922 of file cmt_parser.cxx. Referenced by print(). 06923 { 06924 if (use.package == "cmt_standalone") return; 06925 06926 cmt_string fs = CmtSystem::file_separator (); 06927 06928 use.real_path.replace_all (CmtSystem::file_separator (), fs); 06929 06930 cmt_string system = CmtSystem::get_cmt_config (); 06931 06932 switch (mode) 06933 { 06934 case Csh : 06935 cout << "setenv " << use.prefix << "ROOT \"" << 06936 use.real_path << fs << 06937 use.package << fs << 06938 use.version << "\"" << endl; 06939 06940 if (use.package == "CMT") 06941 { 06942 //cout << "setenv CMTCONFIG `${CMTROOT}/mgr/cmt system`; " << endl; 06943 cout << "setenv CMTCONFIG " << system << endl; 06944 //cout << "setenv CMTEXTRATAGS " << Cmt::m_extra_tags << endl; 06945 } 06946 else 06947 { 06948 cout << "setenv " << use.prefix << "CONFIG \"" << tag << "\"" << endl; 06949 } 06950 06951 break; 06952 case Sh : 06953 cout << use.prefix << "ROOT=\"" << 06954 use.real_path << fs << 06955 use.package << fs << 06956 use.version << "\"; export " << 06957 use.prefix << "ROOT" << endl; 06958 06959 if (use.package == "CMT") 06960 { 06961 //cout << "CMTCONFIG=`${CMTROOT}/mgr/cmt system`; export CMTCONFIG; "; 06962 cout << "CMTCONFIG=" << system << "; export CMTCONFIG" << endl; 06963 //cout << "CMTEXTRATAGS=" << Cmt::m_extra_tags << "; export CMTEXTRATAGS" << endl; 06964 } 06965 else 06966 { 06967 cout << use.prefix << "CONFIG=\"" << 06968 tag << "\"; export " << 06969 use.prefix << "CONFIG" << endl; 06970 } 06971 06972 break; 06973 case Bat : 06974 cout << "set " << use.prefix << "ROOT=" << 06975 use.real_path << fs << 06976 use.package << fs << 06977 use.version << endl; 06978 06979 if (use.package == "CMT") 06980 { 06981 //cout << "set CMTCONFIG=VisualC" << endl; 06982 cout << "set CMTCONFIG=" << system << endl; 06983 //cout << "set CMTEXTRATAGS=" << Cmt::m_extra_tags << endl; 06984 } 06985 else 06986 { 06987 cout << "set " << use.prefix << "CONFIG=" << tag << endl; 06988 } 06989 06990 break; 06991 } 06992 } |
|
Format a set of make macro definitions (one per line) Each macro value is provided enclosed in single quotes. Take the macro values from the macro statements found in recursively read requirements files. Definition at line 7001 of file cmt_parser.cxx. Referenced by do_build_tag_makefile(), do_show_macros(), and do_show_sets(). 07002 { 07003 int number; 07004 07005 set_standard_macros (); 07006 07007 cmt_regexp expression (pattern); 07008 07009 bool has_pattern = (pattern != ""); 07010 07011 for (number = 0; number < Symbol::symbol_number (); number++) 07012 { 07013 Symbol& symbol = Symbol::symbol (number); 07014 07015 if (has_pattern) 07016 { 07017 if (!expression.match (symbol.name)) continue; 07018 } 07019 07020 if (m_action == action_show_macros) 07021 { 07022 // Only keep macros. 07023 if ((symbol.command == CommandSet) || 07024 (symbol.command == CommandSetAppend) || 07025 (symbol.command == CommandSetPrepend) || 07026 (symbol.command == CommandSetRemove) || 07027 (symbol.command == CommandAlias) || 07028 (symbol.command == CommandPath) || 07029 (symbol.command == CommandPathAppend) || 07030 (symbol.command == CommandPathPrepend) || 07031 (symbol.command == CommandPathRemove)) continue; 07032 } 07033 else if (m_action == action_show_sets) 07034 { 07035 // Exclude macros. 07036 if ((symbol.command == CommandMacro) || 07037 (symbol.command == CommandMacroAppend) || 07038 (symbol.command == CommandMacroPrepend) || 07039 (symbol.command == CommandMacroRemove) || 07040 (symbol.command == CommandMacroRemoveAll)) continue; 07041 } 07042 else if (m_action == action_build_tag_makefile) 07043 { 07044 // Exclude scripts. 07045 if ((symbol.command == CommandSetupScript) || 07046 (symbol.command == CommandCleanupScript)) continue; 07047 } 07048 07049 if (symbol.value_lists.size () < 1) continue; 07050 07051 symbol.show_macro (mode); 07052 } 07053 } |
|
Format a set of make macro definitions (one per line) Each macro value is provided enclosed in single quotes. Take the macro values from the macro statements found in recursively read requirements files. Definition at line 7062 of file cmt_parser.cxx. Referenced by do_show_macro_names(), and do_show_set_names(). 07063 { 07064 int number; 07065 07066 set_standard_macros (); 07067 07068 cmt_regexp expression (pattern); 07069 07070 bool has_pattern = (pattern != ""); 07071 07072 for (number = 0; number < Symbol::symbol_number (); number++) 07073 { 07074 Symbol& symbol = Symbol::symbol (number); 07075 07076 if (has_pattern) 07077 { 07078 if (!expression.match (symbol.name)) continue; 07079 } 07080 07081 if (m_action == action_show_macro_names) 07082 { 07083 // Only keep macros. 07084 if ((symbol.command == CommandSet) || 07085 (symbol.command == CommandSetAppend) || 07086 (symbol.command == CommandSetPrepend) || 07087 (symbol.command == CommandSetRemove) || 07088 (symbol.command == CommandAlias) || 07089 (symbol.command == CommandPath) || 07090 (symbol.command == CommandPathAppend) || 07091 (symbol.command == CommandPathPrepend) || 07092 (symbol.command == CommandPathRemove)) continue; 07093 } 07094 else if (m_action == action_show_set_names) 07095 { 07096 // Exclude macros. 07097 if ((symbol.command == CommandMacro) || 07098 (symbol.command == CommandMacroAppend) || 07099 (symbol.command == CommandMacroPrepend) || 07100 (symbol.command == CommandMacroRemove) || 07101 (symbol.command == CommandMacroRemoveAll)) continue; 07102 } 07103 07104 cout << symbol.name << endl; 07105 } 07106 } |
|
Definition at line 7109 of file cmt_parser.cxx. 07110 { 07111 while (tabs > 0) 07112 { 07113 cout << " "; 07114 tabs--; 07115 } 07116 } |
|
Definition at line 7119 of file cmt_parser.cxx. Referenced by do_config(), and parser(). 07120 { 07121 Use& use = Use::current (); 07122 cmt_string dir; 07123 07124 if (m_debug) 07125 { 07126 cout << "Cmt::reach_current_package> pwd = " << 07127 CmtSystem::pwd () << 07128 " path=" << m_current_path << 07129 endl; 07130 } 07131 07132 /* 07133 Try to access the package. 07134 */ 07135 07136 if (m_current_package == "cmt_standalone") 07137 { 07138 if ((m_current_path != "") && (m_current_path != CmtSystem::pwd ())) 07139 { 07140 if (!CmtSystem::cd (m_current_path)) 07141 { 07142 CmtError::set (CmtError::package_not_found, 07143 "ReachCurrentPackage> Cannot reach the path directory"); 07144 return (0); 07145 } 07146 } 07147 07148 if (!CmtSystem::test_file ("requirements")) 07149 { 07150 if (!m_quiet) 07151 { 07152 cout << "#CMT> Cannot reach the requirements file" << endl; 07153 } 07154 07155 CmtError::set (CmtError::package_not_found, 07156 "ReachCurrentPackage> Cannot reach the requirements file"); 07157 return (0); 07158 } 07159 } 07160 else if (m_current_package != "") 07161 { 07162 if (!use.move_to ()) 07163 { 07164 CmtError::set (CmtError::package_not_found, 07165 "ReachCurrentPackage> Cannot reach the path directory"); 07166 return (0); 07167 } 07168 07169 m_current_path = use.real_path; 07170 07171 cmt_string parent = m_current_path; 07172 cmt_string d = m_current_path; 07173 07174 for (;;) 07175 { 07176 d += "/../"; 07177 if (!CmtSystem::is_package_directory (d)) 07178 { 07179 CmtSystem::add_cmt_path (parent, "current package", 07180 m_cmt_path, 07181 m_cmt_path_pwds, 07182 m_cmt_path_sources); 07183 break; 07184 } 07185 parent = d; 07186 } 07187 } 07188 else 07189 { 07190 // 07191 // The cmt command has been given without explicit search for 07192 // a package. Thus it is expected that we are in the context of a 07193 // true package. 07194 // 07195 // This means that there should be a requirements file visible. 07196 // 07197 // If this is not true, we'll make a try into ../cmt and then 07198 // a last try into ../mgr 07199 // 07200 07201 if (!CmtSystem::test_file ("requirements")) 07202 { 07203 if (CmtSystem::cd ("../cmt") && 07204 CmtSystem::test_file ("requirements")) 07205 { 07206 m_current_style = cmt_style; 07207 } 07208 else if (CmtSystem::cd ("../mgr") && 07209 CmtSystem::test_file ("requirements")) 07210 { 07211 m_current_style = mgr_style; 07212 } 07213 else 07214 { 07215 if (!m_quiet) 07216 { 07217 cout << "#CMT> Cannot reach the mgr branch" << endl; 07218 } 07219 07220 CmtError::set (CmtError::package_not_found, 07221 "ReachCurrentPackage> Cannot reach the mgr/cmt directory"); 07222 return (0); 07223 } 07224 } 07225 07226 dir = CmtSystem::pwd (); 07227 07228 CmtSystem::dirname (dir, m_current_path); 07229 CmtSystem::basename (m_current_path, m_current_version); 07230 CmtSystem::dirname (m_current_path, m_current_path); 07231 CmtSystem::basename (m_current_path, m_current_package); 07232 CmtSystem::dirname (m_current_path, m_current_path); 07233 07234 Use& use = Use::current (); 07235 07236 use.package = m_current_package; 07237 use.version = m_current_version; 07238 use.path = m_current_path; 07239 use.style = m_current_style; 07240 } 07241 07242 configure_current_dir (); 07243 07244 /* 07245 Check Tag is always set up 07246 */ 07247 07248 if (m_debug) cerr << "reach_current_package0> current_tag=" << m_current_tag << endl; 07249 07250 if (m_current_tag == "") 07251 { 07252 cmt_string env; 07253 07254 env = CmtSystem::getenv (m_current_config); 07255 if (env != "") 07256 { 07257 Tag* tag; 07258 07259 tag = Tag::add (env, PriorityConfig, "reach current package", 0); 07260 tag->mark (); 07261 //m_current_tag = env; 07262 07263 //if (!m_quiet) cerr << "reach_current_package1> current_tag=" << m_current_tag << endl; 07264 07265 } 07266 } 07267 07268 if (m_debug) 07269 { 07270 cout << "pwd = " << CmtSystem::pwd () << endl; 07271 } 07272 07273 /* 07274 Work on the requirements file. 07275 */ 07276 07277 if (dir != "") dir += CmtSystem::file_separator (); 07278 dir += "requirements"; 07279 parse_requirements (dir, 0); 07280 07281 if (m_debug) cerr << "reach_current_package2> current_tag=" << m_current_tag << endl; 07282 07304 Pattern::apply_all_globals (); 07305 07306 /* 07307 Select all possible tags 07308 */ 07309 07310 Tag::restore_tree (); 07311 07312 return (1); 07313 } |
|
Definition at line 1006 of file cmt_parser.cxx. Referenced by parse_arguments(). 01007 { 01008 //cerr << "restore_all_tags" << endl; 01009 01010 Cmt::configure_tags (use); 01011 01012 /* 01013 Then get existing extra tags 01014 */ 01015 01016 if (CmtSystem::testenv ("CMTEXTRATAGS")) 01017 { 01018 cmt_string s = "CMTEXTRATAGS"; 01019 01020 if (use != 0) 01021 { 01022 s += " in "; 01023 } 01024 01025 Tag* tag; 01026 CmtSystem::cmt_string_vector words; 01027 01028 cmt_string tags = CmtSystem::getenv ("CMTEXTRATAGS"); 01029 01030 CmtSystem::split (tags, " \t,", words); 01031 01032 Cmt::m_extra_tags = ""; 01033 01034 for (int i = 0; i < words.size (); i++) 01035 { 01036 const cmt_string& a = words[i]; 01037 01038 Cmt::m_extra_tags += a; 01039 Cmt::m_extra_tags += ","; 01040 01041 tag = Tag::add (a, PriorityUserTag, s, use); 01042 01043 tag->mark (); 01044 } 01045 } 01046 } |
|
Parse a line reformatted into a set of words. Specific action are taken according to the keyword Definition at line 7320 of file cmt_parser.cxx. Referenced by parse_requirements_line(). 07324 { 07325 cmt_string command; 07326 CommandType command_type = CommandNone; 07327 int i; 07328 07329 CmtError::clear (); 07330 07331 if (words.size () == 0) return; 07332 07333 command = words[0]; 07334 07335 if (command.size () == 0) return; 07336 07337 // 07338 // First analyze the syntax 07339 // 07340 07341 switch (command[0]) 07342 { 07343 case 'a': 07344 if (command == "alias") 07345 { 07346 command_type = CommandAlias; 07347 } 07348 else if (command == "application") 07349 { 07350 command_type = CommandApplication; 07351 } 07352 else if (command == "apply_pattern") 07353 { 07354 command_type = CommandApplyPattern; 07355 } 07356 else if (command == "author") 07357 { 07358 command_type = CommandAuthor; 07359 } 07360 else 07361 { 07362 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07363 } 07364 break; 07365 case 'b': 07366 if (command == "branches") 07367 { 07368 command_type = CommandBranches; 07369 } 07370 else if (command == "build_strategy") 07371 { 07372 command_type = CommandBuildStrategy; 07373 } 07374 else 07375 { 07376 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07377 } 07378 break; 07379 case 'c': 07380 if (command == "cleanup_script") 07381 { 07382 command_type = CommandCleanupScript; 07383 } 07384 else 07385 { 07386 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07387 } 07388 break; 07389 case 'd': 07390 if (command == "document") 07391 { 07392 command_type = CommandDocument; 07393 } 07394 else 07395 { 07396 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07397 } 07398 break; 07399 case 'i': 07400 if (command == "ignore_pattern") 07401 { 07402 command_type = CommandIgnorePattern; 07403 } 07404 else if (command == "include_dirs") 07405 { 07406 command_type = CommandIncludeDirs; 07407 } 07408 else if (command == "include_path") 07409 { 07410 command_type = CommandIncludePath; 07411 } 07412 else 07413 { 07414 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07415 } 07416 break; 07417 case 'l': 07418 if (command == "language") 07419 { 07420 command_type = CommandLanguage; 07421 } 07422 else if (command == "library") 07423 { 07424 command_type = CommandLibrary; 07425 } 07426 else 07427 { 07428 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07429 } 07430 break; 07431 case 'm': 07432 if (command == "macro") 07433 { 07434 command_type = CommandMacro; 07435 } 07436 else if (command == "macro+") 07437 { 07438 command_type = CommandMacroAppend; 07439 } 07440 else if (command == "macro_prepend") 07441 { 07442 command_type = CommandMacroPrepend; 07443 } 07444 else if ((command == "macro_append") || 07445 (command == "macro+")) 07446 { 07447 command_type = CommandMacroAppend; 07448 } 07449 else if (command == "macro_remove") 07450 { 07451 command_type = CommandMacroRemove; 07452 } 07453 else if (command == "macro_remove_all") 07454 { 07455 command_type = CommandMacroRemoveAll; 07456 } 07457 else if (command == "make_fragment") 07458 { 07459 command_type = CommandMakeFragment; 07460 } 07461 else if (command == "manager") 07462 { 07463 command_type = CommandManager; 07464 } 07465 else 07466 { 07467 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07468 } 07469 break; 07470 case 'p': 07471 if (command == "package") 07472 { 07473 command_type = CommandPackage; 07474 } 07475 else if (command == "path") 07476 { 07477 command_type = CommandPath; 07478 } 07479 else if (command == "path_append") 07480 { 07481 command_type = CommandPathAppend; 07482 } 07483 else if (command == "path_prepend") 07484 { 07485 command_type = CommandPathPrepend; 07486 } 07487 else if (command == "path_remove") 07488 { 07489 command_type = CommandPathRemove; 07490 } 07491 else if (command == "pattern") 07492 { 07493 command_type = CommandPattern; 07494 } 07495 else if (command == "public") 07496 { 07497 command_type = CommandPublic; 07498 } 07499 else if (command == "private") 07500 { 07501 command_type = CommandPrivate; 07502 } 07503 else 07504 { 07505 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07506 } 07507 break; 07508 case 's': 07509 if (command == "set") 07510 { 07511 command_type = CommandSet; 07512 } 07513 else if (command == "set_append") 07514 { 07515 command_type = CommandSetAppend; 07516 } 07517 else if (command == "set_prepend") 07518 { 07519 command_type = CommandSetPrepend; 07520 } 07521 else if (command == "set_remove") 07522 { 07523 command_type = CommandSetRemove; 07524 } 07525 else if (command == "setup_script") 07526 { 07527 command_type = CommandSetupScript; 07528 } 07529 else 07530 { 07531 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07532 } 07533 break; 07534 case 't': 07535 if (command == "tag") 07536 { 07537 command_type = CommandTag; 07538 } 07539 else if (command == "tag_exclude") 07540 { 07541 command_type = CommandTagExclude; 07542 } 07543 else 07544 { 07545 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07546 } 07547 break; 07548 case 'u': 07549 if (command == "use") 07550 { 07551 command_type = CommandUse; 07552 } 07553 else 07554 { 07555 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07556 } 07557 break; 07558 case 'v': 07559 if (command == "version_strategy") 07560 { 07561 command_type = CommandVersionStrategy; 07562 } 07563 else if (command == "version") 07564 { 07565 command_type = CommandVersion; 07566 } 07567 else 07568 { 07569 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07570 } 07571 break; 07572 default: 07573 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07574 break; 07575 } 07576 07577 if (CmtError::has_pending_error ()) 07578 { 07579 if (!m_quiet) 07580 { 07581 cout << "#CMT> bad syntax in requirements of " << use->package 07582 << " " << use->version 07583 << " " << use->specified_path 07584 << " line #" << line_number; 07585 cout << " [" << command << " ...]" << endl; 07586 } 07587 07588 return; 07589 } 07590 07591 07592 // 07593 // Then interpret the action 07594 // 07595 07596 switch (command_type) 07597 { 07598 case CommandAlias : 07599 Symbol::action (words, command_type, use); 07600 break; 07601 case CommandApplication : 07602 if (use == &(Use::current ())) 07603 { 07604 Constituent::action (Application, words); 07605 } 07606 break; 07607 case CommandApplyPattern : 07608 ApplyPattern::action (words, use); 07609 break; 07610 case CommandAuthor : 07611 use->author_action (words); 07612 break; 07613 case CommandBranches : 07614 if (use == &(Use::current ())) Branch::action (words); 07615 break; 07616 case CommandBuildStrategy : 07617 m_current_build_strategy = DefaultBuildStrategy; 07618 07619 for (i = 1; i < words.size (); i++) 07620 { 07621 const cmt_string& w = words[i]; 07622 07623 if (w == "prototypes") 07624 { 07625 m_current_build_strategy |= Prototypes; 07626 } 07627 else if (w == "no_prototypes") 07628 { 07629 m_current_build_strategy |= NoPrototypes; 07630 } 07631 else if (w == "keep_makefiles") 07632 { 07633 m_current_build_strategy |= KeepMakefiles; 07634 } 07635 else if (w == "rebuild_makefiles") 07636 { 07637 m_current_build_strategy |= RebuildMakefiles; 07638 } 07639 07640 if ((m_action == action_show_strategies) && !m_quiet) 07641 { 07642 cout << "# Package " << use->package << 07643 " adds " << w << " to build strategy" << endl; 07644 } 07645 } 07646 break; 07647 case CommandCleanupScript : 07648 Script::action (words, CleanupScript, use); 07649 Symbol::action (words, command_type, use); 07650 break; 07651 case CommandDocument : 07652 if (use == &(Use::current ())) 07653 Constituent::action (Document, words); 07654 break; 07655 case CommandIgnorePattern : 07656 IgnorePattern::action (words, use); 07657 break; 07658 case CommandIncludeDirs : 07659 Include::action (words, use); 07660 break; 07661 case CommandIncludePath : 07662 if (words.size () > 1) 07663 { 07664 use->set_include_path (words[1]); 07665 } 07666 break; 07667 case CommandLanguage : 07668 Language::action (words); 07669 break; 07670 case CommandLibrary : 07671 if (use == &(Use::current ())) 07672 Constituent::action (Library, words); 07673 break; 07674 case CommandMacro : 07675 case CommandMacroPrepend : 07676 case CommandMacroAppend : 07677 case CommandMacroRemove : 07678 case CommandMacroRemoveAll : 07679 Symbol::action (words, command_type, use); 07680 break; 07681 case CommandMakeFragment : 07682 Fragment::action (words, use); 07683 break; 07684 case CommandManager : 07685 use->manager_action (words); 07686 break; 07687 case CommandPackage : 07688 if (words.size () > 1) 07689 { 07690 if (use == &(Use::current())) 07691 { 07692 m_current_package = words[1]; 07693 build_prefix (m_current_package, m_current_prefix); 07694 07695 if ((use->package != "") && 07696 (use->package != m_current_package)) 07697 { 07698 /* 07699 Unknown keyword : just ignore the line 07700 */ 07701 if (!m_quiet) 07702 { 07703 cout << "#CMT> package name mismatch in requirements of " << 07704 use->package << " " << 07705 use->version << " line #" << line_number; 07706 cout << " : " << m_current_package << " versus " << 07707 use->package << endl; 07708 } 07709 } 07710 07711 use->set (m_current_package, 07712 m_current_version, 07713 m_current_path, 07714 "", 07715 ""); 07716 07717 use->change_path (m_current_path); 07718 use->style = m_current_style; 07719 } 07720 } 07721 break; 07722 case CommandPath : 07723 case CommandPathAppend : 07724 case CommandPathPrepend : 07725 case CommandPathRemove : 07726 Symbol::action (words, command_type, use); 07727 break; 07728 case CommandPattern : 07729 Pattern::action (words, use); 07730 break; 07731 case CommandPrivate : 07732 m_scope = ScopePrivate; 07733 break; 07734 case CommandPublic : 07735 m_scope = ScopePublic; 07736 break; 07737 case CommandSet : 07738 case CommandSetAppend : 07739 case CommandSetPrepend : 07740 case CommandSetRemove : 07741 Symbol::action (words, command_type, use); 07742 break; 07743 case CommandSetupScript : 07744 Script::action (words, SetupScript, use); 07745 Symbol::action (words, command_type, use); 07746 break; 07747 case CommandTag : 07748 Tag::action (words, use); 07749 break; 07750 case CommandTagExclude : 07751 Tag::action_exclude (words, use); 07752 break; 07753 case CommandUse : 07754 Use::action (words, use); 07755 break; 07756 case CommandVersionStrategy : 07757 if (words.size () > 1) 07758 { 07759 const cmt_string& w = words[1]; 07760 07761 if (w == "best_fit") 07762 { 07763 m_current_strategy = BestFit; 07764 } 07765 else if (w == "best_fit_no_check") 07766 { 07767 m_current_strategy = BestFitNoCheck; 07768 } 07769 else if (w == "first_choice") 07770 { 07771 m_current_strategy = FirstChoice; 07772 } 07773 else if (w == "last_choice") 07774 { 07775 m_current_strategy = LastChoice; 07776 } 07777 else if (w == "keep_all") 07778 { 07779 m_current_strategy = KeepAll; 07780 } 07781 07782 if ((m_action == action_show_strategies) && !m_quiet) 07783 { 07784 cout << "# Package " << use->package << 07785 " sets version strategy to " << w << endl; 07786 } 07787 } 07788 break; 07789 case CommandVersion : 07790 /* 07791 m_current_version = words[1]; 07792 */ 07793 break; 07794 default: 07795 /* 07796 Unknown keyword : just ignore the line 07797 */ 07798 if (!m_quiet) 07799 { 07800 cout << "#CMT> bad syntax in requirements of " << use->package 07801 << " " << use->version << " line #" << line_number; 07802 cout << " [" << command << "...]" << endl; 07803 } 07804 07805 CmtError::set (CmtError::syntax_error, "ParseRequirements> "); 07806 07807 return; 07808 } 07809 } |
|
Definition at line 8983 of file cmt_parser.cxx. Referenced by build_msdev_file(), do_build_constituent_makefile(), do_build_constituents_makefile(), do_build_dependencies(), do_build_library_links(), do_build_make_setup(), do_build_msdev(), do_build_os9_makefile(), do_build_prototype(), do_build_readme(), do_build_triggers(), do_build_windefs(), do_expand_model(), do_filter(), do_lock(), do_remove_library_links(), do_show_all_tags(), do_show_constituent(), do_show_constituent_names(), do_show_constituents(), do_show_include_dirs(), do_show_language(), do_show_languages(), do_show_macro(), do_show_tags(), do_unlock(), print(), print_clean(), print_macros(), and print_symbol_names(). 08984 { 08985 if (m_standard_macros_done) return; 08986 08987 m_standard_macros_done = true; 08988 08989 int number; 08990 cmt_string temp; 08991 Use::UsePtrVector& Uses = Use::uses (); 08992 Use& current_use = Use::current (); 08993 08994 cmt_string fs = CmtSystem::file_separator (); 08995 08996 cmt_string pwd = CmtSystem::pwd (); 08997 08998 if (CmtSystem::test_file ("../cmt/requirements")) m_current_style = cmt_style; 08999 else if (CmtSystem::test_file ("../mgr/requirements")) m_current_style = mgr_style; 09000 else m_current_style = none_style; 09001 09002 // Prepare computation of the best form for relative path from current directory 09003 // to package directories. 09004 CmtSystem::cmt_string_vector vb; 09005 CmtSystem::split (pwd, fs, vb); 09006 09007 09012 bool tag_debug = CmtSystem::testenv ("TAGDEBUG"); 09013 09014 if (tag_debug) cerr << "set_standard_macro0> current_tag=" << m_current_tag << endl; 09015 09016 if (m_current_tag != "") 09017 { 09018 // this is when some -tag= argument was used. 09019 if (tag_debug) cerr << "set_standard_macro0.1> current_tag=" << m_current_tag << endl; 09020 } 09021 else if (Symbol::is_selected ("CMTCONFIG")) 09022 { 09023 // This is when CMTCONFIG has been set from some requirements file 09024 Symbol* macro = Symbol::find ("CMTCONFIG"); 09025 if (macro != 0) 09026 { 09027 m_current_tag = macro->build_macro_value (); 09028 if (tag_debug) cerr << "set_standard_macro1> current_tag=" << m_current_tag << endl; 09029 } 09030 } 09031 else 09032 { 09033 // this is when no -tag= argument was used. 09034 if (tag_debug) cerr << "set_standard_macro(before2)> current_tag=" << m_current_tag << endl; 09035 if (current_use.package == "CMT") 09036 { 09037 m_current_tag = CmtSystem::getenv ("CMTBIN"); 09038 } 09039 else 09040 { 09041 m_current_tag = CmtSystem::getenv ("CMTCONFIG"); 09042 } 09043 09044 if (tag_debug) cerr << "set_standard_macro2> current_tag=" << m_current_tag << endl; 09045 } 09046 09047 if (m_debug) 09048 { 09049 cout << "set_standard_macro3>" << endl; 09050 } 09051 09052 StandardMacroBuilder builder (m_current_tag, 09053 m_current_package, 09054 m_current_version, 09055 m_current_prefix, 09056 m_current_style); 09057 09058 builder.fill_for_tag (); 09059 builder.fill_for_package_tag (); 09060 builder.fill_for_package (m_current_dir); 09061 builder.fill_for_branches (); 09062 builder.fill_for_uses (); 09063 builder.fill_for_use_requirements (); 09064 builder.fill_for_use_includes (); 09065 builder.fill_for_use_fincludes (); 09066 builder.fill_for_use_stamps (); 09067 builder.fill_for_use_cflags (); 09068 builder.fill_for_use_pp_cflags (); 09069 builder.fill_for_use_cppflags (); 09070 builder.fill_for_use_pp_cppflags (); 09071 builder.fill_for_use_fflags (); 09072 builder.fill_for_use_pp_fflags (); 09073 builder.fill_for_use_linkopts (); 09074 builder.fill_for_use_libraries (); 09075 builder.fill_for_includes (); 09076 builder.fill_for_fincludes (); 09077 builder.fill_for_all_constituents (); 09078 09083 const Constituent::ConstituentVector& constituents = 09084 Constituent::constituents (); 09085 09086 if (!Symbol::is_selected ("constituents")) 09087 { 09088 temp = "macro_append constituents \" "; 09089 09090 for (number = 0; number < constituents.size (); number++) 09091 { 09092 const Constituent& constituent = constituents[number]; 09093 09094 if (constituent.group == 0) 09095 { 09096 temp += constituent.name; 09097 temp += " "; 09098 } 09099 } 09100 09101 temp += "\""; 09102 09103 parse_requirements_line (temp, ¤t_use); 09104 } 09105 09106 parse_requirements_line ("macro_append all_constituents \" $(constituents)\"", 09107 ¤t_use); 09108 09109 if (!Symbol::is_selected ("constituentsclean")) 09110 { 09111 temp = "macro_append constituentsclean \" "; 09112 09113 for (number = constituents.size () - 1; number >= 0 ; number--) 09114 { 09115 const Constituent& constituent = constituents[number]; 09116 09117 if (constituent.group == 0) 09118 { 09119 temp += constituent.name; 09120 temp += "clean "; 09121 } 09122 } 09123 09124 temp += "\""; 09125 09126 parse_requirements_line (temp, ¤t_use); 09127 } 09128 09129 parse_requirements_line ("macro_append all_constituentsclean \" $(constituentsclean)\"", 09130 ¤t_use); 09131 09132 const Group::GroupVector& groups = Group::groups (); 09133 09134 for (number = 0; number < groups.size (); number++) 09135 { 09136 const Group& group = groups[number]; 09137 09138 temp = "macro_append "; 09139 temp += group.name (); 09140 temp += "_constituents \" "; 09141 09142 int i; 09143 09144 for (i = 0; i < constituents.size (); i++) 09145 { 09146 const Constituent& constituent = constituents[i]; 09147 09148 if ((constituent.group != 0) && 09149 (group.name () == constituent.group->name ())) 09150 { 09151 temp += constituent.name; 09152 temp += " "; 09153 } 09154 } 09155 09156 temp += "\""; 09157 09158 parse_requirements_line (temp, ¤t_use); 09159 09160 temp = "macro_append "; 09161 temp += group.name (); 09162 temp += "_constituentsclean \" "; 09163 09164 for (i = constituents.size () - 1; i >= 0 ; i--) 09165 { 09166 const Constituent& constituent = constituents[i]; 09167 09168 if ((constituent.group != 0) && 09169 (group.name () == constituent.group->name ())) 09170 { 09171 temp += constituent.name; 09172 temp += "clean "; 09173 } 09174 } 09175 09176 temp += "\""; 09177 09178 parse_requirements_line (temp, ¤t_use); 09179 } 09180 } |
|
Macros implied or required to manage constituents.
Definition at line 9183 of file cmt_parser.cxx. Referenced by load(), and parser(). 09184 { 09185 UseRef use; 09186 bool recursive_copy = m_recursive; 09187 bool debug_copy = m_debug; 09188 09189 if (m_default_path.size () <= 0) return; 09190 if (m_current_package == "CMT") return; 09191 09192 m_recursive = true; 09193 m_debug = false; 09194 use = Use::add (m_default_path, "CMT", m_cmt_version, "", "", 0); 09195 m_recursive = recursive_copy; 09196 m_debug = debug_copy; 09197 } |
|
Definition at line 9200 of file cmt_parser.cxx. Referenced by parser(). 09201 { 09202 cmt_string f = m_cmt_home; 09203 09204 if (f == "") 09205 { 09206 //if (!m_quiet) cerr << "No CMTHOME" << endl; 09207 return; 09208 } 09209 09210 //if (!m_quiet) cerr << "Using CMTHOME in " << f << endl; 09211 09212 UseRef use; 09213 bool recursive_copy = m_recursive; 09214 09215 if (m_default_path.size () <= 0) return; 09216 if (m_current_package == "CMT") return; 09217 09218 m_recursive = true; 09219 09220 cmt_string name = CmtSystem::get_home_package (); 09221 09222 use = Use::add (f, name, "", "", "", 0); 09223 09224 f += CmtSystem::file_separator (); 09225 f += "requirements"; 09226 parse_requirements (f, use); 09227 09228 m_recursive = recursive_copy; 09229 } |
|
Definition at line 9232 of file cmt_parser.cxx. Referenced by parser(). 09233 { 09234 cmt_string f = m_cmt_user_context; 09235 09236 if (f == "") 09237 { 09238 //if (!m_quiet) cerr << "No CMTUSERCONTEXT" << endl; 09239 return; 09240 } 09241 09242 //if (!m_quiet) cerr << "Using CMTUSERCONTEXT in " << f << endl; 09243 09244 UseRef use; 09245 bool recursive_copy = m_recursive; 09246 09247 if (m_default_path.size () <= 0) return; 09248 if (m_current_package == "CMT") return; 09249 09250 m_recursive = true; 09251 09252 cmt_string name = CmtSystem::get_user_context_package (); 09253 09254 use = Use::add (f, name, "", "", "", 0); 09255 09256 f += CmtSystem::file_separator (); 09257 f += "requirements"; 09258 parse_requirements (f, use); 09259 09260 m_recursive = recursive_copy; 09261 } |
|
Definition at line 9264 of file cmt_parser.cxx. 09267 { 09268 result.erase (0); 09269 09270 for (int i = 0; i < v.size (); i++) 09271 { 09272 if (i > 0) result += separator; 09273 result += v[i]; 09274 } 09275 } |
|
Definition at line 9278 of file cmt_parser.cxx. Referenced by PathBuilder::build(), and PathBuilder::clean(). 09279 { 09280 cmt_string result; 09281 09282 vector_to_string (v, " ", result); 09283 09284 return (result); 09285 } |
|
All Attributes are private.
Definition at line 30 of file cmt_parser.cxx. |
|
Definition at line 31 of file cmt_parser.cxx. |
|
Definition at line 32 of file cmt_parser.cxx. |
|
Definition at line 37 of file cmt_parser.cxx. |
|
Definition at line 33 of file cmt_parser.cxx. |
|
Definition at line 34 of file cmt_parser.cxx. |
|
Definition at line 35 of file cmt_parser.cxx. |
|
Definition at line 36 of file cmt_parser.cxx. |
|
Definition at line 39 of file cmt_parser.cxx. |
|
Definition at line 38 of file cmt_parser.cxx. |
|
Definition at line 40 of file cmt_parser.cxx. |
|
Definition at line 59 of file cmt_parser.cxx. |
|
Definition at line 49 of file cmt_parser.cxx. |
|
Definition at line 41 of file cmt_parser.cxx. |
|
Definition at line 45 of file cmt_parser.cxx. |
|
Definition at line 43 of file cmt_parser.cxx. |
|
Definition at line 44 of file cmt_parser.cxx. |
|
Definition at line 46 of file cmt_parser.cxx. |
|
Definition at line 47 of file cmt_parser.cxx. |
|
Definition at line 50 of file cmt_parser.cxx. |
|
Definition at line 51 of file cmt_parser.cxx. |
|
Definition at line 53 of file cmt_parser.cxx. |
|
Definition at line 54 of file cmt_parser.cxx. |
|
Definition at line 55 of file cmt_parser.cxx. |
|
Definition at line 61 of file cmt_parser.cxx. |
|
Definition at line 63 of file cmt_parser.cxx. |
|
Definition at line 57 of file cmt_parser.cxx. |
|
Definition at line 64 of file cmt_parser.cxx. |
|
Definition at line 65 of file cmt_parser.cxx. |
|
Definition at line 66 of file cmt_parser.cxx. |
|
Definition at line 67 of file cmt_parser.cxx. |
|
Definition at line 68 of file cmt_parser.cxx. |
|
Definition at line 69 of file cmt_parser.cxx. |