source: CMT/v1r16p20040901/src/cmt_parser.cxx@ 1

Last change on this file since 1 was 1, checked in by arnault, 21 years ago

Import all tags
File size: 252.0 KB
Line 
1//-----------------------------------------------------------
2// Copyright Christian Arnault LAL-Orsay CNRS
3// arnault@lal.in2p3.fr
4// See the complete license in cmt_license.txt "http://www.cecill.info".
5//-----------------------------------------------------------
6
7#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10#include <ctype.h>
11
12//----------------------------------------------------------
13
14#include "cmt_parser.h"
15#include "cmt_version.h"
16
17#include "cmt_database.h"
18#include "cmt_include.h"
19#include "cmt_script.h"
20#include "cmt_generator.h"
21#include "cmt_system.h"
22#include "cmt.h"
23#include "cmt_error.h"
24#include "cmt_cvs.h"
25#include "cmt_lock.h"
26#include "cmt_triggers.h"
27#include "cmt_model.h"
28#include "cmt_awk.h"
29#include "cmt_syntax.h"
30#include "cmt_install_area.h"
31#include "cmt_cmtpath_pattern.h"
32#include "cmt_sequence.h"
33#include "cmt_map.h"
34#include "cmt_project.h"
35#include "cmt_log.h"
36
37//----------------------------------------------------------
38//
39// Static object definitions for the Cmt class.
40//
41
42ActionType Cmt::m_action;
43ActionType Cmt::m_help_action;
44bool Cmt::m_build_nmake;
45cmt_string Cmt::m_cmt_config;
46cmt_string Cmt::m_cmt_root;
47cmt_string Cmt::m_cmt_home;
48cmt_string Cmt::m_cmt_user_context;
49cmt_string Cmt::m_cmt_site;
50cmt_string Cmt::m_cmt_version;
51int Cmt::m_current_build_strategy = DefaultBuildStrategy;
52int Cmt::m_current_setup_strategy = DefaultSetupStrategy;
53
54cmt_string Cmt::m_current_dir;
55cmt_string Cmt::m_current_package;
56cmt_string Cmt::m_current_config;
57cmt_string Cmt::m_current_path;
58cmt_string Cmt::m_current_prefix;
59cmt_string Cmt::m_current_cmtpath;
60cmt_string Cmt::m_current_offset;
61
62AccessMode Cmt::m_current_access = UserMode;
63CmtDirStyle Cmt::m_current_style = cmt_style;
64CmtStructuringStyle Cmt::m_current_structuring_style = with_version_directory;
65
66cmt_string Cmt::m_current_tag;
67cmt_string Cmt::m_current_target;
68cmt_string Cmt::m_current_version;
69
70cmt_string Cmt::m_extra_tags;
71
72cmt_string Cmt::m_configure_error;
73
74bool Cmt::m_debug;
75
76cmt_string Cmt::m_default_path;
77bool Cmt::m_quiet;
78bool Cmt::m_recursive;
79CmtScopeFilteringMode Cmt::m_scope_filtering_mode;
80bool Cmt::m_simulation;
81bool Cmt::m_standard_macros_done;
82//----------------------------------------------------------
83
84
85//----------------------------------------------------------
86//
87// Utility classes
88//
89//----------------------------------------------------------
90
91
92
93/**
94 * This PathScanner actor simply displays the package name/version/path
95 * It is used by the cmt show packages operation
96 */
97class PackageViewer : public PathScanner::actor
98{
99public:
100 void run (const cmt_string& package,
101 const cmt_string& version,
102 const cmt_string& path);
103};
104
105
106/**
107 * This PathScanner actor accumulates all found packages into a cmt_string_vector
108 * It is used by the broadcast operation
109 */
110class PackageSelector : public PathScanner::actor
111{
112public:
113 PackageSelector (CmtSystem::cmt_string_vector& uses);
114 void run (const cmt_string& package,
115 const cmt_string& version,
116 const cmt_string& path);
117private:
118 CmtSystem::cmt_string_vector& m_uses;
119};
120
121
122
123/**
124 * This PathScanner actor collects all packages clients of the specified one
125 * It is used by the cmt show clients operation
126 */
127class ClientCollector : public PathScanner::actor
128{
129public:
130 ClientCollector (const cmt_string& package,
131 const cmt_string& version);
132 void run (const cmt_string& package,
133 const cmt_string& version,
134 const cmt_string& path);
135 int count ();
136
137private:
138 const cmt_string& m_package;
139 const cmt_string& m_version;
140 int m_count;
141};
142
143
144//----------------------------------------------------------
145static int get_build_strategy ()
146{
147 Project* p = Project::get_current ();
148
149 int strategy = 0;
150
151 if (p == 0) strategy = Cmt::get_current_build_strategy ();
152 else strategy = p->get_build_strategy ();
153
154 return (strategy);
155}
156
157//----------------------------------------------------------
158static int get_setup_strategy ()
159{
160 Project* p = Project::get_current ();
161
162 int strategy = 0;
163
164 if (p == 0) strategy = Cmt::get_current_setup_strategy ();
165 else strategy = p->get_setup_strategy ();
166
167 return (strategy);
168}
169
170//----------------------------------------------------------
171void PackageViewer::run (const cmt_string& package,
172 const cmt_string& version,
173 const cmt_string& path)
174{
175 cout << package << " " << version << " " << path << endl;
176}
177
178//----------------------------------------------------------
179PackageSelector::PackageSelector (CmtSystem::cmt_string_vector& uses) : m_uses(uses)
180{
181}
182
183//----------------------------------------------------------
184void PackageSelector::run (const cmt_string& package,
185 const cmt_string& version,
186 const cmt_string& path)
187{
188 //
189 // this might be called on a package with no version directory.
190 // then simply the version argument is empty.
191 //
192
193 cmt_string r = CmtSystem::file_separator ();
194 r += "requirements";
195
196 cmt_string temp;
197
198 if (version == "")
199 {
200 temp = path;
201 //temp += CmtSystem::file_separator ();
202 //temp += package;
203 temp += CmtSystem::file_separator ();
204 temp += "cmt";
205 temp += r;
206
207 if (!CmtSystem::test_file (temp)) return;
208 }
209 else
210 {
211 temp = path;
212 //temp += CmtSystem::file_separator ();
213 //temp += package;
214 temp += CmtSystem::file_separator ();
215 temp += version;
216 temp += CmtSystem::file_separator ();
217 temp += "cmt";
218 temp += r;
219
220 if (!CmtSystem::test_file (temp))
221 {
222 temp = path;
223 //temp += CmtSystem::file_separator ();
224 //temp += package;
225 temp += CmtSystem::file_separator ();
226 temp += version;
227 temp += CmtSystem::file_separator ();
228 temp += "mgr";
229 temp += r;
230
231 if (!CmtSystem::test_file (temp))
232 {
233 return;
234 }
235 }
236 }
237
238 temp.replace (r.c_str(), "");
239 cmt_string& use = m_uses.add ();
240 use = temp;
241}
242
243//----------------------------------------------------------
244ClientCollector::ClientCollector (const cmt_string& package,
245 const cmt_string& version) :
246 m_package (package), m_version (version), m_count (0)
247{
248}
249
250//----------------------------------------------------------
251void ClientCollector::run (const cmt_string& package,
252 const cmt_string& version,
253 const cmt_string& path)
254{
255 cmt_string dir = path;
256 dir += CmtSystem::file_separator ();
257 dir += package;
258 dir += CmtSystem::file_separator ();
259 if (version != "")
260 {
261 dir += version;
262 dir += CmtSystem::file_separator ();
263 }
264
265 cmt_string req;
266
267 req = dir;
268 req += "cmt";
269 req += CmtSystem::file_separator ();
270 req += "requirements";
271
272 cmt_string requirements;
273 cmt_string line;
274 CmtSystem::cmt_string_vector words;
275
276 if (CmtSystem::test_file (req))
277 {
278 requirements.read (req);
279 }
280 else
281 {
282 req = dir;
283 req += "mgr";
284 req += CmtSystem::file_separator ();
285 req += "requirements";
286 if (CmtSystem::test_file (req))
287 {
288 requirements.read (req);
289 }
290 }
291
292 if (requirements != "")
293 {
294 int pos = 0;
295 int max_pos = requirements.size ();
296
297 while (pos < max_pos)
298 {
299 int cr = requirements.find (pos, "\r\n");
300 int nl = requirements.find (pos, '\n');
301 int first = nl;
302 int length = 1;
303
304 if (cr != cmt_string::npos)
305 {
306 if (nl == cmt_string::npos)
307 {
308 first = cr;
309 length = 2;
310 }
311 else
312 {
313 first = (nl < cr) ? nl : cr;
314 length = (nl < cr) ? 1 : 2;
315 }
316 }
317
318 if (first == cmt_string::npos)
319 {
320 requirements.substr (pos, line);
321 pos = max_pos;
322 }
323 else if (first > pos)
324 {
325 requirements.substr (pos, first - pos, line);
326 pos = first + length;
327 }
328 else
329 {
330 line.erase (0);
331 pos += length;
332 }
333
334 CmtSystem::split (line, " \t", words);
335
336 if ((words.size () > 2) && (words[0] == "use"))
337 {
338 if ((words[1] == m_package) &&
339 ((words[2] == m_version) || (m_version == "")))
340 {
341 cout << "# " << package << " " << version << " " << path;
342 if (m_version == "")
343 {
344 cout << " (use version " << words[2] << ")";
345 }
346 cout << endl;
347 m_count++;
348 }
349 }
350 }
351 }
352}
353
354//----------------------------------------------------------
355int ClientCollector::count ()
356{
357 return (m_count);
358}
359
360
361
362
363//----------------------------------------------------------
364//
365// The Cmt methods
366//
367//----------------------------------------------------------
368
369
370
371/**
372 * Append "CONFIG" to the prefix
373 */
374void Cmt::build_config (const cmt_string& prefix,
375 cmt_string& config)
376{
377 /*
378 Building the config from <prefix>
379 */
380
381 config = prefix;
382 config += "CONFIG";
383}
384
385//----------------------------------------------------------
386void Cmt::build_makefile (const cmt_string& target)
387{
388 Constituent* constituent = 0;
389
390 if (target.size () > 0)
391 {
392 /*
393 Do genmake for one specific target.
394 */
395 constituent = Constituent::find (target);
396 if (constituent != 0)
397 {
398 constituent->build_makefile (m_simulation);
399 }
400 }
401 else
402 {
403 /*
404 Do genmake for all possible targets.
405 */
406 Constituent::build_all_makefiles (m_simulation);
407 }
408}
409
410//----------------------------------------------------------
411void Cmt::build_msdev_file (const cmt_string& target)
412{
413 Constituent* constituent = 0;
414
415 set_standard_macros ();
416
417 if (target != "")
418 {
419 /*
420 Do genmsdev for one specific target.
421 */
422 constituent = Constituent::find (target);
423 if (constituent != 0)
424 {
425 constituent->build_msdev_file (m_simulation);
426 }
427 }
428 else
429 {
430 /*
431 Do genmsdev for all possible targets.
432 */
433 Constituent::build_all_msdev_files (m_simulation);
434 }
435}
436
437/**
438 Visual Studio.net Support
439*/
440void Cmt::build_vsnet_file (const cmt_string& target)
441{
442 Constituent* constituent = 0;
443
444 set_standard_macros ();
445
446 if (target != "")
447 {
448 /*
449 Do genvsnet for one specific target.
450 */
451 constituent = Constituent::find (target);
452 if (constituent != 0)
453 {
454 constituent->build_vsnet_file (m_simulation);
455 }
456 }
457 else
458 {
459 /*
460 Do genvsnet for all possible targets.
461 */
462 Constituent::build_all_vsnet_files (m_simulation);
463 }
464}
465
466//----------------------------------------------------------
467bool Cmt::build_nmake ()
468{
469 return (m_build_nmake);
470}
471
472//----------------------------------------------------------
473void Cmt::build_OS9_makefile (const cmt_string& target)
474{
475 build_makefile (target);
476}
477
478/**
479 * Convert a package name to its upper case copy
480 */
481void Cmt::build_prefix (const cmt_string& package, cmt_string& prefix)
482{
483 int pos;
484 char c;
485
486 /*
487 Building the prefix from <package>
488 */
489
490 prefix = package;
491
492 for (pos = 0; pos < package.size (); pos++)
493 {
494 c = package[pos];
495 prefix[pos] = toupper (c);
496 }
497}
498
499//----------------------------------------------------------
500void Cmt::clear ()
501{
502 m_action = action_none;
503 m_help_action = action_none;
504 m_build_nmake = false;
505 m_cmt_config = "";
506 //m_cmt_path.clear ();
507 //m_cmt_path_pwds.clear ();
508 //m_cmt_path_sources.clear ();
509 m_cmt_root = "";
510 m_cmt_version = "";
511 m_current_build_strategy = DefaultBuildStrategy;
512 m_current_setup_strategy = DefaultSetupStrategy;
513 m_current_dir = "";
514 m_current_package = "";
515 m_current_config = "";
516 m_current_path = "";
517 m_current_prefix = "";
518 m_current_cmtpath = "";
519 m_current_offset = "";
520
521 m_current_access = DeveloperMode;
522
523 m_current_tag = "";
524 m_current_target = "";
525 m_current_version = "";
526 m_default_path = "";
527 m_quiet = false;
528 m_recursive = false;
529
530 m_scope_filtering_mode = default_filtering_mode;
531 m_simulation = false;
532
533 m_standard_macros_done = false;
534
535 Database::clear ();
536 Include::clear_all ();
537 Script::clear_all ();
538 CmtError::clear ();
539}
540
541//----------------------------------------------------------
542void Cmt::configure ()
543{
544 static bool configured = false;
545
546 if (configured) return;
547
548 m_cmt_version = "";
549 m_current_dir = "";
550 m_current_package = "";
551 m_current_prefix = "";
552 m_current_config = "";
553 m_current_path = "";
554 m_current_cmtpath = "";
555 m_current_offset = "";
556
557 m_current_tag = "";
558 m_current_version = "";
559
560 m_configure_error = "";
561
562 m_debug = false;
563 if (getenv ("CMTDEBUG") != 0) m_debug = true;
564
565 m_default_path = "";
566
567 configure_default_path ();
568 configure_version_tag ();
569 configure_uname_tag ();
570 configure_hosttype_tag ();
571 configure_config_tag ();
572 configure_site_tag (0);
573 configure_home (0);
574 configure_current_dir ();
575 configure_current_package ();
576 configure_current_structuring_style ();
577
578 Use& use = Use::current();
579
580 use.set (m_current_package,
581 m_current_version,
582 m_current_path,
583 "",
584 "");
585
586 use.style = m_current_style;
587
588 use.change_path (m_current_path);
589
590 if (CmtError::has_pending_error ())
591 {
592 m_configure_error = CmtError::get_last_error ();
593 }
594}
595
596//----------------------------------------------------------
597void Cmt::configure_cmt_path (Use* use)
598{
599 cmt_string s;
600
601 Symbol* symbol = Symbol::find ("CMTPATH");
602 if (symbol != 0)
603 {
604 bool show_set_hidden = false;
605
606 if (Cmt::m_action == action_show_set)
607 {
608 show_set_hidden = true;
609 Cmt::m_action = action_none;
610 }
611
612 s = symbol->build_macro_value ();
613 Symbol::expand (s);
614
615 if (show_set_hidden)
616 {
617 show_set_hidden = false;
618 Cmt::m_action = action_show_set;
619 }
620 }
621
622 IProjectFactory& factory = ProjectFactory::instance ();
623 factory.reset ();
624
625 CmtSystem::get_cmt_paths (factory, s);
626 if (m_cmt_user_context != "") factory.create_project (m_cmt_user_context, "CMTUSERCONTEXT");
627 if (m_cmt_home != "") factory.create_project (m_cmt_home, "CMTHOME");
628}
629
630//----------------------------------------------------------
631void Cmt::configure_config_tag ()
632{
633 m_cmt_config = CmtSystem::get_cmt_config ();
634 if (m_cmt_config != "")
635 {
636 Tag* tag;
637
638 tag = Tag::add (m_cmt_config, PriorityConfig, "CMTCONFIG", 0);
639 tag->mark ();
640 }
641}
642
643//----------------------------------------------------------
644void Cmt::configure_current_cmtpath ()
645{
646 Use& current_use = Use::current ();
647
648 m_current_cmtpath = "";
649 m_current_offset = "";
650
651 m_current_cmtpath = Project::find_in_cmt_paths (current_use.path);
652
653 if (m_current_cmtpath != "")
654 {
655 static const cmt_string empty_string;
656 static const cmt_string fs = CmtSystem::file_separator ();
657
658 m_current_offset = current_use.path;
659
660 /**
661 try to remove this current CMTPATH entry from path. This
662 has a meaning when the specified path already contains an
663 absolute path.
664 */
665
666 m_current_offset.replace (m_current_cmtpath, empty_string);
667 if (m_current_offset[0] == CmtSystem::file_separator ())
668 {
669 // Just in case there is a part left after removing the cmtpath entry
670
671 m_current_offset.replace (fs, empty_string);
672 }
673 }
674}
675
676class CmtMountFilterParser : public FAwk
677{
678public:
679
680 CmtMountFilterParser ()
681 {
682 reset ();
683 }
684
685 void reset ()
686 {
687 m_current_dir = CmtSystem::pwd ();
688 m_done = false;
689 m_prefix = "";
690 }
691
692 bool is_done () const
693 {
694 return (m_done);
695 }
696
697 const cmt_string& get_current_dir () const
698 {
699 return (m_current_dir);
700 }
701
702 void set_prefix (const cmt_string& prefix)
703 {
704 m_prefix = prefix;
705 }
706
707 void filter (const cmt_string& line)
708 {
709 //cout << "line=" << line << endl;
710
711 if (m_done)
712 {
713 stop ();
714 return;
715 }
716
717 CmtSystem::cmt_string_vector words;
718
719 CmtSystem::split (line, " \t", words);
720
721 int requested = 2;
722
723 if (m_prefix != "")
724 {
725 requested++;
726 }
727
728 if (words.size () < requested) return;
729
730 int n = 0;
731
732 if (m_prefix != "")
733 {
734 if (words[n] != m_prefix) return;
735 n++;
736 }
737
738 cmt_string& path_name = words[n];
739 cmt_string& replacement = words[n+1];
740
741 if (m_current_dir.find (path_name) != cmt_string::npos)
742 {
743 m_current_dir.replace (path_name, replacement);
744 m_done = true;
745 stop ();
746 }
747 }
748
749private:
750 bool m_done;
751 cmt_string m_prefix;
752 cmt_string m_current_dir;
753};
754
755//----------------------------------------------------------
756void Cmt::configure_current_dir ()
757{
758 cmt_string file_name;
759
760 /*
761 Building current_dir :
762
763 o we first get the physical value (using getwd)
764 o then this value is possibly filtered using the
765 cmt_mount_filter file.
766 */
767
768 CmtMountFilterParser mount_filter;
769
770 /**
771 First try with ${CMTROOT}/mgr/cmt_mount_filter
772 with no prefix on lines
773 */
774
775 file_name = m_default_path;
776 if (file_name != "")
777 {
778 file_name += CmtSystem::file_separator ();
779 file_name += "CMT";
780 file_name += CmtSystem::file_separator ();
781 file_name += m_cmt_version;
782 file_name += CmtSystem::file_separator ();
783 file_name += "mgr";
784 file_name += CmtSystem::file_separator ();
785 }
786
787 file_name += "cmt_mount_filter";
788
789 mount_filter.run (file_name);
790
791 /**
792 Now try with .cmtrc
793 with "mount_filter" keyword
794 */
795
796 mount_filter.set_prefix ("mount_filter");
797
798 mount_filter.run (".cmtrc");
799
800 /**
801 Now try with ${HOME}/.cmtrc
802 with "mount_filter" keyword
803 */
804
805 if (CmtSystem::get_home_directory (file_name))
806 {
807 file_name += CmtSystem::file_separator ();
808 file_name += ".cmtrc";
809 mount_filter.run (file_name);
810 }
811
812 m_current_dir = mount_filter.get_current_dir ();
813}
814
815//----------------------------------------------------------
816void Cmt::configure_current_package ()
817{
818 /*
819 Build current_package and current_prefix.
820
821 This is only possible if we are within the cmt/mgr branch of a
822 standard directory tree (i.e. <package>/<version>/cmt or mgr)
823 */
824
825 cmt_string req = "..";
826 req += CmtSystem::file_separator ();
827 req += "cmt";
828 req += CmtSystem::file_separator ();
829 req += "requirements";
830
831 if (CmtSystem::test_file (req))
832 {
833 m_current_style = cmt_style;
834 }
835 else
836 {
837 cmt_string req = "..";
838 req += CmtSystem::file_separator ();
839 req += "mgr";
840 req += CmtSystem::file_separator ();
841 req += "requirements";
842
843 if (CmtSystem::test_file (req))
844 {
845 m_current_style = mgr_style;
846 }
847 else
848 {
849 // This package is probably a standalone one
850 m_current_style = none_style;
851 }
852 }
853
854
855 if (m_current_style != none_style)
856 {
857 //
858 // Here there is a ../cmt or ../mgr branch in front of us
859 // and there is a requirements file there
860 //
861
862 cmt_string up_dir;
863 cmt_string up_branch;
864
865 CmtSystem::dirname (m_current_dir, up_dir);
866 CmtSystem::basename (up_dir, up_branch);
867
868 cmt_string version_file = "..";
869 version_file += CmtSystem::file_separator ();
870 version_file += "cmt";
871 version_file += CmtSystem::file_separator ();
872 version_file += "version.cmt";
873
874 if (CmtSystem::test_file (version_file))
875 {
876 //
877 // There is an explicit version descriptor. This one takes precedence
878 // and forces the structuring style to no directory
879 //
880
881 m_current_package = up_branch;
882 CmtSystem::dirname (up_dir, m_current_path);
883
884 if (m_current_version.read (version_file))
885 {
886 int pos;
887
888 pos = m_current_version.find ('\n');
889 if (pos != cmt_string::npos) m_current_version.erase (pos);
890 pos = m_current_version.find ('\r');
891 if (pos != cmt_string::npos) m_current_version.erase (pos);
892 }
893 else
894 {
895 m_current_version = "v*";
896 }
897
898 if (m_debug)
899 {
900 cout << "Cmt::configure_current_package>" << endl
901 << " m_current_package " << m_current_package << endl
902 << " m_current_version " << m_current_version << endl
903 << " m_current_dir " << m_current_dir << endl
904 << " pwd " << CmtSystem::pwd ()
905 << endl;
906 }
907
908 m_current_style = no_version_style;
909 }
910 else if (CmtSystem::is_version_directory (up_branch))
911 {
912 // The up branch IS a version directory.
913
914 m_current_version = up_branch;
915 CmtSystem::dirname (up_dir, up_dir);
916 CmtSystem::basename (up_dir, m_current_package);
917 CmtSystem::dirname (up_dir, m_current_path);
918 }
919 else
920 {
921 // No version descriptor
922 // No version directory. The version is defaulted to v*
923
924 CmtSystem::basename (up_dir, m_current_package);
925 m_current_version = "v*";
926 CmtSystem::dirname (up_dir, m_current_path);
927
928 m_current_style = no_version_style;
929 }
930
931 build_prefix (m_current_package, m_current_prefix);
932 build_config (m_current_prefix, m_current_config);
933 }
934 else
935 {
936 m_current_package = "cmt_standalone";
937 m_current_version = "";
938 m_current_path = m_current_dir;
939 build_prefix (m_current_package, m_current_prefix);
940 build_config (m_current_prefix, m_current_config);
941 m_current_style = none_style;
942 }
943
944 //cout << "configure_current_package> current style=" << m_current_style << endl;
945}
946
947//----------------------------------------------------------
948void Cmt::configure_current_structuring_style ()
949{
950 cmt_string s;
951
952 s = CmtSystem::getenv ("CMTSTRUCTURINGSTYLE");
953 if (s == "without_version_directory")
954 {
955 m_current_structuring_style = without_version_directory;
956 }
957}
958
959//----------------------------------------------------------
960void Cmt::configure_default_path ()
961{
962 m_default_path = CmtSystem::get_cmt_root ();
963 CmtSystem::get_cmt_version (m_cmt_version);
964 m_cmt_root = m_default_path;
965 m_cmt_root += CmtSystem::file_separator ();
966 m_cmt_root += "CMT";
967 m_cmt_root += CmtSystem::file_separator ();
968 m_cmt_root += m_cmt_version;
969}
970
971//----------------------------------------------------------
972void Cmt::configure_home (Use* use)
973{
974 m_cmt_home = "";
975
976 Symbol* symbol = Symbol::find ("CMTHOME");
977 if (symbol != 0)
978 {
979 m_cmt_home = symbol->build_macro_value ();
980 Symbol::expand (m_cmt_home);
981 }
982 else if (CmtSystem::testenv ("CMTHOME"))
983 {
984 m_cmt_home = CmtSystem::getenv ("CMTHOME");
985 }
986
987 if ((m_cmt_home != "") && !CmtSystem::test_directory (m_cmt_home))
988 {
989 m_cmt_home = "";
990 }
991
992 configure_user_context (0);
993}
994
995//----------------------------------------------------------
996void Cmt::configure_user_context (Use* use)
997{
998 m_cmt_user_context = "";
999
1000 Symbol* symbol = Symbol::find ("CMTUSERCONTEXT");
1001 if (symbol != 0)
1002 {
1003 m_cmt_user_context = symbol->build_macro_value ();
1004 Symbol::expand (m_cmt_user_context);
1005 }
1006 else if (CmtSystem::testenv ("CMTUSERCONTEXT"))
1007 {
1008 m_cmt_user_context = CmtSystem::getenv ("CMTUSERCONTEXT");
1009 }
1010
1011 if ((m_cmt_user_context != "") && !CmtSystem::test_directory (m_cmt_user_context))
1012 {
1013 m_cmt_user_context = "";
1014 }
1015
1016 if (m_debug) cout << "configure_user_context> user_context=" << m_cmt_user_context << endl;
1017
1018 configure_cmt_path (0);
1019}
1020
1021//----------------------------------------------------------
1022void Cmt::configure_hosttype_tag ()
1023{
1024 cmt_string hosttype;
1025
1026 CmtSystem::get_hosttype (hosttype);
1027
1028 if (hosttype != "")
1029 {
1030 Tag* tag;
1031
1032 tag = Tag::add (hosttype, PriorityUname, "HOSTTYPE", 0);
1033 tag->mark ();
1034 }
1035}
1036
1037//----------------------------------------------------------
1038void Cmt::configure_site_tag (Use* use)
1039{
1040 Symbol* symbol = Symbol::find ("CMTSITE");
1041 if (symbol != 0)
1042 {
1043 m_cmt_site = symbol->build_macro_value ();
1044 Symbol::expand (m_cmt_site);
1045 }
1046 else
1047 {
1048 m_cmt_site = CmtSystem::get_cmt_site ();
1049 }
1050
1051 if (m_cmt_site != "")
1052 {
1053 cmt_string s = "CMTSITE";
1054
1055 if (use != 0)
1056 {
1057 s += " in ";
1058 }
1059
1060 Tag* tag;
1061
1062 tag = Tag::add (m_cmt_site, PrioritySite, s, use);
1063 tag->mark ();
1064 }
1065}
1066
1067//----------------------------------------------------------
1068void Cmt::restore_all_tags (Use* use)
1069{
1070 //cerr << "restore_all_tags" << endl;
1071
1072 Cmt::configure_tags (use);
1073
1074 /*
1075 Then get existing extra tags
1076 */
1077
1078 if (CmtSystem::testenv ("CMTEXTRATAGS"))
1079 {
1080 cmt_string s = "CMTEXTRATAGS";
1081
1082 if (use != 0)
1083 {
1084 s += " in ";
1085 }
1086
1087 Tag* tag;
1088 CmtSystem::cmt_string_vector words;
1089
1090 cmt_string tags = CmtSystem::getenv ("CMTEXTRATAGS");
1091
1092 CmtSystem::split (tags, " \t,", words);
1093
1094 Cmt::m_extra_tags = ",";
1095
1096 for (int i = 0; i < words.size (); i++)
1097 {
1098 const cmt_string& a = words[i];
1099
1100 Cmt::m_extra_tags += a;
1101 Cmt::m_extra_tags += ",";
1102
1103 tag = Tag::add (a, PriorityUserTag, s, use);
1104
1105 tag->mark ();
1106 }
1107 }
1108}
1109
1110//----------------------------------------------------------
1111void Cmt::configure_tags (Use* use)
1112{
1113 cmt_string config_tag;
1114
1115 Log;
1116
1117 //if (m_debug) cout << "configure_tags0> current_tag=" << m_current_tag << endl;
1118
1119 log << "current_tag=" << m_current_tag << log_endl;
1120
1121 Symbol* symbol = Symbol::find ("CMTCONFIG");
1122 if (symbol != 0)
1123 {
1124 bool show_set_hidden = false;
1125
1126 if (Cmt::m_action == action_show_set)
1127 {
1128 show_set_hidden = true;
1129 Cmt::m_action = action_none;
1130 }
1131
1132 config_tag = symbol->build_macro_value ();
1133 Symbol::expand (config_tag);
1134
1135 if (show_set_hidden)
1136 {
1137 show_set_hidden = false;
1138 Cmt::m_action = action_show_set;
1139 }
1140 }
1141 else if (CmtSystem::testenv ("CMTCONFIG"))
1142 {
1143 config_tag = CmtSystem::getenv ("CMTCONFIG");
1144 }
1145 else if (CmtSystem::testenv ("CMTBIN"))
1146 {
1147 config_tag = CmtSystem::getenv ("CMTBIN");
1148 }
1149
1150 if (config_tag == "")
1151 {
1152 CmtSystem::get_uname (config_tag);
1153 }
1154
1155 //if (m_debug) cout << "configure_tags> current_tag=" << m_current_tag << endl;
1156 log << "current_tag=" << m_current_tag << log_endl;
1157
1158 cmt_string s = "CMTCONFIG";
1159
1160 if (use != 0)
1161 {
1162 s += " in ";
1163 }
1164
1165 Tag* tag;
1166
1167 tag = Tag::add (config_tag, PriorityConfig, s, use);
1168 tag->mark ();
1169
1170 //m_current_tag = config_tag;
1171}
1172
1173//----------------------------------------------------------
1174void Cmt::configure_uname_tag ()
1175{
1176 cmt_string uname;
1177
1178 CmtSystem::get_uname (uname);
1179
1180 if (uname != "")
1181 {
1182 Tag* tag;
1183
1184 tag = Tag::add (uname, PriorityUname, "uname", 0);
1185 tag->mark ();
1186 }
1187}
1188
1189//----------------------------------------------------------
1190void Cmt::configure_version_tag ()
1191{
1192 int v = 0;
1193 int r = 0;
1194 int p = 0;
1195
1196 CmtSystem::is_version_directory (CMTVERSION, v, r, p);
1197
1198 Tag* tag;
1199
1200 static char temp[80];
1201
1202 sprintf (temp, "CMTv%d", v);
1203
1204 tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
1205 tag->mark ();
1206
1207 sprintf (temp, "CMTr%d", r);
1208
1209 tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
1210 tag->mark ();
1211
1212 sprintf (temp, "CMTp%d", p);
1213
1214 tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
1215 tag->mark ();
1216
1217}
1218
1219//----------------------------------------------------------
1220//
1221// Actions
1222//
1223//----------------------------------------------------------
1224
1225class AwkActor : public Awk
1226{
1227public:
1228
1229 void filter (const cmt_string& line)
1230 {
1231 cout << line << endl;
1232 }
1233};
1234
1235//----------------------------------------------------------
1236void Cmt::do_awk (const CmtSystem::cmt_string_vector& arguments)
1237{
1238 if (arguments.size () < 1)
1239 {
1240 cerr << "#CMT> cmt awk <file> <pattern>" << endl;
1241 return;
1242 }
1243
1244 const cmt_string& file = arguments[0];
1245 const cmt_string& pattern = arguments[1];
1246 cmt_string text;
1247
1248 text.read (file);
1249
1250 static AwkActor a;
1251
1252 cmt_regexp exp (pattern);
1253
1254 a.run (text, exp);
1255}
1256
1257//----------------------------------------------------------
1258void Cmt::do_broadcast (const CmtSystem::cmt_string_vector& arguments,
1259 int argc,
1260 char* argv[])
1261{
1262 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
1263
1264 CmtSystem::cmt_string_vector uses;
1265 CmtSystem::cmt_string_vector packages;
1266 CmtSystem::cmt_string_vector versions;
1267 CmtSystem::cmt_string_vector path_selections;
1268 CmtSystem::cmt_string_vector selections;
1269 CmtSystem::cmt_string_vector exclusions;
1270 cmt_string begin;
1271 cmt_string command;
1272 bool is_cmt = false;
1273 int first = 0;
1274 int i;
1275 bool ignore_errors = false;
1276 bool all_packages = false;
1277
1278 bool local = true;
1279
1280 for (i = 0; i < arguments.size (); i++)
1281 {
1282 const cmt_string& w = arguments[i];
1283
1284 if (command == "")
1285 {
1286 if (w.substr (0, 13) == "-all_packages")
1287 {
1288 local = false;
1289 all_packages = true;
1290 }
1291 else if (w.substr (0, 7) == "-depth=")
1292 {
1293 local = false;
1294
1295 cmt_string depth_str;
1296 int depth_value = 0;
1297
1298 w.substr (7, depth_str);
1299 if ((sscanf (depth_str.c_str (), "%d", &depth_value) < 1) ||
1300 (depth_value < 1))
1301 {
1302 // Syntax error
1303 // We shall restrict to packages found within
1304 // the <depth_value> first elements of CMTPATH.
1305 // If CMTPATH is empty, nothing is selected.
1306 // depth=1 is equivalent to local
1307 }
1308
1309 Project::fill_selection (depth_value, path_selections);
1310 }
1311 else if (w.substr (0, 9) == "-exclude=")
1312 {
1313 cmt_string exclusion;
1314
1315 w.substr (9, exclusion);
1316
1317 int size = exclusion.size ();
1318
1319 if (size >= 2)
1320 {
1321 if (((exclusion[0] == '"') && (exclusion[size - 1] == '"')) ||
1322 ((exclusion[0] == '\'') && (exclusion[size - 1] == '\'')))
1323 {
1324 exclusion.erase (size - 1);
1325 exclusion.erase (0, 1);
1326 }
1327
1328 CmtSystem::split (exclusion, " \t", exclusions);
1329 }
1330 }
1331 else if (w.substr (0, 7) == "-global")
1332 {
1333 path_selections.clear ();
1334
1335 local = false;
1336 }
1337 else if (w.substr (0, 6) == "-local")
1338 {
1339 local = true;
1340 }
1341 else if (w.substr (0, 8) == "-select=")
1342 {
1343 cmt_string selection;
1344
1345 w.substr (8, selection);
1346
1347 int size = selection.size ();
1348
1349 if (size >= 2)
1350 {
1351 if (((selection[0] == '"') && (selection[size - 1] == '"')) ||
1352 ((selection[0] == '\'') && (selection[size - 1] == '\'')))
1353 {
1354 selection.erase (size - 1);
1355 selection.erase (0, 1);
1356 }
1357
1358 CmtSystem::split (selection, " \t", selections);
1359 }
1360 }
1361 else if (w.substr (0, 7) == "-begin=")
1362 {
1363 w.substr (7, begin);
1364 }
1365 else
1366 {
1367 command = w;
1368 }
1369 }
1370 else
1371 {
1372 command += " ";
1373 command += w;
1374 }
1375
1376 }
1377
1378 if (local)
1379 {
1380 Project::fill_selection (1, path_selections);
1381 }
1382
1383 if (command[0] == '-')
1384 {
1385 ignore_errors = true;
1386 command.erase (0, 1);
1387 }
1388
1389 //if (command.substr (0, 3) == "cmt") is_cmt = true;
1390
1391 if (all_packages)
1392 {
1393 PackageSelector selector (uses);
1394 PathScanner scanner;
1395 Project::scan_paths (scanner, selector);
1396 }
1397 else
1398 {
1399 for (i = Uses.size () - 1; i >= 0; i--)
1400 {
1401 Use* use = Uses[i];
1402
1403 if (use->discarded) continue;
1404
1405 if (!use->located ())
1406 {
1407 if (!Cmt::m_quiet)
1408 {
1409 cerr << "#CMT> package " << use->get_package_name () <<
1410 " " << use->version << " " << use->path <<
1411 " not found" <<
1412 endl;
1413 }
1414 }
1415 else
1416 {
1417 if (use->get_package_name () != "CMT")
1418 {
1419 cmt_string& s = uses.add ();
1420
1421 use->get_full_path (s);
1422
1423 s += CmtSystem::file_separator ();
1424 if (use->style == mgr_style) s += "mgr";
1425 else s += "cmt";
1426
1427 cmt_string& v = versions.add ();
1428 v = use->version;
1429
1430 cmt_string& p = packages.add ();
1431 p = use->get_package_name ();
1432
1433 //cout << ">>> adding " << s << " to selection" << endl;
1434 }
1435 }
1436 }
1437
1438 {
1439 cmt_string& s = uses.add ();
1440
1441 Use* use = &(Use::current ());
1442
1443 if (use->get_package_name ().find ("cmt_standalone") != cmt_string::npos)
1444 {
1445 s = CmtSystem::pwd ();
1446 }
1447 else
1448 {
1449 use->get_full_path (s);
1450
1451 s += CmtSystem::file_separator ();
1452
1453 if (use->style == mgr_style) s += "mgr";
1454 else s += "cmt";
1455 }
1456
1457 cmt_string& v = versions.add ();
1458 v = use->version;
1459
1460 cmt_string& p = packages.add ();
1461 p = use->get_package_name ();
1462
1463 //cout << ">>> adding current " << s << " to selection" << endl;
1464 }
1465 }
1466
1467 bool started = false;
1468
1469 if (begin == "") started = true;
1470
1471 Symbol::all_set ();
1472
1473 for (i = 0; i < uses.size (); i++)
1474 {
1475 const cmt_string& s = uses[i];
1476 const cmt_string& v = versions[i];
1477 const cmt_string& p = packages[i];
1478 cmt_string cmtpath;
1479
1480 bool ok = true;
1481 bool selected = true;
1482 bool excluded = false;
1483
1484 if (path_selections.size () > 0)
1485 {
1486 selected = false;
1487
1488 for (int j = 0; j < path_selections.size (); j++)
1489 {
1490 const cmt_string& sel = path_selections[j];
1491
1492 if (s.find (sel) != cmt_string::npos)
1493 {
1494 cmtpath = sel;
1495 selected = true;
1496 break;
1497 }
1498 }
1499
1500 ok = selected;
1501 }
1502
1503 if (ok)
1504 {
1505 if (selections.size () > 0)
1506 {
1507 selected = false;
1508
1509 for (int j = 0; j < selections.size (); j++)
1510 {
1511 const cmt_string& sel = selections[j];
1512
1513 if (s.find (sel) != cmt_string::npos)
1514 {
1515 selected = true;
1516 break;
1517 }
1518 }
1519
1520 ok = selected;
1521 }
1522 }
1523
1524 if (ok && !started)
1525 {
1526 if (s.find (begin) != cmt_string::npos)
1527 {
1528 started = true;
1529 ok = true;
1530 }
1531 else
1532 {
1533 ok = false;
1534 }
1535 }
1536
1537
1538 if (ok)
1539 {
1540 excluded = false;
1541
1542 for (int j = 0; j < exclusions.size (); j++)
1543 {
1544 const cmt_string& exc = exclusions[j];
1545
1546 if (s.find (exc) != cmt_string::npos)
1547 {
1548 excluded = true;
1549 break;
1550 }
1551 }
1552
1553 if (excluded) ok = false;
1554 }
1555
1556 if (!ok)
1557 {
1558 continue;
1559 }
1560
1561
1562
1563 if (!CmtSystem::cd (s))
1564 {
1565 if (s.find ("cmt_standalone") != cmt_string::npos)
1566 {
1567 cerr << "#CMT> Currently not in a CMT package" << endl;
1568 }
1569 else
1570 {
1571 cerr << "#CMT> Cannot move to the package in " << s << " (" << i+1 << "/"
1572 << uses.size () << ")"<< endl;
1573 }
1574
1575 if (!ignore_errors) break;
1576
1577 continue;
1578 }
1579
1580 if (CmtLock::check () == CmtLock::locked_by_another_user)
1581 {
1582 cerr << "#CMT> Ignore locked package in " << s << " (" << i+1 << "/"
1583 << uses.size () << ")" << endl;
1584 continue;
1585 }
1586
1587 if (cmtpath == "")
1588 {
1589 cmt_string sel = CmtSystem::pwd ();
1590 cmtpath = Project::find_in_cmt_paths (sel);
1591 }
1592
1593 cmt_string cmd = command;
1594 static const cmt_string version_template = "<version>";
1595 cmd.replace_all (version_template, v);
1596
1597 static const cmt_string package_template = "<package>";
1598 cmd.replace_all (package_template, p);
1599
1600 static const cmt_string cmtpath_template = "<package_cmtpath>";
1601 cmd.replace_all (cmtpath_template, cmtpath);
1602
1603 static const cmt_string offset_template = "<package_offset>";
1604
1605 static const cmt_string empty_string;
1606 static const cmt_string fs = CmtSystem::file_separator ();
1607 cmt_string offset = s;
1608 offset.replace (cmtpath, empty_string);
1609 if (offset[0] == CmtSystem::file_separator ())
1610 {
1611 offset.replace (fs, empty_string);
1612 }
1613 CmtSystem::dirname (offset, offset);
1614
1615 cmt_string n;
1616 CmtSystem::basename (offset, n);
1617 if (n == p)
1618 {
1619 CmtSystem::dirname (offset, offset);
1620 }
1621 else
1622 {
1623 CmtSystem::dirname (offset, offset);
1624 CmtSystem::dirname (offset, offset);
1625 }
1626
1627 cmd.replace_all (offset_template, offset);
1628
1629
1630 cout << "#--------------------------------------------------------------" << endl;
1631 cout << "# Now trying [" << cmd << "] in " << s << " (" << i+1 << "/" << uses.size ()
1632 << ")" << endl;
1633 cout << "#--------------------------------------------------------------" << endl;
1634
1635 if (is_cmt)
1636 {
1637 //
1638 // There is a bug in the recursive use of the parser. Macros are not set correctly.
1639 // Thus the recursive optimization is now discarded.
1640 //
1641 if (parser (cmd) != 0)
1642 {
1643 CmtError::set (CmtError::execution_error, cmd);
1644 break;
1645 }
1646 }
1647 else
1648 {
1649 int status = CmtSystem::execute (cmd);
1650
1651 //cerr << "do_broadcast> status=" << status << " ignore_errors=" << ignore_errors << endl;
1652
1653 if ((status != 0) && !ignore_errors)
1654 //if ((status != 0) && !ignore_errors)
1655 {
1656 if (status != 2) CmtError::set (CmtError::execution_error, cmd);
1657 break;
1658 }
1659 }
1660 }
1661}
1662
1663//----------------------------------------------------------
1664void Cmt::do_build_constituent_makefile (const CmtSystem::cmt_string_vector& arguments,
1665 int argc,
1666 char* argv[])
1667{
1668 if (CmtLock::check () == CmtLock::locked_by_another_user)
1669 {
1670 CmtError::set (CmtError::conflicting_lock, "build_constituent_makefile>");
1671 return;
1672 }
1673 if (arguments.size () > 0)
1674 {
1675 set_standard_macros ();
1676 Generator::build_constituent_makefile (arguments[0]);
1677 }
1678}
1679
1680//----------------------------------------------------------
1681void Cmt::do_build_constituents_makefile (const CmtSystem::cmt_string_vector& arguments,
1682 int argc,
1683 char* argv[])
1684{
1685 if (CmtLock::check () == CmtLock::locked_by_another_user)
1686 {
1687 CmtError::set (CmtError::conflicting_lock, "build_constituents_makefile>");
1688 return;
1689 }
1690 set_standard_macros ();
1691
1692 Generator::build_constituents_makefile (m_current_package, arguments);
1693}
1694
1695//----------------------------------------------------------
1696void Cmt::do_build_dependencies (const CmtSystem::cmt_string_vector& arguments,
1697 int argc,
1698 char* argv[])
1699{
1700 if (CmtLock::check () == CmtLock::locked_by_another_user)
1701 {
1702 CmtError::set (CmtError::conflicting_lock, "build_dependencies>");
1703 return;
1704 }
1705 if (arguments.size () > 0)
1706 {
1707 set_standard_macros ();
1708
1709 while (argc > 0)
1710 {
1711 if (strcmp (argv[0], "dependencies") != 0)
1712 {
1713 argc--;
1714 argv++;
1715 }
1716 else
1717 {
1718 argc--;
1719 argv++;
1720 argc--;
1721 argv++;
1722
1723 Generator::build_dependencies (arguments[0], argc, argv);
1724
1725 break;
1726 }
1727 }
1728 }
1729}
1730
1731//----------------------------------------------------------
1732void Cmt::do_build_library_links ()
1733{
1734 cmt_string cmtinstallarea = "";
1735 cmt_string tag = "";
1736 cmt_string shlibsuffix;
1737 cmt_string symlinkcmd;
1738
1739 if (CmtLock::check () == CmtLock::locked_by_another_user)
1740 {
1741 CmtError::set (CmtError::conflicting_lock, "build_library_links>");
1742 return;
1743 }
1744
1745 set_standard_macros ();
1746
1747 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
1748 Use& current_use = Use::current ();
1749 int i;
1750
1751 {
1752 Symbol* macro = Symbol::find ("shlibsuffix");
1753 if (macro == 0) return;
1754 shlibsuffix = macro->build_macro_value ();
1755 Symbol::expand (shlibsuffix);
1756 }
1757
1758 {
1759 Symbol* macro = Symbol::find ("cmt_symlink_command");
1760 if (macro != 0)
1761 {
1762 symlinkcmd = macro->build_macro_value ();
1763 Symbol::expand (symlinkcmd);
1764 }
1765 }
1766
1767 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
1768 {
1769 const CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
1770
1771 //cout << "#IA2>" << endl;
1772
1773 cmt_string s1 = ia_mgr.get_installarea ();
1774
1775 {
1776 Symbol* symbol = Symbol::find ("CMTINSTALLAREA");
1777 if (symbol != 0)
1778 {
1779 s1 = symbol->build_macro_value ();
1780 Symbol::expand (s1);
1781 }
1782 }
1783
1784 cmtinstallarea = s1;
1785
1786 cmt_string s2;
1787
1788 {
1789 Symbol* macro = Symbol::find ("tag");
1790 if (macro != 0)
1791 {
1792 s2 = macro->build_macro_value ();
1793 Symbol::expand (s2);
1794 }
1795 }
1796
1797 tag = s2;
1798
1799 cmt_string s = s1;
1800 s += CmtSystem::file_separator ();
1801 s += s2;
1802 s += CmtSystem::file_separator ();
1803 s += "lib";
1804
1805 CmtSystem::mkdir (s);
1806 }
1807
1808 current_use.build_library_links (cmtinstallarea, tag, shlibsuffix, symlinkcmd);
1809
1810 for (i = 0; i < Uses.size (); i++)
1811 {
1812 Use* use = Uses[i];
1813
1814 if (use == 0) continue;
1815 if (use->discarded) continue;
1816
1817 if (use->get_package_name () == "CMT") continue;
1818 if (use->get_package_name () == current_use.get_package_name ()) continue;
1819
1820 use->build_library_links (cmtinstallarea, tag, shlibsuffix, symlinkcmd);
1821 }
1822}
1823
1824//----------------------------------------------------------
1825void Cmt::do_build_make_setup ()
1826{
1827 if (CmtLock::check () == CmtLock::locked_by_another_user)
1828 {
1829 CmtError::set (CmtError::conflicting_lock, "build_make_setup>");
1830 return;
1831 }
1832 set_standard_macros ();
1833 Generator::build_make_setup (m_current_package);
1834}
1835
1836//----------------------------------------------------------
1837void Cmt::do_build_msdev (const CmtSystem::cmt_string_vector& arguments)
1838{
1839 if (CmtLock::check () == CmtLock::locked_by_another_user)
1840 {
1841 CmtError::set (CmtError::conflicting_lock, "build_msdev>");
1842 return;
1843 }
1844
1845 if (true)
1846 {
1847 set_standard_macros ();
1848 if (arguments.size () > 0) build_msdev_file (arguments[0]);
1849 else build_msdev_file ("");
1850 }
1851}
1852
1853void Cmt::do_build_CMT_pacman ()
1854{
1855 cmt_string pacman_file;
1856
1857 pacman_file = m_cmt_root;
1858 pacman_file += CmtSystem::file_separator ();
1859 pacman_file += "mgr";
1860 pacman_file += CmtSystem::file_separator ();
1861 pacman_file += "CMT.pacman";
1862
1863 cmt_string pacman;
1864 cmt_string pattern = "<version>";
1865 cmt_string replacement = CMTVERSION;
1866
1867 pacman.read (pacman_file);
1868
1869 pacman.replace_all (pattern, replacement);
1870
1871 cout << pacman << endl;
1872}
1873
1874// Visual Studio.net Support
1875//----------------------------------------------------------
1876void Cmt::do_build_vsnet (const CmtSystem::cmt_string_vector& arguments)
1877{
1878 if (CmtLock::check () == CmtLock::locked_by_another_user)
1879 {
1880 CmtError::set (CmtError::conflicting_lock, "build_vsnet>");
1881 return;
1882 }
1883
1884 if (true)
1885 {
1886 set_standard_macros ();
1887 if (arguments.size () > 0) build_vsnet_file (arguments[0]);
1888 else build_vsnet_file ("");
1889 }
1890}
1891
1892//----------------------------------------------------------
1893void Cmt::do_build_os9_makefile (const CmtSystem::cmt_string_vector& arguments)
1894{
1895 if (CmtLock::check () == CmtLock::locked_by_another_user)
1896 {
1897 CmtError::set (CmtError::conflicting_lock, "build_os9_makefile>");
1898 return;
1899 }
1900
1901 if (arguments.size () > 0)
1902 {
1903 set_standard_macros ();
1904 build_OS9_makefile (arguments[0]);
1905 }
1906}
1907
1908//----------------------------------------------------------
1909void Cmt::do_build_prototype (const CmtSystem::cmt_string_vector& arguments)
1910{
1911 if (CmtLock::check () == CmtLock::locked_by_another_user)
1912 {
1913 CmtError::set (CmtError::conflicting_lock, "build_prototype>");
1914 return;
1915 }
1916
1917 if (arguments.size () > 0)
1918 {
1919 set_standard_macros ();
1920 Generator::build_prototype (arguments[0]);
1921 }
1922}
1923
1924//----------------------------------------------------------
1925void Cmt::do_build_readme (const CmtSystem::cmt_string_vector& arguments)
1926{
1927 if (CmtLock::check () == CmtLock::locked_by_another_user)
1928 {
1929 CmtError::set (CmtError::conflicting_lock, "build_readme>");
1930 return;
1931 }
1932
1933 set_standard_macros ();
1934 Generator::build_readme (arguments);
1935}
1936
1937//----------------------------------------------------------
1938void Cmt::do_build_tag_makefile ()
1939{
1940 if (CmtLock::check () == CmtLock::locked_by_another_user)
1941 {
1942 CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>");
1943 return;
1944 }
1945
1946 print_macros (Make);
1947}
1948
1949//----------------------------------------------------------
1950void Cmt::do_build_temporary_name ()
1951{
1952 cmt_string name = CmtSystem::get_temporary_name ();
1953 cout << name << endl;
1954}
1955
1956//----------------------------------------------------------
1957void Cmt::do_build_triggers (const CmtSystem::cmt_string_vector& arguments)
1958{
1959 if (CmtLock::check () == CmtLock::locked_by_another_user)
1960 {
1961 CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>");
1962 return;
1963 }
1964
1965 if (arguments.size () > 0)
1966 {
1967 set_standard_macros ();
1968 TriggerGenerator::run (arguments[0]);
1969 }
1970}
1971
1972//----------------------------------------------------------
1973void Cmt::do_build_windefs (const CmtSystem::cmt_string_vector& arguments)
1974{
1975 if (CmtLock::check () == CmtLock::locked_by_another_user)
1976 {
1977 CmtError::set (CmtError::conflicting_lock, "build_windefs>");
1978 return;
1979 }
1980
1981 if (arguments.size () > 0)
1982 {
1983 set_standard_macros ();
1984 Generator::build_windefs (arguments[0]);
1985 }
1986}
1987
1988//----------------------------------------------------------
1989void Cmt::do_check_configuration ()
1990{
1991}
1992
1993//----------------------------------------------------------
1994void Cmt::do_check_files (const CmtSystem::cmt_string_vector& arguments)
1995{
1996 if (arguments.size () >= 2)
1997 {
1998 cmt_string first_file = arguments[0];
1999 cmt_string second_file = arguments[1];
2000
2001 if (first_file == "") return;
2002 if (second_file == "") return;
2003
2004 CmtSystem::compare_and_update_files (first_file, second_file);
2005 }
2006}
2007
2008//----------------------------------------------------------
2009void Cmt::do_check_version (const CmtSystem::cmt_string_vector& arguments)
2010{
2011 if (arguments.size () > 0)
2012 {
2013 cmt_string name = arguments[0];
2014
2015 if (name == "") return;
2016 int v = 0;
2017 int r = 0;
2018 int p = 0;
2019
2020 bool ok = CmtSystem::is_version_directory (name, v, r, p);
2021
2022 if (ok)
2023 {
2024 cout << "# " << name << " is version " << v << " release " << r << " patch " << p << endl;
2025 }
2026 else
2027 {
2028 cout << "# " << name << " is not a version tag" << endl;
2029 }
2030 }
2031}
2032
2033//----------------------------------------------------------
2034void Cmt::do_checkout (const CmtSystem::cmt_string_vector& arguments)
2035{
2036 Cvs::checkout (arguments);
2037}
2038
2039//----------------------------------------------------------
2040void Cmt::do_cleanup (PrintMode& mode)
2041{
2042 print_clean (mode);
2043}
2044
2045//----------------------------------------------------------
2046void Cmt::do_config ()
2047{
2048 if (CmtLock::check () == CmtLock::locked_by_another_user)
2049 {
2050 CmtError::set (CmtError::conflicting_lock, "config>");
2051 return;
2052 }
2053
2054 //Use::UsePtrVector& Uses = Use::get_ordered_uses ();
2055
2056 if (m_debug)
2057 {
2058 cout << "Cmt::do_config> " << endl;
2059 cout << "pwd " << CmtSystem::pwd () << endl;
2060 cout << "current_dir " << m_current_dir << endl;
2061 cout << "default_path " << m_default_path << endl;
2062 cout << "cmt config " <<
2063 m_current_package << " " <<
2064 m_current_version << " " <<
2065 m_current_path << endl;
2066 }
2067
2068 if (m_current_package == "CMT") return;
2069 if (m_current_package == "methods") return;
2070
2071 cmt_string branch;
2072
2073 CmtSystem::basename (m_current_dir, branch);
2074
2075 if ((branch != "mgr") && (branch != "cmt"))
2076 {
2077
2078 //
2079 // Here we are in a standalone package (ie completely unstructured)
2080 //
2081
2082 if (CmtSystem::test_file ("requirements"))
2083 {
2084 cout << "------------------------------------------" << endl;
2085 cout << "Configuring environment for standalone package." << endl;
2086 cout << "CMT version " << m_cmt_version << "." << endl;
2087 cout << "System is " << m_cmt_config << endl;
2088 cout << "------------------------------------------" << endl;
2089
2090 install_test_setup_scripts ();
2091 install_test_cleanup_scripts ();
2092
2093 Generator::build_default_makefile ();
2094 }
2095 else
2096 {
2097 cout << "==============================================" << endl;
2098 cout << "cmt config must be operated either upon "
2099 "an existing package" << endl;
2100 cout << " (ie. when a requirements file already exists)" << endl;
2101 cout << " > cd ..." << endl;
2102 cout << " > cmt config" << endl;
2103 cout << "or to create a new package" << endl;
2104 cout << " > cmt config <package> <version> [<path>]" << endl;
2105 cout << "==============================================" << endl;
2106 }
2107
2108 return;
2109 }
2110
2111 configure_current_package ();
2112
2113 Generator::build_default_makefile ();
2114
2115 CmtSystem::cmt_string_vector makes;
2116 cmt_regexp expression ("[.]n?make(sav)?$");
2117
2118 CmtSystem::scan_dir (".", expression, makes);
2119
2120 if (makes.size () > 0)
2121 {
2122 cout << "Removing all previous make fragments from " << branch << endl;
2123
2124 for (int i = 0; i < makes.size (); i++)
2125 {
2126 const cmt_string& s = makes[i];
2127 CmtSystem::remove_file (s);
2128 }
2129 }
2130
2131 CmtSystem::cd ("..");
2132
2133 CmtSystem::scan_dir (m_cmt_config, expression, makes);
2134
2135 if (makes.size () > 0)
2136 {
2137 cout << "Removing all previous make fragments from "
2138 << m_cmt_config << endl;
2139
2140 for (int i = 0; i < makes.size (); i++)
2141 {
2142 const cmt_string& s = makes[i];
2143 CmtSystem::remove_file (s);
2144 }
2145 }
2146
2147 /*
2148 // cout << "Try a cleanup of the installation area " << endl;
2149
2150 //
2151 // Try a cleanup of the installation area
2152 //
2153 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
2154 {
2155 CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
2156
2157 //cout << "#IA3>" << endl;
2158
2159 if ((get_setup_strategy () & SetupCleanupMask) == SetupCleanup)
2160 {
2161 ia_mgr.config ();
2162 }
2163 }
2164 */
2165
2166 CmtSystem::cd (branch);
2167
2168 Use& use = Use::current ();
2169
2170 use.set (m_current_package,
2171 m_current_version,
2172 m_current_path,
2173 "",
2174 "");
2175
2176 use.change_path (m_current_path);
2177 use.style = m_current_style;
2178
2179 //cout << "do_config> current style=" << m_current_style << endl;
2180
2181 m_quiet = true;
2182
2183 if (!reach_current_package ())
2184 {
2185 cout << "Cannot read the requirements file" << endl;
2186 return;
2187 }
2188
2189 install_setup_scripts ();
2190 install_cleanup_scripts ();
2191
2192 CmtSystem::cd ("..");
2193
2194 Branch::BranchVector& branches = Branch::branches ();
2195
2196 int i;
2197
2198 for (i = 0; i < branches.size (); i++)
2199 {
2200 const Branch& branch = branches[i];
2201 const cmt_string& branch_name = branch.name ();
2202
2203 if (!CmtSystem::test_directory (branch_name))
2204 {
2205 if (!CmtSystem::mkdir (branch_name))
2206 {
2207 cout << "Cannot create the " << branch_name <<" branch" << endl;
2208 }
2209 else
2210 {
2211 cout << "Installing the " << branch_name << " directory" << endl;
2212 }
2213 }
2214 else
2215 {
2216 cout << branch_name << " directory already installed" << endl;
2217 }
2218 }
2219}
2220
2221//----------------------------------------------------------
2222void Cmt::do_create (const CmtSystem::cmt_string_vector& arguments)
2223{
2224 if (arguments.size () < 2) return;
2225
2226 const cmt_string& package = arguments[0];
2227 const cmt_string& version = arguments[1];
2228 cmt_string offset;
2229 if (arguments.size () >= 3) offset = arguments[2];
2230
2231 if (m_debug)
2232 {
2233 cout << "do_create>m_current_package=" << m_current_package << endl;
2234 cout << "do_create>package=" << package << endl;
2235 }
2236
2237 //if (m_current_package == "CMT") return;
2238 //if (m_current_package == "methods") return;
2239
2240 cmt_string the_path;
2241
2242 the_path = CmtSystem::pwd ();
2243
2244 if (offset != "")
2245 {
2246 if (!CmtSystem::absolute_path (offset))
2247 {
2248 // offset is really a relative offset
2249 the_path += CmtSystem::file_separator ();
2250 the_path += offset;
2251 }
2252 else // absolute path
2253 {
2254 the_path = offset;
2255 }
2256 }
2257
2258 CmtSystem::compress_path (the_path);
2259
2260 // Now 'the_path' contains the complete path where the package will be created
2261
2262 cout << "------------------------------------------" << endl;
2263 cout << "Configuring environment for package " << package <<
2264 " version " << version << "." << endl;
2265 cout << "CMT version " << m_cmt_version << "." << endl;
2266 cout << "Root set to " << the_path << "." << endl;
2267 cout << "System is " << m_cmt_config << endl;
2268 cout << "------------------------------------------" << endl;
2269
2270 if (!CmtSystem::test_directory (the_path))
2271 {
2272 if (!CmtSystem::mkdir (the_path))
2273 {
2274 cout << "Cannot create the path directory" << endl;
2275 return;
2276 }
2277 else
2278 {
2279 cout << "Installing the path directory" << endl;
2280 }
2281 }
2282
2283 CmtSystem::cd (the_path);
2284
2285 if (!CmtSystem::test_directory (package))
2286 {
2287 if (!CmtSystem::mkdir (package))
2288 {
2289 cout << "Cannot create the package directory" << endl;
2290 return;
2291 }
2292 else
2293 {
2294 cout << "Installing the package directory" << endl;
2295 }
2296 }
2297 else
2298 {
2299 cout << "Package directory already installed" << endl;
2300 }
2301
2302 CmtSystem::cd (package);
2303
2304 if (m_current_structuring_style == with_version_directory)
2305 {
2306 if (!CmtSystem::test_directory (version))
2307 {
2308 if (!CmtSystem::mkdir (version))
2309 {
2310 cout << "Cannot create the version directory" << endl;
2311 return;
2312 }
2313 else
2314 {
2315 cout << "Installing the version directory" << endl;
2316 }
2317 }
2318 else
2319 {
2320 cout << "Version directory already installed" << endl;
2321 }
2322
2323 CmtSystem::cd (version);
2324 }
2325 else
2326 {
2327 cout << "Version directory will not be created due to structuring style" << endl;
2328 }
2329
2330 if (!CmtSystem::test_directory ("cmt"))
2331 {
2332 if (!CmtSystem::test_directory ("mgr"))
2333 {
2334 if (!CmtSystem::mkdir ("cmt"))
2335 {
2336 cout << "Cannot create the cmt directory" << endl;
2337 return;
2338 }
2339 else
2340 {
2341 if (m_current_structuring_style == with_version_directory)
2342 {
2343 m_current_style = cmt_style;
2344 }
2345 else
2346 {
2347 m_current_style = no_version_style;
2348 }
2349
2350 cout << "Installing the cmt directory" << endl;
2351 }
2352 }
2353 else
2354 {
2355 if (m_current_structuring_style == with_version_directory)
2356 {
2357 m_current_style = mgr_style;
2358 }
2359 else
2360 {
2361 m_current_style = no_version_style;
2362 }
2363
2364 cout << "Mgr directory already installed" << endl;
2365 }
2366 }
2367 else
2368 {
2369 if (m_current_structuring_style == with_version_directory)
2370 {
2371 m_current_style = cmt_style;
2372 }
2373 else
2374 {
2375 m_current_style = no_version_style;
2376 }
2377
2378 cout << "Cmt directory already installed" << endl;
2379 }
2380
2381 if (!CmtSystem::test_directory ("src"))
2382 {
2383 if (!CmtSystem::mkdir ("src"))
2384 {
2385 cout << "Cannot create the src directory" << endl;
2386 return;
2387 }
2388 else
2389 {
2390 cout << "Installing the src directory" << endl;
2391 }
2392 }
2393 else
2394 {
2395 cout << "src directory already installed" << endl;
2396 }
2397
2398 switch (m_current_style)
2399 {
2400 case cmt_style:
2401 case no_version_style:
2402 CmtSystem::cd ("cmt");
2403 break;
2404 case mgr_style:
2405 CmtSystem::cd ("mgr");
2406 break;
2407 }
2408
2409 Generator::build_default_makefile ();
2410
2411 if (!CmtSystem::test_file ("requirements"))
2412 {
2413 // create an empty requirement file.
2414 ofstream f ("requirements");
2415 if (f)
2416 {
2417 f << "package " << package << endl;
2418 f << endl;
2419 f.close ();
2420 }
2421 }
2422
2423 if (m_current_structuring_style == without_version_directory)
2424 {
2425 ofstream f ("version.cmt");
2426 if (f)
2427 {
2428 f << version << endl;
2429 f.close ();
2430 }
2431 }
2432
2433 m_current_package = package;
2434 m_current_version = version;
2435 m_current_path = the_path;
2436 m_current_dir = CmtSystem::pwd ();
2437
2438 do_config ();
2439}
2440
2441//----------------------------------------------------------
2442void Cmt::do_create_project (const CmtSystem::cmt_string_vector& arguments)
2443{
2444 if (arguments.size () < 1) return;
2445
2446 const cmt_string& project = arguments[0];
2447
2448 Project::create (project);
2449}
2450
2451//----------------------------------------------------------
2452void Cmt::do_cvsbranches (const CmtSystem::cmt_string_vector& arguments)
2453{
2454 Cvs::branches (arguments[0]);
2455}
2456
2457//----------------------------------------------------------
2458void Cmt::do_cvssubpackages (const CmtSystem::cmt_string_vector& arguments)
2459{
2460 Cvs::subpackages (arguments[0]);
2461}
2462
2463//----------------------------------------------------------
2464void Cmt::do_cvstags (const CmtSystem::cmt_string_vector& arguments)
2465{
2466 Cvs::tags (arguments);
2467}
2468
2469//----------------------------------------------------------
2470void Cmt::do_do (const CmtSystem::cmt_string_vector& arguments)
2471{
2472 if (arguments.size () > 0)
2473 {
2474 set_standard_macros ();
2475 Symbol::all_set ();
2476
2477 Symbol* symbol = Symbol::find (arguments[0]);
2478
2479 if (symbol == 0)
2480 {
2481 CmtError::set (CmtError::symbol_not_found, arguments[0]);
2482 return;
2483 }
2484
2485 /*
2486 We then look for all <name>=<value> pairs
2487 */
2488 for (int i = 1; i < arguments.size (); i++)
2489 {
2490 cmt_string s = arguments[i];
2491 int pos = s.find ("=");
2492 if (pos == cmt_string::npos) break;
2493 if (pos == 0) break;
2494
2495 cmt_string name;
2496 cmt_string value;
2497
2498 s.substr (0, pos, name);
2499 s.substr (pos + 1, value);
2500
2501 int size = value.size ();
2502
2503 if (size >= 2)
2504 {
2505 if (((value[0] == '"') && (value[size - 1] == '"')) ||
2506 ((value[0] == '\'') && (value[size - 1] == '\'')))
2507 {
2508 value.erase (size - 1);
2509 value.erase (0, 1);
2510 }
2511 }
2512
2513 cmt_string r = "macro ";
2514 r += name;
2515 r += " \"";
2516 r += value;
2517 r += "\"";
2518
2519 Use* current_use = &(Use::current ());
2520
2521 SyntaxParser::parse_requirements_line (r, current_use);
2522 }
2523
2524 cmt_string cmd = symbol->build_macro_value ();
2525 Symbol::expand (cmd);
2526
2527 cout << "Execute action " << arguments[0] << " => " << cmd << endl;
2528
2529 CmtSystem::execute (cmd);
2530 }
2531}
2532
2533//----------------------------------------------------------
2534void Cmt::do_expand_model (const CmtSystem::cmt_string_vector& arguments)
2535{
2536 set_standard_macros ();
2537
2538 if ((arguments[0] == "-strict") && (arguments.size () > 1))
2539 {
2540 CmtModel::strict_expand (arguments[1]);
2541 }
2542 else if ((arguments[0] == "-test") && (arguments.size () > 2))
2543 {
2544 CmtModel::test_regexp (arguments[1], arguments[2]);
2545 }
2546 else if (arguments.size () > 0)
2547 {
2548 CmtModel::expand (arguments[0]);
2549 }
2550}
2551
2552/**
2553 * Handle free filtering of text files containing $(xxx) or ${xxx} patterns
2554 *
2555 * Substitution is performed against CMT macros and environment variables.
2556 *
2557 * Arguments:
2558 *
2559 * cmt filter input-file-name output-file-name
2560 *
2561 */
2562void Cmt::do_filter (const CmtSystem::cmt_string_vector& arguments)
2563{
2564 if (arguments.size () < 2) return;
2565
2566 cmt_string& input = arguments[0];
2567 cmt_string& output = arguments[1];
2568
2569 if (!CmtSystem::test_file (input))
2570 {
2571 cerr << "#CMT> File " << input << " not found" << endl;
2572 return;
2573 }
2574
2575 cmt_string text;
2576
2577 text.read (input);
2578
2579 set_standard_macros ();
2580
2581 Symbol::expand (text);
2582
2583 FILE* file = fopen (output, "wb");
2584 if (file == NULL)
2585 {
2586 cerr << "#CMT> Cannot write filtered file " << output << endl;
2587 }
2588 else
2589 {
2590 text.write (file);
2591 fclose (file);
2592 }
2593}
2594
2595//----------------------------------------------------------
2596void Cmt::do_help (ActionType help_action)
2597{
2598 if (help_action == action_none)
2599 {
2600 CommandParser::show_all ();
2601 }
2602 else
2603 {
2604 CommandParser::show (help_action);
2605 }
2606}
2607
2608//----------------------------------------------------------
2609void Cmt::do_lock (const cmt_string& package,
2610 const cmt_string& version,
2611 const cmt_string& path)
2612{
2613 //(unsused) Use& use = Use::current();
2614
2615 cout << "try to lock package " << package << " in " << CmtSystem::pwd () << endl;
2616
2617 set_standard_macros ();
2618
2619 CmtLock::status status = CmtLock::lock ();
2620}
2621
2622//----------------------------------------------------------
2623void Cmt::do_remove (const cmt_string& package,
2624 const cmt_string& version,
2625 const cmt_string& path)
2626{
2627 //Use::UsePtrVector& Uses = Use::get_ordered_uses ();
2628
2629 if (m_current_package == "CMT") return;
2630 if (m_current_package == "methods") return;
2631
2632 cmt_string the_path;
2633
2634 //the_path = m_default_path;
2635 the_path = CmtSystem::pwd ();
2636
2637 if (path != "")
2638 {
2639 if (!CmtSystem::absolute_path (path))
2640 {
2641 // path is just a suffix
2642 the_path += CmtSystem::file_separator ();
2643 the_path += path;
2644 }
2645 else // absolute path
2646 {
2647 the_path = path;
2648 }
2649 }
2650
2651 CmtSystem::compress_path (the_path);
2652
2653 cout << "------------------------------------------" << endl;
2654 cout << "Removing package " << package <<
2655 " version " << version << "." << endl;
2656 cout << "CMT version " << m_cmt_version << "." << endl;
2657 cout << "Root set to " << the_path << "." << endl;
2658 cout << "System is " << m_cmt_config << endl;
2659 cout << "------------------------------------------" << endl;
2660
2661 the_path += CmtSystem::file_separator ();
2662 the_path += package;
2663
2664 if (!CmtSystem::cd (the_path))
2665 {
2666 cout << "Path " << the_path << " not reachable" << endl;
2667 return;
2668 }
2669
2670 if (CmtSystem::test_directory (version))
2671 {
2672 if (CmtSystem::remove_directory (version))
2673 {
2674 cout << "Version " << version << " has been removed from " << the_path << endl;
2675 CmtSystem::cmt_string_vector contents;
2676 CmtSystem::scan_dir (".", contents);
2677 if (contents.size () == 0)
2678 {
2679 CmtSystem::cd ("..");
2680 if (CmtSystem::remove_directory (package))
2681 {
2682 cout << "Package " << package << " has no more versions. Thus it has been removed."<< endl;
2683 }
2684 }
2685 }
2686 else
2687 {
2688 cout << "Impossible to remove version " << version << " from " << the_path << endl;
2689 }
2690 }
2691 else if (CmtSystem::test_directory ("cmt"))
2692 {
2693 CmtSystem::cd ("cmt");
2694
2695 cmt_string v;
2696
2697 v.read ("version.cmt");
2698 if (v == version)
2699 {
2700 CmtSystem::cd ("..");
2701 if (!CmtSystem::remove_directory ("cmt"))
2702 {
2703 cout << "Unstructured version " << version
2704 << " has been removed from " << the_path << endl;
2705 }
2706 else
2707 {
2708 cout << "Impossible to remove unstructured version " << version
2709 << " from " << the_path << endl;
2710 }
2711 }
2712 else
2713 {
2714 cout << "Version " << version << " not found" << endl;
2715 }
2716 }
2717 else
2718 {
2719 cout << "Version " << version << " not found" << endl;
2720 }
2721}
2722
2723//----------------------------------------------------------
2724void Cmt::do_remove_library_links ()
2725{
2726 if (CmtLock::check () == CmtLock::locked_by_another_user)
2727 {
2728 CmtError::set (CmtError::conflicting_lock, "remove_library_links>");
2729 return;
2730 }
2731
2732 set_standard_macros ();
2733
2734 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
2735 Use& current_use = Use::current ();
2736 int i;
2737 cmt_string shlibsuffix;
2738 cmt_string symunlink;
2739
2740 {
2741 Symbol* macro = Symbol::find ("shlibsuffix");
2742 if (macro == 0) return;
2743 shlibsuffix = macro->build_macro_value ();
2744 Symbol::expand (shlibsuffix);
2745 }
2746
2747 {
2748 Symbol* macro = Symbol::find ("symunlink");
2749 if (macro == 0) return;
2750 symunlink = macro->build_macro_value ();
2751 Symbol::expand (symunlink);
2752 }
2753
2754 for (i = 0; i < Uses.size (); i++)
2755 {
2756 Use* use = Uses[i];
2757
2758 if (use->discarded) continue;
2759
2760 if (!use->located ())
2761 {
2762 if (!m_quiet)
2763 {
2764 cerr << "#CMT> package " << use->get_package_name () <<
2765 " " << use->version << " " << use->path <<
2766 " not found" <<
2767 endl;
2768 }
2769 }
2770 else
2771 {
2772 if (use->get_package_name () == "CMT") continue;
2773 if (use->get_package_name () == current_use.get_package_name ()) continue;
2774
2775 cmt_string s;
2776
2777 s = use->get_package_name ();
2778 s += "_libraries";
2779
2780 Symbol* libraries_macro = Symbol::find (s);
2781
2782 if (libraries_macro == 0) continue;
2783
2784 cmt_string libraries = libraries_macro->build_macro_value ();
2785 Symbol::expand (libraries);
2786
2787 static CmtSystem::cmt_string_vector values;
2788
2789 CmtSystem::split (libraries, " \t", values);
2790
2791 for (int j = 0; j < values.size (); j++)
2792 {
2793 const cmt_string& library = values[j];
2794
2795 static cmt_string libname;
2796 static cmt_string name;
2797
2798 // Is it a simple name or a complete path?
2799
2800 libname = library;
2801 Symbol::expand (libname);
2802
2803 if (CmtSystem::absolute_path (libname))
2804 {
2805 /**
2806 * We assume here that "library" contains a complete path.
2807 * (including the complete syntax libxxx.so)
2808 */
2809
2810 cmt_string suffix;
2811 CmtSystem::basename (library, name);
2812 }
2813 else
2814 {
2815 /**
2816 * Here we expect that only the base name of the library
2817 * is given : ie it should not contain the "lib" prefix,
2818 * nor the suffix .so, nor any path prefix.
2819 * This of course should generally correspond to a constituent name.
2820 */
2821
2822 name = "lib";
2823 name += libname;
2824 name += ".";
2825 name += shlibsuffix;
2826 }
2827
2828 Symbol::expand (libname);
2829
2830 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
2831 {
2832 const CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
2833
2834 //cout << "#IA4>" << endl;
2835
2836 cmt_string s1 = ia_mgr.get_installarea ();
2837
2838 {
2839 Symbol* symbol = Symbol::find ("CMTINSTALLAREA");
2840 if (symbol != 0)
2841 {
2842 s1 = symbol->build_macro_value ();
2843 Symbol::expand (s1);
2844 }
2845 }
2846
2847 cmt_string s2;
2848
2849 {
2850 Symbol* macro = Symbol::find ("tag");
2851 if (macro != 0)
2852 {
2853 s2 = macro->build_macro_value ();
2854 Symbol::expand (s2);
2855 }
2856 }
2857
2858 // Now deleting the reference file
2859
2860 s = symunlink;
2861 s += " ";
2862 s += s1;
2863 s += CmtSystem::file_separator ();
2864 s += s2;
2865 s += CmtSystem::file_separator ();
2866 s += "lib";
2867 s += CmtSystem::file_separator ();
2868 s += name;
2869 s += ".cmtref";
2870 s += " ";
2871 s += s1;
2872 s += CmtSystem::file_separator ();
2873 s += s2;
2874 s += CmtSystem::file_separator ();
2875 s += "lib";
2876 s += CmtSystem::file_separator ();
2877 s += name;
2878 }
2879 else
2880 {
2881 s = symunlink;
2882 s += " ../$(";
2883 s += current_use.get_package_name ();
2884 s += "_tag)/";
2885 s += name;
2886 }
2887
2888 Symbol::expand (s);
2889
2890 if (!m_quiet) cout << s << endl;
2891 int status = CmtSystem::execute (s);
2892
2893 if (status != 0)
2894 {
2895 if (status != 2) CmtError::set (CmtError::execution_error, s);
2896
2897 cerr << "#CMT> Cannot remove the symbolic link " << s << endl;
2898
2899 break;
2900 }
2901 }
2902 }
2903 }
2904}
2905
2906//----------------------------------------------------------
2907void Cmt::do_run (const CmtSystem::cmt_string_vector& arguments)
2908{
2909 if (arguments.size () > 0)
2910 {
2911 set_standard_macros ();
2912 Symbol::all_set ();
2913
2914 cmt_string cmd;
2915
2916 for (int i = 0; i < arguments.size (); i++)
2917 {
2918 cmd += arguments[i];
2919 cmd += " ";
2920 }
2921
2922 CmtSystem::execute (cmd);
2923 }
2924}
2925
2926//----------------------------------------------------------
2927void Cmt::do_run_sequence (const CmtSystem::cmt_string_vector& arguments)
2928{
2929 if (arguments.size () == 0) cerr << "#CMT> run_sequence: no sequence specified" << endl;
2930
2931 SequenceRunner runner;
2932
2933 cout << "# cmt run_sequence: sequence " << arguments[0] << endl;
2934
2935 runner.run (arguments[0]);
2936}
2937
2938//----------------------------------------------------------
2939void Cmt::do_set_version (const CmtSystem::cmt_string_vector& arguments)
2940{
2941 if (arguments.size () == 0) cerr << "#CMT> set version: no version specified" << endl;
2942
2943 const cmt_string& version = arguments[0];
2944
2945 int v, r, p;
2946
2947 if (!CmtSystem::is_version_directory (version, v, r, p))
2948 {
2949 cerr << "#CMT> set version " << version << " is not a correct version syntax" << endl;
2950 return;
2951 }
2952
2953 if ((v == -1) || (r == -1) || (p == -1))
2954 {
2955 cerr << "#CMT> set version " << version
2956 << " You cannot use wild card to set a version" << endl;
2957 return;
2958 }
2959
2960 // We want to install the version.cmt file
2961
2962 // We first check we are in a cmt branch
2963 cmt_string h = CmtSystem::pwd ();
2964 cmt_string branch;
2965 CmtSystem::basename (h, branch);
2966
2967 if (branch != "cmt")
2968 {
2969 cerr << "#CMT> set version " << version << " must be applied in a cmt directory"
2970 << endl;
2971 return;
2972 }
2973
2974 CmtSystem::dirname (h, h);
2975 CmtSystem::basename (h, branch);
2976
2977 if (branch == version)
2978 {
2979 cerr << "#CMT> set version " << version << " is already available as a version directory"
2980 << endl;
2981 return;
2982 }
2983
2984 cout << "Writing version file : " << version << endl;
2985
2986 version.write ("version.cmt");
2987}
2988
2989//----------------------------------------------------------
2990void Cmt::do_set_versions (const CmtSystem::cmt_string_vector& arguments)
2991{
2992 CmtSystem::cmt_string_vector args;
2993
2994 args = arguments;
2995 {
2996 cmt_string& s = args.add ();
2997 s = "cmt";
2998 }
2999 {
3000 cmt_string& s = args.add ();
3001 s = "set";
3002 }
3003 {
3004 cmt_string& s = args.add ();
3005 s = "version";
3006 }
3007 {
3008 cmt_string& s = args.add ();
3009 s = "<version>";
3010 }
3011
3012 m_action = action_broadcast;
3013
3014 do_broadcast (args, 0, 0);
3015}
3016
3017//----------------------------------------------------------
3018void Cmt::do_setup (PrintMode& mode)
3019{
3020 print (mode);
3021
3022 //
3023 // Try a cleanup of the installation area
3024 //
3025 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
3026 {
3027 CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
3028
3029 //cout << "#IA5>" << endl;
3030
3031 ia_mgr.setup ();
3032
3033 /*
3034 if ((get_setup_strategy () & SetupCleanupMask) == SetupCleanup)
3035 {
3036 const cmt_string& installarea = ia_mgr.get_installarea ();
3037
3038 if (installarea != "")
3039 {
3040 cmt_string q;
3041
3042 switch (mode)
3043 {
3044 case Sh :
3045 case Csh :
3046 q = "\'";
3047 break;
3048 default :
3049 break;
3050 }
3051
3052 if (!m_quiet)
3053 {
3054 cout << "echo " << q
3055 << "# Doing cleanup in the installation area " << installarea
3056 << q << endl;
3057 }
3058 }
3059
3060 ia_mgr.config ();
3061 }
3062 */
3063 }
3064}
3065
3066//----------------------------------------------------------
3067void Cmt::do_show_action (const CmtSystem::cmt_string_vector& arguments,
3068 PrintMode& mode)
3069{
3070 cmt_string target;
3071
3072 if (arguments.size () > 0) target = arguments[0];
3073
3074 Symbol* symbol;
3075
3076 set_standard_macros ();
3077
3078 symbol = Symbol::find (target);
3079
3080 if (symbol == 0)
3081 {
3082 cmt_string t = " ";
3083 t += target;
3084 t += " is not defined ";
3085
3086 CmtError::set (CmtError::symbol_not_found, t);
3087
3088 return;
3089 }
3090 else
3091 {
3092 cmt_string t = target;
3093 t += " is a ";
3094
3095 if ((m_action == action_show_action) ||
3096 (m_action == action_show_action_value))
3097 {
3098 if (symbol->type != Symbol::SymbolAction)
3099 {
3100 if (symbol->type == Symbol::SymbolMacro)
3101 {
3102 t += "macro";
3103 }
3104 else if (symbol->type == Symbol::SymbolSet)
3105 {
3106 t += "set";
3107 }
3108 else if (symbol->type == Symbol::SymbolPath)
3109 {
3110 t += "path";
3111 }
3112 else if (symbol->type == Symbol::SymbolAlias)
3113 {
3114 t += "alias";
3115 }
3116
3117 CmtError::set (CmtError::warning, t);
3118 }
3119 }
3120 }
3121
3122 if (symbol->value_lists.size () < 1) return;
3123
3124 symbol->show_macro (mode);
3125}
3126
3127//----------------------------------------------------------
3128void Cmt::do_show_action_names (const CmtSystem::cmt_string_vector& arguments,
3129 PrintMode& mode)
3130{
3131 if (arguments.size () > 0)
3132 {
3133 const cmt_string& pattern = arguments[0];
3134 print_symbol_names (mode, pattern);
3135 }
3136 else
3137 {
3138 print_symbol_names (mode);
3139 }
3140}
3141
3142//----------------------------------------------------------
3143void Cmt::do_show_action_value (const CmtSystem::cmt_string_vector& arguments,
3144 PrintMode& mode)
3145{
3146 do_show_macro (arguments, mode);
3147}
3148
3149//----------------------------------------------------------
3150void Cmt::do_show_actions (const CmtSystem::cmt_string_vector& arguments,
3151 PrintMode& mode)
3152{
3153 if (arguments.size () > 0)
3154 {
3155 const cmt_string& pattern = arguments[0];
3156 print_macros (mode, pattern);
3157 }
3158 else
3159 {
3160 print_macros (mode);
3161 }
3162}
3163
3164//----------------------------------------------------------
3165void Cmt::do_show_all_tags ()
3166{
3167 Tag::TagPtrVector tags = Tag::tags ();
3168 int index;
3169
3170 set_standard_macros ();
3171
3172 for (index = 0; index < tags.size (); index++)
3173 {
3174 const Tag* tag = tags[index];
3175 if (tag != 0)
3176 {
3177 tag->show_definition (true);
3178 }
3179 }
3180}
3181
3182//----------------------------------------------------------
3183void Cmt::do_show_applied_patterns ()
3184{
3185 Pattern::show_all_applied_patterns ();
3186}
3187
3188//----------------------------------------------------------
3189void Cmt::do_show_author ()
3190{
3191 Use& use = Use::current();
3192
3193 cout << use.author << endl;
3194}
3195
3196//----------------------------------------------------------
3197void Cmt::do_show_branches (PrintMode& mode)
3198{
3199 Branch::print_all (mode);
3200}
3201
3202//----------------------------------------------------------
3203void Cmt::do_show_clients (const CmtSystem::cmt_string_vector& arguments)
3204{
3205 cmt_string package;
3206 cmt_string version;
3207 cmt_string path_name;
3208
3209 if (arguments.size () >= 1) package = arguments[0];
3210 if (arguments.size () >= 2) version = arguments[1];
3211 if (arguments.size () >= 3) path_name = arguments[2];
3212
3213 PathScanner scanner;
3214 ClientCollector collector (package, version);
3215
3216 clear ();
3217 configure ();
3218
3219 cout << "# ----------- Clients of " << package <<
3220 " " << version <<
3221 " " << path_name <<
3222 endl;
3223
3224 if (path_name == "")
3225 {
3226 Project::scan_paths (scanner, collector);
3227 }
3228 else
3229 {
3230 scanner.scan_path (path_name, collector);
3231 }
3232 cout << "# ----------- " << collector.count () << " clients found." << endl;
3233}
3234
3235//----------------------------------------------------------
3236void Cmt::do_show_cmtpath_patterns ()
3237{
3238 set_standard_macros ();
3239 CmtPathPattern::show_all ();
3240}
3241
3242//----------------------------------------------------------
3243void Cmt::do_show_constituent (const CmtSystem::cmt_string_vector& arguments)
3244{
3245 if (arguments.size () > 0)
3246 {
3247 set_standard_macros ();
3248
3249 Constituent* c = Constituent::find (arguments[0]);
3250 if (c != 0)
3251 {
3252 c->show ();
3253 }
3254 }
3255}
3256
3257//----------------------------------------------------------
3258void Cmt::do_show_constituent_names ()
3259{
3260 set_standard_macros ();
3261 Constituent::show_names ();
3262}
3263
3264//----------------------------------------------------------
3265void Cmt::do_show_constituents ()
3266{
3267 set_standard_macros ();
3268 Constituent::show_all ();
3269}
3270
3271//----------------------------------------------------------
3272void Cmt::do_show_cycles ()
3273{
3274 set_standard_macros ();
3275 Use& use = Use::current();
3276
3277 use.show_cycles ();
3278}
3279
3280//----------------------------------------------------------
3281void Cmt::do_show_fragment (const CmtSystem::cmt_string_vector& arguments)
3282{
3283 if (arguments.size () > 0) Fragment::show (arguments[0]);
3284}
3285
3286//----------------------------------------------------------
3287void Cmt::do_show_fragments ()
3288{
3289 Fragment::show_all ();
3290}
3291
3292//----------------------------------------------------------
3293void Cmt::do_show_groups ()
3294{
3295 Group::show_all ();
3296}
3297
3298//----------------------------------------------------------
3299void Cmt::do_show_include_dirs ()
3300{
3301 cmt_string temp;
3302
3303 Use& use = Use::current();
3304
3305 set_standard_macros ();
3306
3307 if (use.include_path == "")
3308 {
3309 temp += "$(src) ";
3310 }
3311 else if (use.include_path != "none")
3312 {
3313 temp += use.include_path;
3314 temp += " ";
3315 }
3316
3317 for (int include_number = 0;
3318 include_number < use.includes.size ();
3319 include_number++)
3320 {
3321 Include& incl = use.includes[include_number];
3322
3323 temp += incl.name;
3324 temp += " ";
3325 }
3326
3327 cout << temp << endl;
3328}
3329
3330//----------------------------------------------------------
3331void Cmt::do_show_language (const CmtSystem::cmt_string_vector& arguments)
3332{
3333 if (arguments.size () > 0)
3334 {
3335 set_standard_macros ();
3336 Language::show (arguments[0]);
3337 }
3338}
3339
3340//----------------------------------------------------------
3341void Cmt::do_show_languages ()
3342{
3343 set_standard_macros ();
3344 Language::show_all ();
3345}
3346
3347//----------------------------------------------------------
3348void Cmt::do_show_macro (const CmtSystem::cmt_string_vector& arguments,
3349 PrintMode& mode)
3350{
3351 cmt_string target;
3352
3353 if (arguments.size () > 0) target = arguments[0];
3354
3355 Symbol* symbol;
3356
3357 set_standard_macros ();
3358
3359 symbol = Symbol::find (target);
3360
3361 if (symbol == 0)
3362 {
3363 cmt_string t = " ";
3364 t += target;
3365 t += " is not defined ";
3366
3367 CmtError::set (CmtError::symbol_not_found, t);
3368
3369 return;
3370 }
3371 else
3372 {
3373 cmt_string t = target;
3374 t += " is a ";
3375
3376 if ((m_action == action_show_macro) ||
3377 (m_action == action_show_macro_value))
3378 {
3379 if (symbol->type != Symbol::SymbolMacro)
3380 {
3381 if (symbol->type == Symbol::SymbolAction)
3382 {
3383 t += "action";
3384 }
3385 else if (symbol->type == Symbol::SymbolSet)
3386 {
3387 t += "set";
3388 }
3389 else if (symbol->type == Symbol::SymbolPath)
3390 {
3391 t += "path";
3392 }
3393 else if (symbol->type == Symbol::SymbolAlias)
3394 {
3395 t += "alias";
3396 }
3397
3398 CmtError::set (CmtError::warning, t);
3399 }
3400 }
3401 else if ((m_action == action_show_set) ||
3402 (m_action == action_show_set_value))
3403 {
3404 if ((symbol->type != Symbol::SymbolSet) &&
3405 (symbol->type != Symbol::SymbolPath) &&
3406 (symbol->type != Symbol::SymbolAction) &&
3407 (symbol->type != Symbol::SymbolAlias))
3408 {
3409 t += "macro";
3410
3411 CmtError::set (CmtError::warning, t);
3412 }
3413 }
3414 }
3415
3416 if (symbol->value_lists.size () < 1) return;
3417
3418 symbol->show_macro (mode);
3419}
3420
3421//----------------------------------------------------------
3422void Cmt::do_show_macro_names (const CmtSystem::cmt_string_vector& arguments,
3423 PrintMode& mode)
3424{
3425 if (arguments.size () > 0)
3426 {
3427 const cmt_string& pattern = arguments[0];
3428 print_symbol_names (mode, pattern);
3429 }
3430 else
3431 {
3432 print_symbol_names (mode);
3433 }
3434}
3435
3436//----------------------------------------------------------
3437void Cmt::do_show_macro_value (const CmtSystem::cmt_string_vector& arguments,
3438 PrintMode& mode)
3439{
3440 do_show_macro (arguments, mode);
3441}
3442
3443//----------------------------------------------------------
3444void Cmt::do_show_macros (const CmtSystem::cmt_string_vector& arguments,
3445 PrintMode& mode)
3446{
3447 if (arguments.size () > 0)
3448 {
3449 const cmt_string& pattern = arguments[0];
3450 print_macros (mode, pattern);
3451 }
3452 else
3453 {
3454 print_macros (mode);
3455 }
3456}
3457
3458//----------------------------------------------------------
3459void Cmt::do_show_manager ()
3460{
3461 Use& use = Use::current();
3462
3463 cout << use.manager << endl;
3464}
3465
3466//----------------------------------------------------------
3467void Cmt::do_show_packages (const CmtSystem::cmt_string_vector& arguments)
3468{
3469 cmt_string path_name;
3470
3471 if (arguments.size () > 0) path_name = arguments[0];
3472
3473 PathScanner scanner;
3474 PackageViewer viewer;
3475
3476 if (path_name == "")
3477 {
3478 Project::scan_paths (scanner, viewer);
3479 }
3480 else
3481 {
3482 scanner.scan_path (path_name, viewer);
3483 }
3484}
3485
3486//----------------------------------------------------------
3487void Cmt::do_show_path ()
3488{
3489 Project::show_paths ();
3490}
3491
3492//----------------------------------------------------------
3493void Cmt::do_show_pattern (const CmtSystem::cmt_string_vector& arguments)
3494{
3495 cmt_string name;
3496 if (arguments.size () > 0) name = arguments[0];
3497 Pattern::show (name);
3498}
3499
3500//----------------------------------------------------------
3501void Cmt::do_show_pattern_names ()
3502{
3503 Pattern::show_all_names ();
3504}
3505
3506//----------------------------------------------------------
3507void Cmt::do_show_patterns ()
3508{
3509 Pattern::show_all ();
3510}
3511
3512//----------------------------------------------------------
3513void Cmt::do_show_projects ()
3514{
3515 Project::show_all ();
3516}
3517
3518//----------------------------------------------------------
3519void Cmt::do_show_pwd ()
3520{
3521 cout << m_current_dir << endl;
3522}
3523
3524//----------------------------------------------------------
3525void Cmt::do_show_setup ()
3526{
3527 cout << "----------> uses" << endl;
3528 do_show_uses ();
3529
3530 cout << "----------> tags" << endl;
3531 do_show_tags ();
3532
3533 cout << "----------> CMTPATH" << endl;
3534 do_show_path ();
3535}
3536
3537//----------------------------------------------------------
3538void Cmt::do_show_set (const CmtSystem::cmt_string_vector& arguments,
3539 PrintMode& mode)
3540{
3541 do_show_macro (arguments, mode);
3542}
3543
3544//----------------------------------------------------------
3545void Cmt::do_show_set_names (const CmtSystem::cmt_string_vector& arguments,
3546 PrintMode& mode)
3547{
3548 if (arguments.size () > 0)
3549 {
3550 const cmt_string& pattern = arguments[0];
3551 print_symbol_names (mode, pattern);
3552 }
3553 else
3554 {
3555 print_symbol_names (mode);
3556 }
3557}
3558
3559//----------------------------------------------------------
3560void Cmt::do_show_set_value (const CmtSystem::cmt_string_vector& arguments,
3561 PrintMode& mode)
3562{
3563 do_show_macro (arguments, mode);
3564}
3565
3566//----------------------------------------------------------
3567void Cmt::do_show_sets (const CmtSystem::cmt_string_vector& arguments,
3568 PrintMode& mode)
3569{
3570 if (arguments.size () > 0)
3571 {
3572 const cmt_string& pattern = arguments[0];
3573 print_macros (mode, pattern);
3574 }
3575 else
3576 {
3577 print_macros (mode);
3578 }
3579}
3580
3581//----------------------------------------------------------
3582void Cmt::do_show_strategies ()
3583{
3584 Project* p = Project::get_current ();
3585
3586 if (p != 0) p->show ();
3587 else cout << "No current project" << endl;
3588
3589 cout << "Structuring style : ";
3590
3591 int strategy = 0;
3592
3593 switch (m_current_structuring_style)
3594 {
3595 case without_version_directory:
3596 cout << "without_version_directory";
3597 break;
3598 case with_version_directory:
3599 cout << "with_version_directory";
3600 break;
3601 }
3602
3603 cout << endl;
3604
3605 cout << "Build strategy : ";
3606
3607 if (p == 0) strategy = m_current_build_strategy;
3608 else strategy = p->get_build_strategy ();
3609
3610 if ((strategy & PrototypesMask) == Prototypes)
3611 {
3612 cout << "prototypes";
3613 }
3614 else
3615 {
3616 cout << "no_prototypes";
3617 }
3618
3619 if ((strategy & KeepMakefilesMask) == KeepMakefiles)
3620 {
3621 cout << " keep_makefiles";
3622 }
3623 else
3624 {
3625 cout << " rebuild_makefiles";
3626 }
3627
3628 if ((strategy & InstallAreaMask) == WithInstallArea)
3629 {
3630 cout << " with_installarea";
3631 }
3632 else
3633 {
3634 cout << " without_installarea";
3635 }
3636
3637 cout << endl;
3638
3639 cout << "Setup strategy : ";
3640
3641 strategy = get_setup_strategy ();
3642
3643 if ((strategy & SetupConfigMask) == SetupConfig)
3644 {
3645 cout << "config";
3646 }
3647 else
3648 {
3649 cout << "no_config";
3650 }
3651
3652 if ((strategy & SetupRootMask) == SetupRoot)
3653 {
3654 cout << " root";
3655 }
3656 else
3657 {
3658 cout << " no_root";
3659 }
3660
3661 if ((strategy & SetupCleanupMask) == SetupCleanup)
3662 {
3663 cout << " cleanup";
3664 }
3665 else
3666 {
3667 cout << " no_cleanup";
3668 }
3669
3670 cout << endl;
3671}
3672
3673//----------------------------------------------------------
3674void Cmt::do_show_tags ()
3675{
3676 Tag::TagPtrVector tags = Tag::tags ();
3677 int index;
3678
3679 set_standard_macros ();
3680
3681 for (index = 0; index < tags.size (); index++)
3682 {
3683 const Tag* tag = tags[index];
3684 if (tag != 0)
3685 {
3686 tag->show (m_quiet);
3687 }
3688 }
3689}
3690
3691//----------------------------------------------------------
3692void Cmt::do_show_use_paths (const CmtSystem::cmt_string_vector& arguments)
3693{
3694 const cmt_string& to_name = arguments[0];
3695
3696 Use* current = &(Use::current());
3697
3698 current->get_all_clients (to_name);
3699}
3700
3701//----------------------------------------------------------
3702void Cmt::do_show_uses ()
3703{
3704 Use::show_all ();
3705}
3706
3707//----------------------------------------------------------
3708void Cmt::do_show_version ()
3709{
3710 cout << m_current_version << endl;
3711}
3712
3713//----------------------------------------------------------
3714void Cmt::do_show_versions (const CmtSystem::cmt_string_vector& arguments)
3715{
3716 cmt_string package_name;
3717
3718 if (arguments.size () > 0) package_name = arguments[0];
3719
3720 PathScanner scanner;
3721
3722 Project::scan_paths_for_package (scanner, package_name);
3723}
3724
3725//----------------------------------------------------------
3726void Cmt::do_show_system ()
3727{
3728 cout << CmtSystem::get_cmt_config () << endl;
3729}
3730
3731//----------------------------------------------------------
3732void Cmt::do_unlock (const cmt_string& package,
3733 const cmt_string& version,
3734 const cmt_string& path)
3735{
3736 // (unused??) Use& use = Use::current();
3737
3738 cout << "try to unlock package " << package << " in " << CmtSystem::pwd () << endl;
3739
3740 set_standard_macros ();
3741
3742 CmtLock::status status = CmtLock::unlock ();
3743}
3744
3745//----------------------------------------------------------
3746void Cmt::do_version ()
3747{
3748 cout << CMTVERSION << endl;
3749}
3750
3751
3752
3753//----------------------------------------------------------
3754ActionType Cmt::get_action ()
3755{
3756 return (m_action);
3757}
3758
3759/*
3760const CmtSystem::cmt_string_vector& Cmt::get_cmt_path ()
3761{
3762 return (m_cmt_path);
3763}
3764
3765const CmtSystem::cmt_string_vector& Cmt::get_cmt_path_pwds ()
3766{
3767 return (m_cmt_path_pwds);
3768}
3769
3770const CmtSystem::cmt_string_vector& Cmt::get_cmt_path_sources ()
3771{
3772 return (m_cmt_path_sources);
3773}
3774*/
3775
3776const cmt_string& Cmt::get_cmt_home ()
3777{
3778 return (m_cmt_home);
3779}
3780
3781const cmt_string& Cmt::get_cmt_user_context ()
3782{
3783 return (m_cmt_user_context);
3784}
3785
3786const cmt_string& Cmt::get_cmt_version ()
3787{
3788 return (m_cmt_version);
3789}
3790
3791const cmt_string& Cmt::get_current_dir ()
3792{
3793 return (m_current_dir);
3794}
3795
3796const cmt_string& Cmt::get_current_package ()
3797{
3798 return (m_current_package);
3799}
3800
3801const cmt_string& Cmt::get_current_cmtpath ()
3802{
3803 return (m_current_cmtpath);
3804}
3805
3806const cmt_string& Cmt::get_current_offset ()
3807{
3808 return (m_current_offset);
3809}
3810
3811AccessMode Cmt::get_current_access ()
3812{
3813 return (m_current_access);
3814}
3815
3816int Cmt::get_current_build_strategy ()
3817{
3818 return (m_current_build_strategy);
3819}
3820
3821int Cmt::get_current_setup_strategy ()
3822{
3823 return (m_current_setup_strategy);
3824}
3825
3826CmtStructuringStyle Cmt::get_current_structuring_style ()
3827{
3828 return (m_current_structuring_style);
3829}
3830
3831CmtDirStyle Cmt::get_current_style ()
3832{
3833 return (m_current_style);
3834}
3835
3836const cmt_string& Cmt::get_current_version ()
3837{
3838 return (m_current_version);
3839}
3840
3841const cmt_string& Cmt::get_current_target ()
3842{
3843 return (m_current_target);
3844}
3845
3846bool Cmt::get_debug ()
3847{
3848 return (m_debug);
3849}
3850
3851bool Cmt::get_quiet ()
3852{
3853 return (m_quiet);
3854}
3855
3856bool Cmt::get_recursive ()
3857{
3858 return (m_recursive);
3859}
3860
3861CmtScopeFilteringMode Cmt::get_scope_filtering_mode ()
3862{
3863 if (m_scope_filtering_mode == default_filtering_mode)
3864 {
3865 return (block_private_uses);
3866 }
3867 else
3868 {
3869 return (m_scope_filtering_mode);
3870 }
3871}
3872
3873//----------------------------------------------------------
3874const cmt_string& Cmt::filter_dir (const cmt_string& dir)
3875{
3876 static cmt_string newdir;
3877
3878 CmtSystem::compress_path (dir, newdir);
3879
3880 return (newdir);
3881}
3882
3883//----------------------------------------------------------
3884static void dos_script_prefix (FILE* f,
3885 const cmt_string& cmt_root,
3886 const cmt_string& package,
3887 const cmt_string& version,
3888 const cmt_string& path,
3889 const cmt_string& action,
3890 const cmt_string& option = "")
3891{
3892 cmt_string no_device = path;
3893
3894 if (CmtSystem::absolute_path (path))
3895 {
3896 if (path[1] == ':')
3897 {
3898 no_device = path.substr (2);
3899 }
3900 }
3901
3902 if (package == "cmt_standalone")
3903 {
3904 no_device = "";
3905 }
3906 else
3907 {
3908 no_device = "..\\..\\..";
3909 if (Cmt::get_current_style () == no_version_style)
3910 {
3911 no_device = "..\\..";
3912 }
3913 }
3914
3915
3916 fprintf (f, "@echo off\n");
3917 fprintf (f, "if NOT DEFINED CMTROOT set CMTROOT=%s& set PATH=%%CMTROOT%%\\%%CMTBIN%%;%%PATH%%& set CMTBIN=VisualC& if not defined CMTCONFIG set CMTCONFIG=%%CMTBIN%%\n", cmt_root.c_str ());
3918 fprintf (f, "\n");
3919 fprintf (f, "set cmttempfile=\"%%TEMP%%\\tmpsetup.bat\"\n");
3920 fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe %s -bat "
3921 " -pack=%s -version=%s -path=%%~d0%%~p0%s "
3922 " %s "
3923 "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%cmttempfile%%\n",
3924 action.c_str (),
3925 package.c_str (),
3926 version.c_str (),
3927 no_device.c_str (),
3928 option.c_str ());
3929 fprintf (f, "if exist %%cmttempfile%% call %%cmttempfile%%\n");
3930 fprintf (f, "if exist %%cmttempfile%% del %%cmttempfile%%\n");
3931 fprintf (f, "set cmttempfile=\n");
3932}
3933
3934//----------------------------------------------------------
3935void Cmt::install_cleanup_scripts ()
3936{
3937#ifdef WIN32
3938 static const int modes = 1;
3939 static const cmt_string suffix[1] = {"bat"};
3940 static const PrintMode mode[1] = {Bat};
3941#else
3942 static const int modes = 2;
3943 static const cmt_string suffix[2] = {"csh", "sh"};
3944 static const PrintMode mode[2] = {Csh, Sh};
3945#endif
3946
3947 cout << "Creating cleanup scripts." << endl;
3948
3949 cmt_string temp;
3950 int i;
3951
3952 cmt_string version = m_current_version;
3953 if (version == "v*") version = "";
3954
3955 for (i = 0; i < modes; i++)
3956 {
3957 cmt_string file_name = "cleanup";
3958 file_name += ".";
3959 file_name += suffix[i];
3960 file_name += ".";
3961 file_name += "new";
3962
3963 FILE* f = fopen (file_name.c_str (), "wb");
3964 if (f != NULL)
3965 {
3966 if (mode[i] == Csh)
3967 {
3968 fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
3969 fprintf (f, " setenv CMTROOT %s\n", m_cmt_root.c_str ());
3970 fprintf (f, "endif\n");
3971 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
3972 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
3973 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n");
3974 fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s "
3975 "-pack=%s -version=%s -path=%s $* >${tempfile}; "
3976 "source ${tempfile}\n",
3977 suffix[i].c_str (),
3978 m_current_package.c_str (),
3979 version.c_str (),
3980 m_current_path.c_str ());
3981 fprintf (f, "/bin/rm -f ${tempfile}\n");
3982 }
3983 else if (mode[i] == Sh)
3984 {
3985 fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
3986 fprintf (f, " CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ());
3987 fprintf (f, "fi\n");
3988 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
3989 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
3990 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
3991 fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s "
3992 "-pack=%s -version=%s -path=%s $* >${tempfile}; "
3993 ". ${tempfile}\n",
3994 suffix[i].c_str (),
3995 m_current_package.c_str (),
3996 version.c_str (),
3997 m_current_path.c_str ());
3998 fprintf (f, "/bin/rm -f ${tempfile}\n");
3999 }
4000 else if (mode[i] == Bat)
4001 {
4002 dos_script_prefix (f, m_cmt_root,
4003 m_current_package, version, m_current_path,
4004 "cleanup");
4005 }
4006
4007 fprintf (f, "\n");
4008
4009 fclose (f);
4010
4011 cmt_string old_file_name = "cleanup";
4012 old_file_name += ".";
4013 old_file_name += suffix[i];
4014
4015 CmtSystem::compare_and_update_files (file_name, old_file_name);
4016 }
4017 }
4018}
4019
4020//----------------------------------------------------------
4021void Cmt::install_setup_scripts ()
4022{
4023#ifdef WIN32
4024 static const int modes = 1;
4025 static const cmt_string suffix[1] = {"bat"};
4026 static const PrintMode mode[1] = {Bat};
4027#else
4028 static const int modes = 2;
4029 static const cmt_string suffix[2] = {"csh", "sh"};
4030 static const PrintMode mode[2] = {Csh, Sh};
4031#endif
4032
4033 cout << "Creating setup scripts." << endl;
4034
4035
4036 cmt_string no_cleanup_opt;
4037
4038 if ((get_setup_strategy () & SetupCleanupMask) != SetupCleanup)
4039 {
4040 no_cleanup_opt = " -no_cleanup";
4041 }
4042
4043 cmt_string temp;
4044 int i;
4045
4046 cmt_string version = m_current_version;
4047 if (version == "v*") version = "";
4048
4049 for (i = 0; i < modes; i++)
4050 {
4051 cmt_string file_name = "setup";
4052 file_name += ".";
4053 file_name += suffix[i];
4054 file_name += ".";
4055 file_name += "new";
4056
4057 FILE* f = fopen (file_name.c_str (), "wb");
4058 if (f != NULL)
4059 {
4060 if (mode[i] == Csh)
4061 {
4062 fprintf (f, "# echo \"Setting %s %s in %s\"\n",
4063 m_current_package.c_str (),
4064 version.c_str (),
4065 m_current_path.c_str ());
4066 fprintf (f, "\n");
4067
4068 fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
4069 fprintf (f, " setenv CMTROOT %s\n", m_cmt_root.c_str ());
4070 fprintf (f, "endif\n");
4071 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
4072 fprintf (f, "\n");
4073 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4074 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n");
4075 fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
4076 "-pack=%s -version=%s -path=%s %s $* >${tempfile}; "
4077 "source ${tempfile}\n",
4078 suffix[i].c_str (),
4079 m_current_package.c_str (),
4080 version.c_str (),
4081 m_current_path.c_str (),
4082 no_cleanup_opt.c_str ());
4083 fprintf (f, "/bin/rm -f ${tempfile}\n");
4084 }
4085 else if (mode[i] == Sh)
4086 {
4087 fprintf (f, "# echo \"Setting %s %s in %s\"\n",
4088 m_current_package.c_str (),
4089 version.c_str (),
4090 m_current_path.c_str ());
4091 fprintf (f, "\n");
4092
4093 fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
4094 fprintf (f, " CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ());
4095 fprintf (f, "fi\n");
4096 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
4097 fprintf (f, "\n");
4098 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4099 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
4100 fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
4101 "-pack=%s -version=%s -path=%s %s $* >${tempfile}; "
4102 ". ${tempfile}\n",
4103 suffix[i].c_str (),
4104 m_current_package.c_str (),
4105 version.c_str (),
4106 m_current_path.c_str (),
4107 no_cleanup_opt.c_str ());
4108 fprintf (f, "/bin/rm -f ${tempfile}\n");
4109 }
4110 else if (mode[i] == Bat)
4111 {
4112 fprintf (f, "rem Setting %s %s in %%~d0%%~p0\n",
4113 m_current_package.c_str (),
4114 version.c_str ());
4115 dos_script_prefix (f, m_cmt_root,
4116 m_current_package, version, m_current_path,
4117 "setup", no_cleanup_opt);
4118 }
4119
4120 fprintf (f, "\n");
4121
4122 fclose (f);
4123
4124 cmt_string old_file_name = "setup";
4125 old_file_name += ".";
4126 old_file_name += suffix[i];
4127
4128 CmtSystem::compare_and_update_files (file_name, old_file_name);
4129 }
4130 }
4131}
4132
4133//----------------------------------------------------------
4134void Cmt::install_test_cleanup_scripts ()
4135{
4136#ifdef WIN32
4137 static const int modes = 1;
4138 static const cmt_string suffix[1] = {"bat"};
4139 static const PrintMode mode[1] = {Bat};
4140#else
4141 static const int modes = 2;
4142 static const cmt_string suffix[2] = {"csh", "sh"};
4143 static const PrintMode mode[2] = {Csh, Sh};
4144#endif
4145
4146 cout << "Creating cleanup scripts." << endl;
4147
4148 cmt_string temp;
4149 int i;
4150
4151 cmt_string version = m_current_version;
4152 if (version == "v*") version = "";
4153
4154 for (i = 0; i < modes; i++)
4155 {
4156 cmt_string file_name = "cleanup";
4157 file_name += ".";
4158 file_name += suffix[i];
4159 file_name += ".";
4160 file_name += "new";
4161
4162 FILE* f = fopen (file_name.c_str (), "wb");
4163 if (f != NULL)
4164 {
4165 if (mode[i] == Csh)
4166 {
4167 fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
4168 fprintf (f, " setenv CMTROOT %s\n", m_cmt_root.c_str ());
4169 fprintf (f, "endif\n");
4170 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
4171 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4172 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n");
4173 fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; "
4174 "source ${tempfile}\n",
4175 suffix[i].c_str (),
4176 m_current_path.c_str ());
4177 fprintf (f, "/bin/rm -f ${tempfile}\n");
4178 }
4179 else if (mode[i] == Sh)
4180 {
4181 fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
4182 fprintf (f, " CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ());
4183 fprintf (f, "fi\n");
4184 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
4185 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4186 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
4187 fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; "
4188 ". ${tempfile}\n",
4189 suffix[i].c_str (),
4190 m_current_path.c_str ());
4191 fprintf (f, "/bin/rm -f ${tempfile}\n");
4192 }
4193 else
4194 {
4195 dos_script_prefix (f, m_cmt_root,
4196 "cmt_standalone", "", m_current_path,
4197 "cleanup");
4198 }
4199
4200 fprintf (f, "\n");
4201
4202 fclose (f);
4203
4204 cmt_string old_file_name = "cleanup";
4205 old_file_name += ".";
4206 old_file_name += suffix[i];
4207
4208 CmtSystem::compare_and_update_files (file_name, old_file_name);
4209 }
4210 }
4211}
4212
4213//----------------------------------------------------------
4214void Cmt::install_test_setup_scripts ()
4215{
4216#ifdef WIN32
4217 static const int modes = 1;
4218 static const cmt_string suffix[1] = {"bat"};
4219 static const PrintMode mode[1] = {Bat};
4220#else
4221 static const int modes = 2;
4222 static const cmt_string suffix[2] = {"csh", "sh"};
4223 static const PrintMode mode[2] = {Csh, Sh};
4224#endif
4225
4226 cout << "Creating setup scripts." << endl;
4227
4228 cmt_string no_cleanup_opt;
4229
4230 if ((get_setup_strategy () & SetupCleanupMask) != SetupCleanup)
4231 {
4232 no_cleanup_opt = " -no_cleanup";
4233 }
4234
4235 cmt_string temp;
4236 int i;
4237
4238 for (i = 0; i < modes; i++)
4239 {
4240 cmt_string file_name = "setup";
4241 file_name += ".";
4242 file_name += suffix[i];
4243 file_name += ".";
4244 file_name += "new";
4245
4246 FILE* f = fopen (file_name.c_str (), "wb");
4247 if (f != NULL)
4248 {
4249 if (mode[i] == Csh)
4250 {
4251 fprintf (f, "# echo \"Setting standalone package\"\n");
4252 fprintf (f, "\n");
4253
4254 fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
4255 fprintf (f, " setenv CMTROOT %s\n", m_cmt_root.c_str ());
4256 fprintf (f, "endif\n");
4257 fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
4258 fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4259 fprintf (f, "if $status != 0 then\n set tempfile=/tmp/cmt.$$\nendif\n");
4260 fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${tempfile}; "
4261 "source ${tempfile}\n",
4262 suffix[i].c_str (),
4263 m_current_path.c_str (),
4264 no_cleanup_opt.c_str ());
4265 fprintf (f, "/bin/rm -f ${tempfile}\n");
4266 }
4267 else if (mode[i] == Sh)
4268 {
4269 fprintf (f, "# echo \"Setting standalone package\"\n");
4270 fprintf (f, "\n");
4271
4272 fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
4273 fprintf (f, " CMTROOT=%s; export CMTROOT\n", m_cmt_root.c_str ());
4274 fprintf (f, "fi\n");
4275 fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
4276 fprintf (f, "\n");
4277 fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
4278 fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
4279 fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${tempfile}; "
4280 ". ${tempfile}\n",
4281 suffix[i].c_str (),
4282 m_current_path.c_str (),
4283 no_cleanup_opt.c_str ());
4284 fprintf (f, "/bin/rm -f ${tempfile}\n");
4285 }
4286 else
4287 {
4288 fprintf (f, "rem Setting standalone package\n");
4289 dos_script_prefix (f, m_cmt_root,
4290 "cmt_standalone", "", m_current_path,
4291 "setup", no_cleanup_opt);
4292 }
4293
4294 fprintf (f, "\n");
4295
4296 fclose (f);
4297
4298 cmt_string old_file_name = "setup";
4299 old_file_name += ".";
4300 old_file_name += suffix[i];
4301
4302 CmtSystem::compare_and_update_files (file_name, old_file_name);
4303 }
4304 }
4305}
4306
4307/**
4308 * load is only called from the Windows GUI which pretends to access directly
4309 * the internal data model.
4310 * This is considered to be rather unsafe, and should be replaced by query functions.
4311 */
4312bool Cmt::load (const cmt_string& path,
4313 const cmt_string& package,
4314 const cmt_string& version,
4315 const cmt_string& tag_name)
4316{
4317 clear ();
4318 configure ();
4319
4320 m_action = action_load;
4321 m_recursive = true;
4322
4323 if (((package != "") && (version != "")) || (m_current_package == ""))
4324 {
4325 //
4326 // Here we want to connect to a new package, or to the current package
4327 // but with another tag.
4328 //
4329 // the 'package' argument may include a directory offset. Thus 'path'
4330 // is only expected to hold the base directory.
4331 //
4332 cmt_string offset;
4333 cmt_string package_name;
4334
4335 CmtSystem::dirname (package, offset);
4336 CmtSystem::basename (package, package_name);
4337
4338 if (offset != "")
4339 {
4340 m_current_path = path;
4341 m_current_path += CmtSystem::file_separator ();
4342 m_current_path += offset;
4343 }
4344 else
4345 {
4346 m_current_path = path;
4347 }
4348
4349 m_current_package = package_name;
4350 m_current_version = version;
4351 }
4352
4353 if (tag_name != "")
4354 {
4355 Tag* tag;
4356
4357 Tag::unmark_all ();
4358 configure_version_tag ();
4359 configure_site_tag (0);
4360 configure_uname_tag ();
4361 configure_hosttype_tag ();
4362
4363 m_current_tag = tag_name;
4364
4365 //if (!m_quiet) cerr << "load1> current_tag=" << m_current_tag << endl;
4366
4367 tag = Tag::add (tag_name, PriorityTag, "load", 0);
4368 tag->mark ();
4369 }
4370
4371 /*
4372 Set to developer mode if positioned into the package
4373 (which is detected since we were able to retreive the
4374 Version, Package and Path)
4375 */
4376
4377 if ((m_current_path == "") ||
4378 (m_current_package == "") ||
4379 (m_current_version == ""))
4380 {
4381 m_current_access = UserMode;
4382 }
4383 else
4384 {
4385 m_current_access = DeveloperMode;
4386 }
4387
4388 use_cmt ();
4389
4390 cmt_string dir;
4391
4392 /*
4393 Try to access the package.
4394 */
4395
4396 if (m_current_path != "")
4397 {
4398 dir = m_current_path;
4399 }
4400 else
4401 {
4402 dir = m_default_path;
4403 }
4404
4405 if (!CmtSystem::cd (m_current_path))
4406 {
4407 if (!m_quiet)
4408 {
4409 cerr << "#CMT> Cannot reach the directory " <<
4410 m_current_path << endl;
4411 }
4412 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the path directory");
4413 CmtSystem::cd (m_current_dir);
4414
4415 return (false);
4416 }
4417
4418 dir += CmtSystem::file_separator ();
4419 dir += m_current_package;
4420
4421 if (!CmtSystem::cd (m_current_package))
4422 {
4423 if (!m_quiet)
4424 {
4425 cerr << "#CMT::load> Cannot reach the package " <<
4426 m_current_package << endl;
4427 }
4428 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the package directory");
4429 CmtSystem::cd (m_current_dir);
4430
4431 return (false);
4432 }
4433
4434 dir += CmtSystem::file_separator ();
4435 dir += m_current_version;
4436
4437 m_current_style = none_style;
4438
4439 if (!CmtSystem::cd (m_current_version))
4440 {
4441 if (!CmtSystem::test_directory ("cmt"))
4442 {
4443 if (!m_quiet)
4444 {
4445 cerr << "#CMT> Cannot reach the version " <<
4446 m_current_version << endl;
4447 }
4448 CmtError::set (CmtError::package_not_found, "Load> Cannot reach the version directory");
4449 CmtSystem::cd (m_current_dir);
4450
4451 return (false);
4452 }
4453 else
4454 {
4455 m_current_style = no_version_style;
4456 }
4457 }
4458
4459 if (CmtSystem::cd ("cmt"))
4460 {
4461 dir += CmtSystem::file_separator ();
4462 dir += "cmt";
4463 if (m_current_style == none_style) m_current_style = cmt_style;
4464 }
4465 else
4466 {
4467 /*
4468 if (!m_quiet)
4469 {
4470 cerr << "Cannot reach the cmt branch" << endl;
4471 }
4472 */
4473
4474 if (CmtSystem::cd ("mgr"))
4475 {
4476 dir += CmtSystem::file_separator ();
4477 dir += "mgr";
4478 if (m_current_style == none_style) m_current_style = mgr_style;
4479 }
4480 else
4481 {
4482 if (!m_quiet)
4483 {
4484 cerr << "#CMT> Cannot reach the mgr branch" << endl;
4485 }
4486
4487 CmtError::set (CmtError::package_not_found,
4488 "Load> Cannot reach the mgr/cmt directory");
4489 CmtSystem::cd (m_current_dir);
4490
4491 return (false);
4492 }
4493 }
4494
4495 /*
4496 Check Tag is always set up
4497 */
4498
4499 if (m_current_tag == "")
4500 {
4501 char* env;
4502
4503 env = getenv (m_current_config.c_str ());
4504 if (env != 0)
4505 {
4506 Tag* tag;
4507
4508 tag = Tag::add (env, PriorityConfig, "load", 0);
4509 tag->mark ();
4510 m_current_tag = env;
4511
4512 //if (!m_quiet) cerr << "load2> current_tag=" << m_current_tag << endl;
4513
4514 }
4515 else
4516 {
4517 m_current_tag = m_cmt_config;
4518
4519 //if (!m_quiet) cerr << "load3> current_tag=" << m_current_tag << endl;
4520
4521 }
4522 }
4523
4524 if (m_debug)
4525 {
4526 cout << "pwd = " << CmtSystem::pwd () << endl;
4527 }
4528
4529 configure_current_dir ();
4530 build_prefix (m_current_package, m_current_prefix);
4531 build_config (m_current_prefix, m_current_config);
4532
4533 Use* use = &(Use::current());
4534 use->path = m_current_path;
4535 use->set_package_name (m_current_package);
4536 use->version = m_current_version;
4537 use->prefix = m_current_prefix;
4538 use->done = false;
4539 use->style = m_current_style;
4540
4541 /*
4542 Work on the requirements file.
4543 */
4544
4545 dir += CmtSystem::file_separator ();
4546 dir += "requirements";
4547 SyntaxParser::parse_requirements (dir, use);
4548
4549 if (CmtError::has_pending_error ()) return (false);
4550
4551 /**
4552 * See reach_current_package for an explanation of this call
4553 */
4554 Pattern::apply_all_globals ();
4555
4556 /*
4557 Select all possible tags
4558 */
4559
4560 Tag::restore_tree ();
4561
4562 return (true);
4563}
4564
4565//----------------------------------------------------------
4566bool Cmt::need_prototypes ()
4567{
4568 if ((get_build_strategy () & PrototypesMask) == Prototypes) return (true);
4569 else return (false);
4570}
4571
4572//----------------------------------------------------------
4573void Cmt::parse_arguments (int argc, char* argv[],
4574 CmtSystem::cmt_string_vector& arguments,
4575 cmt_string& extra_line,
4576 cmt_string& extra_file,
4577 PrintMode& mode)
4578{
4579 /*
4580 Decoding arguments.
4581
4582 While decoding all arguments, no requirements analysis should
4583 occur. Every new option, or parameter should be saved and
4584 used later at actual analysis time.
4585 */
4586
4587 cmt_string arg;
4588
4589 m_action = action_none;
4590 m_help_action = action_none;
4591
4592 arguments.clear ();
4593 extra_line.erase (0);
4594 extra_file.erase (0);
4595 mode = Csh;
4596
4597 /*
4598 Tag management.
4599 ---------------
4600
4601 Tag settings may come from :
4602
4603 - existing environment variables:
4604
4605 1) CMTCONFIG
4606
4607 2) CMTEXTRATAGS for addons
4608
4609 - arguments:
4610
4611 -tag=<tag-list>
4612 -tag_add=<tag-list>
4613 -tag_remove=<tag-list>
4614
4615 o Arguments should take precedence over environment variables.
4616 o when nothing is specified:
4617
4618 - primary tag = CMTCONFIG
4619 - tag set is empty
4620
4621
4622 */
4623
4624
4625 restore_all_tags (0);
4626
4627#ifdef WIN32
4628 m_build_nmake = true;
4629#endif
4630
4631 while (argc > 1)
4632 {
4633 int lf;
4634
4635 arg = argv[1];
4636 lf = arg.find ('\r');
4637 if (lf != cmt_string::npos) arg.erase (lf);
4638
4639 if ((arg[0] == '\"') && (arg[arg.size () - 1] == '\"'))
4640 {
4641 arg.erase (0, 1);
4642 arg.erase (arg.size () - 1, 1);
4643 }
4644
4645 //fprintf (stderr, "arg=[%s]\n", arg.c_str ());
4646
4647 switch (arg[0])
4648 {
4649 case 'a' :
4650 if (arg == "awk")
4651 {
4652 argc--;
4653 argv++;
4654 while (argc > 1)
4655 {
4656 cmt_string& s = arguments.add ();
4657 s = argv[1];
4658 argc--;
4659 argv++;
4660 }
4661
4662 m_action = action_awk;
4663 }
4664 break;
4665 case 'b' :
4666 if ((arg == "b") ||
4667 (arg == "br") ||
4668 (arg == "bro") ||
4669 (arg == "broa") ||
4670 (arg == "broad") ||
4671 (arg == "broadc") ||
4672 (arg == "broadca") ||
4673 (arg == "broadcas") ||
4674 (arg == "broadcast"))
4675 {
4676 argc--;
4677 argv++;
4678 while (argc > 1)
4679 {
4680 cmt_string& s = arguments.add ();
4681 s = argv[1];
4682 argc--;
4683 argv++;
4684 }
4685
4686 m_action = action_broadcast;
4687
4688 if (m_scope_filtering_mode == default_filtering_mode)
4689 {
4690 set_scope_filtering_mode (reach_private_uses);
4691 }
4692 }
4693 else if (arg == "build")
4694 {
4695 argc--;
4696 argv++;
4697
4698 if (argc > 1)
4699 {
4700 arg = argv[1];
4701
4702 if (arg == "-nmake")
4703 {
4704 m_build_nmake = true;
4705 argc--;
4706 argv++;
4707 }
4708 }
4709
4710 if (argc > 1)
4711 {
4712 arg = argv[1];
4713
4714 if (arg == "-nmake")
4715 {
4716 argc--;
4717 argv++;
4718 }
4719
4720 if (arg == "constituent_makefile")
4721 {
4722 argc--;
4723 argv++;
4724 if (argc > 1)
4725 {
4726 cmt_string& s = arguments.add ();
4727 s = argv[1];
4728
4729 m_action = action_build_constituent_makefile;
4730 }
4731 else
4732 {
4733 if (!m_quiet) cerr << "#CMT> syntax error : constituent name missing" << endl;
4734 m_action = action_build_constituent_makefile;
4735 m_help_action = action_help;
4736 }
4737 }
4738 else if (arg == "constituents_makefile")
4739 {
4740 argc--;
4741 argv++;
4742 while (argc > 1)
4743 {
4744 cmt_string& s = arguments.add ();
4745 s = argv[1];
4746 argc--;
4747 argv++;
4748 }
4749
4750 m_action = action_build_constituents_makefile;
4751 }
4752 else if (arg == "dependencies")
4753 {
4754 argc--;
4755 argv++;
4756 if (argc > 1)
4757 {
4758 cmt_string& s = arguments.add ();
4759 s = argv[1];
4760
4761 m_action = action_build_dependencies;
4762 }
4763 else
4764 {
4765 if (!m_quiet) cerr << "#CMT> syntax error : arguments missing " << endl;
4766 m_help_action = action_help;
4767 m_action = action_build_dependencies;
4768 }
4769
4770 argc = 0;
4771 }
4772 else if (arg == "library_links")
4773 {
4774 m_action = action_build_library_links;
4775 }
4776 else if (arg == "make_setup")
4777 {
4778 m_action = action_build_make_setup;
4779 }
4780 else if (arg == "msdev")
4781 {
4782 argc--;
4783 argv++;
4784
4785 if (argc > 1)
4786 {
4787 cmt_string& s = arguments.add ();
4788 s = argv[1];
4789 if (s[0] == '-')
4790 {
4791 s = "";
4792 argc++;
4793 argv--;
4794 }
4795 }
4796
4797 m_action = action_build_msdev;
4798 }
4799 else if (arg == "CMT_pacman")
4800 {
4801 m_action = action_build_CMT_pacman;
4802 }
4803 else if (arg == "vsnet")
4804 {
4805 argc--;
4806 argv++;
4807
4808 if (argc > 1)
4809 {
4810 cmt_string& s = arguments.add ();
4811 s = argv[1];
4812 if (s[0] == '-')
4813 {
4814 s = "";
4815 argc++;
4816 argv--;
4817 }
4818 }
4819
4820 m_action = action_build_vsnet;
4821 }
4822 else if (arg == "os9_makefile")
4823 {
4824 argc--;
4825 argv++;
4826 if (argc > 1)
4827 {
4828 cmt_string& s = arguments.add ();
4829 s = argv[1];
4830
4831 m_action = action_build_os9_makefile;
4832 }
4833 else
4834 {
4835 if (!m_quiet) cerr << "#CMT> syntax error : arguments missing " << endl;
4836 m_help_action = action_help;
4837 m_action = action_build_os9_makefile;
4838 }
4839 }
4840 else if (arg == "prototype")
4841 {
4842 argc--;
4843 argv++;
4844 if (argc > 1)
4845 {
4846 cmt_string& s = arguments.add ();
4847 s = argv[1];
4848
4849 m_action = action_build_prototype;
4850 }
4851 else
4852 {
4853 if (!m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
4854 m_help_action = action_help;
4855 m_action = action_build_prototype;
4856 }
4857 }
4858 else if (arg == "readme")
4859 {
4860 m_action = action_build_readme;
4861
4862 argc--;
4863 argv++;
4864 while (argc > 1)
4865 {
4866 cmt_string& s = arguments.add ();
4867 s = argv[1];
4868 argc--;
4869 argv++;
4870 }
4871 }
4872 else if (arg == "tag_makefile")
4873 {
4874 m_action = action_build_tag_makefile;
4875 }
4876 else if (arg == "temporary_name")
4877 {
4878 m_action = action_build_temporary_name;
4879 }
4880 else if (arg == "triggers")
4881 {
4882 argc--;
4883 argv++;
4884 if (argc > 1)
4885 {
4886 cmt_string& s = arguments.add ();
4887 s = argv[1];
4888
4889 m_action = action_build_triggers;
4890 }
4891 else
4892 {
4893 if (!m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
4894 m_help_action = action_help;
4895 m_action = action_build_triggers;
4896 }
4897 }
4898 else if (arg == "windefs")
4899 {
4900 argc--;
4901 argv++;
4902 if (argc > 1)
4903 {
4904 cmt_string& s = arguments.add ();
4905 s = argv[1];
4906
4907 m_action = action_build_windefs;
4908 }
4909 else
4910 {
4911 if (!m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
4912 m_help_action = action_help;
4913 m_action = action_build_windefs;
4914 }
4915 }
4916 else
4917 {
4918 if (!m_quiet) cerr << "#CMT> syntax error : wrong argument" << endl;
4919 m_help_action = action_help;
4920 m_action = action_build;
4921 }
4922 }
4923 else
4924 {
4925 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to build" << endl;
4926 m_help_action = action_help;
4927 m_action = action_build;
4928 }
4929 }
4930 else
4931 {
4932 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
4933 m_help_action = action_help;
4934 }
4935 break;
4936 case 'c' :
4937 if (arg == "check")
4938 {
4939 argc--;
4940 argv++;
4941
4942 if (argc > 1)
4943 {
4944 arg = argv[1];
4945
4946 if (arg == "configuration")
4947 {
4948 m_action = action_check_configuration;
4949 }
4950 else if (arg == "files")
4951 {
4952 argc--;
4953 argv++;
4954 if (argc > 1)
4955 {
4956 cmt_string& s = arguments.add ();
4957 s = argv[1];
4958 argc--;
4959 argv++;
4960 if (argc > 1)
4961 {
4962 cmt_string& s = arguments.add ();
4963 s = argv[1];
4964
4965 m_action = action_check_files;
4966 }
4967 else
4968 {
4969 if (!m_quiet) cerr << "#CMT> syntax error : reference file name missing"
4970 << endl;
4971 m_help_action = action_help;
4972 m_action = action_check_files;
4973 }
4974 }
4975 else
4976 {
4977 if (!m_quiet) cerr << "#CMT> syntax error : file name missing" << endl;
4978 m_help_action = action_help;
4979 m_action = action_check_files;
4980 }
4981 }
4982 else if (arg == "version")
4983 {
4984 argc--;
4985 argv++;
4986 if (argc > 1)
4987 {
4988 cmt_string& s = arguments.add ();
4989 s = argv[1];
4990
4991 m_action = action_check_version;
4992 }
4993 else
4994 {
4995 if (!m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
4996 m_help_action = action_help;
4997 m_action = action_check_version;
4998 }
4999 }
5000 else
5001 {
5002 if (!m_quiet) cerr << "#CMT> syntax error : bad check option" << endl;
5003 m_help_action = action_help;
5004 m_action = action_check;
5005 }
5006 }
5007 else
5008 {
5009 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to check" << endl;
5010 m_help_action = action_help;
5011 m_action = action_check;
5012 }
5013 }
5014 else if (arg == "check_files")
5015 {
5016 argc--;
5017 argv++;
5018 if (argc > 1)
5019 {
5020 cmt_string& s = arguments.add ();
5021 s = argv[1];
5022 argc--;
5023 argv++;
5024 if (argc > 1)
5025 {
5026 cmt_string& s = arguments.add ();
5027 s = argv[1];
5028
5029 m_action = action_check_files;
5030 }
5031 else
5032 {
5033 if (!m_quiet) cerr << "#CMT> syntax error : reference file missing" << endl;
5034 m_help_action = action_help;
5035 m_action = action_check_files;
5036 }
5037 }
5038 else
5039 {
5040 if (!m_quiet) cerr << "#CMT> syntax error : file name missing" << endl;
5041 m_help_action = action_help;
5042 m_action = action_check_files;
5043 }
5044 }
5045 else if ((arg == "co") ||
5046 (arg == "checkout"))
5047 {
5048 // handle all of the command line arguments in a vector
5049 argc--;
5050 argv++;
5051 if (argc > 1)
5052 {
5053 m_action = action_checkout;
5054
5055 while (argc > 1)
5056 {
5057 cmt_string& s = arguments.add ();
5058 s = argv[1];
5059 argc--;
5060 argv++;
5061 }
5062 }
5063 else
5064 {
5065 if (!m_quiet) cerr << "#CMT> syntax error : checkout arguments missing" << endl;
5066 m_help_action = action_help;
5067 m_action = action_checkout;
5068 }
5069 }
5070 else if (arg == "cleanup")
5071 {
5072 m_action = action_cleanup;
5073 }
5074 else if (arg == "config")
5075 {
5076 argc--;
5077 argv++;
5078 if (argc > 1)
5079 {
5080 cerr << "#---------------------------------------------------------" << endl;
5081 cerr << "# Warning: using 'cmt config ...' to create a package is "
5082 "becoming obsolete" << endl;
5083 cerr << "# Please use 'cmt create ...' instead" << endl;
5084 cerr << "#---------------------------------------------------------" << endl;
5085
5086 m_current_package = argv[1];
5087 m_current_version.erase (0);
5088 m_current_path.erase (0);
5089
5090 argc--;
5091 argv++;
5092 if (argc > 1)
5093 {
5094 m_current_version = argv[1];
5095
5096 {
5097 cmt_string& s = arguments.add ();
5098 s = m_current_package;
5099 }
5100 {
5101 cmt_string& s = arguments.add ();
5102 s = m_current_version;
5103 }
5104
5105 argc--;
5106 argv++;
5107 if (argc > 1)
5108 {
5109 m_current_path = argv[1];
5110 if (m_current_path[0] == '-')
5111 {
5112 m_current_path.erase (0);
5113 }
5114 }
5115
5116 m_action = action_create;
5117 }
5118 else
5119 {
5120 if (!m_quiet) cerr << "#CMT> syntax error : create arguments missing" << endl;
5121 m_help_action = action_help;
5122 m_action = action_create;
5123 }
5124 }
5125 else
5126 {
5127 m_action = action_config;
5128 }
5129 }
5130 else if (arg == "create")
5131 {
5132 argc--;
5133 argv++;
5134
5135 if (argc > 1)
5136 {
5137 while (argc > 1)
5138 {
5139 cmt_string& s = arguments.add ();
5140 s = argv[1];
5141 argc--;
5142 argv++;
5143 }
5144
5145 m_action = action_create;
5146 }
5147 else
5148 {
5149 if (!m_quiet) cerr << "#CMT> syntax error : create arguments missing" << endl;
5150 m_help_action = action_help;
5151 m_action = action_create;
5152 }
5153 }
5154 else if (arg == "create_project")
5155 {
5156 argc--;
5157 argv++;
5158
5159 if (argc > 1)
5160 {
5161 while (argc > 1)
5162 {
5163 cmt_string& s = arguments.add ();
5164 s = argv[1];
5165 argc--;
5166 argv++;
5167 }
5168
5169 m_action = action_create_project;
5170 }
5171 else
5172 {
5173 if (!m_quiet) cerr << "#CMT> syntax error : create_project arguments missing" << endl;
5174 m_help_action = action_help;
5175 m_action = action_create_project;
5176 }
5177 }
5178 else if (arg == "cvsbranches")
5179 {
5180 argc--;
5181 argv++;
5182 if (argc > 1)
5183 {
5184 cmt_string& s = arguments.add ();
5185 s = argv[1];
5186 argc--;
5187 argv++;
5188
5189 m_action = action_cvsbranches;
5190 }
5191 else
5192 {
5193 if (!m_quiet) cerr << "#CMT> syntax error : cvsbranches arguments missing" << endl;
5194 m_help_action = action_help;
5195 m_action = action_cvsbranches;
5196 }
5197 }
5198 else if (arg == "cvssubpackages")
5199 {
5200 argc--;
5201 argv++;
5202 if (argc > 1)
5203 {
5204 cmt_string& s = arguments.add ();
5205 s = argv[1];
5206 argc--;
5207 argv++;
5208
5209 m_action = action_cvssubpackages;
5210 }
5211 else
5212 {
5213 if (!m_quiet) cerr << "#CMT> syntax error : cvssubpackages arguments missing" << endl;
5214 m_help_action = action_help;
5215 m_action = action_cvssubpackages;
5216 }
5217 }
5218 else if (arg == "cvstags")
5219 {
5220 argc--;
5221 argv++;
5222 if (argc > 1)
5223 {
5224 while (argc > 1)
5225 {
5226 cmt_string& s = arguments.add ();
5227 s = argv[1];
5228 argc--;
5229 argv++;
5230 }
5231
5232 m_action = action_cvstags;
5233 }
5234 else
5235 {
5236 if (!m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
5237 m_help_action = action_help;
5238 m_action = action_cvstags;
5239 }
5240 }
5241 else
5242 {
5243 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5244 m_help_action = action_help;
5245 }
5246 break;
5247 case 'd' :
5248 if (arg == "do")
5249 {
5250 argc--;
5251 argv++;
5252
5253 if (argc > 1)
5254 {
5255 while (argc > 1)
5256 {
5257 cmt_string& s = arguments.add ();
5258 s = argv[1];
5259 argc--;
5260 argv++;
5261 }
5262
5263 {
5264 cmt_string tag_name = "target_";
5265 tag_name += arguments[0];
5266
5267 Tag* tag;
5268 tag = Tag::add (tag_name, PriorityUserTag, "action", 0);
5269 tag->mark ();
5270 }
5271
5272 m_action = action_do;
5273 }
5274 else
5275 {
5276 if (!m_quiet) cerr << "#CMT> syntax error : action not specified" << endl;
5277 m_help_action = action_help;
5278 m_action = action_do;
5279 }
5280 }
5281 else
5282 {
5283 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5284 m_help_action = action_help;
5285 }
5286 break;
5287 case 'e' :
5288 if (arg == "expand")
5289 {
5290 argc--;
5291 argv++;
5292
5293 if (argc > 1)
5294 {
5295 arg = argv[1];
5296
5297 if (arg == "model")
5298 {
5299 argc--;
5300 argv++;
5301
5302 if (argc > 1)
5303 {
5304 while (argc > 1)
5305 {
5306 cmt_string& s = arguments.add ();
5307 s = argv[1];
5308 argc--;
5309 argv++;
5310 }
5311
5312 m_action = action_expand_model;
5313 }
5314 else
5315 {
5316 if (!m_quiet) cerr << "#CMT> syntax error : model not specified" << endl;
5317 m_help_action = action_help;
5318 m_action = action_expand_model;
5319 }
5320 }
5321 else
5322 {
5323 if (!m_quiet) cerr << "#CMT> syntax error : bad expand option" << endl;
5324 m_help_action = action_help;
5325 m_action = action_expand_model;
5326 }
5327 }
5328 else
5329 {
5330 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to expand" << endl;
5331 m_help_action = action_help;
5332 m_action = action_expand_model;
5333 }
5334 }
5335 else
5336 {
5337 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5338 m_help_action = action_help;
5339 }
5340 break;
5341 case 'f' :
5342 if ((arg == "f") ||
5343 (arg == "fi") ||
5344 (arg == "fil") ||
5345 (arg == "filt") ||
5346 (arg == "filte") ||
5347 (arg == "filter"))
5348 {
5349 // handle all of the command line arguments in a vector
5350 argc--;
5351 argv++;
5352 while (argc > 1)
5353 {
5354 cmt_string& s = arguments.add ();
5355 s = argv[1];
5356 argc--;
5357 argv++;
5358 }
5359
5360 m_action = action_filter;
5361 }
5362 else
5363 {
5364 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5365 m_help_action = action_help;
5366 }
5367 break;
5368 case 'h' :
5369 if ((arg == "h") ||
5370 (arg == "he") ||
5371 (arg == "hel") ||
5372 (arg == "help"))
5373 {
5374 m_help_action = action_help;
5375 }
5376 else
5377 {
5378 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5379 m_help_action = action_help;
5380 }
5381 break;
5382 case 'l' :
5383 if (arg == "lock")
5384 {
5385 argc--;
5386 argv++;
5387 if (argc > 1)
5388 {
5389 m_current_package = argv[1];
5390 {
5391 cmt_string& s = arguments.add ();
5392 s = m_current_package;
5393 }
5394
5395 m_current_version.erase (0);
5396 m_current_path.erase (0);
5397
5398 argc--;
5399 argv++;
5400 if (argc > 1)
5401 {
5402 m_current_version = argv[1];
5403
5404 {
5405 cmt_string& s = arguments.add ();
5406 s = m_current_version;
5407 }
5408
5409 m_action = action_lock;
5410
5411 argc--;
5412 argv++;
5413 if (argc > 1)
5414 {
5415 m_current_path = argv[1];
5416 if (m_current_path[0] == '-')
5417 {
5418 m_current_path.erase (0);
5419 }
5420 }
5421
5422 m_current_access = UserMode;
5423 (Use::current()).set (m_current_package,
5424 m_current_version,
5425 m_current_path);
5426
5427 }
5428 else
5429 {
5430 if (!m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
5431 m_help_action = action_help;
5432 m_action = action_lock;
5433 }
5434 }
5435 else
5436 {
5437 m_action = action_lock;
5438 }
5439 }
5440 else
5441 {
5442 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5443 m_help_action = action_help;
5444 }
5445 break;
5446 case 'r' :
5447 if (arg == "remove")
5448 {
5449 argc--;
5450 argv++;
5451
5452 if (argc > 1)
5453 {
5454 arg = argv[1];
5455
5456 if (arg == "library_links")
5457 {
5458 m_action = action_remove_library_links;
5459 }
5460 else
5461 {
5462 m_current_package = argv[1];
5463 {
5464 cmt_string& s = arguments.add ();
5465 s = m_current_package;
5466 }
5467
5468 m_current_version.erase (0);
5469 m_current_path.erase (0);
5470
5471 argc--;
5472 argv++;
5473 if (argc > 1)
5474 {
5475 m_current_version = argv[1];
5476
5477 {
5478 cmt_string& s = arguments.add ();
5479 s = m_current_version;
5480 }
5481
5482 argc--;
5483 argv++;
5484 if (argc > 1)
5485 {
5486 m_current_path = argv[1];
5487 if (m_current_path[0] == '-')
5488 {
5489 m_current_path.erase (0);
5490 }
5491 }
5492
5493 m_action = action_remove;
5494 }
5495 else
5496 {
5497 if (!m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
5498 m_help_action = action_help;
5499 m_action = action_remove;
5500 }
5501 }
5502 }
5503 else
5504 {
5505 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to remove" << endl;
5506 m_help_action = action_help;
5507 m_action = action_remove;
5508 }
5509 }
5510 else if (arg == "run")
5511 {
5512 argc--;
5513 argv++;
5514 if (argc > 1)
5515 {
5516 cmt_string& s = arguments.add ();
5517 s = argv[1];
5518
5519 m_action = action_run;
5520 }
5521 else
5522 {
5523 if (!m_quiet) cerr << "#CMT> syntax error : run arguments missing" << endl;
5524 m_help_action = action_help;
5525 m_action = action_run;
5526 }
5527 }
5528 else if (arg == "run_sequence")
5529 {
5530 argc--;
5531 argv++;
5532 if (argc > 1)
5533 {
5534 cmt_string& s = arguments.add ();
5535 s = argv[1];
5536
5537 m_action = action_run_sequence;
5538 }
5539 else
5540 {
5541 if (!m_quiet) cerr << "#CMT> syntax error : run_sequence arguments missing" << endl;
5542 m_help_action = action_help;
5543 m_action = action_run_sequence;
5544 }
5545 }
5546 else
5547 {
5548 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
5549 m_help_action = action_help;
5550 }
5551 break;
5552 case 's' :
5553 if (arg == "set")
5554 {
5555 argc--;
5556 argv++;
5557 if (argc > 1)
5558 {
5559 arg = argv[1];
5560
5561 if (arg == "version")
5562 {
5563 argc--;
5564 argv++;
5565
5566 while (argc > 1)
5567 {
5568 cmt_string& s = arguments.add ();
5569 s = argv[1];
5570 argc--;
5571 argv++;
5572 }
5573
5574 m_action = action_set_version;
5575 }
5576 else if (arg == "versions")
5577 {
5578 argc--;
5579 argv++;
5580
5581 while (argc > 1)
5582 {
5583 cmt_string& s = arguments.add ();
5584 s = argv[1];
5585 argc--;
5586 argv++;
5587 }
5588
5589 m_action = action_set_versions;
5590
5591 if (m_scope_filtering_mode == default_filtering_mode)
5592 {
5593 set_scope_filtering_mode (reach_private_uses);
5594 }
5595 }
5596 else
5597 {
5598 if (!m_quiet) cerr << "#CMT> syntax error : bad set argument" << endl;
5599 m_help_action = action_help;
5600 //m_action = action_set;
5601 }
5602 }
5603 else
5604 {
5605 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to set" << endl;
5606 m_help_action = action_help;
5607 //m_action = action_set;
5608 }
5609 }
5610 else if (arg == "setup")
5611 {
5612 m_action = action_setup;
5613 }
5614 else if ((arg == "s") ||
5615 (arg == "sh") ||
5616 (arg == "sho") ||
5617 (arg == "show"))
5618 {
5619 argc--;
5620 argv++;
5621 if (argc > 1)
5622 {
5623 arg = argv[1];
5624
5625 if (arg == "action")
5626 {
5627 argc--;
5628 argv++;
5629 if (argc > 1)
5630 {
5631 cmt_string& s = arguments.add ();
5632 s = argv[1];
5633 m_current_target = argv[1];
5634
5635 m_action = action_show_action;
5636 }
5637 else
5638 {
5639 if (!m_quiet) cerr << "#CMT> syntax error : action name missing" << endl;
5640 m_help_action = action_help;
5641 m_action = action_show_action;
5642 }
5643 }
5644 else if (arg == "action_names")
5645 {
5646 argc--;
5647 argv++;
5648 if (argc > 1)
5649 {
5650 cmt_string& s = arguments.add ();
5651 s = argv[1];
5652 }
5653
5654 m_action = action_show_action_names;
5655 }
5656 else if (arg == "action_value")
5657 {
5658 m_quiet = true;
5659 argc--;
5660 argv++;
5661 if (argc > 1)
5662 {
5663 cmt_string& s = arguments.add ();
5664 s = argv[1];
5665 m_current_target = argv[1];
5666
5667 m_action = action_show_action_value;
5668 }
5669 else
5670 {
5671 if (!m_quiet) cerr << "#CMT> syntax error : action name missing" << endl;
5672 m_help_action = action_help;
5673 m_action = action_show_action_value;
5674 }
5675 }
5676 else if (arg == "actions")
5677 {
5678 argc--;
5679 argv++;
5680 if (argc > 1)
5681 {
5682 cmt_string& s = arguments.add ();
5683 s = argv[1];
5684 }
5685
5686 m_action = action_show_actions;
5687 }
5688 else if (arg == "all_tags")
5689 {
5690 m_action = action_show_all_tags;
5691 }
5692 else if (arg == "applied_patterns")
5693 {
5694 m_action = action_show_applied_patterns;
5695 }
5696 else if (arg == "author")
5697 {
5698 m_action = action_show_author;
5699 }
5700 else if (arg == "branches")
5701 {
5702 m_action = action_show_branches;
5703 }
5704 else if (arg == "clients")
5705 {
5706 argc--;
5707 argv++;
5708 if (argc > 1)
5709 {
5710 cmt_string& s = arguments.add ();
5711 s = argv[1];
5712 m_current_target = argv[1];
5713
5714 m_action = action_show_clients;
5715
5716 argc--;
5717 argv++;
5718 if (argc > 1)
5719 {
5720 cmt_string& s = arguments.add ();
5721 s = argv[1];
5722
5723 argc--;
5724 argv++;
5725 if (argc > 1)
5726 {
5727 cmt_string& s = arguments.add ();
5728 s = argv[1];
5729 }
5730 }
5731 }
5732 else
5733 {
5734 if (!m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
5735 m_help_action = action_help;
5736 m_action = action_show_clients;
5737 }
5738 }
5739 else if (arg == "cmtpath_patterns")
5740 {
5741 m_action = action_show_cmtpath_patterns;
5742 }
5743 else if (arg == "constituent")
5744 {
5745 argc--;
5746 argv++;
5747 if (argc > 1)
5748 {
5749 cmt_string& s = arguments.add ();
5750 s = argv[1];
5751 m_current_target = argv[1];
5752
5753 m_action = action_show_constituent;
5754 }
5755 else
5756 {
5757 if (!m_quiet) cerr << "#CMT> syntax error : constituent name missing" << endl;
5758 m_help_action = action_help;
5759 m_action = action_show_constituent;
5760 }
5761 }
5762 else if (arg == "constituent_names")
5763 {
5764 m_action = action_show_constituent_names;
5765 }
5766 else if (arg == "constituents")
5767 {
5768 m_action = action_show_constituents;
5769 }
5770 else if (arg == "cycles")
5771 {
5772 m_action = action_show_cycles;
5773 }
5774 else if (arg == "fragment")
5775 {
5776 argc--;
5777 argv++;
5778 if (argc > 1)
5779 {
5780 cmt_string& s = arguments.add ();
5781 s = argv[1];
5782 m_current_target = argv[1];
5783
5784 m_action = action_show_fragment;
5785 }
5786 else
5787 {
5788 if (!m_quiet) cerr << "#CMT> syntax error : fragment name missing" << endl;
5789 m_help_action = action_help;
5790 m_action = action_show_fragment;
5791 }
5792 }
5793 else if (arg == "fragments")
5794 {
5795 m_action = action_show_fragments;
5796 }
5797 else if (arg == "groups")
5798 {
5799 m_action = action_show_groups;
5800 }
5801 else if (arg == "include_dirs")
5802 {
5803 m_action = action_show_include_dirs;
5804 }
5805 else if (arg == "language")
5806 {
5807 argc--;
5808 argv++;
5809 if (argc > 1)
5810 {
5811 cmt_string& s = arguments.add ();
5812 s = argv[1];
5813 m_current_target = argv[1];
5814
5815 m_action = action_show_language;
5816 }
5817 else
5818 {
5819 if (!m_quiet) cerr << "#CMT> syntax error : language name missing" << endl;
5820 m_help_action = action_help;
5821 m_action = action_show_language;
5822 }
5823 }
5824 else if (arg == "languages")
5825 {
5826 m_action = action_show_languages;
5827 }
5828 else if (arg == "macro")
5829 {
5830 argc--;
5831 argv++;
5832 if (argc > 1)
5833 {
5834 cmt_string& s = arguments.add ();
5835 s = argv[1];
5836 m_current_target = argv[1];
5837
5838 m_action = action_show_macro;
5839 }
5840 else
5841 {
5842 if (!m_quiet) cerr << "#CMT> syntax error : macro name missing" << endl;
5843 m_help_action = action_help;
5844 m_action = action_show_macro;
5845 }
5846 }
5847 else if (arg == "macro_names")
5848 {
5849 argc--;
5850 argv++;
5851 if (argc > 1)
5852 {
5853 cmt_string& s = arguments.add ();
5854 s = argv[1];
5855 }
5856
5857 m_action = action_show_macro_names;
5858 }
5859 else if (arg == "macro_value")
5860 {
5861 m_quiet = true;
5862 argc--;
5863 argv++;
5864 if (argc > 1)
5865 {
5866 cmt_string& s = arguments.add ();
5867 s = argv[1];
5868 m_current_target = argv[1];
5869
5870 m_action = action_show_macro_value;
5871 }
5872 else
5873 {
5874 if (!m_quiet) cerr << "#CMT> syntax error : macro name missing" << endl;
5875 m_help_action = action_help;
5876 m_action = action_show_macro_value;
5877 }
5878 }
5879 else if (arg == "macros")
5880 {
5881 argc--;
5882 argv++;
5883 if (argc > 1)
5884 {
5885 cmt_string& s = arguments.add ();
5886 s = argv[1];
5887 }
5888
5889 m_action = action_show_macros;
5890 }
5891 else if (arg == "manager")
5892 {
5893 m_action = action_show_manager;
5894 }
5895 else if (arg == "packages")
5896 {
5897 argc--;
5898 argv++;
5899 if (argc > 1)
5900 {
5901 cmt_string& s = arguments.add ();
5902 s = argv[1];
5903 m_current_target = argv[1];
5904 }
5905
5906 m_action = action_show_packages;
5907 }
5908 else if (arg == "path")
5909 {
5910 m_action = action_show_path;
5911 }
5912 else if (arg == "pattern")
5913 {
5914 argc--;
5915 argv++;
5916 if (argc > 1)
5917 {
5918 cmt_string& s = arguments.add ();
5919 s = argv[1];
5920 m_current_target = argv[1];
5921
5922 m_action = action_show_pattern;
5923 }
5924 else
5925 {
5926 if (!m_quiet) cerr << "#CMT> syntax error : pattern name missing" << endl;
5927 m_help_action = action_help;
5928 m_action = action_show_pattern;
5929 }
5930 }
5931 else if (arg == "pattern_names")
5932 {
5933 m_action = action_show_pattern_names;
5934 }
5935 else if (arg == "patterns")
5936 {
5937 m_action = action_show_patterns;
5938 }
5939 else if (arg == "projects")
5940 {
5941 m_action = action_show_projects;
5942 }
5943 else if (arg == "pwd")
5944 {
5945 m_action = action_show_pwd;
5946 }
5947 else if (arg == "setup")
5948 {
5949 m_action = action_show_setup;
5950
5951 if (m_scope_filtering_mode == default_filtering_mode)
5952 {
5953 set_scope_filtering_mode (reach_private_uses);
5954 }
5955 }
5956 else if (arg == "set_names")
5957 {
5958 argc--;
5959 argv++;
5960 if (argc > 1)
5961 {
5962 cmt_string& s = arguments.add ();
5963 s = argv[1];
5964 }
5965
5966 m_action = action_show_set_names;
5967 }
5968 else if (arg == "set_value")
5969 {
5970 m_quiet = true;
5971 argc--;
5972 argv++;
5973 if (argc > 1)
5974 {
5975 cmt_string& s = arguments.add ();
5976 s = argv[1];
5977 m_current_target = argv[1];
5978
5979 m_action = action_show_set_value;
5980 }
5981 else
5982 {
5983 if (!m_quiet) cerr << "#CMT> syntax error : set name missing" << endl;
5984 m_help_action = action_help;
5985 m_action = action_show_set_value;
5986 }
5987 }
5988 else if (arg == "set")
5989 {
5990 argc--;
5991 argv++;
5992 if (argc > 1)
5993 {
5994 cmt_string& s = arguments.add ();
5995 s = argv[1];
5996 m_current_target = argv[1];
5997
5998 m_action = action_show_set;
5999 }
6000 else
6001 {
6002 if (!m_quiet) cerr << "#CMT> syntax error : set name missing" << endl;
6003 m_help_action = action_help;
6004 m_action = action_show_set;
6005 }
6006 }
6007 else if (arg == "sets")
6008 {
6009 argc--;
6010 argv++;
6011 if (argc > 1)
6012 {
6013 cmt_string& s = arguments.add ();
6014 s = argv[1];
6015 }
6016
6017 m_action = action_show_sets;
6018 }
6019 else if (arg == "strategies")
6020 {
6021 m_action = action_show_strategies;
6022 }
6023 else if (arg == "tags")
6024 {
6025 m_action = action_show_tags;
6026 }
6027 else if (arg == "use_paths")
6028 {
6029 argc--;
6030 argv++;
6031 if (argc > 1)
6032 {
6033 while (argc > 1)
6034 {
6035 if (strcmp (argv[1], "-private") == 0)
6036 {
6037 set_scope_filtering_mode (reach_private_uses);
6038 }
6039 else if (strcmp (argv[1], "--private") == 0)
6040 {
6041 set_scope_filtering_mode (reach_private_uses);
6042 }
6043 else
6044 {
6045 cmt_string& s = arguments.add ();
6046 s = argv[1];
6047 }
6048
6049 argc--;
6050 argv++;
6051 }
6052
6053 m_action = action_show_use_paths;
6054 }
6055 else
6056 {
6057 if (!m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
6058 m_help_action = action_help;
6059 m_action = action_show_use_paths;
6060 }
6061 }
6062 else if ((arg == "u") ||
6063 (arg == "us") ||
6064 (arg == "use") ||
6065 (arg == "uses"))
6066 {
6067 m_action = action_show_uses;
6068
6069 if (m_scope_filtering_mode == default_filtering_mode)
6070 {
6071 set_scope_filtering_mode (reach_private_uses);
6072 }
6073 }
6074 else if (arg == "version")
6075 {
6076 m_action = action_show_version;
6077 }
6078 else if (arg == "versions")
6079 {
6080 argc--;
6081 argv++;
6082 if (argc > 1)
6083 {
6084 cmt_string& s = arguments.add ();
6085 s = argv[1];
6086 m_current_target = argv[1];
6087
6088 m_action = action_show_versions;
6089 }
6090 else
6091 {
6092 if (!m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
6093 m_help_action = action_help;
6094 m_action = action_show_versions;
6095 }
6096 }
6097 else
6098 {
6099 if (!m_quiet) cerr << "#CMT> syntax error : bad show argument" << endl;
6100 m_help_action = action_help;
6101 m_action = action_show;
6102 }
6103 }
6104 else
6105 {
6106 if (!m_quiet) cerr << "#CMT> syntax error : don't know what to show" << endl;
6107 m_help_action = action_help;
6108 m_action = action_show;
6109 }
6110 }
6111 else if (arg == "system")
6112 {
6113 m_action = action_system;
6114 }
6115 else
6116 {
6117 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
6118 m_help_action = action_help;
6119 }
6120
6121 break;
6122 case 'u' :
6123 if (arg == "unlock")
6124 {
6125 argc--;
6126 argv++;
6127 if (argc > 1)
6128 {
6129 m_current_package = argv[1];
6130 {
6131 cmt_string& s = arguments.add ();
6132 s = m_current_package;
6133 }
6134
6135 m_current_version.erase (0);
6136 m_current_path.erase (0);
6137
6138 argc--;
6139 argv++;
6140 if (argc > 1)
6141 {
6142 m_current_version = argv[1];
6143
6144 {
6145 cmt_string& s = arguments.add ();
6146 s = m_current_version;
6147 }
6148
6149 m_action = action_unlock;
6150
6151 argc--;
6152 argv++;
6153 if (argc > 1)
6154 {
6155 m_current_path = argv[1];
6156 if (m_current_path[0] == '-')
6157 {
6158 m_current_path.erase (0);
6159 }
6160 }
6161
6162 m_current_access = UserMode;
6163 (Use::current()).set (m_current_package,
6164 m_current_version,
6165 m_current_path);
6166
6167 }
6168 else
6169 {
6170 if (!m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
6171 m_help_action = action_help;
6172 m_action = action_unlock;
6173 }
6174 }
6175 else
6176 {
6177 m_action = action_unlock;
6178 }
6179 }
6180 else
6181 {
6182 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
6183 m_help_action = action_help;
6184 }
6185
6186 break;
6187 case 'v' :
6188 if ((arg == "v") ||
6189 (arg == "ve") ||
6190 (arg == "ver") ||
6191 (arg == "vers") ||
6192 (arg == "versi") ||
6193 (arg == "versio") ||
6194 (arg == "version"))
6195 {
6196 m_action = action_version;
6197 }
6198 else
6199 {
6200 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
6201 m_help_action = action_help;
6202 }
6203 break;
6204 case '+' :
6205 if (arg.substr (0, 6) == "+path=")
6206 {
6207 arg.erase (0, 6);
6208
6209 IProjectFactory& factory = ProjectFactory::instance ();
6210
6211 CmtSystem::add_cmt_path (arg, "argument", factory);
6212 }
6213 else
6214 {
6215 if (!m_quiet) cerr << "#CMT> syntax error : bad verb "
6216 << arg << endl;
6217 m_help_action = action_help;
6218 }
6219
6220 break;
6221 case '-' :
6222 if ((arg == "-help") ||
6223 (arg == "--help"))
6224 {
6225 m_help_action = action_help;
6226 }
6227 else if (arg == "-n")
6228 {
6229 m_simulation = true;
6230 }
6231 else if ((arg == "-q") ||
6232 (arg == "-qu") ||
6233 (arg == "-qui") ||
6234 (arg == "-quie") ||
6235 (arg == "-quiet"))
6236 {
6237 m_quiet = true;
6238 }
6239 else if (arg == "-csh")
6240 {
6241 mode = Csh;
6242 }
6243 else if (arg == "-sh")
6244 {
6245 mode = Sh;
6246 }
6247 else if (arg == "-bat")
6248 {
6249 mode = Bat;
6250 }
6251 else if (arg.substr (0, 5) == "-use=")
6252 {
6253 arg.erase (0, 5);
6254
6255 if (m_action != action_create)
6256 {
6257 CmtSystem::cmt_string_vector words;
6258
6259 CmtSystem::split (arg, ":", words);
6260
6261 m_current_access = UserMode;
6262
6263 if (words.size () > 0) m_current_package = words[0];
6264 if (words.size () > 1) m_current_version = words[1];
6265 if (words.size () > 2) m_current_path = words[2];
6266 (Use::current()).set (m_current_package,
6267 m_current_version,
6268 m_current_path);
6269 }
6270 }
6271 else if (arg.substr (0, 6) == "-pack=")
6272 {
6273 arg.erase (0, 6);
6274 if ((m_action != action_create) && (m_current_package != arg))
6275 {
6276 //CmtSystem::cd (m_default_path);
6277
6278 m_current_access = UserMode;
6279
6280 m_current_package = arg;
6281 m_current_version = "";
6282 m_current_path = m_default_path;
6283
6284 (Use::current()).set (m_current_package,
6285 m_current_version,
6286 m_current_path);
6287 }
6288 }
6289 else if (arg.substr (0, 9) == "-version=")
6290 {
6291 arg.erase (0, 9);
6292 if ((m_action != action_create) && (m_current_version != arg))
6293 {
6294 m_current_access = UserMode;
6295 m_current_version = arg;
6296 (Use::current()).set (m_current_package,
6297 m_current_version,
6298 m_current_path);
6299 }
6300 }
6301 else if (arg.substr (0, 6) == "-path=")
6302 {
6303 arg.erase (0, 6);
6304
6305 /*
6306 cerr << "-path=" << arg <<
6307 " cp=" << m_current_package <<
6308 " cv=" << m_current_version <<
6309 " cp=" << m_current_path << endl;
6310 */
6311
6312 if ((m_action != action_create) && (m_current_path != arg))
6313 {
6314 m_current_access = UserMode;
6315 m_current_path = arg;
6316 (Use::current()).set (m_current_package,
6317 m_current_version,
6318 m_current_path);
6319
6320 IProjectFactory& factory = ProjectFactory::instance ();
6321
6322 //CmtSystem::add_cmt_path (m_current_path, "argument", factory);
6323 }
6324 }
6325 else if (arg.substr (0, 3) == "-f=")
6326 {
6327 arg.substr (3, extra_file);
6328 }
6329 else if (arg.substr (0, 3) == "-e=")
6330 {
6331 cerr << "#CMT> Warning: extra statement = " << arg << endl;
6332 arg.substr (3, extra_line);
6333 }
6334 else if (arg.substr (0, 6) == "-home=")
6335 {
6336 arg.erase (0, 6);
6337 if (CmtSystem::test_directory (arg))
6338 {
6339 m_cmt_home = arg;
6340 }
6341 }
6342 else if (arg.substr (0, 5) == "-tag=")
6343 {
6344 /*
6345 Here we are going to change the complete tag set
6346 */
6347
6348 arg.erase (0, 5);
6349
6350 if (arg != "")
6351 {
6352 Tag* tag;
6353 CmtSystem::cmt_string_vector words;
6354
6355 // First forget about all existing tags
6356 Tag::clear_all ();
6357 Cmt::m_extra_tags = ",";
6358
6359 // Then restore CMTSITE
6360 configure_version_tag ();
6361 configure_site_tag (0);
6362 configure_uname_tag ();
6363 configure_hosttype_tag ();
6364 configure_config_tag ();
6365 configure_home (0);
6366
6367 CmtSystem::split (arg, " \t,", words);
6368
6369 for (int i = 0; i < words.size (); i++)
6370 {
6371 const cmt_string& a = words[i];
6372
6373 cmt_string s = ",";
6374 s += a;
6375 s += ",";
6376
6377 if (i == 0)
6378 {
6379 m_current_tag = a;
6380
6381 if (CmtSystem::testenv ("TAGDEBUG")) cerr
6382 << "parse_argument(tag_add)> current_tag=" << m_current_tag << endl;
6383 }
6384
6385 if (Cmt::m_extra_tags.find (s) == cmt_string::npos)
6386 {
6387 //if (!m_quiet) cerr << " a=[" << a << "]" << endl;
6388
6389 // Then restore uname if the specified tag is CMTCONFIG
6390 if (a == CmtSystem::get_cmt_config ())
6391 {
6392 configure_uname_tag ();
6393 }
6394
6395 tag = Tag::add (a, PriorityArgument, "arguments", 0);
6396
6397 tag->mark ();
6398
6399 Cmt::m_extra_tags += a;
6400 Cmt::m_extra_tags += ",";
6401 }
6402 }
6403 }
6404 }
6405 else if (arg.substr (0, 9) == "-tag_add=")
6406 {
6407 Tag* tag;
6408 CmtSystem::cmt_string_vector words;
6409
6410 arg.erase (0, 9);
6411
6412 //if (!m_quiet) cerr << "-tag_add=" << arg << endl;
6413
6414 CmtSystem::split (arg, " \t,", words);
6415
6416 for (int i = 0; i < words.size (); i++)
6417 {
6418 const cmt_string& a = words[i];
6419
6420 cmt_string s = ",";
6421 s += a;
6422 s += ",";
6423
6424 if (Cmt::m_extra_tags.find (s) == cmt_string::npos)
6425 {
6426 //if (!m_quiet) cerr << " a=[" << a << "]" << endl;
6427
6428 /// Then restore uname if the specified tag is CMTCONFIG
6429 if (a == CmtSystem::get_cmt_config ())
6430 {
6431 configure_uname_tag ();
6432 }
6433
6434 tag = Tag::add (a, PriorityUserTag, "arguments", 0);
6435
6436 tag->mark ();
6437
6438 Cmt::m_extra_tags += a;
6439 Cmt::m_extra_tags += ",";
6440 }
6441 }
6442 }
6443 else if (arg.substr (0, 12) == "-tag_remove=")
6444 {
6445 Tag::TagPtrVector tags = Tag::tags ();
6446 int i;
6447 Tag* tag;
6448
6449 /*
6450 for (i = 0; i < tags.size (); i++)
6451 {
6452 tag = tags[i];
6453 if ((tag != 0) &&
6454 (tag->selected))
6455 {
6456 if (!m_quiet) cerr << " original tag_list=" << tag->name << tag->priority << endl;
6457 }
6458 }
6459 */
6460
6461 CmtSystem::cmt_string_vector words;
6462
6463 arg.erase (0, 12);
6464
6465 //if (!m_quiet) cerr << "-arg_remove=" << arg << endl;
6466
6467 CmtSystem::split (arg, " \t,", words);
6468
6469 //
6470 // Now erase all entries in the old list that match
6471 // the specified tags
6472 //
6473
6474 for (i = 0; i < words.size (); i++)
6475 {
6476 const cmt_string& a = words[i];
6477
6478 cmt_string s = ",";
6479 s += a;
6480 s += ",";
6481
6482 int pos;
6483
6484 pos = Cmt::m_extra_tags.find (s);
6485
6486 if (pos != cmt_string::npos)
6487 {
6488 Cmt::m_extra_tags.erase (pos, s.size () - 1);
6489 }
6490
6491 //if (!m_quiet) cerr << " tag_list=[" << tag_list << "]" << endl;
6492 }
6493
6494 //
6495 // Now reinject the purged list of tags into the database
6496 // exactly as when using -tag=<tag-list>
6497 //
6498
6499 /// First forget about all existing tags
6500 Tag::unmark_all ();
6501
6502 /// Then restore CMTSITE
6503 configure_version_tag ();
6504 configure_site_tag (0);
6505 configure_uname_tag ();
6506 configure_hosttype_tag ();
6507
6508 CmtSystem::split (Cmt::m_extra_tags, " \t,", words);
6509
6510 for (i = 0; i < words.size (); i++)
6511 {
6512 const cmt_string& a = words[i];
6513
6514 //fprintf (stderr, " a=[%s]\n", a.c_str ());
6515
6516 /// Then restore uname if the specified tag is CMTCONFIG
6517 if (a == CmtSystem::get_cmt_config ())
6518 {
6519 configure_uname_tag ();
6520 }
6521
6522 if (i == 0)
6523 {
6524 m_current_tag = a;
6525
6526 //if (!m_quiet) cerr << "parse_argument(tag_remove)> current_tag="
6527 //<< m_current_tag << endl;
6528
6529 tag = Tag::add (a, PriorityTag, "restore configuration", 0);
6530 }
6531 else
6532 {
6533 tag = Tag::add (a, PriorityUserTag, "restore configuration", 0);
6534 }
6535
6536 tag->mark ();
6537 }
6538 }
6539 else if (arg.substr (0, 14) == "-user_context=")
6540 {
6541 arg.erase (0, 14);
6542 if (CmtSystem::test_directory (arg))
6543 {
6544 m_cmt_user_context = arg;
6545 }
6546 }
6547 else if (arg == "--version")
6548 {
6549 m_action = action_version;
6550 }
6551 else if (arg.substr (0, 23) == "-with_version_directory")
6552 {
6553 m_current_structuring_style = with_version_directory;
6554 }
6555 else if (arg.substr (0, 26) == "-without_version_directory")
6556 {
6557 m_current_structuring_style = without_version_directory;
6558 }
6559 else if (arg.substr (0, 11) == "-no_cleanup")
6560 {
6561 m_current_setup_strategy |= SetupNoCleanup;
6562 }
6563 else if ((arg == "-private") ||
6564 (arg == "--private"))
6565 {
6566 set_scope_filtering_mode (reach_private_uses);
6567 }
6568 else if ((arg == "-public") ||
6569 (arg == "--public"))
6570 {
6571 set_scope_filtering_mode (block_private_uses);
6572 }
6573 else
6574 {
6575 if (!m_quiet) cerr << "#CMT> syntax error : bad verb " << arg << endl;
6576 m_help_action = action_help;
6577 }
6578
6579 break;
6580 default:
6581 if (!m_quiet) cerr << "#CMT> syntax error : bad command parameter " << arg << endl;
6582 m_help_action = action_help;
6583 break;
6584 }
6585
6586 argc--;
6587 argv++;
6588 }
6589}
6590
6591//----------------------------------------------------------
6592int Cmt::parser (const cmt_string& command_line)
6593{
6594 CmtSystem::cmt_string_vector v;
6595
6596 CmtSystem::split (command_line, " \t", v);
6597
6598 int argc = v.size ();
6599
6600 char** argv = (char**) malloc ((argc + 1) * sizeof (char*));
6601
6602 int i;
6603 for (i = 0; i < argc; i++)
6604 {
6605 argv[i] = (char*) v[i].c_str ();
6606 }
6607 argv[argc] = 0;
6608
6609 int status = parser (argc, argv);
6610
6611 free (argv);
6612
6613 return (status);
6614}
6615
6616//----------------------------------------------------------
6617int Cmt::parser (int argc, char* argv[])
6618{
6619 PrintMode mode = Csh;
6620 CmtSystem::cmt_string_vector arguments;
6621 cmt_string extra_line;
6622 cmt_string extra_file;
6623
6624 if (argc <= 1)
6625 {
6626 do_help ();
6627 exit (0);
6628 }
6629
6630 clear ();
6631 configure ();
6632
6633 CmtError::clear ();
6634
6635 /*
6636 Set private if positioned inside the package
6637 (which is detected since we were able to retreive the
6638 Version, Package and Path)
6639 */
6640
6641 if ((m_current_path.size () == 0) ||
6642 (m_current_package.size () == 0) ||
6643 (m_current_version.size () == 0))
6644 {
6645 m_current_access = UserMode;
6646 }
6647 else
6648 {
6649 m_current_access = DeveloperMode;
6650 }
6651
6652 parse_arguments (argc, argv, arguments,
6653 extra_line, extra_file, mode);
6654
6655 if (m_configure_error != "")
6656 {
6657 if (!m_quiet) cerr << "#CMT> Error: " << m_configure_error << endl;
6658 return (CmtError::execution_error);
6659 }
6660
6661 if (CmtError::has_pending_error ())
6662 {
6663 int code = CmtError::get_last_error_code ();
6664 if (!m_quiet) CmtError::print ();
6665 clear ();
6666
6667 return (code);
6668 }
6669
6670 if (m_debug)
6671 {
6672 cout << "After parse_argument> pack=" << m_current_package
6673 << " m_current_tag=" << m_current_tag
6674 << " cwd=" << CmtSystem::pwd ()
6675 << endl;
6676 }
6677
6678 /*
6679 Now actual requirements analysis can take place.
6680
6681 Extra lines or files are analysed first.
6682 */
6683
6684 if (strlen (extra_file.c_str ()) > 0) SyntaxParser::parse_requirements (extra_file, (Use*) 0);
6685 if (strlen (extra_line.c_str ()) > 0) SyntaxParser::parse_requirements_line (extra_line, (Use*) 0);
6686
6687 //
6688 // For some of the actions, the CMT package must be automatically
6689 // included
6690 //
6691
6692 if (m_debug) cout << "parser1> current_tag=" << m_current_tag << endl;
6693
6694 if (m_help_action == action_help)
6695 {
6696 do_help (m_action);
6697 return (0);
6698 }
6699
6700 switch (m_action)
6701 {
6702 // case action_none :
6703 case action_awk :
6704 case action_broadcast :
6705 case action_build_constituent_makefile :
6706 case action_build_constituents_makefile :
6707 case action_build_dependencies :
6708 case action_build_library_links :
6709 case action_build_make_setup :
6710 case action_build_msdev :
6711 case action_build_CMT_pacman :
6712 case action_build_vsnet :
6713 case action_build_os9_makefile :
6714 // case action_build_prototype :
6715 case action_build_readme :
6716 case action_build_tag_makefile :
6717 // case action_build_temporary_name :
6718 case action_build_triggers :
6719 case action_build_windefs :
6720 case action_check_configuration :
6721 // case action_check_files :
6722 // case action_check_version :
6723 case action_checkout :
6724 case action_cleanup :
6725 case action_config :
6726 case action_create :
6727 // case action_create_project :
6728 // case action_cvsbranches :
6729 // case action_cvssubpackages :
6730 // case action_cvstags :
6731 case action_do :
6732 case action_expand_model :
6733 case action_filter :
6734 // case action_help :
6735 case action_load :
6736 case action_lock :
6737 case action_remove :
6738 case action_remove_library_links :
6739 case action_run :
6740 case action_run_sequence :
6741 case action_set_version :
6742 case action_set_versions :
6743 case action_setup :
6744 case action_show_action :
6745 case action_show_action_names :
6746 case action_show_action_value :
6747 case action_show_actions :
6748 case action_show_all_tags :
6749 case action_show_applied_patterns :
6750 // case action_show_author :
6751 // case action_show_branches :
6752 // case action_show_clients :
6753 case action_show_cmtpath_patterns :
6754 // case action_show_constituent :
6755 // case action_show_constituent_names :
6756 // case action_show_constituents :
6757 case action_show_cycles :
6758 case action_show_fragment :
6759 case action_show_fragments :
6760 case action_show_groups :
6761 case action_show_include_dirs :
6762 case action_show_language :
6763 case action_show_languages :
6764 case action_show_macro :
6765 case action_show_macro_names :
6766 case action_show_macro_value :
6767 case action_show_macros :
6768 // case action_show_manager :
6769 // case action_show_packages :
6770 case action_show_path :
6771 case action_show_pattern :
6772 case action_show_pattern_names :
6773 case action_show_patterns :
6774 case action_show_projects :
6775 // case action_show_pwd :
6776 case action_show_setup :
6777 case action_show_set :
6778 case action_show_set_names :
6779 case action_show_set_value :
6780 case action_show_sets :
6781 case action_show_strategies :
6782 case action_show_tags :
6783 case action_show_use_paths :
6784 case action_show_uses :
6785 case action_show_version :
6786 // case action_show_versions :
6787 // case action_system :
6788 case action_unlock :
6789 case action_version :
6790 use_cmt ();
6791 //
6792 // Now parse the requirements file stored in ${CMTHOME}
6793 //
6794
6795 use_home_requirements ();
6796
6797 break;
6798 default:
6799 break;
6800 }
6801
6802 if (m_debug) cout << "parser2> current_tag=" << m_current_tag << endl;
6803
6804 //
6805 // Setting up recursive actions
6806 //
6807
6808 switch (m_action)
6809 {
6810 // case action_none :
6811 case action_awk :
6812 case action_broadcast :
6813 case action_build_constituent_makefile :
6814 case action_build_constituents_makefile :
6815 case action_build_dependencies :
6816 case action_build_library_links :
6817 case action_build_make_setup :
6818 case action_build_msdev :
6819 case action_build_CMT_pacman :
6820 case action_build_vsnet :
6821 case action_build_os9_makefile :
6822 // case action_build_prototype :
6823 case action_build_readme :
6824 case action_build_tag_makefile :
6825 // case action_build_temporary_name :
6826 case action_build_triggers :
6827 case action_build_windefs :
6828 case action_check_configuration :
6829 // case action_check_files :
6830 // case action_check_version :
6831 // case action_checkout :
6832 case action_cleanup :
6833 case action_config :
6834 // case action_create :
6835 // case action_create_project :
6836 // case action_cvsbranches :
6837 // case action_cvssubpackages :
6838 // case action_cvstags :
6839 case action_do :
6840 case action_expand_model :
6841 case action_filter :
6842 // case action_help :
6843 case action_load :
6844 // case action_lock :
6845 // case action_remove :
6846 case action_remove_library_links :
6847 case action_run :
6848 case action_run_sequence :
6849 // case action_set_version :
6850 case action_set_versions :
6851 case action_setup :
6852 case action_show_action :
6853 case action_show_action_names :
6854 case action_show_action_value :
6855 case action_show_actions :
6856 case action_show_all_tags :
6857 case action_show_applied_patterns :
6858 // case action_show_author :
6859 // case action_show_branches :
6860 // case action_show_clients :
6861 case action_show_cmtpath_patterns :
6862 case action_show_constituent :
6863 case action_show_constituent_names :
6864 case action_show_constituents :
6865 case action_show_cycles :
6866 case action_show_fragment :
6867 case action_show_fragments :
6868 case action_show_groups :
6869 case action_show_include_dirs :
6870 case action_show_language :
6871 case action_show_languages :
6872 case action_show_macro :
6873 case action_show_macro_names :
6874 case action_show_macro_value :
6875 case action_show_macros :
6876 // case action_show_manager :
6877 // case action_show_packages :
6878 case action_show_path :
6879 case action_show_pattern :
6880 case action_show_pattern_names :
6881 case action_show_patterns :
6882 case action_show_projects :
6883 // case action_show_pwd :
6884 case action_show_setup :
6885 case action_show_set :
6886 case action_show_set_names :
6887 case action_show_set_value :
6888 case action_show_sets :
6889 case action_show_strategies :
6890 case action_show_tags :
6891 case action_show_use_paths :
6892 case action_show_uses :
6893 // case action_show_version :
6894 // case action_show_versions :
6895 // case action_system :
6896 // case action_unlock :
6897 // case action_version :
6898 m_recursive = true;
6899 break;
6900 default:
6901 m_recursive = false;
6902 break;
6903 }
6904
6905 //
6906 // Actions for which the context of the package is checked,
6907 // and the requirements file is analysed.
6908 //
6909
6910 switch (m_action)
6911 {
6912 case action_none :
6913 case action_awk :
6914 case action_broadcast :
6915 case action_build_constituent_makefile :
6916 case action_build_constituents_makefile :
6917 case action_build_dependencies :
6918 case action_build_library_links :
6919 case action_build_make_setup :
6920 case action_build_msdev :
6921 case action_build_CMT_pacman :
6922 case action_build_vsnet :
6923 case action_build_os9_makefile :
6924 // case action_build_prototype :
6925 case action_build_readme :
6926 case action_build_tag_makefile :
6927 // case action_build_temporary_name :
6928 case action_build_triggers :
6929 case action_build_windefs :
6930 case action_check_configuration :
6931 // case action_check_files :
6932 // case action_check_version :
6933 // case action_checkout :
6934 case action_cleanup :
6935 case action_config :
6936 // case action_create :
6937 // case action_create_project :
6938 // case action_cvsbranches :
6939 // case action_cvssubpackages :
6940 // case action_cvstags :
6941 case action_do :
6942 case action_expand_model :
6943 case action_filter :
6944 // case action_help :
6945 case action_load :
6946 case action_lock :
6947 // case action_remove :
6948 case action_remove_library_links :
6949 case action_run :
6950 // case action_run_sequence :
6951 // case action_set_version :
6952 case action_set_versions :
6953 case action_setup :
6954 case action_show_action :
6955 case action_show_action_names :
6956 case action_show_action_value :
6957 case action_show_actions :
6958 case action_show_all_tags :
6959 case action_show_applied_patterns :
6960 case action_show_author :
6961 case action_show_branches :
6962 // case action_show_clients :
6963 case action_show_cmtpath_patterns :
6964 case action_show_constituent :
6965 case action_show_constituent_names :
6966 case action_show_constituents :
6967 case action_show_cycles :
6968 case action_show_fragment :
6969 case action_show_fragments :
6970 case action_show_groups :
6971 case action_show_include_dirs :
6972 case action_show_language :
6973 case action_show_languages :
6974 case action_show_macro :
6975 case action_show_macro_names :
6976 case action_show_macro_value :
6977 case action_show_macros :
6978 case action_show_manager :
6979 // case action_show_packages :
6980 case action_show_path :
6981 case action_show_pattern :
6982 case action_show_pattern_names :
6983 case action_show_patterns :
6984 case action_show_projects :
6985 case action_show_pwd :
6986 case action_show_setup :
6987 case action_show_set :
6988 case action_show_set_names :
6989 case action_show_set_value :
6990 case action_show_sets :
6991 case action_show_strategies :
6992 case action_show_tags :
6993 case action_show_use_paths :
6994 case action_show_uses :
6995 case action_show_version :
6996 // case action_show_versions :
6997 // case action_system :
6998 case action_unlock :
6999 // case action_version :
7000 reach_current_package ();
7001 use_user_context_requirements ();
7002 break;
7003 default:
7004 break;
7005 }
7006
7007 if (m_debug) cout << "parser3> current_tag=" << m_current_tag << endl;
7008
7009 //
7010 // Perform some actions even if there is an error
7011 //
7012
7013 if (CmtError::has_pending_error ())
7014 {
7015 int code = CmtError::get_last_error_code ();
7016 if (!m_quiet) CmtError::print ();
7017
7018 switch (m_action)
7019 {
7020 // case action_none :
7021 // case action_awk :
7022 // case action_broadcast :
7023 case action_build_constituent_makefile :
7024 case action_build_constituents_makefile :
7025 case action_build_dependencies :
7026 case action_build_library_links :
7027 case action_build_make_setup :
7028 case action_build_msdev :
7029 case action_build_CMT_pacman :
7030 case action_build_vsnet :
7031 case action_build_os9_makefile :
7032 case action_build_prototype :
7033 case action_build_readme :
7034 case action_build_tag_makefile :
7035 // case action_build_temporary_name :
7036 case action_build_triggers :
7037 case action_build_windefs :
7038 case action_check_configuration :
7039 // case action_check_files :
7040 // case action_check_version :
7041 // case action_checkout :
7042 case action_cleanup :
7043 // case action_config :
7044 // case action_create :
7045 // case action_create_project :
7046 // case action_cvsbranches :
7047 // case action_cvssubpackages :
7048 // case action_cvstags :
7049 // case action_do :
7050 // case action_expand_model :
7051 // case action_filter :
7052 // case action_help :
7053 case action_load :
7054 case action_lock :
7055 case action_remove :
7056 case action_remove_library_links :
7057 // case action_run :
7058 case action_run_sequence :
7059 // case action_set_version :
7060 // case action_set_versions :
7061 case action_setup :
7062 // case action_show_action :
7063 // case action_show_action_names :
7064 // case action_show_action_value :
7065 // case action_show_actions :
7066 // case action_show_all_tags :
7067 // case action_show_applied_patterns :
7068 // case action_show_author :
7069 // case action_show_branches :
7070 // case action_show_clients :
7071 // case action_show_cmtpath_patterns :
7072 // case action_show_constituent :
7073 // case action_show_constituent_names :
7074 // case action_show_constituents :
7075 // case action_show_cycles :
7076 // case action_show_fragment :
7077 // case action_show_fragments :
7078 // case action_show_groups :
7079 // case action_show_include_dirs :
7080 // case action_show_language :
7081 // case action_show_languages :
7082 // case action_show_macro :
7083 // case action_show_macro_names :
7084 // case action_show_macro_value :
7085 // case action_show_macros :
7086 // case action_show_manager :
7087 // case action_show_packages :
7088 // case action_show_path :
7089 // case action_show_pattern :
7090 // case action_show_pattern_names :
7091 // case action_show_patterns :
7092 // case action_show_projects :
7093 // case action_show_pwd :
7094 // case action_show_setup :
7095 // case action_show_set :
7096 // case action_show_set_names :
7097 // case action_show_set_value :
7098 // case action_show_sets :
7099 // case action_show_strategies :
7100 // case action_show_tags :
7101 // case action_show_use_paths :
7102 // case action_show_uses :
7103 // case action_show_version :
7104 // case action_show_versions :
7105 // case action_system :
7106 case action_unlock :
7107 // case action_version :
7108 clear ();
7109 return (code);
7110 default:
7111 CmtError::clear ();
7112 break;
7113 }
7114 }
7115
7116 //
7117 // Perform actions
7118 //
7119
7120 switch (m_action)
7121 {
7122 case action_none :
7123 //CmtError::set (CmtError::syntax_error, "ParseArguments> ");
7124 break;
7125 case action_awk :
7126 do_awk (arguments);
7127 break;
7128 case action_broadcast :
7129 do_broadcast (arguments, argc, argv);
7130 break;
7131 case action_build_constituent_makefile :
7132 do_build_constituent_makefile (arguments, argc, argv);
7133 break;
7134 case action_build_constituents_makefile :
7135 do_build_constituents_makefile (arguments, argc, argv);
7136 break;
7137 case action_build_dependencies :
7138 do_build_dependencies (arguments, argc, argv);
7139 break;
7140 case action_build_library_links :
7141 do_build_library_links ();
7142 break;
7143 case action_build_make_setup :
7144 do_build_make_setup ();
7145 break;
7146 case action_build_msdev :
7147 do_build_msdev (arguments);
7148 break;
7149 case action_build_CMT_pacman :
7150 do_build_CMT_pacman ();
7151 break;
7152 case action_build_vsnet :
7153 do_build_vsnet (arguments);
7154 break;
7155 case action_build_os9_makefile :
7156 do_build_os9_makefile (arguments);
7157 break;
7158 case action_build_prototype :
7159 do_build_prototype (arguments);
7160 break;
7161 case action_build_readme :
7162 do_build_readme (arguments);
7163 break;
7164 case action_build_tag_makefile :
7165 do_build_tag_makefile ();
7166 break;
7167 case action_build_temporary_name :
7168 do_build_temporary_name ();
7169 break;
7170 case action_build_triggers :
7171 do_build_triggers (arguments);
7172 break;
7173 case action_build_windefs :
7174 do_build_windefs (arguments);
7175 break;
7176 case action_check_configuration :
7177 do_check_configuration ();
7178 break;
7179 case action_check_files :
7180 do_check_files (arguments);
7181 break;
7182 case action_check_version :
7183 do_check_version (arguments);
7184 break;
7185 case action_checkout :
7186 do_checkout (arguments);
7187 break;
7188 case action_cleanup :
7189 do_cleanup (mode);
7190 break;
7191 case action_config :
7192 do_config ();
7193 break;
7194 case action_create :
7195 do_create (arguments);
7196 break;
7197 case action_create_project :
7198 do_create_project (arguments);
7199 break;
7200 case action_cvsbranches :
7201 do_cvsbranches (arguments);
7202 break;
7203 case action_cvssubpackages :
7204 do_cvssubpackages (arguments);
7205 break;
7206 case action_cvstags :
7207 do_cvstags (arguments);
7208 break;
7209 case action_do :
7210 do_do (arguments);
7211 break;
7212 case action_expand_model :
7213 do_expand_model (arguments);
7214 break;
7215 case action_filter :
7216 do_filter (arguments);
7217 break;
7218 case action_help :
7219 do_help (m_help_action);
7220 break;
7221 case action_load :
7222 cerr << "#CMT> action not implemented" << endl;
7223 break;
7224 case action_lock :
7225 do_lock (m_current_package, m_current_version, m_current_path);
7226 break;
7227 case action_remove :
7228 do_remove (m_current_package, m_current_version, m_current_path);
7229 break;
7230 case action_remove_library_links :
7231 do_remove_library_links ();
7232 break;
7233 case action_run :
7234 do_run (arguments);
7235 break;
7236 case action_run_sequence :
7237 do_run_sequence (arguments);
7238 break;
7239 case action_set_version :
7240 do_set_version (arguments);
7241 break;
7242 case action_set_versions :
7243 do_set_versions (arguments);
7244 break;
7245 case action_setup :
7246 do_setup (mode);
7247 break;
7248 case action_show_action :
7249 do_show_action (arguments, mode);
7250 break;
7251 case action_show_action_names :
7252 do_show_action_names (arguments, mode);
7253 break;
7254 case action_show_action_value :
7255 do_show_action_value (arguments, mode);
7256 break;
7257 case action_show_actions :
7258 do_show_actions (arguments, mode);
7259 break;
7260 case action_show_all_tags :
7261 do_show_all_tags ();
7262 break;
7263 case action_show_applied_patterns :
7264 do_show_applied_patterns ();
7265 break;
7266 case action_show_author :
7267 do_show_author ();
7268 break;
7269 case action_show_branches :
7270 do_show_branches (mode);
7271 break;
7272 case action_show_clients :
7273 do_show_clients (arguments);
7274 break;
7275 case action_show_cmtpath_patterns :
7276 do_show_cmtpath_patterns ();
7277 break;
7278 case action_show_constituent :
7279 do_show_constituent (arguments);
7280 break;
7281 case action_show_constituent_names :
7282 do_show_constituent_names ();
7283 break;
7284 case action_show_constituents :
7285 do_show_constituents ();
7286 break;
7287 case action_show_cycles :
7288 do_show_cycles ();
7289 break;
7290 case action_show_fragment :
7291 do_show_fragment (arguments);
7292 break;
7293 case action_show_fragments :
7294 do_show_fragments ();
7295 break;
7296 case action_show_groups :
7297 do_show_groups ();
7298 break;
7299 case action_show_include_dirs :
7300 do_show_include_dirs ();
7301 break;
7302 case action_show_language :
7303 do_show_language (arguments);
7304 break;
7305 case action_show_languages :
7306 do_show_languages ();
7307 break;
7308 case action_show_macro :
7309 do_show_macro (arguments, mode);
7310 break;
7311 case action_show_macro_names :
7312 do_show_macro_names (arguments, mode);
7313 break;
7314 case action_show_macro_value :
7315 do_show_macro_value (arguments, mode);
7316 break;
7317 case action_show_macros :
7318 do_show_macros (arguments, mode);
7319 break;
7320 case action_show_manager :
7321 do_show_manager ();
7322 break;
7323 case action_show_packages :
7324 do_show_packages (arguments);
7325 break;
7326 case action_show_path :
7327 do_show_path ();
7328 break;
7329 case action_show_pattern :
7330 do_show_pattern (arguments);
7331 break;
7332 case action_show_pattern_names :
7333 do_show_pattern_names ();
7334 break;
7335 case action_show_patterns :
7336 do_show_patterns ();
7337 break;
7338 case action_show_projects :
7339 do_show_projects ();
7340 break;
7341 case action_show_pwd :
7342 do_show_pwd ();
7343 break;
7344 case action_show_setup :
7345 do_show_setup ();
7346 break;
7347 case action_show_set :
7348 do_show_set (arguments, mode);
7349 break;
7350 case action_show_set_names :
7351 do_show_set_names (arguments, mode);
7352 break;
7353 case action_show_set_value :
7354 do_show_set_value (arguments, mode);
7355 break;
7356 case action_show_sets :
7357 do_show_sets (arguments, mode);
7358 break;
7359 case action_show_strategies :
7360 do_show_strategies ();
7361 break;
7362 case action_show_tags :
7363 do_show_tags ();
7364 break;
7365 case action_show_use_paths :
7366 do_show_use_paths (arguments);
7367 break;
7368 case action_show_uses :
7369 do_show_uses ();
7370 break;
7371 case action_show_version :
7372 do_show_version ();
7373 break;
7374 case action_show_versions :
7375 do_show_versions (arguments);
7376 break;
7377 case action_system :
7378 do_show_system ();
7379 break;
7380 case action_unlock :
7381 do_unlock (m_current_package, m_current_version, m_current_path);
7382 break;
7383 case action_version :
7384 do_version ();
7385 break;
7386 default:
7387 CmtError::set (CmtError::syntax_error, "ParseArguments>");
7388 break;
7389 }
7390
7391 if (CmtError::has_pending_error ())
7392 {
7393 int code = CmtError::get_last_error_code ();
7394 if (!m_quiet) CmtError::print ();
7395 clear ();
7396 return (code);
7397 }
7398 else
7399 {
7400 clear ();
7401 return (0);
7402 }
7403}
7404
7405
7406/**
7407 * Format as one single line a set of 'setenv' statements
7408 * joined with semi-colons to form one shell command.
7409 */
7410void Cmt::print (PrintMode mode)
7411{
7412 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
7413 Use& current_use = Use::current ();
7414
7415 cmt_string tag;
7416
7417 set_standard_macros ();
7418
7419 //cerr << "# current_tag=" << m_current_tag << endl;
7420 //cerr << "# current_config=" << m_current_config << endl;
7421
7422 if (m_current_tag == "")
7423 {
7424 if (mode == Bat) tag = "%CMTCONFIG%";
7425 else tag = "${CMTCONFIG}";
7426 }
7427 else
7428 {
7429 tag = m_current_tag;
7430 }
7431
7432 //
7433 // Now check if all extra tags are still valid. Some of them
7434 // may be discarded du to some conflict with highest priority
7435 // tags, or with exclude statements
7436 //
7437
7438 {
7439 CmtSystem::cmt_string_vector words;
7440
7441 cmt_string tags;
7442
7443 tags = Cmt::m_extra_tags;
7444
7445 CmtSystem::split (tags, " \t,", words);
7446
7447 Cmt::m_extra_tags = ",";
7448
7449 for (int i = 0; i < words.size (); i++)
7450 {
7451 Tag* tag;
7452 const cmt_string& a = words[i];
7453
7454 tag = Tag::find (a);
7455
7456 if ((tag != 0) && (tag->is_selected ()))
7457 {
7458 Cmt::m_extra_tags += a;
7459 Cmt::m_extra_tags += ",";
7460 }
7461 }
7462 }
7463
7464 if (m_debug)
7465 {
7466 cout << "Before all print contexts" << endl;
7467 }
7468
7469 if (Uses.size () > 0)
7470 {
7471 int number;
7472
7473 for (number = 0; number < Uses.size (); number++)
7474 {
7475 Use& use = *(Uses[number]);
7476
7477 if (use.discarded) continue;
7478
7479 print_context (use, mode, tag);
7480 }
7481 }
7482
7483 print_context (Use::current (), mode, tag);
7484
7485 if (m_debug)
7486 {
7487 cout << "After all print contexts" << endl;
7488 }
7489
7490 Symbol::all_print (mode);
7491 // Script::all_print (mode);
7492
7493 if (m_debug)
7494 {
7495 cout << "After all print" << endl;
7496 }
7497
7498 cout << endl;
7499}
7500
7501
7502/**
7503 * Format as one single line a set of 'unsetenv' statements
7504 * joined with semi-colons to form one shell command.
7505 */
7506void Cmt::print_clean (PrintMode mode)
7507{
7508 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
7509
7510 set_standard_macros ();
7511
7512 Script::all_print_clean (mode);
7513 Symbol::all_print_clean (mode);
7514
7515 switch (mode)
7516 {
7517 case Csh :
7518 if (m_current_package != "CMT")
7519 {
7520 cout << "unsetenv " << m_current_prefix << "ROOT" << endl;
7521 cout << "unsetenv " << m_current_prefix << "CONFIG" << endl;
7522 }
7523 break;
7524 case Sh :
7525 if (m_current_package != "CMT")
7526 {
7527 cout << "unset " << m_current_prefix << "ROOT" << endl;
7528 cout << "unset " << m_current_prefix << "CONFIG" << endl;
7529 }
7530 break;
7531 case Bat :
7532 if (m_current_package != "CMT")
7533 {
7534 cout << "set " << m_current_prefix << "ROOT=" << endl;
7535 cout << "set " << m_current_prefix << "CONFIG=" << endl;
7536 }
7537 break;
7538 }
7539
7540 if (Uses.size () > 0)
7541 {
7542 int number;
7543
7544 for (number = 0; number < Uses.size (); number++)
7545 {
7546 Use* use = Uses[number];
7547
7548 if (use->discarded) continue;
7549
7550 Package* p = use->get_package ();
7551 if (p->is_cmt ()) continue;
7552
7553 switch (mode)
7554 {
7555 case Csh :
7556 cout << "unsetenv " << use->prefix << "ROOT" << endl;
7557 cout << "unsetenv " << use->prefix << "CONFIG" << endl;
7558 break;
7559 case Sh :
7560 cout << "unset " << use->prefix << "ROOT" << endl;
7561 cout << "unset " << use->prefix << "CONFIG" << endl;
7562 break;
7563 case Bat :
7564 cout << "set " << use->prefix << "ROOT=" << endl;
7565 cout << "set " << use->prefix << "CONFIG" << endl;
7566 break;
7567 }
7568 }
7569 }
7570
7571 switch (mode)
7572 {
7573 case Csh :
7574 cout << "unsetenv CMTEXTRATAGS" << endl;
7575 break;
7576 case Sh :
7577 cout << "unset CMTEXTRATAGS" << endl;
7578 break;
7579 case Bat :
7580 cout << "set CMTEXTRATAGS=" << endl;
7581 break;
7582 }
7583
7584 cout << endl;
7585}
7586
7587//----------------------------------------------------------
7588void Cmt::print_context (Use& use, PrintMode mode, const cmt_string& tag)
7589{
7590 if (use.get_package_name () == "cmt_standalone") return;
7591
7592 cmt_string fs = CmtSystem::file_separator ();
7593
7594 use.real_path.replace_all (CmtSystem::file_separator (), fs);
7595
7596 cmt_string system = CmtSystem::get_cmt_config ();
7597
7598 Project* p = Project::get_current ();
7599 int strategy = 0;
7600
7601 strategy = get_setup_strategy ();
7602
7603 bool do_config = ((strategy & SetupConfigMask) == SetupConfig);
7604 bool do_root = ((strategy & SetupRootMask) == SetupRoot);
7605
7606 switch (mode)
7607 {
7608 case Csh :
7609 if (do_root)
7610 {
7611 cout << "setenv " << use.prefix << "ROOT \"" <<
7612 use.get_full_path () << "\"" << endl;
7613 }
7614
7615 if (use.get_package_name () == "CMT")
7616 {
7617 cout << "setenv CMTCONFIG " << system << endl;
7618 }
7619 else
7620 {
7621 if (do_config)
7622 {
7623 cout << "setenv " << use.prefix << "CONFIG \"" << tag << "\"" << endl;
7624 }
7625 }
7626
7627 break;
7628 case Sh :
7629 if (do_root)
7630 {
7631 cout << use.prefix << "ROOT=\"" <<
7632 use.get_full_path () << "\"; export " <<
7633 use.prefix << "ROOT" << endl;
7634 }
7635
7636 if (use.get_package_name () == "CMT")
7637 {
7638 cout << "CMTCONFIG=" << system << "; export CMTCONFIG" << endl;
7639 }
7640 else
7641 {
7642 if (do_config)
7643 {
7644 cout << use.prefix << "CONFIG=\"" <<
7645 tag << "\"; export " <<
7646 use.prefix << "CONFIG" << endl;
7647 }
7648 }
7649
7650 break;
7651 case Bat :
7652 if (do_root)
7653 {
7654 cout << "set " << use.prefix << "ROOT=" <<
7655 use.get_full_path () << endl;
7656 }
7657
7658 if (use.get_package_name () == "CMT")
7659 {
7660 cout << "set CMTCONFIG=" << system << endl;
7661 }
7662 else
7663 {
7664 if (do_config)
7665 {
7666 cout << "set " << use.prefix << "CONFIG=" << tag << endl;
7667 }
7668 }
7669
7670 break;
7671 }
7672}
7673
7674/**
7675 * Format a set of make macro definitions (one per line)
7676 * Each macro value is provided enclosed in single quotes
7677 *
7678 * Take the macro values from the macro statements found
7679 * in recursively read requirements files.
7680 */
7681void Cmt::print_symbol_names (PrintMode mode, const cmt_string& pattern)
7682{
7683 int number;
7684
7685 set_standard_macros ();
7686
7687 cmt_regexp expression (pattern);
7688
7689 bool has_pattern = (pattern != "");
7690
7691 for (number = 0; number < Symbol::symbol_number (); number++)
7692 {
7693 Symbol& symbol = Symbol::symbol (number);
7694
7695 if (has_pattern)
7696 {
7697 if (!expression.match (symbol.name)) continue;
7698 }
7699
7700 if (m_action == action_show_macro_names)
7701 {
7702 // Only keep macros.
7703 if ((symbol.type == Symbol::SymbolSet) ||
7704 (symbol.type == Symbol::SymbolAlias) ||
7705 (symbol.type == Symbol::SymbolPath) ||
7706 (symbol.type == Symbol::SymbolAction)) continue;
7707 }
7708 else if (m_action == action_show_set_names)
7709 {
7710 // Exclude macros.
7711 if ((symbol.type == Symbol::SymbolMacro) ||
7712 (symbol.type == Symbol::SymbolAction)) continue;
7713 }
7714 else if (m_action == action_show_action_names)
7715 {
7716 // Exclude macros.
7717 if (symbol.type != Symbol::SymbolAction) continue;
7718 }
7719
7720 cout << symbol.name << endl;
7721 }
7722}
7723
7724/**
7725 * Format a set of make macro definitions (one per line)
7726 * Each macro value is provided enclosed in single quotes
7727 *
7728 * Take the macro values from the macro statements found
7729 * in recursively read requirements files.
7730 */
7731void Cmt::print_macros (PrintMode mode, const cmt_string& pattern)
7732{
7733 int number;
7734
7735 set_standard_macros ();
7736
7737 cmt_regexp expression (pattern);
7738
7739 bool has_pattern = (pattern != "");
7740
7741 for (number = 0; number < Symbol::symbol_number (); number++)
7742 {
7743 Symbol& symbol = Symbol::symbol (number);
7744
7745 if (has_pattern)
7746 {
7747 if (!expression.match (symbol.name)) continue;
7748 }
7749
7750 if (m_action == action_show_macros)
7751 {
7752 // Only keep macros.
7753 if ((symbol.type == Symbol::SymbolSet) ||
7754 (symbol.type == Symbol::SymbolAlias) ||
7755 (symbol.type == Symbol::SymbolPath) ||
7756 (symbol.type == Symbol::SymbolAction)) continue;
7757 }
7758 else if (m_action == action_show_sets)
7759 {
7760 // Exclude macros.
7761 if ((symbol.type == Symbol::SymbolMacro) ||
7762 (symbol.type == Symbol::SymbolAction)) continue;
7763 }
7764 else if (m_action == action_build_tag_makefile)
7765 {
7766 // Exclude scripts and actions
7767 if ((symbol.type == Symbol::SymbolSetupScript) ||
7768 (symbol.type == Symbol::SymbolCleanupScript) ||
7769 (symbol.type == Symbol::SymbolAction)) continue;
7770 }
7771 else if (m_action == action_show_actions)
7772 {
7773 if (symbol.type != Symbol::SymbolAction) continue;
7774 }
7775
7776 if (symbol.value_lists.size () < 1) continue;
7777
7778 symbol.show_macro (mode);
7779 }
7780}
7781
7782//----------------------------------------------------------
7783void Cmt::print_tabs (int tabs)
7784{
7785 while (tabs > 0)
7786 {
7787 cout << " ";
7788 tabs--;
7789 }
7790}
7791
7792//----------------------------------------------------------
7793int Cmt::reach_current_package ()
7794{
7795 Use& use = Use::current ();
7796 cmt_string dir;
7797
7798 if (m_debug)
7799 {
7800 cout << "Cmt::reach_current_package> pwd = "
7801 << CmtSystem::pwd ()
7802 << " path=" << m_current_path
7803 << " package=" << m_current_package
7804 << endl;
7805 }
7806
7807 /*
7808 Try to access the package.
7809 */
7810
7811 if (m_current_package == "cmt_standalone")
7812 {
7813 if ((m_current_path != "") && (m_current_path != CmtSystem::pwd ()))
7814 {
7815 if (!CmtSystem::cd (m_current_path))
7816 {
7817 CmtError::set (CmtError::package_not_found,
7818 "ReachCurrentPackage> Cannot reach the path directory");
7819 return (0);
7820 }
7821 }
7822
7823 if (!CmtSystem::test_file ("requirements"))
7824 {
7825 /*
7826 if (!m_quiet)
7827 {
7828 cout << "#CMT> Cannot reach the requirements file" << endl;
7829 }
7830
7831 CmtError::set (CmtError::package_not_found,
7832 "ReachCurrentPackage> Cannot reach the requirements file");
7833 */
7834 return (0);
7835 }
7836 }
7837 else if (m_current_package != "")
7838 {
7839 if (!use.move_to ())
7840 {
7841 CmtError::set (CmtError::package_not_found,
7842 "ReachCurrentPackage> Cannot reach the path directory");
7843 return (0);
7844 }
7845
7846 m_current_path = use.real_path;
7847 }
7848 else
7849 {
7850 //
7851 // The cmt command has been given without explicit search for
7852 // a package. Thus it is expected that we are in the context of a
7853 // true package.
7854 //
7855 // This means that there should be a requirements file visible.
7856 //
7857 // If this is not true, we'll make a try into ../cmt and then
7858 // a last try into ../mgr
7859 //
7860
7861 if (!CmtSystem::test_file ("requirements"))
7862 {
7863 if (CmtSystem::cd ("../cmt") &&
7864 CmtSystem::test_file ("requirements"))
7865 {
7866 m_current_style = cmt_style;
7867 }
7868 else if (CmtSystem::cd ("../mgr") &&
7869 CmtSystem::test_file ("requirements"))
7870 {
7871 m_current_style = mgr_style;
7872 }
7873 else
7874 {
7875 if (!m_quiet)
7876 {
7877 cerr << "#CMT> Cannot reach the mgr branch" << endl;
7878 }
7879
7880 CmtError::set (CmtError::package_not_found,
7881 "ReachCurrentPackage> Cannot reach the mgr/cmt directory");
7882 return (0);
7883 }
7884 }
7885
7886 dir = CmtSystem::pwd ();
7887
7888 CmtSystem::dirname (dir, m_current_path);
7889 CmtSystem::basename (m_current_path, m_current_version);
7890
7891 if (CmtSystem::is_version_directory (m_current_version))
7892 {
7893 CmtSystem::dirname (m_current_path, m_current_path);
7894 CmtSystem::basename (m_current_path, m_current_package);
7895 CmtSystem::dirname (m_current_path, m_current_path);
7896 }
7897 else
7898 {
7899 m_current_package = m_current_version;
7900 m_current_version = "";
7901 CmtSystem::dirname (m_current_path, m_current_path);
7902
7903 m_current_style = no_version_style;
7904 }
7905
7906 use.set_package_name (m_current_package);
7907 use.version = m_current_version;
7908 use.path = m_current_path;
7909 use.style = m_current_style;
7910 }
7911
7912 configure_current_dir ();
7913 build_prefix (m_current_package, m_current_prefix);
7914 build_config (m_current_prefix, m_current_config);
7915
7916 /*
7917 Check Tag is always set up
7918 */
7919
7920 if (m_debug) cout << "reach_current_package0> current_tag=" << m_current_tag << endl;
7921
7922 if (m_current_tag == "")
7923 {
7924 cmt_string env;
7925
7926 env = CmtSystem::getenv (m_current_config);
7927 if (env != "")
7928 {
7929 Tag* tag;
7930
7931 tag = Tag::add (env, PriorityConfig, "reach current package", 0);
7932 tag->mark ();
7933 //m_current_tag = env;
7934
7935 //if (!m_quiet) cerr << "reach_current_package1> current_tag=" << m_current_tag << endl;
7936
7937 }
7938 }
7939
7940 if (m_debug)
7941 {
7942 cout << "pwd = " << CmtSystem::pwd () << endl;
7943 }
7944
7945 /*
7946 Work on the requirements file.
7947 */
7948
7949 if (dir != "") dir += CmtSystem::file_separator ();
7950 dir += "requirements";
7951 SyntaxParser::parse_requirements (dir, &use);
7952
7953 if (m_debug) cout << "reach_current_package2> current_tag=" << m_current_tag << endl;
7954
7955 /**
7956 * It would be useful to change this mechanism. Instead of
7957 * applying all global patterns at once to all use contexts, it
7958 * would be much better to apply it at the end of each
7959 * requirements file parsing, and only in the context the
7960 * appropriate Use.
7961 *
7962 * This would avoid the current flaw which is that when a global
7963 * pattern specifies a "private" definition, it is actually
7964 * applied in the scope context of the Current Use and not in
7965 * each individual Use. Therefore the private is lost.
7966 *
7967 * However, this induces problems since some pattern definitions
7968 * are done AFTER the use statements, which will NOT receive the
7969 * pattern aplications.
7970 *
7971 * Therefore it is decided to leave this "bad" mechanism until
7972 * everybody is aware of this constraint.
7973 *
7974 *
7975 */
7976 Pattern::apply_all_globals ();
7977
7978 /*
7979 Select all possible tags
7980 */
7981
7982 Tag::restore_tree ();
7983
7984 return (1);
7985}
7986
7987static cmt_string get_best_form (const CmtSystem::cmt_string_vector& pwd,
7988 const cmt_string& path)
7989{
7990 static cmt_string fs = CmtSystem::file_separator ();
7991 cmt_string result;
7992
7993 /*
7994 //if (CmtSystem::getenv ("CMTTESTPREFIX") != "")
7995 {
7996 */
7997
7998 //
7999 // If there is a common prefix between
8000 // use->real_path and pwd
8001 // we have
8002 // use->real_path = /<prefix>/aaa
8003 // pwd = /<prefix>/bbb
8004 //
8005 // Then use->real_path may be expressed as:
8006 // ../..../../aaa
8007 // where ../..../../ moves up to /<prefix>
8008 //
8009 // Then we try to find the shortest between
8010 //
8011 // /<prefix> and ../..../..
8012 //
8013 cmt_string a = path;
8014
8015 CmtSystem::cmt_string_vector va;
8016
8017 va.clear ();
8018
8019 CmtSystem::split (a, fs, va);
8020
8021 int m = va.size ();
8022 if (pwd.size () < m) m = pwd.size ();
8023
8024 int i;
8025
8026 //cout << "Package " << use->get_package_name () << endl;
8027
8028 for (i = 0; i < m; i++)
8029 {
8030 const cmt_string& fa = va[i];
8031 const cmt_string& fb = pwd[i];
8032
8033 //cout << " fa=" << fa << " fb=" << fb << endl;
8034
8035 if (fa != fb) break;
8036 }
8037
8038 cmt_string ups = "";
8039
8040 if (i > 0)
8041 {
8042 // We have the prefix.
8043 // if we count what remains from pwd, then
8044 // we have the number of ../ required to
8045 // move to /<prefix>
8046 int j;
8047
8048 for (j = i; j < pwd.size (); j++)
8049 {
8050 if (j > i) ups += fs;
8051 ups += "..";
8052 }
8053
8054 for (j = i; j < va.size (); j++)
8055 {
8056 ups += fs;
8057 ups += va[j];
8058 }
8059 }
8060
8061 //
8062 // Here ups contains the ../..../../aaa form
8063 // for the use->real_path or is empty when there
8064 // were no common prefix.
8065 //
8066
8067 //if (ups != "")
8068 if ((ups != "") &&
8069 (ups.size () < path.size ()))
8070 {
8071 result = ups;
8072 }
8073 else
8074 {
8075 result = path;
8076 }
8077
8078 return (result);
8079}
8080
8081/**
8082 * This completely local class holds primitive actions for building
8083 * standard macros.
8084 */
8085class StandardMacroBuilder
8086{
8087public:
8088
8089 /**
8090 * CMTVERSION
8091 */
8092 void fill_for_CMTVERSION ()
8093 {
8094 buffer = "macro CMTVERSION \"";
8095 buffer += CMTVERSION;
8096 buffer += "\"";
8097 apply ();
8098 }
8099
8100 StandardMacroBuilder (const cmt_string& tag,
8101 const cmt_string& package,
8102 const cmt_string& version,
8103 const cmt_string& prefix,
8104 CmtDirStyle style)
8105 {
8106 fs = CmtSystem::file_separator ();
8107 buffer = "";
8108 pwd = CmtSystem::pwd ();
8109 CmtSystem::split (pwd, fs, vb);
8110 current_use = &(Use::current ());
8111 current_tag = tag;
8112 current_package = package;
8113 current_version = version;
8114 current_prefix = prefix;
8115 current_style = style;
8116 }
8117
8118 void apply ()
8119 {
8120 SyntaxParser::parse_requirements_line (buffer, current_use);
8121 buffer = "";
8122 }
8123
8124 /**
8125 * tag
8126 */
8127 void fill_for_tag ()
8128 {
8129 static bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
8130
8131 if (!Symbol::is_selected ("tag"))
8132 {
8133 if (tag_debug) cerr << "set_standard_macro2.1> current_tag=" << current_tag << endl;
8134
8135 if (current_tag == "")
8136 {
8137 buffer = "macro tag \"$(CMTCONFIG)\"";
8138 }
8139 else
8140 {
8141 buffer = "macro tag \"";
8142 buffer += current_tag;
8143 buffer += "\"";
8144 }
8145
8146 if (tag_debug) cerr << " define tag: " << buffer << endl;
8147
8148 apply ();
8149 }
8150 }
8151
8152 /**
8153 * PACKAGE_ROOT
8154 */
8155 void fill_for_package (const cmt_string& current_dir)
8156 {
8157 buffer = "macro package \"";
8158 buffer += current_package;
8159 buffer += "\"";
8160 apply ();
8161
8162 buffer = "macro version \"";
8163 buffer += current_version;
8164 buffer += "\"";
8165 apply ();
8166
8167 if (!Symbol::is_selected ("PACKAGE_ROOT"))
8168 {
8169 buffer = "macro PACKAGE_ROOT \"$(";
8170 buffer += current_prefix;
8171 buffer += "ROOT";
8172 buffer += ")\"";
8173
8174 apply ();
8175 }
8176 }
8177
8178 /**
8179 * srcdir
8180 * src =$(srcdir)/
8181 * inc
8182 * mgrdir
8183 * mgr =../$(mgrdir)/
8184 * bin
8185 * javabin
8186 * doc
8187 * version
8188 * package
8189 *
8190 * <package>_project
8191 * <package>_cmtpath
8192 * <package>_offset
8193 * package_cmtpath
8194 * package_offset
8195 * project
8196 *
8197 */
8198 void fill_for_branches ()
8199 {
8200 /**
8201 * Basic macros (src, mgr, ...)
8202 */
8203
8204 if (current_style == none_style)
8205 {
8206 buffer = "macro srcdir \".";
8207 buffer += "\"";
8208 apply ();
8209
8210 buffer = "macro src \".";
8211 buffer += fs;
8212 buffer += "\"";
8213 apply ();
8214
8215 buffer = "macro inc \".";
8216 buffer += fs;
8217 buffer += "\"";
8218 apply ();
8219
8220 buffer = "macro mgr \".";
8221 buffer += fs;
8222 buffer += "\"";
8223 apply ();
8224
8225 buffer = "macro bin \".";
8226 buffer += fs;
8227 buffer += "\"";
8228 apply ();
8229
8230 buffer = "macro javabin \".";
8231 buffer += fs;
8232 buffer += "\"";
8233 apply ();
8234
8235 buffer = "macro doc \".";
8236 buffer += fs;
8237 buffer += "\"";
8238 apply ();
8239 }
8240 else
8241 {
8242 if (!Symbol::is_selected ("srcdir"))
8243 {
8244 buffer = "macro srcdir \"..";
8245 buffer += fs;
8246 buffer += "src";
8247 buffer += "\"";
8248 apply ();
8249 }
8250
8251 if (!Symbol::is_selected ("src"))
8252 {
8253 buffer = "macro src \"..";
8254 buffer += fs;
8255 buffer += "src";
8256 buffer += fs;
8257 buffer += "\"";
8258 apply ();
8259 }
8260
8261 if (!Symbol::is_selected ("inc"))
8262 {
8263 buffer = "macro inc \"..";
8264 buffer += fs;
8265 buffer += "src";
8266 buffer += fs;
8267 buffer += "\"";
8268 apply ();
8269 }
8270
8271 if (!Symbol::is_selected ("doc"))
8272 {
8273 buffer = "macro doc \"..";
8274 buffer += fs;
8275 buffer += "doc";
8276 buffer += fs;
8277 buffer += "\"";
8278 apply ();
8279 }
8280
8281 if (!Symbol::is_selected ("bin"))
8282 {
8283 cmt_string package_tag = current_package;
8284 package_tag += "_tag";
8285
8286 buffer = "macro bin \"..";
8287 buffer += fs;
8288 buffer += "$(";
8289 buffer += package_tag;
8290 buffer += ")";
8291 buffer += fs;
8292 buffer += "\"";
8293 apply ();
8294 }
8295
8296 if (!Symbol::is_selected ("javabin"))
8297 {
8298 buffer = "macro javabin \"..";
8299 buffer += fs;
8300 buffer += "classes";
8301 buffer += fs;
8302 buffer += "\"";
8303 apply ();
8304 }
8305
8306 if (current_style == mgr_style)
8307 {
8308 buffer = "macro mgrdir \"mgr\"";
8309 apply ();
8310
8311 buffer = "macro mgr \"..";
8312 buffer += fs;
8313 buffer += "mgr";
8314 buffer += fs;
8315 buffer += "\"";
8316 apply ();
8317 }
8318 else
8319 {
8320 buffer = "macro mgrdir \"cmt\"";
8321 apply ();
8322
8323 buffer = "macro mgr \"..";
8324 buffer += fs;
8325 buffer += "cmt";
8326 buffer += fs;
8327 buffer += "\"";
8328 apply ();
8329 }
8330
8331 Cmt::configure_current_cmtpath ();
8332 }
8333 }
8334
8335 /**
8336 * project
8337 */
8338 void fill_for_project ()
8339 {
8340 if (current_style == none_style) return;
8341
8342 cmt_string project_name;
8343 Project* project = Project::get_current ();
8344 if (project != 0)
8345 {
8346 project_name = project->get_name ();
8347 }
8348
8349 buffer = "macro project \"";
8350 buffer += project_name;
8351 buffer += "\"";
8352 apply ();
8353 }
8354
8355 /**
8356 * use_requirements
8357 */
8358 void fill_for_use_requirements ()
8359 {
8360 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8361
8362 if (Uses.size () == 0) return;
8363
8364 if (!Symbol::is_selected ("use_requirements"))
8365 {
8366 buffer = "macro use_requirements \"";
8367 buffer += "requirements ";
8368
8369 for (int number = 0; number < Uses.size (); number++)
8370 {
8371 Use* use = Uses[number];
8372
8373 if (use->discarded) continue;
8374
8375 if (use->located ())
8376 {
8377 buffer += "$(";
8378 buffer += use->prefix;
8379 buffer += "ROOT)";
8380 buffer += fs;
8381
8382 if (use->style == mgr_style) buffer += "mgr";
8383 else buffer += "cmt";
8384
8385 buffer += fs;
8386 buffer += "requirements ";
8387 }
8388 }
8389
8390 buffer += "\"";
8391
8392 apply ();
8393 }
8394 }
8395
8396 /**
8397 * use_includes
8398 */
8399 void fill_for_use_includes ()
8400 {
8401 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8402
8403 if (Uses.size () == 0) return;
8404
8405 if (!Symbol::is_selected ("use_includes"))
8406 {
8407 buffer = "macro_append use_includes \' ";
8408
8409 for (int number = 0; number < Uses.size (); number++)
8410 {
8411 Use* use = Uses[number];
8412
8413 if (use->discarded) continue;
8414
8415 Package* p = use->get_package ();
8416 if (p->is_cmt ()) continue;
8417
8418 if (Cmt::get_debug ())
8419 {
8420 cout << "fill use_includes for " << use->get_package_name ()
8421 << " discarded=" << use->discarded
8422 << " auto_imports=" << use->auto_imports << endl;
8423 }
8424
8425 if (use->auto_imports == Off) continue;
8426
8427 use->fill_includes_macro (buffer);
8428 }
8429
8430 buffer += "\'";
8431
8432 apply ();
8433 }
8434 }
8435
8436 /**
8437 * use_fincludes
8438 */
8439 void fill_for_use_fincludes ()
8440 {
8441 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8442
8443 if (Uses.size () == 0) return;
8444
8445 if (!Symbol::is_selected ("use_fincludes"))
8446 {
8447 buffer = "macro_append use_fincludes \" $(use_includes)\"";
8448 apply ();
8449 }
8450 }
8451
8452 /**
8453 * use_stamps
8454 */
8455 void fill_for_use_stamps ()
8456 {
8457 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8458
8459 if (Uses.size () == 0) return;
8460
8461 if (!Symbol::is_selected ("use_stamps"))
8462 {
8463 buffer = "macro use_stamps \"";
8464 (Use::current()).fill_macro (buffer, "stamps");
8465
8466 for (int number = 0; number < Uses.size (); number++)
8467 {
8468 Use* use = Uses[number];
8469
8470 if (use->discarded) continue;
8471
8472 Package* p = use->get_package ();
8473 if (p->is_cmt ()) continue;
8474
8475 use->fill_macro (buffer, "stamps");
8476 }
8477
8478 buffer += "\"";
8479
8480 apply ();
8481 }
8482 }
8483
8484 /**
8485 * use_cflags
8486 */
8487 void fill_for_use_cflags ()
8488 {
8489 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8490
8491 if (Uses.size () == 0) return;
8492
8493 if (!Symbol::is_selected ("use_cflags"))
8494 {
8495 Use::fill_macro_all (buffer, "cflags");
8496 apply ();
8497 }
8498 }
8499
8500 /**
8501 * use_pp_cflags
8502 */
8503 void fill_for_use_pp_cflags ()
8504 {
8505 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8506
8507 if (Uses.size () == 0) return;
8508
8509 if (!Symbol::is_selected ("use_pp_cflags"))
8510 {
8511 Use::fill_macro_all (buffer, "pp_cflags");
8512 apply ();
8513 }
8514 }
8515
8516 /**
8517 * use_cppflags
8518 */
8519 void fill_for_use_cppflags ()
8520 {
8521 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8522
8523 if (Uses.size () == 0) return;
8524
8525 if (!Symbol::is_selected ("use_cppflags"))
8526 {
8527 Use::fill_macro_all (buffer, "cppflags");
8528 apply ();
8529 }
8530 }
8531
8532 /**
8533 * use_pp_cppflags
8534 */
8535 void fill_for_use_pp_cppflags ()
8536 {
8537 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8538
8539 if (Uses.size () == 0) return;
8540
8541 if (!Symbol::is_selected ("use_pp_cppflags"))
8542 {
8543 Use::fill_macro_all (buffer, "pp_cppflags");
8544 apply ();
8545 }
8546 }
8547
8548 /**
8549 * use_fflags
8550 */
8551 void fill_for_use_fflags ()
8552 {
8553 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8554
8555 if (Uses.size () == 0) return;
8556
8557 if (!Symbol::is_selected ("use_fflags"))
8558 {
8559 Use::fill_macro_all (buffer, "fflags");
8560 apply ();
8561 }
8562 }
8563
8564 /**
8565 * use_pp_fflags
8566 */
8567 void fill_for_use_pp_fflags ()
8568 {
8569 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8570
8571 if (Uses.size () == 0) return;
8572
8573 if (!Symbol::is_selected ("use_pp_fflags"))
8574 {
8575 Use::fill_macro_all (buffer, "pp_fflags");
8576 apply ();
8577 }
8578 }
8579
8580 /**
8581 * use_linkopts
8582 */
8583 void fill_for_use_linkopts ()
8584 {
8585 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8586
8587 if (Uses.size () == 0) return;
8588
8589 if (!Symbol::is_selected ("use_linkopts"))
8590 {
8591 Use::fill_macro_all (buffer, "linkopts");
8592 apply ();
8593 }
8594 }
8595
8596 /**
8597 * use_libraries
8598 */
8599 void fill_for_use_libraries ()
8600 {
8601 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8602
8603 if (Uses.size () == 0) return;
8604
8605 if (!Symbol::is_selected ("use_libraries"))
8606 {
8607 buffer = "macro use_libraries \"";
8608
8609 for (int number = 0; number < Uses.size (); number++)
8610 {
8611 Use* use = Uses[number];
8612
8613 if (use->discarded) continue;
8614
8615 Package* p = use->get_package ();
8616 if (p->is_cmt ()) continue;
8617
8618 use->fill_macro (buffer, "libraries");
8619 }
8620
8621 buffer += "\"";
8622
8623 apply ();
8624 }
8625 }
8626
8627 /**
8628 * includes
8629 */
8630 void fill_for_includes ()
8631 {
8632 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8633
8634 if (Uses.size () == 0) return;
8635
8636 if (!Symbol::is_selected ("includes"))
8637 {
8638 buffer = "macro_append includes \' ";
8639
8640 Use& use = Use::current();
8641
8642 if (use.include_path == "")
8643 {
8644 buffer += "$(ppcmd)\"$(srcdir)\" ";
8645 }
8646 else if (use.include_path != "none")
8647 {
8648 buffer += "$(ppcmd)\"";
8649 buffer += use.include_path;
8650 buffer += "\" ";
8651 }
8652
8653 for (int include_number = 0;
8654 include_number < use.includes.size ();
8655 include_number++)
8656 {
8657 Include& incl = use.includes[include_number];
8658
8659 buffer += "$(ppcmd)\"";
8660 buffer += incl.name;
8661 buffer += "\" ";
8662 }
8663
8664 buffer += "$(use_includes)\'";
8665
8666 apply ();
8667 }
8668 }
8669
8670 /**
8671 * fincludes
8672 */
8673 void fill_for_fincludes ()
8674 {
8675 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8676
8677 if (Uses.size () == 0) return;
8678
8679 if (!Symbol::is_selected ("fincludes"))
8680 {
8681 buffer = "macro_append fincludes \" $(includes)\"";
8682 apply ();
8683 }
8684 }
8685
8686 /**
8687 * Macros specific to constituents.
8688 * This includes the compiler flags
8689 * and fills in these macros from uses packages. This takes care
8690 * of -no_auto_imports and -import= directives
8691 *
8692 * <constituent>_use_linkopts
8693 * <prefix>_<constituent>_cflags
8694 * <prefix>_<constituent>_pp_cflags
8695 * <prefix>_<constituent>_cppflags
8696 * <prefix>_<constituent>_pp_cppflags
8697 * <prefix>_<constituent>_fflags
8698 * <prefix>_<constituent>_pp_fflags
8699 * <constituent>linkopts
8700 * <constituent>_GUID
8701 *
8702 */
8703 void fill_for_all_constituents ()
8704 {
8705 /// First, finish the parsing of constituent parameters.
8706 Constituent::parse_all ();
8707
8708 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
8709
8710 const Constituent::ConstituentVector& constituents =
8711 Constituent::constituents ();
8712
8713
8714 /// Prepare the auto_imports states in a vector
8715
8716 cmt_vector<bool> base_auto_imports_states;
8717
8718 base_auto_imports_states.resize (Uses.size ());
8719
8720 int number;
8721
8722 for (number = 0; number < Uses.size (); number++)
8723 {
8724 Use* use = Uses[number];
8725 base_auto_imports_states[number] = (use->auto_imports != Off);
8726 }
8727
8728 /// Now scan all constituents
8729
8730 for (number = 0; number < constituents.size (); number++)
8731 {
8732 const Constituent& constituent = constituents[number];
8733
8734 Use::UsePtrVector imports;
8735 int i;
8736
8737 /**
8738 * Problem for imports in constituents.
8739 *
8740 * 1) use_xxx has holes due to the corresponding
8741 * -no_auto_imports options attached to some
8742 * use statements (including the transitive ones)
8743 *
8744 * 2) the -import=yyy options provided to a given constituent
8745 * should restore the appropriate holes as well as
8746 * all transitive ones.
8747 *
8748 * 3) for use_linkopts, missing pieces must be filled at
8749 * the right position. (for others, order is not relevant
8750 * while transitive access is required for all)
8751 *
8752 */
8753
8754 if (constituent.type == Document) continue;
8755 if (constituent.imports.size () == 0)
8756 {
8757 buffer = "macro_append ";
8758 buffer += constituent.name;
8759 buffer += "_use_linkopts ";
8760 buffer += " \" ";
8761
8762 current_use->fill_macro (buffer, "linkopts");
8763
8764 for (i = 0; i < Uses.size (); i++)
8765 {
8766 if (base_auto_imports_states[i])
8767 {
8768 Use* u = Uses[i];
8769
8770 if (u->discarded) continue;
8771
8772 Package* p = u->get_package ();
8773 if (p->is_cmt ()) continue;
8774
8775 u->fill_macro (buffer, "linkopts");
8776 }
8777 }
8778 buffer += "\"";
8779 apply ();
8780
8781 /*
8782 buffer = "macro_append ";
8783 buffer += constituent.name;
8784 buffer += "_use_linkopts ";
8785
8786 buffer += " \" $(use_linkopts)\"";
8787 apply ();
8788 */
8789
8790 continue;
8791 }
8792
8793 /**
8794 * Create a private copy of the state vector. This private copy
8795 * will be updated according to -import=xxx modifiers for the
8796 * current constituent.
8797 */
8798 cmt_vector<bool> auto_imports_states (base_auto_imports_states);
8799
8800 for (i = 0; i < constituent.imports.size (); i++)
8801 {
8802 const cmt_string& import = constituent.imports[i];
8803
8804 //
8805 // Resolve the imported uses
8806 //
8807
8808 int use_index = Use::find_index (import, "", "");
8809
8810 if (use_index >= 0)
8811 {
8812 Use* u = Uses[use_index];
8813
8814 if (u->discarded) continue;
8815
8816 if (Cmt::get_debug ())
8817 {
8818 cout << constituent.name << " needs imports " << import << " "
8819 << use_index << " "
8820 << u->get_package()->get_name() << endl;
8821 }
8822
8823 Package* p = u->get_package ();
8824 if (p->is_cmt ()) continue;
8825
8826 if (u->auto_imports != Off) continue;
8827
8828 Use::set_auto_imports_state (use_index, auto_imports_states);
8829 }
8830 }
8831
8832 if (Cmt::get_debug ())
8833 {
8834 cout << constituent.name << " has imports " << endl;
8835 }
8836
8837
8838 /**
8839 * Find all newly exposed packages and precompute this list inside
8840 * a vector.
8841 */
8842 for (i = 0; i < base_auto_imports_states.size (); i++)
8843 {
8844 if (auto_imports_states[i] != base_auto_imports_states[i])
8845 {
8846 Use* u = Uses[i];
8847
8848 if (u->discarded) continue;
8849
8850 Package* p = u->get_package ();
8851 if (p->is_cmt ()) continue;
8852
8853 if (Cmt::get_debug ())
8854 {
8855 cout << constituent.name << " has import " << p->get_name () << endl;
8856 }
8857
8858 if (u->auto_imports != Off) continue;
8859
8860 imports.push_back (u);
8861 }
8862 }
8863
8864 if (imports.size () == 0) return;
8865
8866 cmt_string prefix;
8867
8868 //
8869 // Documents are not considered
8870 //
8871 switch (constituent.type)
8872 {
8873 case Application:
8874 prefix = "app_";
8875 break;
8876 case Library:
8877 prefix = "lib_";
8878 break;
8879 }
8880
8881 buffer = "macro_append ";
8882 buffer += prefix;
8883 buffer += constituent.name;
8884 buffer += "_cflags ";
8885 buffer += " \' ";
8886 for (i = 0; i < imports.size (); i++)
8887 {
8888 Use* u = imports[i];
8889
8890 u->fill_includes_macro (buffer);
8891 u->fill_macro (buffer, "cflags");
8892 }
8893 buffer += "\'";
8894 apply ();
8895
8896 buffer = "macro_append ";
8897 buffer += prefix;
8898 buffer += constituent.name;
8899 buffer += "_pp_cflags ";
8900 buffer += " \" ";
8901 for (i = 0; i < imports.size (); i++)
8902 {
8903 Use* u = imports[i];
8904
8905 u->fill_macro (buffer, "pp_cflags");
8906 }
8907 buffer += "\"";
8908 apply ();
8909
8910 buffer = "macro_append ";
8911 buffer += prefix;
8912 buffer += constituent.name;
8913 buffer += "_cppflags ";
8914 buffer += " \' ";
8915 for (i = 0; i < imports.size (); i++)
8916 {
8917 Use* u = imports[i];
8918
8919 u->fill_includes_macro (buffer);
8920 u->fill_macro (buffer, "cppflags");
8921 }
8922 buffer += "\'";
8923 apply ();
8924
8925 buffer = "macro_append ";
8926 buffer += prefix;
8927 buffer += constituent.name;
8928 buffer += "_pp_cppflags ";
8929 buffer += " \" ";
8930 for (i = 0; i < imports.size (); i++)
8931 {
8932 Use* u = imports[i];
8933
8934 u->fill_macro (buffer, "pp_cppflags");
8935 }
8936 buffer += "\"";
8937 apply ();
8938
8939 buffer = "macro_append ";
8940 buffer += prefix;
8941 buffer += constituent.name;
8942 buffer += "_fflags ";
8943 buffer += " \' ";
8944 for (i = 0; i < imports.size (); i++)
8945 {
8946 Use* u = imports[i];
8947
8948 u->fill_includes_macro (buffer);
8949 u->fill_macro (buffer, "fflags");
8950 }
8951 buffer += "\'";
8952 apply ();
8953
8954 buffer = "macro_append ";
8955 buffer += prefix;
8956 buffer += constituent.name;
8957 buffer += "_pp_fflags ";
8958 buffer += " \" ";
8959 for (i = 0; i < imports.size (); i++)
8960 {
8961 Use* u = imports[i];
8962
8963 u->fill_macro (buffer, "pp_fflags");
8964 }
8965 buffer += "\"";
8966 apply ();
8967
8968 /**
8969 * Setting ${CONSTITUENT}linkopts is a temporary solution
8970 * until the backward compatibility solution for a proper
8971 * replacement of use_linkopts by ${CONSTITUENT}_use_linkopts
8972 * is acheived.
8973 *
8974 */
8975 buffer = "macro_append ";
8976 buffer += constituent.name;
8977 buffer += "linkopts ";
8978 buffer += " \" ";
8979 for (i = 0; i < imports.size (); i++)
8980 {
8981 Use* u = imports[i];
8982
8983 u->fill_macro (buffer, "linkopts");
8984 }
8985 buffer += "\"";
8986 apply ();
8987
8988 /**
8989 * Only for linkopts we take care of the order. This means
8990 * that ${CONSTITUENT}_use_linkopts should be used in place of use_linkopts.
8991 *
8992 * (see the application fragments)
8993 * that ${CONSTITUENT}_use_linkopts will be used in place of use_linkopts.
8994 */
8995 buffer = "macro_append ";
8996 buffer += constituent.name;
8997 buffer += "_use_linkopts ";
8998 buffer += " \" ";
8999
9000 current_use->fill_macro (buffer, "linkopts");
9001
9002 for (i = 0; i < Uses.size (); i++)
9003 {
9004 if (auto_imports_states[i])
9005 {
9006 Use* u = Uses[i];
9007
9008 if (u->discarded) continue;
9009
9010 Package* p = u->get_package ();
9011 if (p->is_cmt ()) continue;
9012
9013 u->fill_macro (buffer, "linkopts");
9014 }
9015 }
9016 buffer += "\"";
9017 apply ();
9018
9019 //==== GLAST addition for vs.net ==========
9020 buffer = "macro ";
9021 buffer += constituent.name;
9022 buffer += "_GUID \"{88BF15AB-5A2D-4bea-B64F-02752C2A1F4F}\" ";
9023 apply ();
9024 }
9025 }
9026
9027 /**
9028 * Macros to be defined once current_package is known
9029 * and even before reading its requirements file.
9030 */
9031 void fill_for_current_package (const cmt_string& current_dir)
9032 {
9033 fill_for_tag ();
9034 fill_for_package (current_dir);
9035 }
9036
9037private:
9038 cmt_string fs;
9039 cmt_string buffer;
9040 CmtSystem::cmt_string_vector vb;
9041 cmt_string pwd;
9042 Use* current_use;
9043 cmt_string current_tag;
9044 cmt_string current_package;
9045 cmt_string current_version;
9046 cmt_string current_prefix;
9047 CmtDirStyle current_style;
9048};
9049
9050//----------------------------------------------------------
9051void Cmt::set_current_access (AccessMode mode)
9052{
9053 m_current_access = mode;
9054}
9055
9056//----------------------------------------------------------
9057void Cmt::set_current_build_strategy (int strategy)
9058{
9059 m_current_build_strategy = strategy;
9060}
9061
9062//----------------------------------------------------------
9063void Cmt::set_current_setup_strategy (int strategy)
9064{
9065 m_current_setup_strategy = strategy;
9066}
9067
9068//----------------------------------------------------------
9069void Cmt::set_scope_filtering_mode (CmtScopeFilteringMode mode)
9070{
9071 m_scope_filtering_mode = mode;
9072}
9073
9074//----------------------------------------------------------
9075void Cmt::set_standard_macros ()
9076{
9077 if (m_standard_macros_done) return;
9078
9079 m_standard_macros_done = true;
9080
9081 int number;
9082 cmt_string temp;
9083 Use::UsePtrVector& Uses = Use::get_ordered_uses ();
9084 Use& current_use = Use::current ();
9085
9086 cmt_string fs = CmtSystem::file_separator ();
9087
9088 cmt_string pwd = CmtSystem::pwd ();
9089
9090 if (CmtSystem::test_file ("../cmt/requirements")) m_current_style = cmt_style;
9091 else if (CmtSystem::test_file ("../mgr/requirements")) m_current_style = mgr_style;
9092 else m_current_style = none_style;
9093
9094 {
9095 cmt_string v;
9096 CmtSystem::dirname (pwd, v);
9097 CmtSystem::basename (v, v);
9098 if (!CmtSystem::is_version_directory (v))
9099 {
9100 m_current_style = no_version_style;
9101 }
9102 }
9103
9104 // Prepare computation of the best form for relative path from current directory
9105 // to package directories.
9106 CmtSystem::cmt_string_vector vb;
9107 CmtSystem::split (pwd, fs, vb);
9108
9109
9110 /**
9111 * TAG management
9112 */
9113
9114 bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
9115
9116 if (tag_debug) cerr << "set_standard_macro0> current_tag=" << m_current_tag << endl;
9117
9118 if (m_current_tag != "")
9119 {
9120 // this is when some -tag= argument was used.
9121 if (tag_debug) cerr << "set_standard_macro0.1> current_tag=" << m_current_tag << endl;
9122 }
9123 else if (Symbol::is_selected ("CMTCONFIG"))
9124 {
9125 // This is when CMTCONFIG has been set from some requirements file
9126 Symbol* macro = Symbol::find ("CMTCONFIG");
9127 if (macro != 0)
9128 {
9129 m_current_tag = macro->build_macro_value ();
9130 if (tag_debug) cerr << "set_standard_macro1> current_tag=" << m_current_tag << endl;
9131 }
9132 }
9133 else
9134 {
9135 // this is when no -tag= argument was used.
9136 if (tag_debug) cerr << "set_standard_macro(before2)> current_tag=" << m_current_tag << endl;
9137 if (current_use.get_package_name () == "CMT")
9138 {
9139 m_current_tag = CmtSystem::getenv ("CMTBIN");
9140 }
9141 else
9142 {
9143 m_current_tag = CmtSystem::getenv ("CMTCONFIG");
9144 }
9145
9146 if (tag_debug) cerr << "set_standard_macro2> current_tag=" << m_current_tag << endl;
9147 }
9148
9149 if (m_debug)
9150 {
9151 cout << "set_standard_macro3>" << endl;
9152 }
9153
9154 StandardMacroBuilder builder (m_current_tag,
9155 m_current_package,
9156 m_current_version,
9157 m_current_prefix,
9158 m_current_style);
9159
9160
9161 //
9162 // Definitions for installation area mechanisms
9163 //
9164 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
9165 {
9166 CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
9167
9168 //cout << "#IA6>" << endl;
9169
9170 ia_mgr.setup_current_installarea ();
9171 }
9172
9173 builder.fill_for_current_package (m_current_dir);
9174
9175 builder.fill_for_branches ();
9176 builder.fill_for_project ();
9177 builder.fill_for_use_requirements ();
9178 builder.fill_for_use_includes ();
9179 builder.fill_for_use_fincludes ();
9180 builder.fill_for_use_stamps ();
9181 builder.fill_for_use_cflags ();
9182 builder.fill_for_use_pp_cflags ();
9183 builder.fill_for_use_cppflags ();
9184 builder.fill_for_use_pp_cppflags ();
9185 builder.fill_for_use_fflags ();
9186 builder.fill_for_use_pp_fflags ();
9187 builder.fill_for_use_linkopts ();
9188 builder.fill_for_use_libraries ();
9189 builder.fill_for_includes ();
9190 builder.fill_for_fincludes ();
9191 builder.fill_for_all_constituents ();
9192
9193 /**
9194 * Macros implied or required to manage constituents.
9195 */
9196
9197 const Constituent::ConstituentVector& constituents =
9198 Constituent::constituents ();
9199
9200 if (!Symbol::is_selected ("constituents"))
9201 {
9202 temp = "macro_append constituents \" ";
9203
9204 for (number = 0; number < constituents.size (); number++)
9205 {
9206 const Constituent& constituent = constituents[number];
9207
9208 if (constituent.group == 0)
9209 {
9210 temp += constituent.name;
9211 temp += " ";
9212 }
9213 }
9214
9215 temp += "\"";
9216
9217 SyntaxParser::parse_requirements_line (temp, &current_use);
9218 }
9219
9220 SyntaxParser::parse_requirements_line ("macro_append all_constituents \" $(constituents)\"",
9221 &current_use);
9222
9223 if (!Symbol::is_selected ("constituentsclean"))
9224 {
9225 temp = "macro_append constituentsclean \" ";
9226
9227 for (number = constituents.size () - 1; number >= 0 ; number--)
9228 {
9229 const Constituent& constituent = constituents[number];
9230
9231 if (constituent.group == 0)
9232 {
9233 temp += constituent.name;
9234 temp += "clean ";
9235 }
9236 }
9237
9238 temp += "\"";
9239
9240 SyntaxParser::parse_requirements_line (temp, &current_use);
9241 }
9242
9243 SyntaxParser::parse_requirements_line ("macro_append all_constituentsclean \" $(constituentsclean)\"",
9244 &current_use);
9245
9246 const Group::GroupVector& groups = Group::groups ();
9247
9248 for (number = 0; number < groups.size (); number++)
9249 {
9250 const Group& group = groups[number];
9251
9252 temp = "macro_append ";
9253 temp += group.name ();
9254 temp += "_constituents \" ";
9255
9256 int i;
9257
9258 for (i = 0; i < constituents.size (); i++)
9259 {
9260 const Constituent& constituent = constituents[i];
9261
9262 if ((constituent.group != 0) &&
9263 (group.name () == constituent.group->name ()))
9264 {
9265 temp += constituent.name;
9266 temp += " ";
9267 }
9268 }
9269
9270 temp += "\"";
9271
9272 SyntaxParser::parse_requirements_line (temp, &current_use);
9273
9274 temp = "macro_append ";
9275 temp += group.name ();
9276 temp += "_constituentsclean \" ";
9277
9278 for (i = constituents.size () - 1; i >= 0 ; i--)
9279 {
9280 const Constituent& constituent = constituents[i];
9281
9282 if ((constituent.group != 0) &&
9283 (group.name () == constituent.group->name ()))
9284 {
9285 temp += constituent.name;
9286 temp += "clean ";
9287 }
9288 }
9289
9290 temp += "\"";
9291
9292 SyntaxParser::parse_requirements_line (temp, &current_use);
9293 }
9294
9295 //
9296 // Definitions for installation area mechanisms. Apply all cmtpath patterns
9297 //
9298 if ((get_build_strategy () & InstallAreaMask) == WithInstallArea)
9299 {
9300 CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
9301
9302 //cout << "#IA7>" << endl;
9303
9304 ia_mgr.setup ();
9305 }
9306
9307 CmtPathPattern::apply_all ();
9308}
9309
9310//----------------------------------------------------------
9311void Cmt::use_cmt ()
9312{
9313 UseRef use;
9314 bool recursive_copy = m_recursive;
9315 bool debug_copy = m_debug;
9316
9317 if (m_default_path.size () <= 0) return;
9318 if (m_current_package == "CMT") return;
9319
9320 m_recursive = true;
9321 m_debug = false;
9322 use = Use::add (m_default_path, "CMT", m_cmt_version, "", "", 0);
9323 m_recursive = recursive_copy;
9324 m_debug = debug_copy;
9325}
9326
9327//----------------------------------------------------------
9328void Cmt::use_home_requirements ()
9329{
9330 use_special_requirements (m_cmt_home,
9331 CmtSystem::get_home_package (),
9332 "requirements");
9333}
9334
9335//----------------------------------------------------------
9336void Cmt::use_user_context_requirements ()
9337{
9338 use_special_requirements (m_cmt_user_context,
9339 CmtSystem::get_user_context_package (),
9340 "requirements");
9341}
9342
9343//----------------------------------------------------------
9344void Cmt::use_special_requirements (const cmt_string& path,
9345 const cmt_string& name,
9346 const cmt_string& file_name)
9347{
9348 if (path == "")
9349 {
9350 return;
9351 }
9352
9353 UseRef use;
9354 bool recursive_copy = m_recursive;
9355
9356 if (m_default_path.size () <= 0) return;
9357 if (m_current_package == "CMT") return;
9358
9359 m_recursive = true;
9360
9361 use = Use::add (path, name, "v0", "", "", 0);
9362
9363 cmt_string f = m_cmt_user_context;
9364 f += CmtSystem::file_separator ();
9365 f += file_name;
9366 SyntaxParser::parse_requirements (f, use);
9367
9368 m_recursive = recursive_copy;
9369}
9370
9371//-------------------------------------------------
9372void Cmt::vector_to_string (const CmtSystem::cmt_string_vector& v,
9373 const cmt_string& separator,
9374 cmt_string& result)
9375{
9376 result.erase (0);
9377
9378 for (int i = 0; i < v.size (); i++)
9379 {
9380 const cmt_string& s = v[i];
9381 if (s == "") continue;
9382
9383 if (i > 0) result += separator;
9384 result += v[i];
9385 }
9386}
9387
9388//-------------------------------------------------
9389cmt_string Cmt::vector_to_string (const CmtSystem::cmt_string_vector& v)
9390{
9391 cmt_string result;
9392
9393 vector_to_string (v, " ", result);
9394
9395 return (result);
9396}
Note: See TracBrowser for help on using the repository browser.