Context Navigation

source: CMT/v1r25-branch/source/cmt_parser.cxx @ 642

Last change on this file since 642 was 642, checked in by rybkin, 11 years ago
merge -r 631:635 HEAD
Property svn:eol-style set to `native`
File size: 249.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: